\n`;
+ content += ` typedef ${api.name} ${api.type};`;
+ content += `
\n`;
+
+ return content;
+}
+
+function produceSignatureForMacro(version, api, type) {
+ let content = "";
+
+ const githubLink = produceGitHubLink(version, api, type);
+
+ content += ` \n`;
+
+ if (githubLink) {
+ content += ` \n`;
+ content += ` #define ${api.name} ${sanitize(api.value)}`;
+ content += `
\n`;
+
+ return content;
+}
+
+function produceSignature(version, api, type) {
+ if (type === 'macro') {
+ return produceSignatureForMacro(version, api, type);
+ }
+ else if (type === 'alias') {
+ return produceSignatureForAlias(version, api, type);
+ }
+ else if (type === 'function' || type === 'callback') {
+ return produceSignatureForFunction(version, api, type);
+ }
+ else if (type === 'object') {
+ return produceSignatureForObject(version, api, type);
+ }
+ else if (type === 'struct') {
+ return produceSignatureForStruct(version, api, type);
+ }
+ else if (type === 'struct' || type === 'enum') {
+ return "";
+ }
+ else {
+ throw new Error(`unknown type: ${api.kind}`);
+ }
+}
+
+function isFunctionPointer(type) {
+ return type.match(/^(const\s+)?[A-Za-z0-9_]+\s+\*?\(\*/);
+}
+
+function isEnum(type) {
+ return type.match(/^enum\s+/);
+}
+
+function isStruct(type) {
+ return type.match(/^struct\s+/);
+}
+
+function internalKind(version, api) {
+ if (api.kind === 'struct' && api.opaque) {
+ return 'object';
+ }
+
+ return api.kind;
+}
+
+function externalKind(kind) {
+ if (kind === 'object') {
+ return 'struct';
+ }
+
+ return kind;
+}
+
+async function produceIndexForGroup(version, group, versionApis) {
+ let content = "";
+
+ if (versionApis['groups'][group].apis.length == 0) {
+ return;
+ }
+
+ const apis = Object.values(versionApis['groups'][group].apis);
+
+ let fileName = group;
+ if (fileName.endsWith('.h')) {
+ fileName = fileName.substr(0, fileName.length - 2);
+ }
+
+ const system = fileName.startsWith('sys/');
+ let groupName = system ? fileName.substr(4) : fileName;
+
+ content += ` \n`;
+
+ content += `
\n`;
+ content += `
\n`;
+ content += `
\n`;
+
+ content += ` \n`;
+
+ let details = undefined;
+
+ if (versionApis['groups'][group].info?.details) {
+ details = markdown.render(versionApis['groups'][group].info.details, { __version: version });
+ } else if (versionApis['groups'][group].info?.summary) {
+ details = versionApis['groups'][group].info.summary;
+ }
+
+ if (details) {
+ content += `
\n`;
+ content += ` ${details}\n`;
+ content += `
\n`;
+ }
+
+ for (const kind of [ 'object', 'struct', 'macro', 'enum', 'callback', 'alias', 'function' ]) {
+ content += produceIndexForApiKind(version, apis.filter(api => {
+ if (kind === 'object') {
+ return api.kind === 'struct' && api.opaque;
+ }
+ else if (kind === 'struct') {
+ return api.kind === 'struct' && !api.opaque;
+ }
+ else {
+ return api.kind === kind;
+ }
+ }), kind);
+ }
+
+ content += `
\n`;
+
+ for (const item of apis) {
+ if (item.changed) {
+ content += `
\n`;
+ } else {
+ content += `
\n`;
+ }
+
+ content += `
\n`;
+
+ let shortComment = Array.isArray(item.comment) ? item.comment[0] : item.comment;
+ shortComment = shortComment || '';
+
+ shortComment = shortComment.replace(/\..*/, '');
+
+ content += `
\n`;
+ content += ` ${render(version, shortComment)}\n`;
+ content += `
\n`;
+ content += `
\n`;
+ }
+
+ content += `
\n`;
+
+ return content;
+}
+
+function versionIndexContent(version, apiData) {
+ let content = "";
+ let hasSystem = false;
+
+ content += `
\n`;
+ content += ` \n`;
+
+ content += `\n`;
+ content += `
Groups \n`;
+ content += `
\n`;
+
+ for (const group of Object.keys(apiData['groups']).sort((a, b) => {
+ if (a.startsWith('sys/')) { return 1; }
+ if (b.startsWith('sys/')) { return -1; }
+ return a.localeCompare(b);
+ }).map(fn => {
+ let n = fn;
+ let sys = false;
+
+ if (n.endsWith('.h')) {
+ n = n.substr(0, n.length - 2);
+ }
+
+ if (n.startsWith('sys/')) {
+ n = n.substr(4);
+ sys = true;
+ }
+
+ return {
+ name: n, filename: fn, system: sys, info: apiData['groups'][fn].info, apis: apiData['groups'][fn]
+ };
+ }).filter(filedata => {
+ return Object.keys(filedata.apis).length > 0 && !fileDenylist.includes(filedata.filename);
+ })) {
+ if (group.system && !hasSystem) {
+ hasSystem = true;
+
+ content += ` \n`;
+ content += `\n`;
+ content += `
System Groups (Advanced) \n`;
+ content += `
\n`;
+
+ content += `
\n`;
+
+ return content;
+}
+
+async function produceDocumentationIndex(version, apiData) {
+ const content = versionIndexContent(version, apiData);
+
+ const versionDir = `${outputPath}/${version}`;
+ const filename = `${versionDir}/index.html`;
+
+ await fs.mkdir(versionDir, { recursive: true });
+ await fs.writeFile(filename, await layout({
+ title: `APIs (${projectTitle} ${version})`,
+ content: content
+ }));
+}
+
+async function documentationIsUpToDateForVersion(version, apiData) {
+ try {
+ const existingMetadata = JSON.parse(await fs.readFile(`${outputPath}/${version}/.metadata`));
+ return existingMetadata?.commit === apiData.info.commit;
+ }
+ catch (e) {
+ }
+
+ return false;
+}
+
+async function produceDocumentationMetadata(version, apiData) {
+ const versionDir = `${outputPath}/${version}`;
+ const filename = `${versionDir}/.metadata`;
+
+ await fs.mkdir(versionDir, { recursive: true });
+ await fs.writeFile(filename, JSON.stringify(apiData.info, null, 2) + "\n");
+}
+
+async function cleanupOldDocumentation(version) {
+ const versionDir = `${outputPath}/${version}`;
+
+ for (const fn of await fs.readdir(versionDir)) {
+ if (fn === '.metadata') {
+ continue;
+ }
+
+ const path = `${versionDir}/${fn}`;
+ await fs.rm(path, { recursive: true });
+ }
+}
+
+async function produceDocumentationForVersion(version, apiData) {
+ if (!options.force && await documentationIsUpToDateForVersion(version, apiData)) {
+ if (options.verbose) {
+ console.log(`Documentation exists for ${version} at version ${apiData.info.commit.substr(0, 7)}; skipping...`);
+ }
+
+ return;
+ }
+
+ if (options.verbose) {
+ console.log(`Producing documentation for ${version}...`);
+ }
+
+ await cleanupOldDocumentation(version);
+
+ await produceDocumentationForApis(version, apiData);
+
+ for (const group in apiData['groups']) {
+ await produceIndexForGroup(version, group, apiData);
+ }
+
+ await produceDocumentationIndex(version, apiData);
+
+ await produceDocumentationMetadata(version, apiData);
+}
+
+function versionDeltaData(version, api) {
+ const base = { version: version, api: api };
+
+ if (api.kind === 'function') {
+ return {
+ ...base,
+ returns: api.returns?.type || 'int',
+ params: api.params?.map((p) => p.type) || [ 'void' ]
+ };
+ }
+ else if (api.kind === 'enum') {
+ return {
+ ...base,
+ members: api.members?.map((m) => { return { 'name': m.name, 'value': m.value } })
+ };
+ }
+ else if (api.kind === 'callback') {
+ return { ...base, };
+ }
+ else if (api.kind === 'alias') {
+ return { ...base, };
+ }
+ else if (api.kind === 'struct') {
+ return {
+ ...base,
+ members: api.members?.map((m) => { return { 'name': m.name, 'type': m.type } })
+ };
+ }
+ else if (api.kind === 'macro') {
+ return {
+ ...base,
+ name: api.name,
+ value: api.value
+ };
+ }
+ else {
+ throw new Error(`unknown api kind: '${api.kind}'`);
+ }
+}
+
+function deltasEqual(a, b) {
+ const unversionedA = { ...a };
+ const unversionedB = { ...b };
+
+ delete unversionedA.version;
+ delete unversionedA.api;
+ delete unversionedA.changed;
+ delete unversionedB.version;
+ delete unversionedB.api;
+ delete unversionedB.changed;
+
+ return JSON.stringify(unversionedA) === JSON.stringify(unversionedB);
+}
+
+const apiForVersionCache = { };
+function allApisForVersion(version, apiData) {
+ if (apiForVersionCache[version]) {
+ return apiForVersionCache[version];
+ }
+
+ let result = { };
+ for (const file in apiData['groups']) {
+ result = { ...result, ...apiData['groups'][file].apis };
+ }
+
+ apiForVersionCache[version] = result;
+ return result;
+}
+
+function seedVersionApis(apiData) {
+ for (const version in apiData) {
+ allApisForVersion(version, apiData[version]);
+ }
+}
+
+function calculateVersionDeltas(apiData) {
+ for (const version in apiData) {
+ const apisForVersion = allApisForVersion(version, apiData[version]);
+
+ for (const api in apisForVersion) {
+ if (!versionDeltas[api]) {
+ versionDeltas[api] = [ ];
+ }
+
+ versionDeltas[api].push(versionDeltaData(version, apisForVersion[api]));
+ }
+ }
+
+ for (const api in versionDeltas) {
+ const count = versionDeltas[api].length;
+
+ versionDeltas[api][count - 1].changed = true;
+
+ for (let i = count - 2; i >= 0; i--) {
+ versionDeltas[api][i].changed = !deltasEqual(versionDeltas[api][i], versionDeltas[api][i + 1]);
+ }
+ }
+}
+
+async function produceSearch(versions) {
+ if (options.verbose) {
+ console.log(`Producing search page...`);
+ }
+
+ let content = "";
+
+ content += `\n`;
+ content += `\n`;
+ content += `\n`;
+ content += `\n`;
+
+ content += `\n`;
+
+ content += `
\n`;
+ content += ` \n`;
+
+ content += `\n`;
+
+ content += `
\n`;
+ content += ` Search \n`;
+ content += `
\n`;
+
+ content += `\n`;
+
+ content += `
\n`;
+ content += `
Results \n`;
+ content += `
\n`;
+ content += `
\n`;
+ content += `
\n`;
+ content += `
\n`;
+
+ const filename = `${outputPath}/search.html`;
+
+ await fs.mkdir(outputPath, { recursive: true });
+ await fs.writeFile(filename, await layout({
+ title: `API search (${projectTitle})`,
+ content: content
+ }));
+}
+
+async function produceMainIndex(versions) {
+ const versionDefault = versions[0];
+
+ if (options.verbose) {
+ console.log(`Producing documentation index...`);
+ }
+
+ let content = "";
+
+ content += `\n`;
+ content += `\n`;
+
+ content += versionIndexContent(versionDefault, apiData[versionDefault]);
+
+ const filename = `${outputPath}/index.html`;
+
+ await fs.mkdir(outputPath, { recursive: true });
+ await fs.writeFile(filename, await layout({
+ title: `APIs (${projectTitle} ${versionDefault})`,
+ content: content
+ }));
+}
+
+function versionSort(a, b) {
+ if (a === b) {
+ return 0;
+ }
+
+ const aVersion = a.match(/^v(\d+)(?:\.(\d+)(?:\.(\d+)(?:\.(\d+))?)?)?(?:-(.*))?$/);
+ const bVersion = b.match(/^v(\d+)(?:\.(\d+)(?:\.(\d+)(?:\.(\d+))?)?)?(?:-(.*))?$/);
+
+ if (!aVersion && !bVersion) {
+ return a.localeCompare(b);
+ }
+ else if (aVersion && !bVersion) {
+ return -1;
+ }
+ else if (!aVersion && bVersion) {
+ return 1;
+ }
+
+ for (let i = 1; i < 5; i++) {
+ if (!aVersion[i] && !bVersion[i]) {
+ break;
+ }
+ else if (aVersion[i] && !bVersion[i]) {
+ return 1;
+ }
+ else if (!aVersion[i] && bVersion[i]) {
+ return -1;
+ }
+ else if (aVersion[i] !== bVersion[i]) {
+ return aVersion[i] - bVersion[i];
+ }
+ }
+
+ if (aVersion[5] && !bVersion[5]) {
+ return -1;
+ }
+ else if (!aVersion[5] && bVersion[5]) {
+ return 1;
+ }
+ else if (aVersion[5] && bVersion[5]) {
+ return aVersion[5].localeCompare(bVersion[5]);
+ }
+
+ return 0;
+}
+
+program.option('--output
')
+ .option('--layout ')
+ .option('--jekyll-layout ')
+ .option('--version ')
+ .option('--verbose')
+ .option('--force')
+ .option('--strict');
+program.parse();
+
+const options = program.opts();
+
+if (program.args.length != 2) {
+ console.error(`usage: ${path.basename(process.argv[1])} raw_api_dir output_dir`);
+ process.exit(1);
+}
+
+const docsPath = program.args[0];
+const outputPath = program.args[1];
+
+(async () => {
+ try {
+ const v = options.version ? options.version :
+ (await fs.readdir(docsPath))
+ .filter(a => a.endsWith('.json'))
+ .map(a => a.replace(/\.json$/, ''));
+
+ versions.push(...v.sort(versionSort).reverse());
+
+ for (const version of versions) {
+ if (options.verbose) {
+ console.log(`Reading documentation data for ${version}...`);
+ }
+
+ apiData[version] = JSON.parse(await fs.readFile(`${docsPath}/${version}.json`));
+ }
+
+ if (showVersions) {
+ if (options.verbose) {
+ console.log(`Calculating version deltas...`);
+ }
+
+ calculateVersionDeltas(apiData);
+ }
+
+ for (const version of versions) {
+ await produceDocumentationForVersion(version, apiData[version]);
+ }
+
+ await produceSearch(versions);
+ await produceMainIndex(versions);
+ } catch (e) {
+ console.error(e);
+ process.exit(1);
+ }
+})();
diff --git a/script/api-docs/generate b/script/api-docs/generate
new file mode 100755
index 00000000000..76f3d8ce6a8
--- /dev/null
+++ b/script/api-docs/generate
@@ -0,0 +1,115 @@
+#!/usr/bin/env bash
+#
+# Usage: generate repo_path output_path
+#
+# Example: generate https://github.com/libgit2/libgit2 path_to_output
+# to clone the repository from GitHub and produce documentation;
+# the repo_path can also be a local path
+
+set -eo pipefail
+
+source_path=$(mktemp -d)
+verbose=
+force=
+
+for var in "$@"; do
+ if [ "${var}" == "--verbose" ]; then
+ verbose=true
+ elif [ "${var}" == "--force" ]; then
+ force=true
+ elif [ "${repo_path}" == "" ]; then
+ repo_path="${var}"
+ elif [ "${output_path}" == "" ]; then
+ output_path="${var}"
+ else
+ repo_path=""
+ output_path=""
+ fi
+done
+
+if [ "${repo_path}" = "" -o "${output_path}" = "" ]; then
+ echo "usage: $0 [--verbose] [--force] repo_path output_path" 1>&2
+ exit 1
+fi
+
+function do_checkout {
+ if [ "$1" = "" ]; then
+ echo "usage: $0 source_path" 1>&2
+ exit 1
+ fi
+
+ if [ "${verbose}" ]; then
+ echo ":: Checking out source trees..."
+ echo ""
+ fi
+
+ source_path=$1
+
+ mkdir -p "${source_path}"
+ git clone "${repo_path}" "${source_path}/main" --no-checkout
+ ( cd "${source_path}/main" && git sparse-checkout set --no-cone 'include/*' )
+ ( cd "${source_path}/main" && git read-tree origin/main )
+ ( cd "${source_path}/main" && git checkout -- include )
+
+ for tag in $(git --git-dir="${source_path}/main/.git" tag -l); do
+ git --git-dir="${source_path}/main/.git" worktree add -f "${source_path}/${tag}" "${tag}" --no-checkout
+ ( cd "${source_path}/${tag}" && git sparse-checkout set --no-cone 'include/*' )
+ ( cd "${source_path}/${tag}" && git read-tree HEAD )
+
+ if [ "${tag}" == "v0.1.0" ]; then
+ ( cd "${source_path}/${tag}" && git checkout -- src/git )
+ elif [ "${tag}" == "v0.2.0" -o "${tag}" == "v0.3.0" ]; then
+ ( cd "${source_path}/${tag}" && git checkout -- src/git2 )
+ else
+ ( cd "${source_path}/${tag}" && git checkout -- include )
+ fi
+ done
+}
+
+do_checkout ${source_path}
+
+if [ "${verbose}" ]; then
+ echo ""
+ echo ":: Generating raw API documentation..."
+ echo ""
+fi
+
+for version in ${source_path}/*; do
+ version=$(echo "${version}" | sed -e "s/.*\///")
+ commit=$( cd "${source_path}/${version}" && git rev-parse HEAD )
+
+ if [ -f "${output_path}/api/${version}.json" ]; then
+ existing_commit=$(jq -r .info.commit < "${output_path}/api/${version}.json")
+
+ if [ "${existing_commit}" == "${commit}" -a ! "${force}" ]; then
+ if [ "${verbose}" ]; then
+ echo "Raw API documentation for ${version} exists; skipping..."
+ fi
+
+ continue
+ fi
+ fi
+
+ echo "Generating raw API documentation for ${version}..."
+ mkdir -p "${output_path}/api"
+ node ./api-generator.js "${source_path}/${version}" > "${output_path}/api/${version}.json"
+done
+
+if [ "${verbose}" ]; then
+ echo ""
+ echo ":: Generating HTML documentation..."
+ echo ""
+fi
+
+search_options=""
+docs_options=""
+if [ "${verbose}" ]; then
+ search_options="${search_options} --verbose"
+ docs_options="${docs_options} --verbose"
+fi
+if [ "${force}" ]; then
+ docs_options="${docs_options} --force"
+fi
+
+node ./search-generator.js ${search_options} "${output_path}/api" "${output_path}/search-index"
+node ./docs-generator.js ${docs_options} --jekyll-layout default "${output_path}/api" "${output_path}/reference"
diff --git a/script/api-docs/package-lock.json b/script/api-docs/package-lock.json
new file mode 100644
index 00000000000..3ba22260f12
--- /dev/null
+++ b/script/api-docs/package-lock.json
@@ -0,0 +1,85 @@
+{
+ "name": "api-docs",
+ "lockfileVersion": 3,
+ "requires": true,
+ "packages": {
+ "": {
+ "dependencies": {
+ "commander": "^12.1.0",
+ "markdown-it": "^14.1.0",
+ "minisearch": "^7.1.1"
+ }
+ },
+ "node_modules/argparse": {
+ "version": "2.0.1",
+ "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
+ "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q=="
+ },
+ "node_modules/commander": {
+ "version": "12.1.0",
+ "resolved": "https://registry.npmjs.org/commander/-/commander-12.1.0.tgz",
+ "integrity": "sha512-Vw8qHK3bZM9y/P10u3Vib8o/DdkvA2OtPtZvD871QKjy74Wj1WSKFILMPRPSdUSx5RFK1arlJzEtA4PkFgnbuA==",
+ "engines": {
+ "node": ">=18"
+ }
+ },
+ "node_modules/entities": {
+ "version": "4.5.0",
+ "resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz",
+ "integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==",
+ "engines": {
+ "node": ">=0.12"
+ },
+ "funding": {
+ "url": "https://github.com/fb55/entities?sponsor=1"
+ }
+ },
+ "node_modules/linkify-it": {
+ "version": "5.0.0",
+ "resolved": "https://registry.npmjs.org/linkify-it/-/linkify-it-5.0.0.tgz",
+ "integrity": "sha512-5aHCbzQRADcdP+ATqnDuhhJ/MRIqDkZX5pyjFHRRysS8vZ5AbqGEoFIb6pYHPZ+L/OC2Lc+xT8uHVVR5CAK/wQ==",
+ "dependencies": {
+ "uc.micro": "^2.0.0"
+ }
+ },
+ "node_modules/markdown-it": {
+ "version": "14.1.0",
+ "resolved": "https://registry.npmjs.org/markdown-it/-/markdown-it-14.1.0.tgz",
+ "integrity": "sha512-a54IwgWPaeBCAAsv13YgmALOF1elABB08FxO9i+r4VFk5Vl4pKokRPeX8u5TCgSsPi6ec1otfLjdOpVcgbpshg==",
+ "dependencies": {
+ "argparse": "^2.0.1",
+ "entities": "^4.4.0",
+ "linkify-it": "^5.0.0",
+ "mdurl": "^2.0.0",
+ "punycode.js": "^2.3.1",
+ "uc.micro": "^2.1.0"
+ },
+ "bin": {
+ "markdown-it": "bin/markdown-it.mjs"
+ }
+ },
+ "node_modules/mdurl": {
+ "version": "2.0.0",
+ "resolved": "https://registry.npmjs.org/mdurl/-/mdurl-2.0.0.tgz",
+ "integrity": "sha512-Lf+9+2r+Tdp5wXDXC4PcIBjTDtq4UKjCPMQhKIuzpJNW0b96kVqSwW0bT7FhRSfmAiFYgP+SCRvdrDozfh0U5w=="
+ },
+ "node_modules/minisearch": {
+ "version": "7.1.1",
+ "resolved": "https://registry.npmjs.org/minisearch/-/minisearch-7.1.1.tgz",
+ "integrity": "sha512-b3YZEYCEH4EdCAtYP7OlDyx7FdPwNzuNwLQ34SfJpM9dlbBZzeXndGavTrC+VCiRWomL21SWfMc6SCKO/U2ZNw=="
+ },
+ "node_modules/punycode.js": {
+ "version": "2.3.1",
+ "resolved": "https://registry.npmjs.org/punycode.js/-/punycode.js-2.3.1.tgz",
+ "integrity": "sha512-uxFIHU0YlHYhDQtV4R9J6a52SLx28BCjT+4ieh7IGbgwVJWO+km431c4yRlREUAsAmt/uMjQUyQHNEPf0M39CA==",
+ "engines": {
+ "node": ">=6"
+ }
+ },
+ "node_modules/uc.micro": {
+ "version": "2.1.0",
+ "resolved": "https://registry.npmjs.org/uc.micro/-/uc.micro-2.1.0.tgz",
+ "integrity": "sha512-ARDJmphmdvUk6Glw7y9DQ2bFkKBHwQHLi2lsaH6PPmz/Ka9sFOBsBluozhDltWmnv9u/cF6Rt87znRTPV+yp/A=="
+ }
+ }
+}
diff --git a/script/api-docs/package.json b/script/api-docs/package.json
new file mode 100644
index 00000000000..67a6fe7aa2a
--- /dev/null
+++ b/script/api-docs/package.json
@@ -0,0 +1,7 @@
+{
+ "dependencies": {
+ "commander": "^12.1.0",
+ "markdown-it": "^14.1.0",
+ "minisearch": "^7.1.1"
+ }
+}
diff --git a/script/api-docs/search-generator.js b/script/api-docs/search-generator.js
new file mode 100755
index 00000000000..cad73f947ae
--- /dev/null
+++ b/script/api-docs/search-generator.js
@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+
+const markdownit = require('markdown-it');
+const { program } = require('commander');
+const minisearch = require('minisearch');
+
+const path = require('node:path');
+const fs = require('node:fs/promises');
+
+const linkPrefix = '/docs/reference';
+
+const defaultBranch = 'main';
+
+function uniqueifyId(api, nodes) {
+ let suffix = "", i = 1;
+
+ while (true) {
+ const possibleId = `${api.kind}-${api.name}${suffix}`;
+ let collision = false;
+
+ for (const item of nodes) {
+ if (item.id === possibleId) {
+ collision = true;
+ break;
+ }
+ }
+
+ if (!collision) {
+ return possibleId;
+ }
+
+ suffix = `-${++i}`;
+ }
+}
+
+async function produceSearchIndex(version, apiData) {
+ const nodes = [ ];
+
+ for (const group in apiData['groups']) {
+ for (const name in apiData['groups'][group]['apis']) {
+ const api = apiData['groups'][group]['apis'][name];
+
+ let displayName = name;
+
+ if (api.kind === 'macro') {
+ displayName = displayName.replace(/\(.*/, '');
+ }
+
+ const apiSearchData = {
+ id: uniqueifyId(api, nodes),
+ name: displayName,
+ group: group,
+ kind: api.kind
+ };
+
+ apiSearchData.description = Array.isArray(api.comment) ?
+ api.comment[0] : api.comment;
+
+ let detail = "";
+
+ if (api.kind === 'macro') {
+ detail = api.value;
+ }
+ else if (api.kind === 'alias') {
+ detail = api.type;
+ }
+ else {
+ let details = undefined;
+
+ if (api.kind === 'struct' || api.kind === 'enum') {
+ details = api.members;
+ }
+ else if (api.kind === 'function' || api.kind === 'callback') {
+ details = api.params;
+ }
+ else {
+ throw new Error(`unknown api type '${api.kind}'`);
+ }
+
+ for (const item of details || [ ]) {
+ if (detail.length > 0) {
+ detail += ' ';
+ }
+
+ detail += item.name;
+
+ if (item.comment) {
+ detail += ' ';
+ detail += item.comment;
+ }
+ }
+
+ if (api.kind === 'function' || api.kind === 'callback') {
+ if (detail.length > 0 && api.returns?.type) {
+ detail += ' ' + api.returns.type;
+ }
+
+ if (detail.length > 0 && api.returns?.comment) {
+ detail += ' ' + api.returns.comment;
+ }
+ }
+ }
+
+ detail = detail.replaceAll(/\s+/g, ' ')
+ .replaceAll(/[\"\'\`]/g, '');
+
+ apiSearchData.detail = detail;
+
+ nodes.push(apiSearchData);
+ }
+ }
+
+ const index = new minisearch({
+ fields: [ 'name', 'description', 'detail' ],
+ storeFields: [ 'name', 'group', 'kind', 'description' ],
+ searchOptions: { boost: { name: 5, description: 2 } }
+ });
+
+ index.addAll(nodes);
+
+ const filename = `${outputPath}/${version}.json`;
+ await fs.mkdir(outputPath, { recursive: true });
+ await fs.writeFile(filename, JSON.stringify(index, null, 2));
+}
+
+function versionSort(a, b) {
+ if (a === b) {
+ return 0;
+ }
+
+ const aVersion = a.match(/^v(\d+)(?:\.(\d+)(?:\.(\d+)(?:\.(\d+))?)?)?(?:-(.*))?$/);
+ const bVersion = b.match(/^v(\d+)(?:\.(\d+)(?:\.(\d+)(?:\.(\d+))?)?)?(?:-(.*))?$/);
+
+ if (!aVersion && !bVersion) {
+ return a.localeCompare(b);
+ }
+ else if (aVersion && !bVersion) {
+ return -1;
+ }
+ else if (!aVersion && bVersion) {
+ return 1;
+ }
+
+ for (let i = 1; i < 5; i++) {
+ if (!aVersion[i] && !bVersion[i]) {
+ break;
+ }
+ else if (aVersion[i] && !bVersion[i]) {
+ return 1;
+ }
+ else if (!aVersion[i] && bVersion[i]) {
+ return -1;
+ }
+ else if (aVersion[i] !== bVersion[i]) {
+ return aVersion[i] - bVersion[i];
+ }
+ }
+
+ if (aVersion[5] && !bVersion[5]) {
+ return -1;
+ }
+ else if (!aVersion[5] && bVersion[5]) {
+ return 1;
+ }
+ else if (aVersion[5] && bVersion[5]) {
+ return aVersion[5].localeCompare(bVersion[5]);
+ }
+
+ return 0;
+}
+
+program.option('--verbose')
+ .option('--version ');
+program.parse();
+
+const options = program.opts();
+
+if (program.args.length != 2) {
+ console.error(`usage: ${path.basename(process.argv[1])} raw_api_dir output_dir`);
+ process.exit(1);
+}
+
+const docsPath = program.args[0];
+const outputPath = program.args[1];
+
+(async () => {
+ try {
+ const v = options.version ? options.version :
+ (await fs.readdir(docsPath))
+ .filter(a => a.endsWith('.json'))
+ .map(a => a.replace(/\.json$/, ''));
+
+ const versions = v.sort(versionSort).reverse();
+
+ for (const version of versions) {
+ if (options.verbose) {
+ console.log(`Reading documentation data for ${version}...`);
+ }
+
+ const apiData = JSON.parse(await fs.readFile(`${docsPath}/${version}.json`));
+
+ if (options.verbose) {
+ console.log(`Creating minisearch index for ${version}...`);
+ }
+
+ await produceSearchIndex(version, apiData);
+ }
+ } catch (e) {
+ console.error(e);
+ process.exit(1);
+ }
+})();
diff --git a/script/valgrind.sh b/script/valgrind.sh
index b5deed2b06e..aacd767a7c8 100755
--- a/script/valgrind.sh
+++ b/script/valgrind.sh
@@ -1,2 +1,2 @@
#!/bin/bash
-exec valgrind --leak-check=full --show-reachable=yes --error-exitcode=125 --num-callers=50 --suppressions="$(dirname "${BASH_SOURCE[0]}")/valgrind.supp" "$@"
+exec valgrind --leak-check=full --show-reachable=yes --child-silent-after-fork=yes --error-exitcode=125 --num-callers=50 --suppressions="$(dirname "${BASH_SOURCE[0]}")/valgrind.supp" "$@"
diff --git a/script/valgrind.supp b/script/valgrind.supp
index 8c4549f62be..79e8378f07e 100644
--- a/script/valgrind.supp
+++ b/script/valgrind.supp
@@ -80,6 +80,13 @@
fun:__check_pf
}
+{
+ ignore-glibc-getaddrinfo-fn
+ Memcheck:Leak
+ ...
+ fun:getaddrinfo
+}
+
{
ignore-curl-global-init
Memcheck:Leak
@@ -191,6 +198,16 @@
...
}
+{
+ ignore-openssl-undefined-in-connect
+ Memcheck:Cond
+ ...
+ obj:*libcrypto.so*
+ ...
+ fun:openssl_connect
+ ...
+}
+
{
ignore-libssh2-rsa-sha1-sign
Memcheck:Leak
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index e108b2e79ce..f76bbecc138 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -9,7 +9,7 @@ if(DEPRECATE_HARD)
add_definitions(-DGIT_DEPRECATE_HARD)
endif()
-if(USE_LEAK_CHECKER STREQUAL "valgrind")
+if(DEBUG_LEAK_CHECKER STREQUAL "valgrind")
add_definitions(-DVALGRIND)
endif()
@@ -20,30 +20,34 @@ endif()
if(DEBUG_POOL)
set(GIT_DEBUG_POOL 1)
endif()
-add_feature_info(debugpool GIT_DEBUG_POOL "debug pool allocator")
+add_feature_info("Debug pool" GIT_DEBUG_POOL "debug-mode struct pool allocators")
if(DEBUG_STRICT_ALLOC)
set(GIT_DEBUG_STRICT_ALLOC 1)
endif()
-add_feature_info(debugalloc GIT_DEBUG_STRICT_ALLOC "debug strict allocators")
+add_feature_info("Debug alloc" GIT_DEBUG_STRICT_ALLOC "debug-mode strict allocators")
if(DEBUG_STRICT_OPEN)
set(GIT_DEBUG_STRICT_OPEN 1)
endif()
-add_feature_info(debugopen GIT_DEBUG_STRICT_OPEN "path validation in open")
+add_feature_info("Debug open" GIT_DEBUG_STRICT_OPEN "strict path validation in open")
#
# Optional feature enablement
#
-include(SelectGSSAPI)
+include(SelectThreads)
+include(SelectNsec)
include(SelectHTTPSBackend)
include(SelectHashes)
include(SelectHTTPParser)
include(SelectRegex)
+include(SelectXdiff)
include(SelectSSH)
-include(SelectWinHTTP)
-include(SelectZlib)
+include(SelectCompression)
+include(SelectI18n)
+include(SelectAuthNTLM)
+include(SelectAuthNegotiate)
#
# Platform support
@@ -52,26 +56,48 @@ include(SelectZlib)
# futimes/futimens
if(HAVE_FUTIMENS)
- set(GIT_USE_FUTIMENS 1)
-endif ()
-add_feature_info(futimens GIT_USE_FUTIMENS "futimens support")
+ set(GIT_FUTIMENS 1)
+endif()
# qsort
-check_prototype_definition(qsort_r
- "void qsort_r(void *base, size_t nmemb, size_t size, void *thunk, int (*compar)(void *, const void *, const void *))"
- "" "stdlib.h" GIT_QSORT_R_BSD)
+# old-style FreeBSD qsort_r() has the 'context' parameter as the first argument
+# of the comparison function:
+check_prototype_definition_safe(qsort_r
+ "void (qsort_r)(void *base, size_t nmemb, size_t size, void *context, int (*compar)(void *, const void *, const void *))"
+ "" "stdlib.h" GIT_QSORT_BSD)
+
+# GNU or POSIX qsort_r() has the 'context' parameter as the last argument of the
+# comparison function:
+check_prototype_definition_safe(qsort_r
+ "void (qsort_r)(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *, void *), void *context)"
+ "" "stdlib.h" GIT_QSORT_GNU)
+
+# C11 qsort_s() has the 'context' parameter as the last argument of the
+# comparison function, and returns an error status:
+check_prototype_definition_safe(qsort_s
+ "errno_t (qsort_s)(void *base, rsize_t nmemb, rsize_t size, int (*compar)(const void *, const void *, void *), void *context)"
+ "0" "stdlib.h" GIT_QSORT_C11)
+
+# MSC qsort_s() has the 'context' parameter as the first argument of the
+# comparison function, and as the last argument of qsort_s():
+check_prototype_definition_safe(qsort_s
+ "void (qsort_s)(void *base, size_t num, size_t width, int (*compare )(void *, const void *, const void *), void *context)"
+ "" "stdlib.h" GIT_QSORT_MSC)
-check_prototype_definition(qsort_r
- "void qsort_r(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *, void *), void *arg)"
- "" "stdlib.h" GIT_QSORT_R_GNU)
+# random / entropy data
-check_function_exists(qsort_s GIT_QSORT_S)
+check_symbol_exists(getentropy unistd.h GIT_RAND_GETENTROPY)
+check_symbol_exists(getloadavg stdlib.h GIT_RAND_GETLOADAVG)
-# random / entropy data
+# poll
-check_function_exists(getentropy GIT_RAND_GETENTROPY)
-check_function_exists(getloadavg GIT_RAND_GETLOADAVG)
+if(WIN32)
+ set(GIT_IO_WSAPOLL 1)
+else()
+ check_symbol_exists(poll poll.h GIT_IO_POLL)
+ check_symbol_exists(select sys/select.h GIT_IO_SELECT)
+endif()
# determine architecture of the machine
@@ -85,26 +111,11 @@ else()
message(FATAL_ERROR "Unsupported architecture (CMAKE_SIZEOF_VOID_P is unset)")
endif()
-# nanosecond mtime/ctime support
-
-if(USE_NSEC)
- set(GIT_USE_NSEC 1)
-endif()
-
-# high-resolution stat support
-
-if(HAVE_STRUCT_STAT_ST_MTIM)
- set(GIT_USE_STAT_MTIM 1)
-elseif(HAVE_STRUCT_STAT_ST_MTIMESPEC)
- set(GIT_USE_STAT_MTIMESPEC 1)
-elseif(HAVE_STRUCT_STAT_ST_MTIME_NSEC)
- set(GIT_USE_STAT_MTIME_NSEC 1)
-endif()
-
# realtime support
check_library_exists(rt clock_gettime "time.h" NEED_LIBRT)
-if(NEED_LIBRT)
+
+if(NEED_LIBRT AND NOT CMAKE_SYSTEM_NAME MATCHES "iOS")
list(APPEND LIBGIT2_SYSTEM_LIBS rt)
list(APPEND LIBGIT2_PC_LIBS "-lrt")
endif()
@@ -112,7 +123,8 @@ endif()
# platform libraries
if(WIN32)
- list(APPEND LIBGIT2_SYSTEM_LIBS ws2_32)
+ list(APPEND LIBGIT2_SYSTEM_LIBS "ws2_32" "secur32")
+ list(APPEND LIBGIT2_PC_LIBS "-lws2_32" "-lsecur32")
endif()
if(CMAKE_SYSTEM_NAME MATCHES "(Solaris|SunOS)")
@@ -129,46 +141,13 @@ if(AMIGA)
add_definitions(-DNO_ADDRINFO -DNO_READDIR_R -DNO_MMAP)
endif()
-# threads
-
-if(USE_THREADS)
- if(NOT WIN32)
- find_package(Threads REQUIRED)
- list(APPEND LIBGIT2_SYSTEM_LIBS ${CMAKE_THREAD_LIBS_INIT})
- list(APPEND LIBGIT2_PC_LIBS ${CMAKE_THREAD_LIBS_INIT})
- endif()
-
- set(GIT_THREADS 1)
-endif()
-add_feature_info(threadsafe USE_THREADS "threadsafe support")
-
#
-# Optional bundled features
+# Set build time information
#
-# ntlmclient
-if(USE_NTLMCLIENT)
- set(GIT_NTLM 1)
- add_subdirectory("${PROJECT_SOURCE_DIR}/deps/ntlmclient" "${PROJECT_BINARY_DIR}/deps/ntlmclient")
- list(APPEND LIBGIT2_DEPENDENCY_INCLUDES "${PROJECT_SOURCE_DIR}/deps/ntlmclient")
- list(APPEND LIBGIT2_DEPENDENCY_OBJECTS "$")
-endif()
-add_feature_info(ntlmclient GIT_NTLM "NTLM authentication support for Unix")
-
-#
-# Optional external dependencies
-
-# iconv
-if(USE_ICONV)
- find_package(Iconv)
-endif()
-if(ICONV_FOUND)
- set(GIT_USE_ICONV 1)
- list(APPEND LIBGIT2_SYSTEM_INCLUDES ${ICONV_INCLUDE_DIR})
- list(APPEND LIBGIT2_SYSTEM_LIBS ${ICONV_LIBRARIES})
- list(APPEND LIBGIT2_PC_LIBS ${ICONV_LIBRARIES})
-endif()
-add_feature_info(iconv GIT_USE_ICONV "iconv encoding conversion support")
+set(GIT_BUILD_CPU "${CMAKE_SYSTEM_PROCESSOR}")
+execute_process(COMMAND git rev-parse HEAD
+ OUTPUT_VARIABLE GIT_BUILD_COMMIT OUTPUT_STRIP_TRAILING_WHITESPACE)
#
# Include child projects
@@ -177,7 +156,7 @@ add_feature_info(iconv GIT_USE_ICONV "iconv encoding conversion support")
add_subdirectory(libgit2)
add_subdirectory(util)
-if(BUILD_CLI)
+if(BUILD_CLI AND NOT CMAKE_SYSTEM_NAME MATCHES "iOS")
add_subdirectory(cli)
endif()
diff --git a/src/cli/CMakeLists.txt b/src/cli/CMakeLists.txt
index ac1659c17fe..d121c588a6c 100644
--- a/src/cli/CMakeLists.txt
+++ b/src/cli/CMakeLists.txt
@@ -1,11 +1,11 @@
set(CLI_INCLUDES
"${libgit2_BINARY_DIR}/src/util"
"${libgit2_BINARY_DIR}/include"
- "${libgit2_BINARY_DIR}/include/git2"
"${libgit2_SOURCE_DIR}/src/util"
"${libgit2_SOURCE_DIR}/src/cli"
"${libgit2_SOURCE_DIR}/include"
- "${LIBGIT2_DEPENDENCY_INCLUDES}")
+ "${LIBGIT2_DEPENDENCY_INCLUDES}"
+ "${LIBGIT2_SYSTEM_INCLUDES}")
if(WIN32 AND NOT CYGWIN)
file(GLOB CLI_SRC_OS win32/*.c)
@@ -40,7 +40,6 @@ add_executable(git2_cli ${CLI_SRC_C} ${CLI_SRC_OS} ${CLI_OBJECTS}
${LIBGIT2_DEPENDENCY_OBJECTS})
target_link_libraries(git2_cli ${CLI_LIBGIT2_LIBRARY} ${LIBGIT2_SYSTEM_LIBS})
-set_target_properties(git2_cli PROPERTIES C_STANDARD 90)
set_target_properties(git2_cli PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${libgit2_BINARY_DIR})
set_target_properties(git2_cli PROPERTIES OUTPUT_NAME ${LIBGIT2_FILENAME})
diff --git a/src/cli/cmd.c b/src/cli/cmd.c
index 2a7e71cdbcb..0b1fafb4423 100644
--- a/src/cli/cmd.c
+++ b/src/cli/cmd.c
@@ -5,7 +5,7 @@
* a Linking Exception. For full terms see the included COPYING file.
*/
-#include "cli.h"
+#include "common.h"
#include "cmd.h"
const cli_cmd_spec *cli_cmd_spec_byname(const char *name)
diff --git a/src/cli/cmd.h b/src/cli/cmd.h
index 8b1a1b38fd7..bce4709fb7a 100644
--- a/src/cli/cmd.h
+++ b/src/cli/cmd.h
@@ -25,9 +25,14 @@ extern const cli_cmd_spec cli_cmds[];
extern const cli_cmd_spec *cli_cmd_spec_byname(const char *name);
/* Commands */
+extern int cmd_blame(int argc, char **argv);
extern int cmd_cat_file(int argc, char **argv);
extern int cmd_clone(int argc, char **argv);
+extern int cmd_config(int argc, char **argv);
extern int cmd_hash_object(int argc, char **argv);
extern int cmd_help(int argc, char **argv);
+extern int cmd_index_pack(int argc, char **argv);
+extern int cmd_init(int argc, char **argv);
+extern int cmd_version(int argc, char **argv);
#endif /* CLI_cmd_h__ */
diff --git a/src/cli/cmd_blame.c b/src/cli/cmd_blame.c
new file mode 100644
index 00000000000..180a948f987
--- /dev/null
+++ b/src/cli/cmd_blame.c
@@ -0,0 +1,287 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include
+#include
+#include "common.h"
+#include "cmd.h"
+#include "error.h"
+#include "sighandler.h"
+#include "progress.h"
+
+#include "fs_path.h"
+#include "futils.h"
+#include "date.h"
+#include "hashmap.h"
+
+#define COMMAND_NAME "blame"
+
+static char *file;
+static int porcelain, line_porcelain;
+
+static const cli_opt_spec opts[] = {
+ CLI_COMMON_OPT,
+
+ { CLI_OPT_TYPE_SWITCH, "porcelain", 'p', &porcelain, 1,
+ CLI_OPT_USAGE_DEFAULT, NULL, "show machine readable output" },
+ { CLI_OPT_TYPE_SWITCH, "line-porcelain", 0, &line_porcelain, 1,
+ CLI_OPT_USAGE_DEFAULT, NULL, "show individual lines in machine readable output" },
+ { CLI_OPT_TYPE_LITERAL },
+ { CLI_OPT_TYPE_ARG, "file", 0, &file, 0,
+ CLI_OPT_USAGE_REQUIRED, "file", "file to blame" },
+
+ { 0 }
+};
+
+static void print_help(void)
+{
+ cli_opt_usage_fprint(stdout, PROGRAM_NAME, COMMAND_NAME, opts, 0);
+ printf("\n");
+
+ printf("Show the origin of each line of a file.\n");
+ printf("\n");
+
+ printf("Options:\n");
+
+ cli_opt_help_fprint(stdout, opts);
+}
+
+static int strintlen(size_t n)
+{
+ int len = 1;
+
+ while (n > 10) {
+ n /= 10;
+ len++;
+
+ if (len == INT_MAX)
+ break;
+ }
+
+ return len;
+}
+
+static int fmt_date(git_str *out, git_time_t time, int offset)
+{
+ time_t t;
+ struct tm gmt;
+
+ GIT_ASSERT_ARG(out);
+
+ t = (time_t)(time + offset * 60);
+
+ if (p_gmtime_r(&t, &gmt) == NULL)
+ return -1;
+
+ return git_str_printf(out, "%.4u-%02u-%02u %02u:%02u:%02u %+03d%02d",
+ gmt.tm_year + 1900, gmt.tm_mon + 1, gmt.tm_mday,
+ gmt.tm_hour, gmt.tm_min, gmt.tm_sec,
+ offset / 60, offset % 60);
+}
+
+static int print_standard(git_blame *blame)
+{
+ size_t max_line_number = 0;
+ int max_lineno_len, max_line_len, max_author_len = 0, max_path_len = 0;
+ const char *last_path = NULL;
+ const git_blame_line *line;
+ bool paths_differ = false;
+ git_str date_str = GIT_STR_INIT;
+ size_t i;
+ int ret = 0;
+
+ /* Compute the maximum size of things */
+ for (i = 0; i < git_blame_hunkcount(blame); i++) {
+ const git_blame_hunk *hunk = git_blame_hunk_byindex(blame, i);
+ size_t hunk_author_len = strlen(hunk->orig_signature->name);
+ size_t hunk_path_len = strlen(hunk->orig_path);
+ size_t hunk_max_line_number =
+ hunk->orig_start_line_number + hunk->lines_in_hunk;
+
+ if (hunk_max_line_number > max_line_number)
+ max_line_number = hunk_max_line_number;
+
+ if (hunk_author_len > INT_MAX)
+ max_author_len = INT_MAX;
+ else if ((int)hunk_author_len > max_author_len)
+ max_author_len = (int)hunk_author_len;
+
+ if (hunk_path_len > INT_MAX)
+ hunk_path_len = INT_MAX;
+ else if ((int)hunk_path_len > max_path_len)
+ max_path_len = (int)hunk_path_len;
+
+ if (!paths_differ && last_path != NULL &&
+ strcmp(last_path, hunk->orig_path) != 0) {
+ paths_differ = true;
+ }
+
+ last_path = hunk->orig_path;
+ }
+
+ max_lineno_len = strintlen(max_line_number);
+
+ max_author_len--;
+
+ for (i = 1; i < git_blame_linecount(blame); i++) {
+ const git_blame_hunk *hunk = git_blame_hunk_byline(blame, i);
+ int oid_abbrev;
+
+ if (!hunk)
+ break;
+
+ oid_abbrev = hunk->boundary ? 7 : 8;
+ printf("%s%.*s ", hunk->boundary ? "^" : "",
+ oid_abbrev, git_oid_tostr_s(&hunk->orig_commit_id));
+
+ if (paths_differ)
+ printf("%-*.*s ", max_path_len, max_path_len, hunk->orig_path);
+
+ git_str_clear(&date_str);
+ if (fmt_date(&date_str,
+ hunk->orig_signature->when.time,
+ hunk->orig_signature->when.offset) < 0) {
+ ret = cli_error_git();
+ goto done;
+ }
+
+ if ((line = git_blame_line_byindex(blame, i)) == NULL) {
+ ret = cli_error_git();
+ goto done;
+ }
+
+ max_line_len = (int)min(line->len, INT_MAX);
+
+ printf("(%-*.*s %s %*" PRIuZ ") %.*s" ,
+ max_author_len, max_author_len, hunk->orig_signature->name,
+ date_str.ptr,
+ max_lineno_len, i,
+ max_line_len, line->ptr);
+ printf("\n");
+ }
+
+done:
+ git_str_dispose(&date_str);
+ return ret;
+}
+
+GIT_INLINE(uint32_t) oid_hashcode(const git_oid *oid)
+{
+ uint32_t hash;
+ memcpy(&hash, oid->id, sizeof(uint32_t));
+ return hash;
+}
+
+GIT_HASHSET_SETUP(git_blame_commitmap, const git_oid *, oid_hashcode, git_oid_equal);
+
+static int print_porcelain(git_blame *blame)
+{
+ git_blame_commitmap seen_ids = GIT_HASHSET_INIT;
+ size_t i, j;
+
+ for (i = 0; i < git_blame_hunkcount(blame); i++) {
+ const git_blame_line *line;
+ const git_blame_hunk *hunk = git_blame_hunk_byindex(blame, i);
+
+ for (j = 0; j < hunk->lines_in_hunk; j++) {
+ size_t line_number = hunk->final_start_line_number + j;
+ bool seen = git_blame_commitmap_contains(&seen_ids, &hunk->orig_commit_id);
+
+ printf("%s %" PRIuZ " %" PRIuZ,
+ git_oid_tostr_s(&hunk->orig_commit_id),
+ hunk->orig_start_line_number + j,
+ hunk->final_start_line_number + j);
+
+ if (!j)
+ printf(" %" PRIuZ, hunk->lines_in_hunk);
+
+ printf("\n");
+
+ if ((!j && !seen) || line_porcelain) {
+ printf("author %s\n", hunk->orig_signature->name);
+ printf("author-mail <%s>\n", hunk->orig_signature->email);
+ printf("author-time %" PRId64 "\n", hunk->orig_signature->when.time);
+ printf("author-tz %+03d%02d\n",
+ hunk->orig_signature->when.offset / 60,
+ hunk->orig_signature->when.offset % 60);
+
+ printf("committer %s\n", hunk->orig_committer->name);
+ printf("committer-mail <%s>\n", hunk->orig_committer->email);
+ printf("committer-time %" PRId64 "\n", hunk->orig_committer->when.time);
+ printf("committer-tz %+03d%02d\n",
+ hunk->orig_committer->when.offset / 60,
+ hunk->orig_committer->when.offset % 60);
+
+ printf("summary %s\n", hunk->summary);
+
+ /* TODO: previous */
+
+ printf("filename %s\n", hunk->orig_path);
+ }
+
+ if ((line = git_blame_line_byindex(blame, line_number)) == NULL)
+ return cli_error_git();
+
+ printf("\t%.*s\n", (int)min(line->len, INT_MAX),
+ line->ptr);
+
+ if (!seen)
+ git_blame_commitmap_add(&seen_ids, &hunk->orig_commit_id);
+ }
+ }
+
+ git_blame_commitmap_dispose(&seen_ids);
+ return 0;
+}
+
+int cmd_blame(int argc, char **argv)
+{
+ cli_repository_open_options open_opts = { argv + 1, argc - 1 };
+ git_blame_options blame_opts = GIT_BLAME_OPTIONS_INIT;
+ git_repository *repo = NULL;
+ git_str workdir_path = GIT_STR_INIT;
+ git_blame *blame = NULL;
+ cli_opt invalid_opt;
+ int ret = 0;
+
+ blame_opts.flags |= GIT_BLAME_USE_MAILMAP;
+
+ if (cli_opt_parse(&invalid_opt, opts, argv + 1, argc - 1, CLI_OPT_PARSE_GNU))
+ return cli_opt_usage_error(COMMAND_NAME, opts, &invalid_opt);
+
+ if (cli_opt__show_help) {
+ print_help();
+ return 0;
+ }
+
+ if (!file) {
+ ret = cli_error_usage("you must specify a file to blame");
+ goto done;
+ }
+
+ if (cli_repository_open(&repo, &open_opts) < 0)
+ return cli_error_git();
+
+ if ((ret = cli_resolve_path(&workdir_path, repo, file)) != 0)
+ goto done;
+
+ if (git_blame_file(&blame, repo, workdir_path.ptr, &blame_opts) < 0) {
+ ret = cli_error_git();
+ goto done;
+ }
+
+ if (porcelain || line_porcelain)
+ ret = print_porcelain(blame);
+ else
+ ret = print_standard(blame);
+
+done:
+ git_str_dispose(&workdir_path);
+ git_blame_free(blame);
+ git_repository_free(repo);
+ return ret;
+}
diff --git a/src/cli/cmd_cat_file.c b/src/cli/cmd_cat_file.c
index fb53a722ba2..95a0240cae8 100644
--- a/src/cli/cmd_cat_file.c
+++ b/src/cli/cmd_cat_file.c
@@ -6,7 +6,7 @@
*/
#include
-#include "cli.h"
+#include "common.h"
#include "cmd.h"
#define COMMAND_NAME "cat-file"
@@ -19,14 +19,11 @@ typedef enum {
DISPLAY_TYPE
} display_t;
-static int show_help;
static int display = DISPLAY_CONTENT;
static char *type_name, *object_spec;
static const cli_opt_spec opts[] = {
- { CLI_OPT_TYPE_SWITCH, "help", 0, &show_help, 1,
- CLI_OPT_USAGE_HIDDEN | CLI_OPT_USAGE_STOP_PARSING, NULL,
- "display help about the " COMMAND_NAME " command" },
+ CLI_COMMON_OPT,
{ CLI_OPT_TYPE_SWITCH, NULL, 't', &display, DISPLAY_TYPE,
CLI_OPT_USAGE_REQUIRED, NULL, "display the type of the object" },
@@ -45,7 +42,7 @@ static const cli_opt_spec opts[] = {
static void print_help(void)
{
- cli_opt_usage_fprint(stdout, PROGRAM_NAME, COMMAND_NAME, opts);
+ cli_opt_usage_fprint(stdout, PROGRAM_NAME, COMMAND_NAME, opts, 0);
printf("\n");
printf("Display the content for the given object in the repository.\n");
@@ -139,6 +136,7 @@ static int print_pretty(git_object *object)
int cmd_cat_file(int argc, char **argv)
{
+ cli_repository_open_options open_opts = { argv + 1, argc - 1};
git_repository *repo = NULL;
git_object *object = NULL;
git_object_t type;
@@ -148,12 +146,12 @@ int cmd_cat_file(int argc, char **argv)
if (cli_opt_parse(&invalid_opt, opts, argv + 1, argc - 1, CLI_OPT_PARSE_GNU))
return cli_opt_usage_error(COMMAND_NAME, opts, &invalid_opt);
- if (show_help) {
+ if (cli_opt__show_help) {
print_help();
return 0;
}
- if (git_repository_open_ext(&repo, ".", GIT_REPOSITORY_OPEN_FROM_ENV, NULL) < 0)
+ if (cli_repository_open(&repo, &open_opts) < 0)
return cli_error_git();
if ((giterr = git_revparse_single(&object, repo, object_spec)) < 0) {
diff --git a/src/cli/cmd_clone.c b/src/cli/cmd_clone.c
index a382b5875df..c18cb28d4e0 100644
--- a/src/cli/cmd_clone.c
+++ b/src/cli/cmd_clone.c
@@ -7,7 +7,7 @@
#include
#include
-#include "cli.h"
+#include "common.h"
#include "cmd.h"
#include "error.h"
#include "sighandler.h"
@@ -18,15 +18,13 @@
#define COMMAND_NAME "clone"
-static char *branch, *remote_path, *local_path;
-static int show_help, quiet, checkout = 1, bare;
+static char *branch, *remote_path, *local_path, *depth;
+static int quiet, checkout = 1, bare;
static bool local_path_exists;
static cli_progress progress = CLI_PROGRESS_INIT;
static const cli_opt_spec opts[] = {
- { CLI_OPT_TYPE_SWITCH, "help", 0, &show_help, 1,
- CLI_OPT_USAGE_HIDDEN | CLI_OPT_USAGE_STOP_PARSING, NULL,
- "display help about the " COMMAND_NAME " command" },
+ CLI_COMMON_OPT,
{ CLI_OPT_TYPE_SWITCH, "quiet", 'q', &quiet, 1,
CLI_OPT_USAGE_DEFAULT, NULL, "display the type of the object" },
@@ -36,6 +34,8 @@ static const cli_opt_spec opts[] = {
CLI_OPT_USAGE_DEFAULT, NULL, "don't create a working directory" },
{ CLI_OPT_TYPE_VALUE, "branch", 'b', &branch, 0,
CLI_OPT_USAGE_DEFAULT, "name", "branch to check out" },
+ { CLI_OPT_TYPE_VALUE, "depth", 0, &depth, 0,
+ CLI_OPT_USAGE_DEFAULT, "depth", "commit depth to check out " },
{ CLI_OPT_TYPE_LITERAL },
{ CLI_OPT_TYPE_ARG, "repository", 0, &remote_path, 0,
CLI_OPT_USAGE_REQUIRED, "repository", "repository path" },
@@ -46,7 +46,7 @@ static const cli_opt_spec opts[] = {
static void print_help(void)
{
- cli_opt_usage_fprint(stdout, PROGRAM_NAME, COMMAND_NAME, opts);
+ cli_opt_usage_fprint(stdout, PROGRAM_NAME, COMMAND_NAME, opts, 0);
printf("\n");
printf("Clone a repository into a new directory.\n");
@@ -71,6 +71,22 @@ static char *compute_local_path(const char *orig_path)
return local_path;
}
+static int compute_depth(const char *depth)
+{
+ int64_t i;
+ const char *endptr;
+
+ if (!depth)
+ return 0;
+
+ if (git__strntol64(&i, depth, strlen(depth), &endptr, 10) < 0 || i < 0 || i > INT_MAX || *endptr) {
+ fprintf(stderr, "fatal: depth '%s' is not valid.\n", depth);
+ exit(128);
+ }
+
+ return (int)i;
+}
+
static bool validate_local_path(const char *path)
{
if (!git_fs_path_exists(path))
@@ -117,7 +133,7 @@ int cmd_clone(int argc, char **argv)
if (cli_opt_parse(&invalid_opt, opts, argv + 1, argc - 1, CLI_OPT_PARSE_GNU))
return cli_opt_usage_error(COMMAND_NAME, opts, &invalid_opt);
- if (show_help) {
+ if (cli_opt__show_help) {
print_help();
return 0;
}
@@ -127,11 +143,9 @@ int cmd_clone(int argc, char **argv)
goto done;
}
- if (bare)
- clone_opts.bare = 1;
-
- if (branch)
- clone_opts.checkout_branch = branch;
+ clone_opts.bare = !!bare;
+ clone_opts.checkout_branch = branch;
+ clone_opts.fetch_opts.depth = compute_depth(depth);
if (!checkout)
clone_opts.checkout_opts.checkout_strategy = GIT_CHECKOUT_NONE;
diff --git a/src/cli/cmd_config.c b/src/cli/cmd_config.c
new file mode 100644
index 00000000000..9056e81f0b7
--- /dev/null
+++ b/src/cli/cmd_config.c
@@ -0,0 +1,241 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include
+
+#include "common.h"
+#include "cmd.h"
+
+#define COMMAND_NAME "config"
+
+typedef enum {
+ ACTION_NONE = 0,
+ ACTION_GET,
+ ACTION_ADD,
+ ACTION_REPLACE_ALL,
+ ACTION_LIST
+} action_t;
+
+static action_t action = ACTION_NONE;
+static int show_origin;
+static int show_scope;
+static int null_separator;
+static int config_level;
+static char *config_filename;
+static char *name, *value, *value_pattern;
+
+static const cli_opt_spec opts[] = {
+ CLI_COMMON_OPT, \
+
+ { CLI_OPT_TYPE_SWITCH, "null", 'z', &null_separator, 1,
+ 0, NULL, "use NUL as a separator" },
+
+ { CLI_OPT_TYPE_SWITCH, "system", 0, &config_level, GIT_CONFIG_LEVEL_SYSTEM,
+ 0, NULL, "read/write to system configuration" },
+ { CLI_OPT_TYPE_SWITCH, "global", 0, &config_level, GIT_CONFIG_LEVEL_GLOBAL,
+ CLI_OPT_USAGE_CHOICE, NULL, "read/write to global configuration" },
+ { CLI_OPT_TYPE_SWITCH, "local", 0, &config_level, GIT_CONFIG_LEVEL_LOCAL,
+ CLI_OPT_USAGE_CHOICE, NULL, "read/write to local configuration" },
+ { CLI_OPT_TYPE_VALUE, "file", 0, &config_filename, 0,
+ CLI_OPT_USAGE_CHOICE, "filename", "read/write to specified configuration file" },
+
+ { CLI_OPT_TYPE_SWITCH, "get", 0, &action, ACTION_GET,
+ CLI_OPT_USAGE_REQUIRED, NULL, "get a configuration value" },
+ { CLI_OPT_TYPE_SWITCH, "add", 0, &action, ACTION_ADD,
+ CLI_OPT_USAGE_CHOICE, NULL, "add a configuration value" },
+ { CLI_OPT_TYPE_SWITCH, "replace-all", 0, &action, ACTION_REPLACE_ALL,
+ CLI_OPT_USAGE_CHOICE, NULL, "add a configuration value, replacing any old values" },
+ { CLI_OPT_TYPE_SWITCH, "list", 'l', &action, ACTION_LIST,
+ CLI_OPT_USAGE_CHOICE | CLI_OPT_USAGE_SHOW_LONG,
+ NULL, "list all configuration entries" },
+ { CLI_OPT_TYPE_SWITCH, "show-origin", 0, &show_origin, 1,
+ 0, NULL, "show origin of configuration" },
+ { CLI_OPT_TYPE_SWITCH, "show-scope", 0, &show_scope, 1,
+ 0, NULL, "show scope of configuration" },
+ { CLI_OPT_TYPE_ARG, "name", 0, &name, 0,
+ 0, "name", "name of configuration entry" },
+ { CLI_OPT_TYPE_ARG, "value", 0, &value, 0,
+ 0, "value", "value of configuration entry" },
+ { CLI_OPT_TYPE_ARG, "regexp", 0, &value_pattern, 0,
+ 0, "regexp", "regular expression of values to replace" },
+ { 0 },
+};
+
+static void print_help(void)
+{
+ cli_opt_usage_fprint(stdout, PROGRAM_NAME, COMMAND_NAME, opts, 0);
+ printf("\n");
+
+ printf("Query and set configuration options.\n");
+ printf("\n");
+
+ printf("Options:\n");
+
+ cli_opt_help_fprint(stdout, opts);
+}
+
+static int get_config(git_config *config)
+{
+ git_buf value = GIT_BUF_INIT;
+ char sep = null_separator ? '\0' : '\n';
+ int error;
+
+ error = git_config_get_string_buf(&value, config, name);
+
+ if (error && error != GIT_ENOTFOUND)
+ return cli_error_git();
+
+ else if (error == GIT_ENOTFOUND)
+ return 1;
+
+ printf("%s%c", value.ptr, sep);
+ return 0;
+}
+
+static int add_config(git_config *config)
+{
+ if (git_config_set_multivar(config, name, "$^", value) < 0)
+ return cli_error_git();
+
+ return 0;
+}
+
+static int replace_all_config(git_config *config)
+{
+ if (git_config_set_multivar(config, name, value_pattern ? value_pattern : ".*", value) < 0)
+ return cli_error_git();
+
+ return 0;
+}
+
+static const char *level_name(git_config_level_t level)
+{
+ switch (level) {
+ case GIT_CONFIG_LEVEL_PROGRAMDATA:
+ return "programdata";
+ case GIT_CONFIG_LEVEL_SYSTEM:
+ return "system";
+ case GIT_CONFIG_LEVEL_XDG:
+ return "global";
+ case GIT_CONFIG_LEVEL_GLOBAL:
+ return "global";
+ case GIT_CONFIG_LEVEL_LOCAL:
+ return "local";
+ case GIT_CONFIG_LEVEL_APP:
+ return "command";
+ default:
+ return "unknown";
+ }
+}
+
+static int list_config(git_config *config)
+{
+ git_config_iterator *iterator;
+ git_config_entry *entry;
+ char data_separator = null_separator ? '\0' : '\t';
+ char kv_separator = null_separator ? '\n' : '=';
+ char entry_separator = null_separator ? '\0' : '\n';
+ int error;
+
+ if (git_config_iterator_new(&iterator, config) < 0)
+ return cli_error_git();
+
+ while ((error = git_config_next(&entry, iterator)) == 0) {
+ if (show_scope)
+ printf("%s%c",
+ level_name(entry->level),
+ data_separator);
+
+ if (show_origin)
+ printf("%s%s%s%c",
+ entry->backend_type ? entry->backend_type : "",
+ entry->backend_type && entry->origin_path ? ":" : "",
+ entry->origin_path ? entry->origin_path : "",
+ data_separator);
+
+ printf("%s%c%s%c", entry->name, kv_separator, entry->value,
+ entry_separator);
+ }
+
+ if (error != GIT_ITEROVER)
+ return cli_error_git();
+
+ git_config_iterator_free(iterator);
+ return 0;
+}
+
+int cmd_config(int argc, char **argv)
+{
+ git_repository *repo = NULL;
+ git_config *config = NULL;
+ cli_repository_open_options open_opts = { argv + 1, argc - 1};
+ cli_opt invalid_opt;
+ int ret = 0;
+
+ if (cli_opt_parse(&invalid_opt, opts, argv + 1, argc - 1, CLI_OPT_PARSE_GNU))
+ return cli_opt_usage_error(COMMAND_NAME, opts, &invalid_opt);
+
+ if (cli_opt__show_help) {
+ print_help();
+ return 0;
+ }
+
+ if (config_filename) {
+ if (git_config_new(&config) < 0 ||
+ git_config_add_file_ondisk(config, config_filename,
+ GIT_CONFIG_LEVEL_APP, NULL, 0) < 0) {
+ ret = cli_error_git();
+ goto done;
+ }
+ } else {
+ if (cli_repository_open(&repo, &open_opts) < 0 ||
+ git_repository_config(&config, repo) < 0) {
+ ret = cli_error_git();
+ goto done;
+ }
+
+ if (config_level &&
+ git_config_open_level(&config, config, config_level) < 0) {
+ ret = cli_error_git();
+ goto done;
+ }
+ }
+
+ switch (action) {
+ case ACTION_ADD:
+ if (!name || !value || value_pattern)
+ ret = cli_error_usage("%s --add requires two arguments", COMMAND_NAME);
+ else
+ ret = add_config(config);
+ break;
+ case ACTION_REPLACE_ALL:
+ if (!name || !value)
+ ret = cli_error_usage("%s --replace-all requires two or three arguments", COMMAND_NAME);
+ else
+ ret = replace_all_config(config);
+ break;
+ case ACTION_GET:
+ if (!name)
+ ret = cli_error_usage("%s --get requires an argument", COMMAND_NAME);
+ else
+ ret = get_config(config);
+ break;
+ case ACTION_LIST:
+ if (name)
+ ret = cli_error_usage("%s --list does not take an argument", COMMAND_NAME);
+ else
+ ret = list_config(config);
+ break;
+ default:
+ ret = cli_error_usage("unknown action");
+ }
+
+done:
+ git_config_free(config);
+ git_repository_free(repo);
+ return ret;
+}
diff --git a/src/cli/cmd_hash_object.c b/src/cli/cmd_hash_object.c
index 93b980d6676..94e7eb91f0d 100644
--- a/src/cli/cmd_hash_object.c
+++ b/src/cli/cmd_hash_object.c
@@ -6,22 +6,19 @@
*/
#include
-#include "cli.h"
+#include "common.h"
#include "cmd.h"
#include "futils.h"
#define COMMAND_NAME "hash-object"
-static int show_help;
static char *type_name;
static int write_object, read_stdin, literally;
static char **filenames;
static const cli_opt_spec opts[] = {
- { CLI_OPT_TYPE_SWITCH, "help", 0, &show_help, 1,
- CLI_OPT_USAGE_HIDDEN | CLI_OPT_USAGE_STOP_PARSING, NULL,
- "display help about the " COMMAND_NAME " command" },
+ CLI_COMMON_OPT,
{ CLI_OPT_TYPE_VALUE, NULL, 't', &type_name, 0,
CLI_OPT_USAGE_DEFAULT, "type", "the type of object to hash (default: \"blob\")" },
@@ -38,7 +35,7 @@ static const cli_opt_spec opts[] = {
static void print_help(void)
{
- cli_opt_usage_fprint(stdout, PROGRAM_NAME, COMMAND_NAME, opts);
+ cli_opt_usage_fprint(stdout, PROGRAM_NAME, COMMAND_NAME, opts, 0);
printf("\n");
printf("Compute the object ID for a given file and optionally write that file\nto the object database.\n");
@@ -92,6 +89,7 @@ static int hash_buf(
int cmd_hash_object(int argc, char **argv)
{
+ cli_repository_open_options open_opts = { argv + 1, argc - 1};
git_repository *repo = NULL;
git_odb *odb = NULL;
git_oid_t oid_type;
@@ -104,7 +102,7 @@ int cmd_hash_object(int argc, char **argv)
if (cli_opt_parse(&invalid_opt, opts, argv + 1, argc - 1, CLI_OPT_PARSE_GNU))
return cli_opt_usage_error(COMMAND_NAME, opts, &invalid_opt);
- if (show_help) {
+ if (cli_opt__show_help) {
print_help();
return 0;
}
@@ -113,7 +111,7 @@ int cmd_hash_object(int argc, char **argv)
return cli_error_usage("invalid object type '%s'", type_name);
if (write_object &&
- (git_repository_open_ext(&repo, ".", GIT_REPOSITORY_OPEN_FROM_ENV, NULL) < 0 ||
+ (cli_repository_open(&repo, &open_opts) < 0 ||
git_repository_odb(&odb, repo) < 0)) {
ret = cli_error_git();
goto done;
diff --git a/src/cli/cmd_help.c b/src/cli/cmd_help.c
index 7ee9822427c..c01163d3c89 100644
--- a/src/cli/cmd_help.c
+++ b/src/cli/cmd_help.c
@@ -7,17 +7,16 @@
#include
#include
-#include "cli.h"
+#include "common.h"
#include "cmd.h"
#define COMMAND_NAME "help"
static char *command;
-static int show_help;
static const cli_opt_spec opts[] = {
- { CLI_OPT_TYPE_SWITCH, "help", 0, &show_help, 1,
- CLI_OPT_USAGE_HIDDEN, NULL, "display help about the help command" },
+ CLI_COMMON_OPT,
+
{ CLI_OPT_TYPE_ARG, "command", 0, &command, 0,
CLI_OPT_USAGE_DEFAULT, "command", "the command to show help for" },
{ 0 },
@@ -25,7 +24,7 @@ static const cli_opt_spec opts[] = {
static int print_help(void)
{
- cli_opt_usage_fprint(stdout, PROGRAM_NAME, COMMAND_NAME, opts);
+ cli_opt_usage_fprint(stdout, PROGRAM_NAME, COMMAND_NAME, opts, CLI_OPT_USAGE_SHOW_HIDDEN);
printf("\n");
printf("Display help information about %s. If a command is specified, help\n", PROGRAM_NAME);
@@ -39,7 +38,7 @@ static int print_commands(void)
{
const cli_cmd_spec *cmd;
- cli_opt_usage_fprint(stdout, PROGRAM_NAME, NULL, cli_common_opts);
+ cli_opt_usage_fprint(stdout, PROGRAM_NAME, NULL, cli_common_opts, CLI_OPT_USAGE_SHOW_HIDDEN);
printf("\n");
printf("These are the %s commands available:\n\n", PROGRAM_NAME);
@@ -62,7 +61,7 @@ int cmd_help(int argc, char **argv)
return cli_opt_usage_error(COMMAND_NAME, opts, &invalid_opt);
/* Show the meta-help */
- if (show_help)
+ if (cli_opt__show_help)
return print_help();
/* We were not asked to show help for a specific command. */
diff --git a/src/cli/cmd_index_pack.c b/src/cli/cmd_index_pack.c
new file mode 100644
index 00000000000..6a67990b47d
--- /dev/null
+++ b/src/cli/cmd_index_pack.c
@@ -0,0 +1,114 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include
+#include "common.h"
+#include "cmd.h"
+#include "progress.h"
+
+#define COMMAND_NAME "index-pack"
+
+#define BUFFER_SIZE (1024 * 1024)
+
+static int verbose, read_stdin;
+static char *filename;
+static cli_progress progress = CLI_PROGRESS_INIT;
+
+static const cli_opt_spec opts[] = {
+ CLI_COMMON_OPT,
+
+ { CLI_OPT_TYPE_SWITCH, "verbose", 'v', &verbose, 1,
+ CLI_OPT_USAGE_DEFAULT, NULL, "display progress output" },
+
+ { CLI_OPT_TYPE_LITERAL },
+
+ { CLI_OPT_TYPE_SWITCH, "stdin", 0, &read_stdin, 1,
+ CLI_OPT_USAGE_REQUIRED, NULL, "read from stdin" },
+ { CLI_OPT_TYPE_ARG, "pack-file", 0, &filename, 0,
+ CLI_OPT_USAGE_CHOICE, "pack-file", "packfile path" },
+
+ { 0 },
+};
+
+static void print_help(void)
+{
+ cli_opt_usage_fprint(stdout, PROGRAM_NAME, COMMAND_NAME, opts, 0);
+ printf("\n");
+
+ printf("Indexes a packfile and writes the index to disk.\n");
+ printf("\n");
+
+ printf("Options:\n");
+
+ cli_opt_help_fprint(stdout, opts);
+}
+
+int cmd_index_pack(int argc, char **argv)
+{
+ cli_opt invalid_opt;
+ git_indexer *idx = NULL;
+ git_indexer_options idx_opts = GIT_INDEXER_OPTIONS_INIT;
+ git_indexer_progress stats = {0};
+ char buf[BUFFER_SIZE];
+ ssize_t read_len;
+ int fd, ret;
+
+ if (cli_opt_parse(&invalid_opt, opts, argv + 1, argc - 1, CLI_OPT_PARSE_GNU))
+ return cli_opt_usage_error(COMMAND_NAME, opts, &invalid_opt);
+
+ if (cli_opt__show_help) {
+ print_help();
+ return 0;
+ }
+
+ if (verbose) {
+ idx_opts.progress_cb = cli_progress_indexer;
+ idx_opts.progress_cb_payload = &progress;
+ }
+
+ if (read_stdin) {
+ fd = fileno(stdin);
+ } else if ((fd = p_open(filename, O_RDONLY)) < 0) {
+ ret = cli_error_git();
+ goto done;
+ }
+
+#ifdef GIT_EXPERIMENTAL_SHA256
+ idx_opts.oid_type = GIT_OID_SHA1;
+
+ ret = git_indexer_new(&idx, ".", &idx_opts);
+#else
+ ret = git_indexer_new(&idx, ".", 0, NULL, &idx_opts);
+#endif
+
+ if (ret < 0) {
+ ret = cli_error_git();
+ goto done;
+ }
+
+ while ((read_len = p_read(fd, buf, sizeof(buf))) > 0) {
+ if (git_indexer_append(idx, buf, (size_t)read_len, &stats) < 0) {
+ ret = cli_error_git();
+ goto done;
+ }
+ }
+
+ if (git_indexer_commit(idx, &stats) < 0) {
+ ret = cli_error_git();
+ goto done;
+ }
+
+ cli_progress_finish(&progress);
+
+done:
+ if (!read_stdin && fd >= 0)
+ p_close(fd);
+
+ cli_progress_dispose(&progress);
+ git_indexer_free(idx);
+ return ret;
+}
diff --git a/src/cli/cmd_init.c b/src/cli/cmd_init.c
new file mode 100644
index 00000000000..40037d6d6b4
--- /dev/null
+++ b/src/cli/cmd_init.c
@@ -0,0 +1,100 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include
+#include
+#include "common.h"
+#include "cmd.h"
+#include "error.h"
+#include "sighandler.h"
+#include "progress.h"
+
+#include "fs_path.h"
+#include "futils.h"
+
+#define COMMAND_NAME "init"
+
+static char *branch, *git_dir, *template_dir, *path;
+static int quiet, bare;
+
+static const cli_opt_spec opts[] = {
+ CLI_COMMON_OPT,
+
+ { CLI_OPT_TYPE_SWITCH, "quiet", 'q', &quiet, 1,
+ CLI_OPT_USAGE_DEFAULT, NULL, "quiet mode; don't display informational messages" },
+ { CLI_OPT_TYPE_SWITCH, "bare", 0, &bare, 1,
+ CLI_OPT_USAGE_DEFAULT, NULL, "don't create a working directory" },
+ { CLI_OPT_TYPE_VALUE, "initial-branch", 'b', &branch, 0,
+ CLI_OPT_USAGE_DEFAULT, "name", "initial branch name" },
+ { CLI_OPT_TYPE_VALUE, "separate-git-dir", 0, &git_dir, 0,
+ CLI_OPT_USAGE_DEFAULT, "git-dir", "path to separate git directory" },
+ { CLI_OPT_TYPE_VALUE, "template", 0, &template_dir, 0,
+ CLI_OPT_USAGE_DEFAULT, "template-dir", "path to git directory templates" },
+ { CLI_OPT_TYPE_LITERAL },
+ { CLI_OPT_TYPE_ARG, "directory", 0, &path, 0,
+ CLI_OPT_USAGE_DEFAULT, "directory", "directory to create repository in" },
+ { 0 }
+};
+
+static void print_help(void)
+{
+ cli_opt_usage_fprint(stdout, PROGRAM_NAME, COMMAND_NAME, opts, 0);
+ printf("\n");
+
+ printf("Create a new git repository.\n");
+ printf("\n");
+
+ printf("Options:\n");
+
+ cli_opt_help_fprint(stdout, opts);
+}
+
+int cmd_init(int argc, char **argv)
+{
+ git_repository *repo = NULL;
+ git_repository_init_options init_opts = GIT_REPOSITORY_INIT_OPTIONS_INIT;
+ cli_opt invalid_opt;
+ const char *repo_path;
+ int ret = 0;
+
+ if (cli_opt_parse(&invalid_opt, opts, argv + 1, argc - 1, CLI_OPT_PARSE_GNU))
+ return cli_opt_usage_error(COMMAND_NAME, opts, &invalid_opt);
+
+ if (cli_opt__show_help) {
+ print_help();
+ return 0;
+ }
+
+ init_opts.flags |= GIT_REPOSITORY_INIT_MKPATH |
+ GIT_REPOSITORY_INIT_EXTERNAL_TEMPLATE;
+
+ if (bare && git_dir)
+ return cli_error_usage("the '--bare' and '--separate-git-dir' options cannot be used together");
+
+ if (bare)
+ init_opts.flags |= GIT_REPOSITORY_INIT_BARE;
+
+ init_opts.template_path = template_dir;
+ init_opts.initial_head = branch;
+
+ if (git_dir) {
+ init_opts.workdir_path = path;
+ repo_path = git_dir;
+ } else {
+ repo_path = path;
+ }
+
+ if (git_repository_init_ext(&repo, repo_path, &init_opts) < 0) {
+ ret = cli_error_git();
+ } else if (!quiet) {
+ printf("Initialized empty Git repository in %s\n",
+ git_repository_path(repo));
+ }
+
+ git_repository_free(repo);
+ return ret;
+}
diff --git a/src/cli/cmd_version.c b/src/cli/cmd_version.c
new file mode 100644
index 00000000000..9c84068b6fb
--- /dev/null
+++ b/src/cli/cmd_version.c
@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include
+#include
+#include "common.h"
+#include "cmd.h"
+
+#define COMMAND_NAME "version"
+
+static int build_options;
+
+struct info_names {
+ int key;
+ const char *name;
+};
+
+static const struct info_names buildinfo_names[] = {
+ { GIT_BUILDINFO_CPU, "cpu" },
+ { GIT_BUILDINFO_COMMIT, "built from commit" },
+ { 0, NULL }
+};
+
+static const struct info_names feature_names[] = {
+ { GIT_FEATURE_SHA1, "sha1" },
+ { GIT_FEATURE_SHA256, "sha256" },
+ { GIT_FEATURE_THREADS, "threads" },
+ { GIT_FEATURE_NSEC, "nsec" },
+ { GIT_FEATURE_COMPRESSION, "compression" },
+ { GIT_FEATURE_I18N, "i18n" },
+ { GIT_FEATURE_REGEX, "regex" },
+ { GIT_FEATURE_SSH, "ssh" },
+ { GIT_FEATURE_HTTPS, "https" },
+ { GIT_FEATURE_HTTP_PARSER, "http_parser" },
+ { GIT_FEATURE_AUTH_NTLM, "auth_ntlm" },
+ { GIT_FEATURE_AUTH_NEGOTIATE, "auth_negotiate" },
+ { 0, NULL }
+};
+
+static const cli_opt_spec opts[] = {
+ CLI_COMMON_OPT,
+
+ { CLI_OPT_TYPE_SWITCH, "build-options", 0, &build_options, 1,
+ CLI_OPT_USAGE_DEFAULT, NULL, "show compile-time options" },
+ { 0 },
+};
+
+static int print_help(void)
+{
+ cli_opt_usage_fprint(stdout, PROGRAM_NAME, COMMAND_NAME, opts, 0);
+ printf("\n");
+
+ printf("Display version information for %s.\n", PROGRAM_NAME);
+ printf("\n");
+
+ printf("Options:\n");
+
+ cli_opt_help_fprint(stdout, opts);
+
+ return 0;
+}
+
+int cmd_version(int argc, char **argv)
+{
+ cli_opt invalid_opt;
+ const struct info_names *i;
+ const char *backend;
+ int supported_features;
+
+ if (cli_opt_parse(&invalid_opt, opts, argv + 1, argc - 1, CLI_OPT_PARSE_GNU))
+ return cli_opt_usage_error(COMMAND_NAME, opts, &invalid_opt);
+
+ if (cli_opt__show_help) {
+ print_help();
+ return 0;
+ }
+
+ printf("%s version %s\n", PROGRAM_NAME, LIBGIT2_VERSION);
+
+ if (build_options) {
+ supported_features = git_libgit2_features();
+
+ for (i = buildinfo_names; i->key; i++) {
+ const char *value = git_libgit2_buildinfo(i->key);
+
+ if (value && *value)
+ printf("%s: %s\n", i->name, value);
+ }
+
+ printf("sizeof-long: %" PRIuZ "\n", sizeof(long));
+ printf("sizeof-size_t: %" PRIuZ "\n", sizeof(size_t));
+
+ for (i = feature_names; i->key; i++) {
+ if (!(supported_features & i->key))
+ continue;
+
+ backend = git_libgit2_feature_backend(i->key);
+ printf("backend-%s: %s\n", i->name, backend);
+ }
+ }
+
+ return 0;
+}
diff --git a/src/cli/common.c b/src/cli/common.c
new file mode 100644
index 00000000000..dbeefea48ed
--- /dev/null
+++ b/src/cli/common.c
@@ -0,0 +1,168 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include
+#include
+
+#include "git2_util.h"
+#include "vector.h"
+#include "fs_path.h"
+
+#include "common.h"
+#include "error.h"
+
+static int parse_option(cli_opt *opt, void *data)
+{
+ git_str kv = GIT_STR_INIT, env = GIT_STR_INIT;
+ git_vector *cmdline_config = data;
+ int error = 0;
+
+ if (opt->spec && opt->spec->alias == 'c') {
+ if (git_str_puts(&kv, opt->value) < 0) {
+ error = cli_error_git();
+ goto done;
+ }
+ }
+
+ else if (opt->spec && !strcmp(opt->spec->name, "config-env")) {
+ char *val = strchr(opt->value, '=');
+
+ if (val == NULL || *(val + 1) == '\0') {
+ error = cli_error("invalid config format: '%s'", opt->value);
+ goto done;
+ }
+
+ if (git_str_put(&kv, opt->value, (val - opt->value)) < 0) {
+ error = cli_error_git();
+ goto done;
+ }
+
+ val++;
+
+ if ((error = git__getenv(&env, val)) == GIT_ENOTFOUND) {
+ error = cli_error("missing environment variable '%s' for configuration '%s'", val, kv.ptr);
+ goto done;
+ } else if (error) {
+ error = cli_error_git();
+ goto done;
+ }
+
+ if (git_str_putc(&kv, '=') < 0 ||
+ git_str_puts(&kv, env.ptr) < 0) {
+ error = cli_error_git();
+ goto done;
+ }
+ }
+
+ if (kv.size > 0 &&
+ git_vector_insert(cmdline_config, git_str_detach(&kv)) < 0)
+ error = cli_error_git();
+
+done:
+ git_str_dispose(&env);
+ git_str_dispose(&kv);
+ return error;
+}
+
+static int parse_common_options(
+ git_repository *repo,
+ cli_repository_open_options *opts)
+{
+ cli_opt_spec common_opts[] = {
+ { CLI_COMMON_OPT_CONFIG },
+ { CLI_COMMON_OPT_CONFIG_ENV },
+ { 0 }
+ };
+ git_config_backend_memory_options config_opts =
+ GIT_CONFIG_BACKEND_MEMORY_OPTIONS_INIT;
+ git_vector cmdline = GIT_VECTOR_INIT;
+ git_config *config = NULL;
+ git_config_backend *backend = NULL;
+ int error = 0;
+
+ config_opts.backend_type = "command line";
+
+ if ((error = cli_opt_foreach(common_opts, opts->args,
+ opts->args_len, CLI_OPT_PARSE_GNU, parse_option,
+ &cmdline)) < 0)
+ goto done;
+
+ if (git_vector_length(&cmdline) == 0)
+ goto done;
+
+ if (git_repository_config(&config, repo) < 0 ||
+ git_config_backend_from_values(&backend,
+ (const char **)cmdline.contents, cmdline.length,
+ &config_opts) < 0 ||
+ git_config_add_backend(config, backend, GIT_CONFIG_LEVEL_APP,
+ repo, 0) < 0)
+ error = cli_error_git();
+
+done:
+ if (error && backend)
+ backend->free(backend);
+ git_config_free(config);
+ git_vector_dispose_deep(&cmdline);
+ return error;
+}
+
+int cli_repository_open(
+ git_repository **out,
+ cli_repository_open_options *opts)
+{
+ git_repository *repo;
+
+ if (git_repository_open_ext(&repo, ".", GIT_REPOSITORY_OPEN_FROM_ENV, NULL) < 0)
+ return -1;
+
+ if (opts && parse_common_options(repo, opts) < 0)
+ return -1;
+
+ *out = repo;
+ return 0;
+}
+
+/*
+ * This resolves paths - not _pathspecs_ like git - it accepts an absolute
+ * path (to a path within the repository working directory) or a path
+ * relative to the current directory.
+ */
+int cli_resolve_path(git_str *out, git_repository *repo, const char *given_path)
+{
+ git_str path = GIT_STR_INIT;
+ int error = 0;
+
+ if (!git_fs_path_is_absolute(given_path)) {
+ char cwd[GIT_PATH_MAX];
+
+ if (p_getcwd(cwd, GIT_PATH_MAX) < 0)
+ error = cli_error_os();
+ else if (git_str_puts(&path, cwd) < 0 ||
+ git_fs_path_apply_relative(&path, given_path) < 0)
+ error = cli_error_git();
+
+ if (error)
+ goto done;
+ } else if (git_str_puts(&path, given_path) < 0) {
+ error = cli_error_git();
+ goto done;
+ }
+
+ error = git_fs_path_make_relative(&path, git_repository_workdir(repo));
+
+ if (error == GIT_ENOTFOUND)
+ error = cli_error("path '%s' is not inside the git repository '%s'",
+ given_path, git_repository_workdir(repo));
+ else if (error < 0)
+ error = cli_error_git();
+ else
+ git_str_swap(out, &path);
+
+done:
+ git_str_dispose(&path);
+ return error;
+}
diff --git a/src/cli/common.h b/src/cli/common.h
new file mode 100644
index 00000000000..330f776c91e
--- /dev/null
+++ b/src/cli/common.h
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#ifndef CLI_common_h__
+#define CLI_common_h__
+
+#define PROGRAM_NAME "git2"
+
+#include "git2_util.h"
+
+#include "error.h"
+#include "opt.h"
+#include "opt_usage.h"
+
+/*
+ * Common command arguments.
+ */
+
+extern int cli_opt__show_help;
+extern int cli_opt__use_pager;
+
+#define CLI_COMMON_OPT_HELP \
+ CLI_OPT_TYPE_SWITCH, "help", 0, &cli_opt__show_help, 1, \
+ CLI_OPT_USAGE_HIDDEN | CLI_OPT_USAGE_STOP_PARSING, \
+ NULL, "display help information"
+#define CLI_COMMON_OPT_CONFIG \
+ CLI_OPT_TYPE_VALUE, NULL, 'c', NULL, 0, \
+ CLI_OPT_USAGE_HIDDEN, \
+ "key=value", "add configuration value"
+#define CLI_COMMON_OPT_CONFIG_ENV \
+ CLI_OPT_TYPE_VALUE, "config-env", 0, NULL, 0, \
+ CLI_OPT_USAGE_HIDDEN, \
+ "key=value", "set configuration value to environment variable"
+#define CLI_COMMON_OPT_NO_PAGER \
+ CLI_OPT_TYPE_SWITCH, "no-pager", 0, &cli_opt__use_pager, 0, \
+ CLI_OPT_USAGE_HIDDEN, \
+ NULL, "don't paginate multi-page output"
+
+#define CLI_COMMON_OPT \
+ { CLI_COMMON_OPT_HELP }, \
+ { CLI_COMMON_OPT_CONFIG }, \
+ { CLI_COMMON_OPT_CONFIG_ENV }, \
+ { CLI_COMMON_OPT_NO_PAGER }
+
+typedef struct {
+ char **args;
+ int args_len;
+} cli_repository_open_options;
+
+extern int cli_repository_open(
+ git_repository **out,
+ cli_repository_open_options *opts);
+
+extern int cli_resolve_path(
+ git_str *out,
+ git_repository *repo,
+ const char *given_path);
+
+#endif /* CLI_common_h__ */
diff --git a/src/cli/error.h b/src/cli/error.h
index cce7a54c093..abf8a5160d1 100644
--- a/src/cli/error.h
+++ b/src/cli/error.h
@@ -8,7 +8,7 @@
#ifndef CLI_error_h__
#define CLI_error_h__
-#include "cli.h"
+#include "common.h"
#include
#define CLI_EXIT_OK 0
diff --git a/src/cli/main.c b/src/cli/main.c
index cbfc50eec35..4716d6ddee9 100644
--- a/src/cli/main.c
+++ b/src/cli/main.c
@@ -7,17 +7,19 @@
#include
#include
-#include "cli.h"
+#include "common.h"
#include "cmd.h"
-static int show_help = 0;
+int cli_opt__show_help = 0;
+int cli_opt__use_pager = 1;
+
static int show_version = 0;
static char *command = NULL;
static char **args = NULL;
const cli_opt_spec cli_common_opts[] = {
- { CLI_OPT_TYPE_SWITCH, "help", 0, &show_help, 1,
- CLI_OPT_USAGE_DEFAULT, NULL, "display help information" },
+ CLI_COMMON_OPT,
+
{ CLI_OPT_TYPE_SWITCH, "version", 0, &show_version, 1,
CLI_OPT_USAGE_DEFAULT, NULL, "display the version" },
{ CLI_OPT_TYPE_ARG, "command", 0, &command, 0,
@@ -28,21 +30,64 @@ const cli_opt_spec cli_common_opts[] = {
};
const cli_cmd_spec cli_cmds[] = {
+ { "blame", cmd_blame, "Show the origin of each line of a file" },
{ "cat-file", cmd_cat_file, "Display an object in the repository" },
{ "clone", cmd_clone, "Clone a repository into a new directory" },
+ { "config", cmd_config, "View or set configuration values " },
{ "hash-object", cmd_hash_object, "Hash a raw object and product its object ID" },
{ "help", cmd_help, "Display help information" },
+ { "index-pack", cmd_index_pack, "Create an index for a packfile" },
+ { "init", cmd_init, "Create a new git repository" },
+ { "version", cmd_version, "Show application version information" },
{ NULL }
};
+/*
+ * Reorder the argv as it was given, since git has the notion of global
+ * options (like `--help` or `-c key=val`) that we want to pass to the
+ * subcommand, and that can appear early in the arguments, before the
+ * command name. Put the command-name in argv[1] to allow easier parsing.
+ */
+static void reorder_args(char **argv, size_t first)
+{
+ char *tmp;
+ size_t i;
+
+ if (first == 1)
+ return;
+
+ tmp = argv[first];
+
+ for (i = first; i > 1; i--)
+ argv[i] = argv[i - 1];
+
+ argv[1] = tmp;
+}
+
+/*
+ * When invoked without a command, or just with `--help`, we invoke
+ * the help command; but we want to preserve only arguments that would
+ * be useful for that.
+ */
+static void help_args(int *argc, char **argv)
+{
+ cli_opt__show_help = 0;
+
+ argv[0] = "help";
+ *argc = 1;
+}
+
+static void version_args(int *argc, char **argv)
+{
+ argv[0] = "version";
+ *argc = 1;
+}
+
int main(int argc, char **argv)
{
const cli_cmd_spec *cmd;
cli_opt_parser optparser;
cli_opt opt;
- char *help_args[3] = { NULL };
- int help_args_len;
- int args_len = 0;
int ret = 0;
if (git_libgit2_init() < 0) {
@@ -56,7 +101,7 @@ int main(int argc, char **argv)
while (cli_opt_parser_next(&opt, &optparser)) {
if (!opt.spec) {
cli_opt_status_fprint(stderr, PROGRAM_NAME, &opt);
- cli_opt_usage_fprint(stderr, PROGRAM_NAME, NULL, cli_common_opts);
+ cli_opt_usage_fprint(stderr, PROGRAM_NAME, NULL, cli_common_opts, CLI_OPT_USAGE_SHOW_HIDDEN);
ret = CLI_EXIT_USAGE;
goto done;
}
@@ -66,30 +111,21 @@ int main(int argc, char **argv)
* remaining arguments as args for the command itself.
*/
if (command) {
- args = &argv[optparser.idx];
- args_len = (int)(argc - optparser.idx);
+ reorder_args(argv, optparser.idx);
break;
}
}
if (show_version) {
- printf("%s version %s\n", PROGRAM_NAME, LIBGIT2_VERSION);
+ version_args(&argc, argv);
+ ret = cmd_version(argc, argv);
goto done;
}
- /*
- * If `--help ` is specified, delegate to that command's
- * `--help` option. If no command is specified, run the `help`
- * command. Do this by updating the args to emulate that behavior.
- */
- if (!command || show_help) {
- help_args[0] = command ? (char *)command : "help";
- help_args[1] = command ? "--help" : NULL;
- help_args_len = command ? 2 : 1;
-
- command = help_args[0];
- args = help_args;
- args_len = help_args_len;
+ if (!command) {
+ help_args(&argc, argv);
+ ret = cmd_help(argc, argv);
+ goto done;
}
if ((cmd = cli_cmd_spec_byname(command)) == NULL) {
@@ -98,7 +134,7 @@ int main(int argc, char **argv)
goto done;
}
- ret = cmd->fn(args_len, args);
+ ret = cmd->fn(argc - 1, &argv[1]);
done:
git_libgit2_shutdown();
diff --git a/src/cli/opt.c b/src/cli/opt.c
index 62a3430d16e..204de10c271 100644
--- a/src/cli/opt.c
+++ b/src/cli/opt.c
@@ -10,7 +10,7 @@
* This file was produced by using the `rename.pl` script included with
* adopt. The command-line specified was:
*
- * ./rename.pl cli_opt --filename=opt --include=cli.h --inline=GIT_INLINE --header-guard=CLI_opt_h__ --lowercase-status --without-usage
+ * ./rename.pl cli_opt --filename=opt --include=common.h --inline=GIT_INLINE --header-guard=CLI_opt_h__ --lowercase-status --without-usage
*/
#include
@@ -19,7 +19,11 @@
#include
#include
-#include "cli.h"
+#if defined(__sun) || defined(__illumos__) || defined(__CYGWIN__)
+# include
+#endif
+
+#include "common.h"
#include "opt.h"
#ifdef _WIN32
@@ -73,7 +77,7 @@ GIT_INLINE(const cli_opt_spec *) spec_for_long(
/* Handle --option=value arguments */
if (spec->type == CLI_OPT_TYPE_VALUE &&
- eql &&
+ spec->name && eql &&
strncmp(arg, spec->name, eql_pos) == 0 &&
spec->name[eql_pos] == '\0') {
*has_value = 1;
@@ -575,6 +579,28 @@ cli_opt_status_t cli_opt_parse(
return validate_required(opt, specs, given_specs);
}
+int cli_opt_foreach(
+ const cli_opt_spec specs[],
+ char **args,
+ size_t args_len,
+ unsigned int flags,
+ int (*callback)(cli_opt *, void *),
+ void *callback_data)
+{
+ cli_opt_parser parser;
+ cli_opt opt;
+ int ret;
+
+ cli_opt_parser_init(&parser, specs, args, args_len, flags);
+
+ while (cli_opt_parser_next(&opt, &parser)) {
+ if ((ret = callback(&opt, callback_data)) != 0)
+ return ret;
+ }
+
+ return 0;
+}
+
static int spec_name_fprint(FILE *file, const cli_opt_spec *spec)
{
int error;
diff --git a/src/cli/opt.h b/src/cli/opt.h
index 6c1d4603ecd..226f74db8bc 100644
--- a/src/cli/opt.h
+++ b/src/cli/opt.h
@@ -10,7 +10,7 @@
* This file was produced by using the `rename.pl` script included with
* adopt. The command-line specified was:
*
- * ./rename.pl cli_opt --filename=opt --include=cli.h --inline=GIT_INLINE --header-guard=CLI_opt_h__ --lowercase-status --without-usage
+ * ./rename.pl cli_opt --filename=opt --include=common.h --inline=GIT_INLINE --header-guard=CLI_opt_h__ --lowercase-status --without-usage
*/
#ifndef CLI_opt_h__
@@ -275,8 +275,8 @@ typedef struct cli_opt_parser {
size_t arg_idx;
size_t in_args;
size_t in_short;
- int needs_sort : 1,
- in_literal : 1;
+ unsigned int needs_sort : 1,
+ in_literal : 1;
} cli_opt_parser;
/**
@@ -300,6 +300,24 @@ cli_opt_status_t cli_opt_parse(
size_t args_len,
unsigned int flags);
+/**
+ * Quickly executes the given callback for each argument.
+ *
+ * @param specs A NULL-terminated array of `cli_opt_spec`s that can be parsed
+ * @param args The arguments that will be parsed
+ * @param args_len The length of arguments to be parsed
+ * @param flags The `cli_opt_flag_t flags for parsing
+ * @param callback The callback to invoke for each specified option
+ * @param callback_data Data to be provided to the callback
+ */
+int cli_opt_foreach(
+ const cli_opt_spec specs[],
+ char **args,
+ size_t args_len,
+ unsigned int flags,
+ int (*callback)(cli_opt *, void *),
+ void *callback_data);
+
/**
* Initializes a parser that parses the given arguments according to the
* given specifications.
diff --git a/src/cli/opt_usage.c b/src/cli/opt_usage.c
index 478b416316d..b887509d7c2 100644
--- a/src/cli/opt_usage.c
+++ b/src/cli/opt_usage.c
@@ -5,35 +5,84 @@
* a Linking Exception. For full terms see the included COPYING file.
*/
-#include "cli.h"
+#include "common.h"
#include "str.h"
-static int print_spec_name(git_str *out, const cli_opt_spec *spec)
+#define is_switch_or_value(spec) \
+ ((spec)->type == CLI_OPT_TYPE_SWITCH || \
+ (spec)->type == CLI_OPT_TYPE_VALUE)
+
+static int print_spec_args(git_str *out, const cli_opt_spec *spec)
{
- if (spec->type == CLI_OPT_TYPE_VALUE && spec->alias &&
- !(spec->usage & CLI_OPT_USAGE_VALUE_OPTIONAL) &&
- !(spec->usage & CLI_OPT_USAGE_SHOW_LONG))
- return git_str_printf(out, "-%c <%s>", spec->alias, spec->value_name);
- if (spec->type == CLI_OPT_TYPE_VALUE && spec->alias &&
- !(spec->usage & CLI_OPT_USAGE_SHOW_LONG))
- return git_str_printf(out, "-%c [<%s>]", spec->alias, spec->value_name);
- if (spec->type == CLI_OPT_TYPE_VALUE &&
- !(spec->usage & CLI_OPT_USAGE_VALUE_OPTIONAL))
- return git_str_printf(out, "--%s[=<%s>]", spec->name, spec->value_name);
- if (spec->type == CLI_OPT_TYPE_VALUE)
- return git_str_printf(out, "--%s=<%s>", spec->name, spec->value_name);
+ GIT_ASSERT(!is_switch_or_value(spec));
+
if (spec->type == CLI_OPT_TYPE_ARG)
return git_str_printf(out, "<%s>", spec->value_name);
if (spec->type == CLI_OPT_TYPE_ARGS)
return git_str_printf(out, "<%s>...", spec->value_name);
if (spec->type == CLI_OPT_TYPE_LITERAL)
return git_str_printf(out, "--");
- if (spec->alias && !(spec->usage & CLI_OPT_USAGE_SHOW_LONG))
+
+ GIT_ASSERT(!"unknown option spec type");
+ return -1;
+}
+
+GIT_INLINE(int) print_spec_alias(git_str *out, const cli_opt_spec *spec)
+{
+ GIT_ASSERT(is_switch_or_value(spec) && spec->alias);
+
+ if (spec->type == CLI_OPT_TYPE_VALUE &&
+ !(spec->usage & CLI_OPT_USAGE_VALUE_OPTIONAL))
+ return git_str_printf(out, "-%c <%s>", spec->alias, spec->value_name);
+ else if (spec->type == CLI_OPT_TYPE_VALUE)
+ return git_str_printf(out, "-%c [<%s>]", spec->alias, spec->value_name);
+ else
return git_str_printf(out, "-%c", spec->alias);
- if (spec->name)
+}
+
+GIT_INLINE(int) print_spec_name(git_str *out, const cli_opt_spec *spec)
+{
+ GIT_ASSERT(is_switch_or_value(spec) && spec->name);
+
+ if (spec->type == CLI_OPT_TYPE_VALUE &&
+ !(spec->usage & CLI_OPT_USAGE_VALUE_OPTIONAL))
+ return git_str_printf(out, "--%s=<%s>", spec->name, spec->value_name);
+ else if (spec->type == CLI_OPT_TYPE_VALUE)
+ return git_str_printf(out, "--%s[=<%s>]", spec->name, spec->value_name);
+ else
return git_str_printf(out, "--%s", spec->name);
+}
+
+GIT_INLINE(int) print_spec_full(git_str *out, const cli_opt_spec *spec)
+{
+ int error = 0;
- GIT_ASSERT(0);
+ if (is_switch_or_value(spec)) {
+ if (spec->alias)
+ error |= print_spec_alias(out, spec);
+
+ if (spec->alias && spec->name)
+ error |= git_str_printf(out, ", ");
+
+ if (spec->name)
+ error |= print_spec_name(out, spec);
+ } else {
+ error |= print_spec_args(out, spec);
+ }
+
+ return error;
+}
+
+GIT_INLINE(int) print_spec(git_str *out, const cli_opt_spec *spec)
+{
+ if (is_switch_or_value(spec)) {
+ if (spec->alias && !(spec->usage & CLI_OPT_USAGE_SHOW_LONG))
+ return print_spec_alias(out, spec);
+ else
+ return print_spec_name(out, spec);
+ }
+
+ return print_spec_args(out, spec);
}
/*
@@ -46,7 +95,8 @@ int cli_opt_usage_fprint(
FILE *file,
const char *command,
const char *subcommand,
- const cli_opt_spec specs[])
+ const cli_opt_spec specs[],
+ unsigned int print_flags)
{
git_str usage = GIT_BUF_INIT, opt = GIT_BUF_INIT;
const cli_opt_spec *spec;
@@ -55,7 +105,7 @@ int cli_opt_usage_fprint(
int error;
/* TODO: query actual console width. */
- int console_width = 80;
+ int console_width = 78;
if ((error = git_str_printf(&usage, "usage: %s", command)) < 0)
goto done;
@@ -73,7 +123,8 @@ int cli_opt_usage_fprint(
next_choice = !!((spec + 1)->usage & CLI_OPT_USAGE_CHOICE);
- if (spec->usage & CLI_OPT_USAGE_HIDDEN)
+ if ((spec->usage & CLI_OPT_USAGE_HIDDEN) &&
+ !(print_flags & CLI_OPT_USAGE_SHOW_HIDDEN))
continue;
if (choice)
@@ -86,7 +137,7 @@ int cli_opt_usage_fprint(
if (!optional && !choice && next_choice)
git_str_putc(&opt, '(');
- if ((error = print_spec_name(&opt, spec)) < 0)
+ if ((error = print_spec(&opt, spec)) < 0)
goto done;
if (!optional && choice && !next_choice)
@@ -111,11 +162,11 @@ int cli_opt_usage_fprint(
git_str_putc(&usage, ' ');
linelen = prefixlen;
- } else {
- git_str_putc(&usage, ' ');
- linelen += git_str_len(&opt) + 1;
}
+ git_str_putc(&usage, ' ');
+ linelen += git_str_len(&opt) + 1;
+
git_str_puts(&usage, git_str_cstr(&opt));
if (git_str_oom(&usage)) {
@@ -140,7 +191,7 @@ int cli_opt_usage_error(
const cli_opt *invalid_opt)
{
cli_opt_status_fprint(stderr, PROGRAM_NAME, invalid_opt);
- cli_opt_usage_fprint(stderr, PROGRAM_NAME, subcommand, specs);
+ cli_opt_usage_fprint(stderr, PROGRAM_NAME, subcommand, specs, 0);
return CLI_EXIT_USAGE;
}
@@ -150,35 +201,53 @@ int cli_opt_help_fprint(
{
git_str help = GIT_BUF_INIT;
const cli_opt_spec *spec;
+ bool required;
int error = 0;
/* Display required arguments first */
for (spec = specs; spec->type; ++spec) {
- if (! (spec->usage & CLI_OPT_USAGE_REQUIRED) ||
- (spec->usage & CLI_OPT_USAGE_HIDDEN))
+ if ((spec->usage & CLI_OPT_USAGE_HIDDEN) ||
+ (spec->type == CLI_OPT_TYPE_LITERAL))
+ continue;
+
+ required = ((spec->usage & CLI_OPT_USAGE_REQUIRED) ||
+ ((spec->usage & CLI_OPT_USAGE_CHOICE) && required));
+
+ if (!required)
continue;
git_str_printf(&help, " ");
- if ((error = print_spec_name(&help, spec)) < 0)
+ if ((error = print_spec_full(&help, spec)) < 0)
goto done;
- git_str_printf(&help, ": %s\n", spec->help);
+ git_str_printf(&help, "\n");
+
+ if (spec->help)
+ git_str_printf(&help, " %s\n", spec->help);
}
/* Display the remaining arguments */
for (spec = specs; spec->type; ++spec) {
- if ((spec->usage & CLI_OPT_USAGE_REQUIRED) ||
- (spec->usage & CLI_OPT_USAGE_HIDDEN))
+ if ((spec->usage & CLI_OPT_USAGE_HIDDEN) ||
+ (spec->type == CLI_OPT_TYPE_LITERAL))
+ continue;
+
+ required = ((spec->usage & CLI_OPT_USAGE_REQUIRED) ||
+ ((spec->usage & CLI_OPT_USAGE_CHOICE) && required));
+
+ if (required)
continue;
git_str_printf(&help, " ");
- if ((error = print_spec_name(&help, spec)) < 0)
+ if ((error = print_spec_full(&help, spec)) < 0)
goto done;
- git_str_printf(&help, ": %s\n", spec->help);
+ git_str_printf(&help, "\n");
+ if (spec->help)
+ git_str_printf(&help, " %s\n", spec->help);
}
if (git_str_oom(&help) ||
diff --git a/src/cli/opt_usage.h b/src/cli/opt_usage.h
index c752494e1aa..b9b75b84b35 100644
--- a/src/cli/opt_usage.h
+++ b/src/cli/opt_usage.h
@@ -8,6 +8,10 @@
#ifndef CLI_opt_usage_h__
#define CLI_opt_usage_h__
+typedef enum {
+ CLI_OPT_USAGE_SHOW_HIDDEN = (1 << 0),
+} cli_opt_usage_flags;
+
/**
* Prints usage information to the given file handle.
*
@@ -21,7 +25,8 @@ int cli_opt_usage_fprint(
FILE *file,
const char *command,
const char *subcommand,
- const cli_opt_spec specs[]);
+ const cli_opt_spec specs[],
+ unsigned int print_flags);
int cli_opt_usage_error(
const char *subcommand,
diff --git a/src/cli/progress.c b/src/cli/progress.c
index ba52655e75e..d975b0954ac 100644
--- a/src/cli/progress.c
+++ b/src/cli/progress.c
@@ -15,10 +15,10 @@
/*
* Show updates to the percentage and number of objects received
* separately from the throughput to give an accurate progress while
- * avoiding too much noise on the screen.
+ * avoiding too much noise on the screen. (In milliseconds.)
*/
-#define PROGRESS_UPDATE_TIME 0.10
-#define THROUGHPUT_UPDATE_TIME 1.00
+#define PROGRESS_UPDATE_TIME 60
+#define THROUGHPUT_UPDATE_TIME 500
#define is_nl(c) ((c) == '\r' || (c) == '\n')
@@ -54,7 +54,7 @@ static int progress_write(cli_progress *progress, bool force, git_str *line)
bool has_nl;
size_t no_nl = no_nl_len(line->ptr, line->size);
size_t nl = nl_len(&has_nl, line->ptr + no_nl, line->size - no_nl);
- double now = git__timer();
+ uint64_t now = git_time_monotonic();
size_t i;
/* Avoid spamming the console with progress updates */
@@ -191,20 +191,21 @@ static int fetch_receiving(
{
char *recv_units[] = { "B", "KiB", "MiB", "GiB", "TiB", NULL };
char *rate_units[] = { "B/s", "KiB/s", "MiB/s", "GiB/s", "TiB/s", NULL };
+ uint64_t now, elapsed;
- double now, recv_len, rate, elapsed;
+ double recv_len, rate;
size_t recv_unit_idx = 0, rate_unit_idx = 0;
bool done = (stats->received_objects == stats->total_objects);
if (!progress->action_start)
- progress->action_start = git__timer();
+ progress->action_start = git_time_monotonic();
if (done && progress->action_finish)
now = progress->action_finish;
else if (done)
- progress->action_finish = now = git__timer();
+ progress->action_finish = now = git_time_monotonic();
else
- now = git__timer();
+ now = git_time_monotonic();
if (progress->throughput_update &&
now - progress->throughput_update < THROUGHPUT_UPDATE_TIME) {
@@ -241,7 +242,21 @@ static int fetch_receiving(
done ? ", done." : "");
}
-static int fetch_resolving(
+static int indexer_indexing(
+ cli_progress *progress,
+ const git_indexer_progress *stats)
+{
+ bool done = (stats->received_objects == stats->total_objects);
+
+ return progress_printf(progress, false,
+ "Indexing objects: %3d%% (%d/%d)%s\r",
+ percent(stats->received_objects, stats->total_objects),
+ stats->received_objects,
+ stats->total_objects,
+ done ? ", done." : "");
+}
+
+static int indexer_resolving(
cli_progress *progress,
const git_indexer_progress *stats)
{
@@ -282,7 +297,42 @@ int cli_progress_fetch_transfer(const git_indexer_progress *stats, void *payload
/* fall through */
case CLI_PROGRESS_RESOLVING:
- error = fetch_resolving(progress, stats);
+ error = indexer_resolving(progress, stats);
+ break;
+
+ default:
+ /* should not be reached */
+ GIT_ASSERT(!"unexpected progress state");
+ }
+
+ return error;
+}
+
+int cli_progress_indexer(
+ const git_indexer_progress *stats,
+ void *payload)
+{
+ cli_progress *progress = (cli_progress *)payload;
+ int error = 0;
+
+ switch (progress->action) {
+ case CLI_PROGRESS_NONE:
+ progress->action = CLI_PROGRESS_INDEXING;
+ /* fall through */
+
+ case CLI_PROGRESS_INDEXING:
+ if ((error = indexer_indexing(progress, stats)) < 0)
+ break;
+
+ if (stats->indexed_deltas == stats->total_deltas)
+ break;
+
+ progress_complete(progress);
+ progress->action = CLI_PROGRESS_RESOLVING;
+ /* fall through */
+
+ case CLI_PROGRESS_RESOLVING:
+ error = indexer_resolving(progress, stats);
break;
default:
diff --git a/src/cli/progress.h b/src/cli/progress.h
index 7a445ec2966..f08d68f19e4 100644
--- a/src/cli/progress.h
+++ b/src/cli/progress.h
@@ -22,6 +22,7 @@
typedef enum {
CLI_PROGRESS_NONE,
CLI_PROGRESS_RECEIVING,
+ CLI_PROGRESS_INDEXING,
CLI_PROGRESS_RESOLVING,
CLI_PROGRESS_CHECKING_OUT
} cli_progress_t;
@@ -30,11 +31,11 @@ typedef struct {
cli_progress_t action;
/* Actions may time themselves (eg fetch) but are not required to */
- double action_start;
- double action_finish;
+ uint64_t action_start;
+ uint64_t action_finish;
/* Last console update, avoid too frequent updates. */
- double last_update;
+ uint64_t last_update;
/* Accumulators for partial output and deferred updates. */
git_str sideband;
@@ -42,7 +43,7 @@ typedef struct {
git_str deferred;
/* Last update about throughput */
- double throughput_update;
+ uint64_t throughput_update;
double throughput_bytes;
} cli_progress;
@@ -74,6 +75,17 @@ extern int cli_progress_fetch_transfer(
const git_indexer_progress *stats,
void *payload);
+/**
+ * Prints indexer progress to the console. Suitable for a
+ * `progress_cb` callback for `git_indexer_options`.
+ *
+ * @param stats The indexer stats
+ * @param payload A pointer to the cli_progress
+ */
+extern int cli_progress_indexer(
+ const git_indexer_progress *stats,
+ void *payload);
+
/**
* Prints checkout progress to the console. Suitable for a
* `progress_cb` callback for `git_checkout_options`.
diff --git a/src/cli/unix/sighandler.c b/src/cli/unix/sighandler.c
index 6b4982d48f2..05ac8672cad 100644
--- a/src/cli/unix/sighandler.c
+++ b/src/cli/unix/sighandler.c
@@ -8,7 +8,8 @@
#include
#include
#include "git2_util.h"
-#include "cli.h"
+#include "common.h"
+#include "sighandler.h"
static void (*interrupt_handler)(void) = NULL;
diff --git a/src/cli/win32/precompiled.h b/src/cli/win32/precompiled.h
index b0309b864ad..031370e87e7 100644
--- a/src/cli/win32/precompiled.h
+++ b/src/cli/win32/precompiled.h
@@ -1,3 +1,3 @@
#include
-#include "cli.h"
+#include "common.h"
diff --git a/src/cli/win32/sighandler.c b/src/cli/win32/sighandler.c
index cc0b6464033..05a67fb14fe 100644
--- a/src/cli/win32/sighandler.c
+++ b/src/cli/win32/sighandler.c
@@ -8,7 +8,7 @@
#include "git2_util.h"
#include
-#include "cli.h"
+#include "sighandler.h"
static void (*interrupt_handler)(void) = NULL;
diff --git a/src/libgit2/CMakeLists.txt b/src/libgit2/CMakeLists.txt
index 03b57121291..0dddb025e14 100644
--- a/src/libgit2/CMakeLists.txt
+++ b/src/libgit2/CMakeLists.txt
@@ -2,15 +2,13 @@
# git library functionality.
add_library(libgit2 OBJECT)
-set_target_properties(libgit2 PROPERTIES C_STANDARD 90)
-set_target_properties(libgit2 PROPERTIES C_EXTENSIONS OFF)
include(PkgBuildConfig)
+include(CMakePackageConfigHelpers)
set(LIBGIT2_INCLUDES
"${PROJECT_BINARY_DIR}/src/util"
"${PROJECT_BINARY_DIR}/include"
- "${PROJECT_BINARY_DIR}/include/git2"
"${PROJECT_SOURCE_DIR}/src/libgit2"
"${PROJECT_SOURCE_DIR}/src/util"
"${PROJECT_SOURCE_DIR}/include")
@@ -25,8 +23,7 @@ target_sources(libgit2 PRIVATE ${SRC_H})
file(GLOB SRC_GIT2 *.c *.h
streams/*.c streams/*.h
- transports/*.c transports/*.h
- xdiff/*.c xdiff/*.h)
+ transports/*.c transports/*.h)
list(SORT SRC_GIT2)
target_sources(libgit2 PRIVATE ${SRC_GIT2})
@@ -40,23 +37,6 @@ if(APPLE)
set_source_files_properties(streams/stransport.c PROPERTIES COMPILE_FLAGS -Wno-deprecated)
endif()
-# the xdiff dependency is not (yet) warning-free, disable warnings
-# as errors for the xdiff sources until we've sorted them out
-if(MSVC)
- set_source_files_properties(xdiff/xdiffi.c PROPERTIES COMPILE_FLAGS -WX-)
- set_source_files_properties(xdiff/xemit.c PROPERTIES COMPILE_FLAGS -WX-)
- set_source_files_properties(xdiff/xhistogram.c PROPERTIES COMPILE_FLAGS -WX-)
- set_source_files_properties(xdiff/xmerge.c PROPERTIES COMPILE_FLAGS -WX-)
- set_source_files_properties(xdiff/xutils.c PROPERTIES COMPILE_FLAGS -WX-)
- set_source_files_properties(xdiff/xpatience.c PROPERTIES COMPILE_FLAGS -WX-)
-else()
- set_source_files_properties(xdiff/xdiffi.c PROPERTIES COMPILE_FLAGS "-Wno-sign-compare -Wno-unused-parameter")
- set_source_files_properties(xdiff/xemit.c PROPERTIES COMPILE_FLAGS "-Wno-sign-compare -Wno-unused-parameter")
- set_source_files_properties(xdiff/xhistogram.c PROPERTIES COMPILE_FLAGS "-Wno-sign-compare")
- set_source_files_properties(xdiff/xutils.c PROPERTIES COMPILE_FLAGS "-Wno-sign-compare")
- set_source_files_properties(xdiff/xpatience.c PROPERTIES COMPILE_FLAGS "-Wno-sign-compare")
-endif()
-
ide_split_sources(libgit2)
list(APPEND LIBGIT2_OBJECTS $ $ ${LIBGIT2_DEPENDENCY_OBJECTS})
list(APPEND LIBGIT2_INCLUDES ${LIBGIT2_DEPENDENCY_INCLUDES})
@@ -78,18 +58,14 @@ set(LIBGIT2_SYSTEM_LIBS ${LIBGIT2_SYSTEM_LIBS} PARENT_SCOPE)
add_library(libgit2package ${SRC_RC} ${LIBGIT2_OBJECTS})
target_link_libraries(libgit2package ${LIBGIT2_SYSTEM_LIBS})
target_include_directories(libgit2package SYSTEM PRIVATE ${LIBGIT2_INCLUDES})
+target_include_directories(libgit2package INTERFACE $)
set_target_properties(libgit2package PROPERTIES C_STANDARD 90)
+set_target_properties(libgit2package PROPERTIES C_EXTENSIONS OFF)
set_target_properties(libgit2package PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR})
set_target_properties(libgit2package PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR})
set_target_properties(libgit2package PROPERTIES ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR})
-# Workaround for Cmake bug #0011240 (see http://public.kitware.com/Bug/view.php?id=11240)
-# Win64+MSVC+static libs = linker error
-if(MSVC AND GIT_ARCH_64 AND NOT BUILD_SHARED_LIBS)
- set_target_properties(libgit2package PROPERTIES STATIC_LIBRARY_FLAGS "/MACHINE:x64")
-endif()
-
ide_split_sources(libgit2package)
if(SONAME)
@@ -127,9 +103,32 @@ FILE(READ "${PROJECT_SOURCE_DIR}/include/git2.h" LIBGIT2_INCLUDE)
STRING(REGEX REPLACE "#include \"git2\/" "#include \"${LIBGIT2_FILENAME}/" LIBGIT2_INCLUDE "${LIBGIT2_INCLUDE}")
FILE(WRITE "${PROJECT_BINARY_DIR}/include/${LIBGIT2_FILENAME}.h" ${LIBGIT2_INCLUDE})
+# cmake package targets
+
+set(LIBGIT2_TARGETS_EXPORT_NAME "${PROJECT_NAME}Targets")
+
+write_basic_package_version_file(
+ "${PROJECT_BINARY_DIR}/cmake/${PROJECT_NAME}ConfigVersion.cmake"
+ VERSION ${PROJECT_VERSION}
+ COMPATIBILITY SameMajorVersion)
+
+configure_file(config.cmake.in
+ "${PROJECT_BINARY_DIR}/cmake/${PROJECT_NAME}Config.cmake"
+ @ONLY)
+
+install(FILES
+ "${PROJECT_BINARY_DIR}/cmake/${PROJECT_NAME}Config.cmake"
+ "${PROJECT_BINARY_DIR}/cmake/${PROJECT_NAME}ConfigVersion.cmake"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}")
+install(
+ EXPORT ${LIBGIT2_TARGETS_EXPORT_NAME}
+ NAMESPACE "${PROJECT_NAME}::"
+ DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}")
+
# Install
install(TARGETS libgit2package
+ EXPORT ${LIBGIT2_TARGETS_EXPORT_NAME}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
diff --git a/src/libgit2/annotated_commit.c b/src/libgit2/annotated_commit.c
index 7bd8b6077f9..c5c8ace789d 100644
--- a/src/libgit2/annotated_commit.c
+++ b/src/libgit2/annotated_commit.c
@@ -39,8 +39,8 @@ static int annotated_commit_init(
if ((error = git_commit_dup(&annotated_commit->commit, commit)) < 0)
goto done;
- git_oid_fmt(annotated_commit->id_str, git_commit_id(commit));
- annotated_commit->id_str[GIT_OID_SHA1_HEXSIZE] = '\0';
+ git_oid_tostr(annotated_commit->id_str, GIT_OID_MAX_HEXSIZE + 1,
+ git_commit_id(commit));
if (!description)
description = annotated_commit->id_str;
diff --git a/src/libgit2/annotated_commit.h b/src/libgit2/annotated_commit.h
index c87eaa8057b..1f805fe9bda 100644
--- a/src/libgit2/annotated_commit.h
+++ b/src/libgit2/annotated_commit.h
@@ -41,7 +41,7 @@ struct git_annotated_commit {
const char *ref_name;
const char *remote_url;
- char id_str[GIT_OID_SHA1_HEXSIZE+1];
+ char id_str[GIT_OID_MAX_HEXSIZE + 1];
};
extern int git_annotated_commit_from_head(git_annotated_commit **out,
diff --git a/src/libgit2/apply.c b/src/libgit2/apply.c
index 18304da4df7..24922cfa550 100644
--- a/src/libgit2/apply.c
+++ b/src/libgit2/apply.c
@@ -19,6 +19,8 @@
#include "zstream.h"
#include "reader.h"
#include "index.h"
+#include "repository.h"
+#include "hashmap_str.h"
#include "apply.h"
typedef struct {
@@ -95,7 +97,7 @@ static void patch_image_free(patch_image *image)
return;
git_pool_clear(&image->pool);
- git_vector_free(&image->lines);
+ git_vector_dispose(&image->lines);
}
static bool match_hunk(
@@ -451,7 +453,7 @@ static int apply_one(
git_reader *postimage_reader,
git_index *postimage,
git_diff *diff,
- git_strmap *removed_paths,
+ git_hashset_str *removed_paths,
size_t i,
const git_apply_options *opts)
{
@@ -488,7 +490,7 @@ static int apply_one(
*/
if (delta->status != GIT_DELTA_RENAMED &&
delta->status != GIT_DELTA_ADDED) {
- if (git_strmap_exists(removed_paths, delta->old_file.path)) {
+ if (git_hashset_str_contains(removed_paths, delta->old_file.path)) {
error = apply_err("path '%s' has been renamed or deleted", delta->old_file.path);
goto done;
}
@@ -572,11 +574,11 @@ static int apply_one(
if (delta->status == GIT_DELTA_RENAMED ||
delta->status == GIT_DELTA_DELETED)
- error = git_strmap_set(removed_paths, delta->old_file.path, (char *) delta->old_file.path);
+ error = git_hashset_str_add(removed_paths, delta->old_file.path);
if (delta->status == GIT_DELTA_RENAMED ||
delta->status == GIT_DELTA_ADDED)
- git_strmap_delete(removed_paths, delta->new_file.path);
+ git_hashset_str_remove(removed_paths, delta->new_file.path);
done:
git_str_dispose(&pre_contents);
@@ -596,20 +598,17 @@ static int apply_deltas(
git_diff *diff,
const git_apply_options *opts)
{
- git_strmap *removed_paths;
+ git_hashset_str removed_paths = GIT_HASHSET_INIT;
size_t i;
int error = 0;
- if (git_strmap_new(&removed_paths) < 0)
- return -1;
-
for (i = 0; i < git_diff_num_deltas(diff); i++) {
- if ((error = apply_one(repo, pre_reader, preimage, post_reader, postimage, diff, removed_paths, i, opts)) < 0)
+ if ((error = apply_one(repo, pre_reader, preimage, post_reader, postimage, diff, &removed_paths, i, opts)) < 0)
goto done;
}
done:
- git_strmap_free(removed_paths);
+ git_hashset_str_dispose(&removed_paths);
return error;
}
@@ -622,6 +621,7 @@ int git_apply_to_tree(
{
git_index *postimage = NULL;
git_reader *pre_reader = NULL, *post_reader = NULL;
+ git_index_options index_opts = GIT_INDEX_OPTIONS_FOR_REPO(repo);
git_apply_options opts = GIT_APPLY_OPTIONS_INIT;
const git_diff_delta *delta;
size_t i;
@@ -644,7 +644,7 @@ int git_apply_to_tree(
* put the current tree into the postimage as-is - the diff will
* replace any entries contained therein
*/
- if ((error = git_index_new(&postimage)) < 0 ||
+ if ((error = git_index_new_ext(&postimage, &index_opts)) < 0 ||
(error = git_index_read_tree(postimage, preimage)) < 0 ||
(error = git_reader_for_index(&post_reader, repo, postimage)) < 0)
goto done;
@@ -714,7 +714,6 @@ static int git_apply__to_workdir(
goto done;
}
- checkout_opts.checkout_strategy |= GIT_CHECKOUT_SAFE;
checkout_opts.checkout_strategy |= GIT_CHECKOUT_DISABLE_PATHSPEC_MATCH;
checkout_opts.checkout_strategy |= GIT_CHECKOUT_DONT_WRITE_INDEX;
@@ -729,7 +728,7 @@ static int git_apply__to_workdir(
error = git_checkout_index(repo, postimage, &checkout_opts);
done:
- git_vector_free(&paths);
+ git_vector_dispose(&paths);
return error;
}
@@ -811,6 +810,7 @@ int git_apply(
git_index *index = NULL, *preimage = NULL, *postimage = NULL;
git_reader *pre_reader = NULL, *post_reader = NULL;
git_apply_options opts = GIT_APPLY_OPTIONS_INIT;
+ git_index_options index_opts = GIT_INDEX_OPTIONS_FOR_REPO(repo);
int error = GIT_EINVALID;
GIT_ASSERT_ARG(repo);
@@ -851,8 +851,8 @@ int git_apply(
* having the full repo index, so we will limit our checkout
* to only write these files that were affected by the diff.
*/
- if ((error = git_index_new(&preimage)) < 0 ||
- (error = git_index_new(&postimage)) < 0 ||
+ if ((error = git_index_new_ext(&preimage, &index_opts)) < 0 ||
+ (error = git_index_new_ext(&postimage, &index_opts)) < 0 ||
(error = git_reader_for_index(&post_reader, repo, postimage)) < 0)
goto done;
diff --git a/src/libgit2/attr.c b/src/libgit2/attr.c
index 1623b1d4570..8d096d7d85c 100644
--- a/src/libgit2/attr.c
+++ b/src/libgit2/attr.c
@@ -13,6 +13,7 @@
#include "attr_file.h"
#include "ignore.h"
#include "git2/oid.h"
+#include "hashmap_str.h"
#include
const char *git_attr__true = "[internal]__TRUE__";
@@ -254,7 +255,7 @@ int git_attr_foreach_ext(
git_attr_file *file;
git_attr_rule *rule;
git_attr_assignment *assign;
- git_strmap *seen = NULL;
+ git_hashset_str seen = GIT_HASHSET_INIT;
git_dir_flag dir_flag = GIT_DIR_FLAG_UNKNOWN;
GIT_ASSERT_ARG(repo);
@@ -267,8 +268,7 @@ int git_attr_foreach_ext(
if (git_attr_path__init(&path, pathname, git_repository_workdir(repo), dir_flag) < 0)
return -1;
- if ((error = collect_attr_files(repo, NULL, opts, pathname, &files)) < 0 ||
- (error = git_strmap_new(&seen)) < 0)
+ if ((error = collect_attr_files(repo, NULL, opts, pathname, &files)) < 0)
goto cleanup;
git_vector_foreach(&files, i, file) {
@@ -277,10 +277,10 @@ int git_attr_foreach_ext(
git_vector_foreach(&rule->assigns, k, assign) {
/* skip if higher priority assignment was already seen */
- if (git_strmap_exists(seen, assign->name))
+ if (git_hashset_str_contains(&seen, assign->name))
continue;
- if ((error = git_strmap_set(seen, assign->name, assign)) < 0)
+ if ((error = git_hashset_str_add(&seen, assign->name)) < 0)
goto cleanup;
error = callback(assign->name, assign->value, payload);
@@ -293,7 +293,7 @@ int git_attr_foreach_ext(
}
cleanup:
- git_strmap_free(seen);
+ git_hashset_str_dispose(&seen);
release_attr_files(&files);
git_attr_path__free(&path);
@@ -384,6 +384,8 @@ static int attr_setup(
git_attr_file_source index_source = { GIT_ATTR_FILE_SOURCE_INDEX, NULL, GIT_ATTR_FILE, NULL };
git_attr_file_source head_source = { GIT_ATTR_FILE_SOURCE_HEAD, NULL, GIT_ATTR_FILE, NULL };
git_attr_file_source commit_source = { GIT_ATTR_FILE_SOURCE_COMMIT, NULL, GIT_ATTR_FILE, NULL };
+ git_attr_cache *attrcache;
+ const char *attr_cfg_file = NULL;
git_index *idx = NULL;
const char *workdir;
int error = 0;
@@ -407,8 +409,10 @@ static int attr_setup(
error = 0;
}
- if ((error = preload_attr_file(repo, attr_session, NULL,
- git_repository_attr_cache(repo)->cfg_attr_file)) < 0)
+ if ((attrcache = git_repository_attr_cache(repo)) != NULL)
+ attr_cfg_file = git_attr_cache_attributesfile(attrcache);
+
+ if ((error = preload_attr_file(repo, attr_session, NULL, attr_cfg_file)) < 0)
goto out;
if ((error = git_repository__item_path(&info, repo, GIT_REPOSITORY_ITEM_INFO)) < 0 ||
@@ -424,9 +428,13 @@ static int attr_setup(
goto out;
if ((error = git_repository_index__weakptr(&idx, repo)) < 0 ||
- (error = preload_attr_source(repo, attr_session, &index_source)) < 0)
+ (error = preload_attr_source(repo, attr_session, &index_source)) < 0) {
+ if (error != GIT_ENOTFOUND)
goto out;
+ error = 0;
+ }
+
if ((opts && (opts->flags & GIT_ATTR_CHECK_INCLUDE_HEAD) != 0) &&
(error = preload_attr_source(repo, attr_session, &head_source)) < 0)
goto out;
@@ -460,6 +468,7 @@ int git_attr_add_macro(
{
int error;
git_attr_rule *macro = NULL;
+ git_attr_cache *attrcache;
git_pool *pool;
GIT_ASSERT_ARG(repo);
@@ -471,7 +480,8 @@ int git_attr_add_macro(
macro = git__calloc(1, sizeof(git_attr_rule));
GIT_ERROR_CHECK_ALLOC(macro);
- pool = &git_repository_attr_cache(repo)->pool;
+ attrcache = git_repository_attr_cache(repo);
+ pool = git_attr_cache_pool(attrcache);
macro->match.pattern = git_pool_strdup(pool, name);
GIT_ERROR_CHECK_ALLOC(macro->match.pattern);
@@ -614,7 +624,7 @@ static void release_attr_files(git_vector *files)
git_attr_file__free(file);
files->contents[i] = NULL;
}
- git_vector_free(files);
+ git_vector_dispose(files);
}
static int collect_attr_files(
@@ -627,6 +637,8 @@ static int collect_attr_files(
int error = 0;
git_str dir = GIT_STR_INIT, attrfile = GIT_STR_INIT;
const char *workdir = git_repository_workdir(repo);
+ git_attr_cache *attrcache;
+ const char *attr_cfg_file = NULL;
attr_walk_up_info info = { NULL };
GIT_ASSERT(!git_fs_path_is_absolute(path));
@@ -675,8 +687,13 @@ static int collect_attr_files(
if (error < 0)
goto cleanup;
- if (git_repository_attr_cache(repo)->cfg_attr_file != NULL) {
- error = push_attr_file(repo, attr_session, files, NULL, git_repository_attr_cache(repo)->cfg_attr_file);
+ if ((attrcache = git_repository_attr_cache(repo)) != NULL)
+ attr_cfg_file = git_attr_cache_attributesfile(attrcache);
+
+
+ if (attr_cfg_file) {
+ error = push_attr_file(repo, attr_session, files, NULL, attr_cfg_file);
+
if (error < 0)
goto cleanup;
}
diff --git a/src/libgit2/attr_file.c b/src/libgit2/attr_file.c
index afa8ec7b379..56647042064 100644
--- a/src/libgit2/attr_file.c
+++ b/src/libgit2/attr_file.c
@@ -69,7 +69,7 @@ int git_attr_file__clear_rules(git_attr_file *file, bool need_lock)
git_vector_foreach(&file->rules, i, rule)
git_attr_rule__free(rule);
- git_vector_free(&file->rules);
+ git_vector_dispose(&file->rules);
if (need_lock)
git_mutex_unlock(&file->lock);
@@ -143,6 +143,8 @@ int git_attr_file__load(
blobsize = git_blob_rawsize(blob);
GIT_ERROR_CHECK_BLOBSIZE(blobsize);
+ if (blobsize > GIT_ATTR_MAX_FILE_SIZE) /* TODO: issue warning when warning API is available */
+ goto cleanup;
git_str_put(&content, git_blob_rawcontent(blob), (size_t)blobsize);
break;
}
@@ -155,6 +157,7 @@ int git_attr_file__load(
if (p_stat(entry->fullpath, &st) < 0 ||
S_ISDIR(st.st_mode) ||
(fd = git_futils_open_ro(entry->fullpath)) < 0 ||
+ (st.st_size > GIT_ATTR_MAX_FILE_SIZE) ||
(error = git_futils_readbuffer_fd(&content, fd, (size_t)st.st_size)) < 0)
nonexistent = true;
@@ -198,6 +201,8 @@ int git_attr_file__load(
blobsize = git_blob_rawsize(blob);
GIT_ERROR_CHECK_BLOBSIZE(blobsize);
+ if (blobsize > GIT_ATTR_MAX_FILE_SIZE) /* TODO: issue warning when warning API is available */
+ goto cleanup;
if ((error = git_str_put(&content,
git_blob_rawcontent(blob), (size_t)blobsize)) < 0)
goto cleanup;
@@ -342,7 +347,7 @@ int git_attr_file__parse_buffer(
{
const char *scan = data, *context = NULL;
git_attr_rule *rule = NULL;
- int error = 0;
+ int ignorecase = 0, error = 0;
/* If subdir file path, convert context for file paths */
if (attrs->entry && git_fs_path_root(attrs->entry->path) < 0 &&
@@ -374,6 +379,13 @@ int git_attr_file__parse_buffer(
continue;
}
+ if (repo &&
+ (error = git_repository__configmap_lookup(&ignorecase, repo, GIT_CONFIGMAP_IGNORECASE)) < 0)
+ goto out;
+
+ if (ignorecase)
+ rule->match.flags |= GIT_ATTR_FNMATCH_ICASE;
+
if (rule->match.flags & GIT_ATTR_FNMATCH_MACRO) {
/* TODO: warning if macro found in file below repo root */
if (!allow_macros)
@@ -477,7 +489,7 @@ bool git_attr_fnmatch__match(
*/
if (match->containing_dir) {
if (match->flags & GIT_ATTR_FNMATCH_ICASE) {
- if (git__strncasecmp(path->path, match->containing_dir, match->containing_dir_length))
+ if (git__prefixcmp_icase(path->path, match->containing_dir))
return 0;
} else {
if (git__prefixcmp(path->path, match->containing_dir))
@@ -991,7 +1003,7 @@ static void git_attr_rule__clear(git_attr_rule *rule)
if (!(rule->match.flags & GIT_ATTR_FNMATCH_IGNORE)) {
git_vector_foreach(&rule->assigns, i, assign)
GIT_REFCOUNT_DEC(assign, git_attr_assignment__free);
- git_vector_free(&rule->assigns);
+ git_vector_dispose(&rule->assigns);
}
/* match.pattern is stored in a git_pool, so no need to free */
diff --git a/src/libgit2/attr_file.h b/src/libgit2/attr_file.h
index 08630d1a6eb..8025359ba9b 100644
--- a/src/libgit2/attr_file.h
+++ b/src/libgit2/attr_file.h
@@ -21,6 +21,8 @@
#define GIT_ATTR_FILE_SYSTEM "gitattributes"
#define GIT_ATTR_FILE_XDG "attributes"
+#define GIT_ATTR_MAX_FILE_SIZE 100 * 1024 * 1024
+
#define GIT_ATTR_FNMATCH_NEGATIVE (1U << 0)
#define GIT_ATTR_FNMATCH_DIRECTORY (1U << 1)
#define GIT_ATTR_FNMATCH_FULLPATH (1U << 2)
diff --git a/src/libgit2/attrcache.c b/src/libgit2/attrcache.c
index 405944ed156..2a822147a65 100644
--- a/src/libgit2/attrcache.c
+++ b/src/libgit2/attrcache.c
@@ -13,6 +13,38 @@
#include "sysdir.h"
#include "ignore.h"
#include "path.h"
+#include "hashmap_str.h"
+
+GIT_HASHMAP_STR_SETUP(git_attr_cache_filemap, git_attr_file_entry *);
+GIT_HASHMAP_STR_SETUP(git_attr_cache_macromap, git_attr_rule *);
+
+struct git_attr_cache {
+ char *cfg_attr_file; /* cached value of core.attributesfile */
+ char *cfg_excl_file; /* cached value of core.excludesfile */
+
+ /* hash path to git_attr_file_entry records */
+ git_attr_cache_filemap files;
+ /* hash name to git_attr_rule */
+ git_attr_cache_macromap macros;
+
+ git_mutex lock;
+ git_pool pool;
+};
+
+const char *git_attr_cache_attributesfile(git_attr_cache *cache)
+{
+ return cache->cfg_attr_file;
+}
+
+const char *git_attr_cache_excludesfile(git_attr_cache *cache)
+{
+ return cache->cfg_excl_file;
+}
+
+git_pool *git_attr_cache_pool(git_attr_cache *cache)
+{
+ return &cache->pool;
+}
GIT_INLINE(int) attr_cache_lock(git_attr_cache *cache)
{
@@ -34,7 +66,12 @@ GIT_INLINE(void) attr_cache_unlock(git_attr_cache *cache)
GIT_INLINE(git_attr_file_entry *) attr_cache_lookup_entry(
git_attr_cache *cache, const char *path)
{
- return git_strmap_get(cache->files, path);
+ git_attr_file_entry *result;
+
+ if (git_attr_cache_filemap_get(&result, &cache->files, path) == 0)
+ return result;
+
+ return NULL;
}
int git_attr_cache__alloc_file_entry(
@@ -92,7 +129,7 @@ static int attr_cache_make_entry(
git_repository_workdir(repo), path, &cache->pool)) < 0)
return error;
- if ((error = git_strmap_set(cache->files, entry->path, entry)) < 0)
+ if ((error = git_attr_cache_filemap_put(&cache->files, entry->path, entry)) < 0)
return error;
*out = entry;
@@ -271,12 +308,11 @@ bool git_attr_cache__is_cached(
{
git_attr_cache *cache = git_repository_attr_cache(repo);
git_attr_file_entry *entry;
- git_strmap *files;
- if (!cache || !(files = cache->files))
+ if (!cache)
return false;
- if ((entry = git_strmap_get(files, filename)) == NULL)
+ if (git_attr_cache_filemap_get(&entry, &cache->files, filename) != 0)
return false;
return entry && (entry->file[source_type] != NULL);
@@ -318,6 +354,9 @@ static int attr_cache__lookup_path(
static void attr_cache__free(git_attr_cache *cache)
{
+ git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
+ git_attr_rule *rule;
+ git_attr_file_entry *entry;
bool unlock;
if (!cache)
@@ -325,30 +364,24 @@ static void attr_cache__free(git_attr_cache *cache)
unlock = (attr_cache_lock(cache) == 0);
- if (cache->files != NULL) {
- git_attr_file_entry *entry;
+ while (git_attr_cache_filemap_iterate(&iter, NULL, &entry, &cache->files) == 0) {
git_attr_file *file;
- int i;
-
- git_strmap_foreach_value(cache->files, entry, {
- for (i = 0; i < GIT_ATTR_FILE_NUM_SOURCES; ++i) {
- if ((file = git_atomic_swap(entry->file[i], NULL)) != NULL) {
- GIT_REFCOUNT_OWN(file, NULL);
- git_attr_file__free(file);
- }
+ size_t i;
+
+ for (i = 0; i < GIT_ATTR_FILE_NUM_SOURCES; i++) {
+ if ((file = git_atomic_swap(entry->file[i], NULL)) != NULL) {
+ GIT_REFCOUNT_OWN(file, NULL);
+ git_attr_file__free(file);
}
- });
- git_strmap_free(cache->files);
+ }
}
- if (cache->macros != NULL) {
- git_attr_rule *rule;
+ iter = GIT_HASHMAP_ITER_INIT;
+ while (git_attr_cache_macromap_iterate(&iter, NULL, &rule, &cache->macros) == 0)
+ git_attr_rule__free(rule);
- git_strmap_foreach_value(cache->macros, rule, {
- git_attr_rule__free(rule);
- });
- git_strmap_free(cache->macros);
- }
+ git_attr_cache_filemap_dispose(&cache->files);
+ git_attr_cache_macromap_dispose(&cache->macros);
git_pool_clear(&cache->pool);
@@ -401,9 +434,7 @@ int git_attr_cache__init(git_repository *repo)
/* allocate hashtable for attribute and ignore file contents,
* hashtable for attribute macros, and string pool
*/
- if ((ret = git_strmap_new(&cache->files)) < 0 ||
- (ret = git_strmap_new(&cache->macros)) < 0 ||
- (ret = git_pool_init(&cache->pool, 1)) < 0)
+ if ((ret = git_pool_init(&cache->pool, 1)) < 0)
goto cancel;
if (git_atomic_compare_and_swap(&repo->attrcache, NULL, cache) != NULL)
@@ -457,11 +488,11 @@ int git_attr_cache__insert_macro(git_repository *repo, git_attr_rule *macro)
goto out;
locked = true;
- if ((preexisting = git_strmap_get(cache->macros, macro->match.pattern)) != NULL)
- git_attr_rule__free(preexisting);
+ if (git_attr_cache_macromap_get(&preexisting, &cache->macros, macro->match.pattern) == 0)
+ git_attr_rule__free(preexisting);
- if ((error = git_strmap_set(cache->macros, macro->match.pattern, macro)) < 0)
- goto out;
+ if ((error = git_attr_cache_macromap_put(&cache->macros, macro->match.pattern, macro)) < 0)
+ goto out;
out:
if (locked)
@@ -472,7 +503,12 @@ int git_attr_cache__insert_macro(git_repository *repo, git_attr_rule *macro)
git_attr_rule *git_attr_cache__lookup_macro(
git_repository *repo, const char *name)
{
- git_strmap *macros = git_repository_attr_cache(repo)->macros;
+ git_attr_cache *cache = git_repository_attr_cache(repo);
+ git_attr_rule *rule;
+
+ if (!cache ||
+ git_attr_cache_macromap_get(&rule, &cache->macros, name) != 0)
+ return NULL;
- return git_strmap_get(macros, name);
+ return rule;
}
diff --git a/src/libgit2/attrcache.h b/src/libgit2/attrcache.h
index b13e0e8f0a8..2693278d4b8 100644
--- a/src/libgit2/attrcache.h
+++ b/src/libgit2/attrcache.h
@@ -10,22 +10,18 @@
#include "common.h"
#include "attr_file.h"
-#include "strmap.h"
#define GIT_ATTR_CONFIG "core.attributesfile"
#define GIT_IGNORE_CONFIG "core.excludesfile"
-typedef struct {
- char *cfg_attr_file; /* cached value of core.attributesfile */
- char *cfg_excl_file; /* cached value of core.excludesfile */
- git_strmap *files; /* hash path to git_attr_cache_entry records */
- git_strmap *macros; /* hash name to vector */
- git_mutex lock;
- git_pool pool;
-} git_attr_cache;
+typedef struct git_attr_cache git_attr_cache;
extern int git_attr_cache__init(git_repository *repo);
+extern const char *git_attr_cache_attributesfile(git_attr_cache *ac);
+extern const char *git_attr_cache_excludesfile(git_attr_cache *ac);
+extern git_pool *git_attr_cache_pool(git_attr_cache *ac);
+
/* get file - loading and reload as needed */
extern int git_attr_cache__get(
git_attr_file **file,
diff --git a/src/libgit2/blame.c b/src/libgit2/blame.c
index b70cd615ec8..4f99de69bd1 100644
--- a/src/libgit2/blame.c
+++ b/src/libgit2/blame.c
@@ -19,7 +19,6 @@
#include "repository.h"
#include "blame_git.h"
-
static int hunk_byfinalline_search_cmp(const void *key, const void *entry)
{
git_blame_hunk *hunk = (git_blame_hunk*)entry;
@@ -60,10 +59,11 @@ static bool hunk_starts_at_or_after_line(git_blame_hunk *hunk, size_t line)
}
static git_blame_hunk *new_hunk(
- size_t start,
- size_t lines,
- size_t orig_start,
- const char *path)
+ size_t start,
+ size_t lines,
+ size_t orig_start,
+ const char *path,
+ git_blame *blame)
{
git_blame_hunk *hunk = git__calloc(1, sizeof(git_blame_hunk));
if (!hunk) return NULL;
@@ -72,27 +72,31 @@ static git_blame_hunk *new_hunk(
hunk->final_start_line_number = start;
hunk->orig_start_line_number = orig_start;
hunk->orig_path = path ? git__strdup(path) : NULL;
- git_oid_clear(&hunk->orig_commit_id, GIT_OID_SHA1);
- git_oid_clear(&hunk->final_commit_id, GIT_OID_SHA1);
+ git_oid_clear(&hunk->orig_commit_id, blame->repository->oid_type);
+ git_oid_clear(&hunk->final_commit_id, blame->repository->oid_type);
return hunk;
}
static void free_hunk(git_blame_hunk *hunk)
{
- git__free((void*)hunk->orig_path);
+ git__free((char *)hunk->orig_path);
+ git__free((char *)hunk->summary);
git_signature_free(hunk->final_signature);
+ git_signature_free(hunk->final_committer);
git_signature_free(hunk->orig_signature);
+ git_signature_free(hunk->orig_committer);
git__free(hunk);
}
-static git_blame_hunk *dup_hunk(git_blame_hunk *hunk)
+static git_blame_hunk *dup_hunk(git_blame_hunk *hunk, git_blame *blame)
{
git_blame_hunk *newhunk = new_hunk(
hunk->final_start_line_number,
hunk->lines_in_hunk,
hunk->orig_start_line_number,
- hunk->orig_path);
+ hunk->orig_path,
+ blame);
if (!newhunk)
return NULL;
@@ -102,7 +106,10 @@ static git_blame_hunk *dup_hunk(git_blame_hunk *hunk)
newhunk->boundary = hunk->boundary;
if (git_signature_dup(&newhunk->final_signature, hunk->final_signature) < 0 ||
- git_signature_dup(&newhunk->orig_signature, hunk->orig_signature) < 0) {
+ git_signature_dup(&newhunk->final_committer, hunk->final_committer) < 0 ||
+ git_signature_dup(&newhunk->orig_signature, hunk->orig_signature) < 0 ||
+ git_signature_dup(&newhunk->orig_committer, hunk->orig_committer) < 0 ||
+ (newhunk->summary = git__strdup(hunk->summary)) == NULL) {
free_hunk(newhunk);
return NULL;
}
@@ -115,12 +122,12 @@ static git_blame_hunk *dup_hunk(git_blame_hunk *hunk)
static void shift_hunks_by(git_vector *v, size_t start_line, int shift_by)
{
size_t i;
-
- if (!git_vector_bsearch2(&i, v, hunk_byfinalline_search_cmp, &start_line)) {
- for (; i < v->length; i++) {
- git_blame_hunk *hunk = (git_blame_hunk*)v->contents[i];
- hunk->final_start_line_number += shift_by;
+ for (i = 0; i < v->length; i++) {
+ git_blame_hunk *hunk = (git_blame_hunk*)v->contents[i];
+ if(hunk->final_start_line_number < start_line){
+ continue;
}
+ hunk->final_start_line_number += shift_by;
}
}
@@ -137,10 +144,9 @@ git_blame *git_blame__alloc(
gbr->options = opts;
if (git_vector_init(&gbr->hunks, 8, hunk_cmp) < 0 ||
- git_vector_init(&gbr->paths, 8, paths_cmp) < 0 ||
- (gbr->path = git__strdup(path)) == NULL ||
- git_vector_insert(&gbr->paths, git__strdup(path)) < 0)
- {
+ git_vector_init(&gbr->paths, 8, paths_cmp) < 0 ||
+ (gbr->path = git__strdup(path)) == NULL ||
+ git_vector_insert(&gbr->paths, git__strdup(path)) < 0) {
git_blame_free(gbr);
return NULL;
}
@@ -163,9 +169,11 @@ void git_blame_free(git_blame *blame)
git_vector_foreach(&blame->hunks, i, hunk)
free_hunk(hunk);
- git_vector_free(&blame->hunks);
- git_vector_free_deep(&blame->paths);
+ git_vector_dispose(&blame->hunks);
+ git_array_clear(blame->lines);
+
+ git_vector_dispose_deep(&blame->paths);
git_array_clear(blame->line_index);
@@ -176,31 +184,76 @@ void git_blame_free(git_blame *blame)
git__free(blame);
}
-uint32_t git_blame_get_hunk_count(git_blame *blame)
+size_t git_blame_hunkcount(git_blame *blame)
{
GIT_ASSERT_ARG(blame);
- return (uint32_t)blame->hunks.length;
+
+ return blame->hunks.length;
+}
+
+size_t git_blame_linecount(git_blame *blame)
+{
+ GIT_ASSERT_ARG(blame);
+
+ return git_array_size(blame->line_index);
+}
+
+const git_blame_line *git_blame_line_byindex(
+ git_blame *blame,
+ size_t idx)
+{
+ GIT_ASSERT_ARG_WITH_RETVAL(blame, NULL);
+ GIT_ASSERT_WITH_RETVAL(idx > 0 && idx <= git_array_size(blame->line_index), NULL);
+
+ return git_array_get(blame->lines, idx - 1);
}
-const git_blame_hunk *git_blame_get_hunk_byindex(git_blame *blame, uint32_t index)
+const git_blame_hunk *git_blame_hunk_byindex(
+ git_blame *blame,
+ size_t index)
{
GIT_ASSERT_ARG_WITH_RETVAL(blame, NULL);
- return (git_blame_hunk*)git_vector_get(&blame->hunks, index);
+ return git_vector_get(&blame->hunks, index);
}
-const git_blame_hunk *git_blame_get_hunk_byline(git_blame *blame, size_t lineno)
+const git_blame_hunk *git_blame_hunk_byline(
+ git_blame *blame,
+ size_t lineno)
{
size_t i, new_lineno = lineno;
GIT_ASSERT_ARG_WITH_RETVAL(blame, NULL);
- if (!git_vector_bsearch2(&i, &blame->hunks, hunk_byfinalline_search_cmp, &new_lineno)) {
- return git_blame_get_hunk_byindex(blame, (uint32_t)i);
- }
+ if (git_vector_bsearch2(&i, &blame->hunks,
+ hunk_byfinalline_search_cmp, &new_lineno) != 0)
+ return NULL;
+
+ return git_blame_hunk_byindex(blame, i);
+}
- return NULL;
+#ifndef GIT_DEPRECATE_HARD
+uint32_t git_blame_get_hunk_count(git_blame *blame)
+{
+ size_t count = git_blame_hunkcount(blame);
+ GIT_ASSERT(count < UINT32_MAX);
+ return (uint32_t)count;
}
+const git_blame_hunk *git_blame_get_hunk_byindex(
+ git_blame *blame,
+ uint32_t index)
+{
+ return git_blame_hunk_byindex(blame, index);
+}
+
+const git_blame_hunk *git_blame_get_hunk_byline(
+ git_blame *blame,
+ size_t lineno)
+{
+ return git_blame_hunk_byline(blame, lineno);
+}
+#endif
+
static int normalize_options(
git_blame_options *out,
const git_blame_options *in,
@@ -237,7 +290,8 @@ static git_blame_hunk *split_hunk_in_vector(
git_vector *vec,
git_blame_hunk *hunk,
size_t rel_line,
- bool return_new)
+ bool return_new,
+ git_blame *blame)
{
size_t new_line_count;
git_blame_hunk *nh;
@@ -250,8 +304,9 @@ static git_blame_hunk *split_hunk_in_vector(
}
new_line_count = hunk->lines_in_hunk - rel_line;
- nh = new_hunk(hunk->final_start_line_number + rel_line, new_line_count,
- hunk->orig_start_line_number + rel_line, hunk->orig_path);
+ nh = new_hunk(hunk->final_start_line_number + rel_line,
+ new_line_count, hunk->orig_start_line_number + rel_line,
+ hunk->orig_path, blame);
if (!nh)
return NULL;
@@ -278,42 +333,77 @@ static int index_blob_lines(git_blame *blame)
const char *buf = blame->final_buf;
size_t len = blame->final_buf_size;
int num = 0, incomplete = 0, bol = 1;
+ git_blame_line *line = NULL;
size_t *i;
if (len && buf[len-1] != '\n')
incomplete++; /* incomplete line at the end */
+
while (len--) {
if (bol) {
i = git_array_alloc(blame->line_index);
GIT_ERROR_CHECK_ALLOC(i);
*i = buf - blame->final_buf;
+
+ GIT_ASSERT(line == NULL);
+ line = git_array_alloc(blame->lines);
+ GIT_ERROR_CHECK_ALLOC(line);
+
+ line->ptr = buf;
bol = 0;
}
+
if (*buf++ == '\n') {
+ GIT_ASSERT(line);
+ line->len = (buf - line->ptr) - 1;
+ line = NULL;
+
num++;
bol = 1;
}
}
+
i = git_array_alloc(blame->line_index);
GIT_ERROR_CHECK_ALLOC(i);
*i = buf - blame->final_buf;
+
+ if (!bol) {
+ GIT_ASSERT(line);
+ line->len = buf - line->ptr;
+ line = NULL;
+ }
+
+ GIT_ASSERT(!line);
+
blame->num_lines = num + incomplete;
return blame->num_lines;
}
static git_blame_hunk *hunk_from_entry(git_blame__entry *e, git_blame *blame)
{
+ const char *summary;
git_blame_hunk *h = new_hunk(
- e->lno+1, e->num_lines, e->s_lno+1, e->suspect->path);
+ e->lno+1, e->num_lines, e->s_lno+1, e->suspect->path,
+ blame);
if (!h)
return NULL;
git_oid_cpy(&h->final_commit_id, git_commit_id(e->suspect->commit));
git_oid_cpy(&h->orig_commit_id, git_commit_id(e->suspect->commit));
- git_commit_author_with_mailmap(
- &h->final_signature, e->suspect->commit, blame->mailmap);
- git_signature_dup(&h->orig_signature, h->final_signature);
+
+ if (git_commit_author_with_mailmap(
+ &h->final_signature, e->suspect->commit, blame->mailmap) < 0 ||
+ git_commit_committer_with_mailmap(
+ &h->final_committer, e->suspect->commit, blame->mailmap) < 0 ||
+ git_signature_dup(&h->orig_signature, h->final_signature) < 0 ||
+ git_signature_dup(&h->orig_committer, h->final_committer) < 0 ||
+ (summary = git_commit_summary(e->suspect->commit)) == NULL ||
+ (h->summary = git__strdup(summary)) == NULL) {
+ free_hunk(h);
+ return NULL;
+ }
+
h->boundary = e->is_boundary ? 1 : 0;
return h;
}
@@ -342,12 +432,12 @@ static int blame_internal(git_blame *blame)
if ((error = load_blob(blame)) < 0 ||
(error = git_blame__get_origin(&o, blame, blame->final, blame->path)) < 0)
- goto cleanup;
+ goto on_error;
if (git_blob_rawsize(blame->final_blob) > SIZE_MAX) {
git_error_set(GIT_ERROR_NOMEMORY, "blob is too large to blame");
error = -1;
- goto cleanup;
+ goto on_error;
}
blame->final_buf = git_blob_rawcontent(blame->final_blob);
@@ -366,17 +456,19 @@ static int blame_internal(git_blame *blame)
blame->ent = ent;
- error = git_blame__like_git(blame, blame->options.flags);
+ if ((error = git_blame__like_git(blame, blame->options.flags)) < 0)
+ goto on_error;
-cleanup:
- for (ent = blame->ent; ent; ) {
- git_blame__entry *e = ent->next;
+ for (ent = blame->ent; ent; ent = ent->next) {
git_blame_hunk *h = hunk_from_entry(ent, blame);
-
git_vector_insert(&blame->hunks, h);
+ }
+on_error:
+ for (ent = blame->ent; ent; ) {
+ git_blame__entry *next = ent->next;
git_blame__free_entry(ent);
- ent = e;
+ ent = next;
}
return error;
@@ -439,20 +531,21 @@ static int buffer_hunk_cb(
GIT_UNUSED(delta);
- wedge_line = (hunk->old_lines == 0) ? hunk->new_start : hunk->old_start;
+ wedge_line = (hunk->new_start >= hunk->old_start || hunk->old_lines==0) ? hunk->new_start : hunk->old_start;
blame->current_diff_line = wedge_line;
-
- blame->current_hunk = (git_blame_hunk*)git_blame_get_hunk_byline(blame, wedge_line);
+ blame->current_hunk = (git_blame_hunk*)git_blame_hunk_byline(blame, wedge_line);
if (!blame->current_hunk) {
/* Line added at the end of the file */
- blame->current_hunk = new_hunk(wedge_line, 0, wedge_line, blame->path);
+ blame->current_hunk = new_hunk(wedge_line, 0, wedge_line,
+ blame->path, blame);
+ blame->current_diff_line++;
GIT_ERROR_CHECK_ALLOC(blame->current_hunk);
-
git_vector_insert(&blame->hunks, blame->current_hunk);
} else if (!hunk_starts_at_or_after_line(blame->current_hunk, wedge_line)){
/* If this hunk doesn't start between existing hunks, split a hunk up so it does */
blame->current_hunk = split_hunk_in_vector(&blame->hunks, blame->current_hunk,
- wedge_line - blame->current_hunk->orig_start_line_number, true);
+ wedge_line - blame->current_hunk->final_start_line_number, true,
+ blame);
GIT_ERROR_CHECK_ALLOC(blame->current_hunk);
}
@@ -477,13 +570,12 @@ static int buffer_line_cb(
hunk_ends_at_or_before_line(blame->current_hunk, blame->current_diff_line)) {
/* Append to the current buffer-blame hunk */
blame->current_hunk->lines_in_hunk++;
- shift_hunks_by(&blame->hunks, blame->current_diff_line+1, 1);
+ shift_hunks_by(&blame->hunks, blame->current_diff_line, 1);
} else {
/* Create a new buffer-blame hunk with this line */
shift_hunks_by(&blame->hunks, blame->current_diff_line, 1);
- blame->current_hunk = new_hunk(blame->current_diff_line, 1, 0, blame->path);
+ blame->current_hunk = new_hunk(blame->current_diff_line, 1, 0, blame->path, blame);
GIT_ERROR_CHECK_ALLOC(blame->current_hunk);
-
git_vector_insert_sorted(&blame->hunks, blame->current_hunk, NULL);
}
blame->current_diff_line++;
@@ -491,15 +583,16 @@ static int buffer_line_cb(
if (line->origin == GIT_DIFF_LINE_DELETION) {
/* Trim the line from the current hunk; remove it if it's now empty */
- size_t shift_base = blame->current_diff_line + blame->current_hunk->lines_in_hunk+1;
+ size_t shift_base = blame->current_diff_line + blame->current_hunk->lines_in_hunk;
if (--(blame->current_hunk->lines_in_hunk) == 0) {
size_t i;
- shift_base--;
+ size_t i_next;
if (!git_vector_search2(&i, &blame->hunks, ptrs_equal_cmp, blame->current_hunk)) {
git_vector_remove(&blame->hunks, i);
free_hunk(blame->current_hunk);
- blame->current_hunk = (git_blame_hunk*)git_blame_get_hunk_byindex(blame, (uint32_t)i);
+ i_next = min( i , blame->hunks.length -1);
+ blame->current_hunk = (git_blame_hunk*)git_blame_hunk_byindex(blame, (uint32_t)i_next);
}
}
shift_hunks_by(&blame->hunks, shift_base, -1);
@@ -529,7 +622,7 @@ int git_blame_buffer(
/* Duplicate all of the hunk structures in the reference blame */
git_vector_foreach(&reference->hunks, i, hunk) {
- git_blame_hunk *h = dup_hunk(hunk);
+ git_blame_hunk *h = dup_hunk(hunk, blame);
GIT_ERROR_CHECK_ALLOC(h);
git_vector_insert(&blame->hunks, h);
diff --git a/src/libgit2/blame.h b/src/libgit2/blame.h
index 4141e2bb557..152834ebba7 100644
--- a/src/libgit2/blame.h
+++ b/src/libgit2/blame.h
@@ -71,6 +71,7 @@ struct git_blame {
git_blame_options options;
git_vector hunks;
+ git_array_t(git_blame_line) lines;
git_vector paths;
git_blob *final_blob;
diff --git a/src/libgit2/blame_git.c b/src/libgit2/blame_git.c
index 2504b338ac5..69897b3860c 100644
--- a/src/libgit2/blame_git.c
+++ b/src/libgit2/blame_git.c
@@ -9,7 +9,6 @@
#include "commit.h"
#include "blob.h"
-#include "xdiff/xinclude.h"
#include "diff_xdiff.h"
/*
diff --git a/src/libgit2/branch.c b/src/libgit2/branch.c
index 4cbd1e26f7a..9a31c9c6ffc 100644
--- a/src/libgit2/branch.c
+++ b/src/libgit2/branch.c
@@ -134,9 +134,9 @@ int git_branch_create(
const git_commit *commit,
int force)
{
- char commit_id[GIT_OID_SHA1_HEXSIZE + 1];
+ char commit_id[GIT_OID_MAX_HEXSIZE + 1];
- git_oid_tostr(commit_id, GIT_OID_SHA1_HEXSIZE + 1, git_commit_id(commit));
+ git_oid_tostr(commit_id, GIT_OID_MAX_HEXSIZE + 1, git_commit_id(commit));
return create_branch(ref_out, repository, branch_name, commit, commit_id, force);
}
diff --git a/src/libgit2/cache.c b/src/libgit2/cache.c
index 2f68e357cbd..629c56387e0 100644
--- a/src/libgit2/cache.c
+++ b/src/libgit2/cache.c
@@ -14,6 +14,9 @@
#include "odb.h"
#include "object.h"
#include "git2/oid.h"
+#include "hashmap_oid.h"
+
+GIT_HASHMAP_OID_FUNCTIONS(git_cache_oidmap, GIT_HASHMAP_INLINE, git_cached_obj *);
bool git_cache__enabled = true;
ssize_t git_cache__max_storage = (256 * 1024 * 1024);
@@ -45,9 +48,6 @@ int git_cache_init(git_cache *cache)
{
memset(cache, 0, sizeof(*cache));
- if ((git_oidmap_new(&cache->map)) < 0)
- return -1;
-
if (git_rwlock_init(&cache->lock)) {
git_error_set(GIT_ERROR_OS, "failed to initialize cache rwlock");
return -1;
@@ -60,15 +60,15 @@ int git_cache_init(git_cache *cache)
static void clear_cache(git_cache *cache)
{
git_cached_obj *evict = NULL;
+ git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
if (git_cache_size(cache) == 0)
return;
- git_oidmap_foreach_value(cache->map, evict, {
+ while (git_cache_oidmap_iterate(&iter, NULL, &evict, &cache->map) == 0)
git_cached_obj_decref(evict);
- });
- git_oidmap_clear(cache->map);
+ git_cache_oidmap_clear(&cache->map);
git_atomic_ssize_add(&git_cache__current_storage, -cache->used_memory);
cache->used_memory = 0;
}
@@ -83,10 +83,15 @@ void git_cache_clear(git_cache *cache)
git_rwlock_wrunlock(&cache->lock);
}
+size_t git_cache_size(git_cache *cache)
+{
+ return git_cache_oidmap_size(&cache->map);
+}
+
void git_cache_dispose(git_cache *cache)
{
git_cache_clear(cache);
- git_oidmap_free(cache->map);
+ git_cache_oidmap_dispose(&cache->map);
git_rwlock_free(&cache->lock);
git__memzero(cache, sizeof(*cache));
}
@@ -94,8 +99,9 @@ void git_cache_dispose(git_cache *cache)
/* Called with lock */
static void cache_evict_entries(git_cache *cache)
{
- size_t evict_count = git_cache_size(cache) / 2048, i;
+ size_t evict_count = git_cache_size(cache) / 2048;
ssize_t evicted_memory = 0;
+ git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
if (evict_count < 8)
evict_count = 8;
@@ -106,17 +112,16 @@ static void cache_evict_entries(git_cache *cache)
return;
}
- i = 0;
while (evict_count > 0) {
- git_cached_obj *evict;
const git_oid *key;
+ git_cached_obj *evict;
- if (git_oidmap_iterate((void **) &evict, cache->map, &i, &key) == GIT_ITEROVER)
+ if (git_cache_oidmap_iterate(&iter, &key, &evict, &cache->map) != 0)
break;
evict_count--;
evicted_memory += evict->size;
- git_oidmap_delete(cache->map, key);
+ git_cache_oidmap_remove(&cache->map, key);
git_cached_obj_decref(evict);
}
@@ -132,12 +137,12 @@ static bool cache_should_store(git_object_t object_type, size_t object_size)
static void *cache_get(git_cache *cache, const git_oid *oid, unsigned int flags)
{
- git_cached_obj *entry;
+ git_cached_obj *entry = NULL;
if (!git_cache__enabled || git_rwlock_rdlock(&cache->lock) < 0)
return NULL;
- if ((entry = git_oidmap_get(cache->map, oid)) != NULL) {
+ if (git_cache_oidmap_get(&entry, &cache->map, oid) == 0) {
if (flags && entry->flags != flags) {
entry = NULL;
} else {
@@ -172,8 +177,8 @@ static void *cache_store(git_cache *cache, git_cached_obj *entry)
cache_evict_entries(cache);
/* not found */
- if ((stored_entry = git_oidmap_get(cache->map, &entry->oid)) == NULL) {
- if (git_oidmap_set(cache->map, &entry->oid, entry) == 0) {
+ if (git_cache_oidmap_get(&stored_entry, &cache->map, &entry->oid) != 0) {
+ if (git_cache_oidmap_put(&cache->map, &entry->oid, entry) == 0) {
git_cached_obj_incref(entry);
cache->used_memory += entry->size;
git_atomic_ssize_add(&git_cache__current_storage, (ssize_t)entry->size);
@@ -187,7 +192,7 @@ static void *cache_store(git_cache *cache, git_cached_obj *entry)
entry = stored_entry;
} else if (stored_entry->flags == GIT_CACHE_STORE_RAW &&
entry->flags == GIT_CACHE_STORE_PARSED) {
- if (git_oidmap_set(cache->map, &entry->oid, entry) == 0) {
+ if (git_cache_oidmap_put(&cache->map, &entry->oid, entry) == 0) {
git_cached_obj_decref(stored_entry);
git_cached_obj_incref(entry);
} else {
diff --git a/src/libgit2/cache.h b/src/libgit2/cache.h
index 42c4fa80d7f..4c14013a300 100644
--- a/src/libgit2/cache.h
+++ b/src/libgit2/cache.h
@@ -14,7 +14,7 @@
#include "git2/odb.h"
#include "thread.h"
-#include "oidmap.h"
+#include "hashmap_oid.h"
enum {
GIT_CACHE_STORE_ANY = 0,
@@ -30,10 +30,12 @@ typedef struct {
git_atomic32 refcount;
} git_cached_obj;
+GIT_HASHMAP_OID_STRUCT(git_cache_oidmap, git_cached_obj *);
+
typedef struct {
- git_oidmap *map;
- git_rwlock lock;
- ssize_t used_memory;
+ git_cache_oidmap map;
+ git_rwlock lock;
+ ssize_t used_memory;
} git_cache;
extern bool git_cache__enabled;
@@ -45,6 +47,7 @@ int git_cache_set_max_object_size(git_object_t type, size_t size);
int git_cache_init(git_cache *cache);
void git_cache_dispose(git_cache *cache);
void git_cache_clear(git_cache *cache);
+size_t git_cache_size(git_cache *cache);
void *git_cache_store_raw(git_cache *cache, git_odb_object *entry);
void *git_cache_store_parsed(git_cache *cache, git_object *entry);
@@ -53,11 +56,6 @@ git_odb_object *git_cache_get_raw(git_cache *cache, const git_oid *oid);
git_object *git_cache_get_parsed(git_cache *cache, const git_oid *oid);
void *git_cache_get_any(git_cache *cache, const git_oid *oid);
-GIT_INLINE(size_t) git_cache_size(git_cache *cache)
-{
- return (size_t)git_oidmap_size(cache->map);
-}
-
GIT_INLINE(void) git_cached_obj_incref(void *_obj)
{
git_cached_obj *obj = _obj;
diff --git a/src/libgit2/checkout.c b/src/libgit2/checkout.c
index 6a4643196b0..f4b1ea96f84 100644
--- a/src/libgit2/checkout.c
+++ b/src/libgit2/checkout.c
@@ -30,8 +30,8 @@
#include "fs_path.h"
#include "attr.h"
#include "pool.h"
-#include "strmap.h"
#include "path.h"
+#include "hashmap_str.h"
/* See docs/checkout-internals.md for more information */
@@ -72,7 +72,7 @@ typedef struct {
size_t total_steps;
size_t completed_steps;
git_checkout_perfdata perfdata;
- git_strmap *mkdir_map;
+ git_hashset_str mkdir_pathcache;
git_attr_session attr_session;
} checkout_data;
@@ -294,6 +294,9 @@ static int checkout_action_no_wd(
*action = CHECKOUT_ACTION__NONE;
+ if ((data->strategy & GIT_CHECKOUT_NONE))
+ return 0;
+
switch (delta->status) {
case GIT_DELTA_UNMODIFIED: /* case 12 */
error = checkout_notify(data, GIT_CHECKOUT_NOTIFY_DIRTY, delta, NULL);
@@ -302,17 +305,17 @@ static int checkout_action_no_wd(
*action = CHECKOUT_ACTION_IF(RECREATE_MISSING, UPDATE_BLOB, NONE);
break;
case GIT_DELTA_ADDED: /* case 2 or 28 (and 5 but not really) */
- *action = CHECKOUT_ACTION_IF(SAFE, UPDATE_BLOB, NONE);
+ *action = CHECKOUT_ACTION__UPDATE_BLOB;
break;
case GIT_DELTA_MODIFIED: /* case 13 (and 35 but not really) */
*action = CHECKOUT_ACTION_IF(RECREATE_MISSING, UPDATE_BLOB, CONFLICT);
break;
case GIT_DELTA_TYPECHANGE: /* case 21 (B->T) and 28 (T->B)*/
if (delta->new_file.mode == GIT_FILEMODE_TREE)
- *action = CHECKOUT_ACTION_IF(SAFE, UPDATE_BLOB, NONE);
+ *action = CHECKOUT_ACTION__UPDATE_BLOB;
break;
case GIT_DELTA_DELETED: /* case 8 or 25 */
- *action = CHECKOUT_ACTION_IF(SAFE, REMOVE, NONE);
+ *action = CHECKOUT_ACTION__REMOVE;
break;
default: /* impossible */
break;
@@ -494,6 +497,9 @@ static int checkout_action_with_wd(
{
*action = CHECKOUT_ACTION__NONE;
+ if ((data->strategy & GIT_CHECKOUT_NONE))
+ return 0;
+
switch (delta->status) {
case GIT_DELTA_UNMODIFIED: /* case 14/15 or 33 */
if (checkout_is_workdir_modified(data, &delta->old_file, &delta->new_file, wd)) {
@@ -512,14 +518,14 @@ static int checkout_action_with_wd(
if (checkout_is_workdir_modified(data, &delta->old_file, &delta->new_file, wd))
*action = CHECKOUT_ACTION_IF(FORCE, REMOVE, CONFLICT);
else
- *action = CHECKOUT_ACTION_IF(SAFE, REMOVE, NONE);
+ *action = CHECKOUT_ACTION__REMOVE;
break;
case GIT_DELTA_MODIFIED: /* case 16, 17, 18 (or 36 but not really) */
if (wd->mode != GIT_FILEMODE_COMMIT &&
checkout_is_workdir_modified(data, &delta->old_file, &delta->new_file, wd))
*action = CHECKOUT_ACTION_IF(FORCE, UPDATE_BLOB, CONFLICT);
else
- *action = CHECKOUT_ACTION_IF(SAFE, UPDATE_BLOB, NONE);
+ *action = CHECKOUT_ACTION__UPDATE_BLOB;
break;
case GIT_DELTA_TYPECHANGE: /* case 22, 23, 29, 30 */
if (delta->old_file.mode == GIT_FILEMODE_TREE) {
@@ -527,13 +533,13 @@ static int checkout_action_with_wd(
/* either deleting items in old tree will delete the wd dir,
* or we'll get a conflict when we attempt blob update...
*/
- *action = CHECKOUT_ACTION_IF(SAFE, UPDATE_BLOB, NONE);
+ *action = CHECKOUT_ACTION__UPDATE_BLOB;
else if (wd->mode == GIT_FILEMODE_COMMIT) {
/* workdir is possibly a "phantom" submodule - treat as a
* tree if the only submodule info came from the config
*/
if (submodule_is_config_only(data, wd->path))
- *action = CHECKOUT_ACTION_IF(SAFE, UPDATE_BLOB, NONE);
+ *action = CHECKOUT_ACTION__UPDATE_BLOB;
else
*action = CHECKOUT_ACTION_IF(FORCE, REMOVE_AND_UPDATE, CONFLICT);
} else
@@ -542,7 +548,7 @@ static int checkout_action_with_wd(
else if (checkout_is_workdir_modified(data, &delta->old_file, &delta->new_file, wd))
*action = CHECKOUT_ACTION_IF(FORCE, REMOVE_AND_UPDATE, CONFLICT);
else
- *action = CHECKOUT_ACTION_IF(SAFE, REMOVE_AND_UPDATE, NONE);
+ *action = CHECKOUT_ACTION__REMOVE_AND_UPDATE;
/* don't update if the typechange is to a tree */
if (delta->new_file.mode == GIT_FILEMODE_TREE)
@@ -563,6 +569,9 @@ static int checkout_action_with_wd_blocker(
{
*action = CHECKOUT_ACTION__NONE;
+ if ((data->strategy & GIT_CHECKOUT_NONE))
+ return 0;
+
switch (delta->status) {
case GIT_DELTA_UNMODIFIED:
/* should show delta as dirty / deleted */
@@ -597,6 +606,9 @@ static int checkout_action_with_wd_dir(
{
*action = CHECKOUT_ACTION__NONE;
+ if ((data->strategy & GIT_CHECKOUT_NONE))
+ return 0;
+
switch (delta->status) {
case GIT_DELTA_UNMODIFIED: /* case 19 or 24 (or 34 but not really) */
GIT_ERROR_CHECK_ERROR(
@@ -627,7 +639,7 @@ static int checkout_action_with_wd_dir(
* directory if is it left empty, so we can defer removing the
* dir and it will succeed if no children are left.
*/
- *action = CHECKOUT_ACTION_IF(SAFE, UPDATE_BLOB, NONE);
+ *action = CHECKOUT_ACTION__UPDATE_BLOB;
}
else if (delta->new_file.mode != GIT_FILEMODE_TREE)
/* For typechange to dir, dir is already created so no action */
@@ -1419,8 +1431,10 @@ static int checkout_mkdir(
struct git_futils_mkdir_options mkdir_opts = {0};
int error;
- mkdir_opts.dir_map = data->mkdir_map;
- mkdir_opts.pool = &data->pool;
+ if (git_pool_is_initialized(&data->pool)) {
+ mkdir_opts.cache_pool = &data->pool;
+ mkdir_opts.cache_pathset = &data->mkdir_pathcache;
+ }
error = git_futils_mkdir_relative(
path, base, mode, flags, &mkdir_opts);
@@ -2316,11 +2330,11 @@ static void checkout_data_clear(checkout_data *data)
data->opts.baseline = NULL;
}
- git_vector_free(&data->removes);
+ git_vector_dispose(&data->removes);
git_pool_clear(&data->pool);
- git_vector_free_deep(&data->remove_conflicts);
- git_vector_free_deep(&data->update_conflicts);
+ git_vector_dispose_deep(&data->remove_conflicts);
+ git_vector_dispose_deep(&data->update_conflicts);
git__free(data->pfx);
data->pfx = NULL;
@@ -2331,8 +2345,7 @@ static void checkout_data_clear(checkout_data *data)
git_index_free(data->index);
data->index = NULL;
- git_strmap_free(data->mkdir_map);
- data->mkdir_map = NULL;
+ git_hashset_str_dispose(&data->mkdir_pathcache);
git_attr_session__free(&data->attr_session);
}
@@ -2432,14 +2445,12 @@ static int checkout_data_init(
/* if you are forcing, allow all safe updates, plus recreate missing */
if ((data->opts.checkout_strategy & GIT_CHECKOUT_FORCE) != 0)
- data->opts.checkout_strategy |= GIT_CHECKOUT_SAFE |
- GIT_CHECKOUT_RECREATE_MISSING;
+ data->opts.checkout_strategy |= GIT_CHECKOUT_RECREATE_MISSING;
/* if the repository does not actually have an index file, then this
* is an initial checkout (perhaps from clone), so we allow safe updates
*/
- if (!data->index->on_disk &&
- (data->opts.checkout_strategy & GIT_CHECKOUT_SAFE) != 0)
+ if (!data->index->on_disk)
data->opts.checkout_strategy |= GIT_CHECKOUT_RECREATE_MISSING;
data->strategy = data->opts.checkout_strategy;
@@ -2513,8 +2524,7 @@ static int checkout_data_init(
(error = git_vector_init(&data->remove_conflicts, 0, NULL)) < 0 ||
(error = git_vector_init(&data->update_conflicts, 0, NULL)) < 0 ||
(error = git_str_puts(&data->target_path, data->opts.target_directory)) < 0 ||
- (error = git_fs_path_to_dir(&data->target_path)) < 0 ||
- (error = git_strmap_new(&data->mkdir_map)) < 0)
+ (error = git_fs_path_to_dir(&data->target_path)) < 0)
goto cleanup;
data->target_len = git_str_len(&data->target_path);
diff --git a/src/libgit2/checkout.h b/src/libgit2/checkout.h
index 517fbf3b15e..e613325c7e8 100644
--- a/src/libgit2/checkout.h
+++ b/src/libgit2/checkout.h
@@ -12,8 +12,6 @@
#include "git2/checkout.h"
#include "iterator.h"
-#define GIT_CHECKOUT__NOTIFY_CONFLICT_TREE (1u << 12)
-
/**
* Update the working directory to match the target iterator. The
* expected baseline value can be passed in via the checkout options
diff --git a/src/libgit2/cherrypick.c b/src/libgit2/cherrypick.c
index 04812b1c6f5..561370169fc 100644
--- a/src/libgit2/cherrypick.c
+++ b/src/libgit2/cherrypick.c
@@ -73,8 +73,7 @@ static int cherrypick_normalize_opts(
const char *their_label)
{
int error = 0;
- unsigned int default_checkout_strategy = GIT_CHECKOUT_SAFE |
- GIT_CHECKOUT_ALLOW_CONFLICTS;
+ unsigned int default_checkout_strategy = GIT_CHECKOUT_ALLOW_CONFLICTS;
GIT_UNUSED(repo);
@@ -106,10 +105,10 @@ static int cherrypick_state_cleanup(git_repository *repo)
static int cherrypick_seterr(git_commit *commit, const char *fmt)
{
- char commit_oidstr[GIT_OID_SHA1_HEXSIZE + 1];
+ char commit_oidstr[GIT_OID_MAX_HEXSIZE + 1];
git_error_set(GIT_ERROR_CHERRYPICK, fmt,
- git_oid_tostr(commit_oidstr, GIT_OID_SHA1_HEXSIZE + 1, git_commit_id(commit)));
+ git_oid_tostr(commit_oidstr, GIT_OID_MAX_HEXSIZE + 1, git_commit_id(commit)));
return -1;
}
@@ -173,7 +172,7 @@ int git_cherrypick(
git_cherrypick_options opts;
git_reference *our_ref = NULL;
git_commit *our_commit = NULL;
- char commit_oidstr[GIT_OID_SHA1_HEXSIZE + 1];
+ char commit_oidstr[GIT_OID_MAX_HEXSIZE + 1];
const char *commit_msg, *commit_summary;
git_str their_label = GIT_STR_INIT;
git_index *index = NULL;
diff --git a/src/libgit2/clone.c b/src/libgit2/clone.c
index b73880e4486..237efc0ba7d 100644
--- a/src/libgit2/clone.c
+++ b/src/libgit2/clone.c
@@ -16,14 +16,14 @@
#include "git2/commit.h"
#include "git2/tree.h"
+#include "checkout.h"
#include "remote.h"
#include "futils.h"
#include "refs.h"
#include "fs_path.h"
#include "repository.h"
#include "odb.h"
-
-static int clone_local_into(git_repository *repo, git_remote *remote, const git_fetch_options *fetch_opts, const git_checkout_options *co_opts, const char *branch, int link);
+#include "net.h"
static int create_branch(
git_reference **branch,
@@ -336,8 +336,9 @@ static int create_and_configure_origin(
git_remote_create_cb remote_create = options->remote_cb;
void *payload = options->remote_cb_payload;
- /* If the path exists and is a dir, the url should be the absolute path */
- if (git_fs_path_root(url) < 0 && git_fs_path_exists(url) && git_fs_path_isdir(url)) {
+ /* If the path is local and exists it should be the absolute path. */
+ if (!git_net_str_is_url(url) && git_fs_path_root(url) < 0 &&
+ git_fs_path_exists(url)) {
if (p_realpath(url, buf) == NULL)
return -1;
@@ -360,35 +361,50 @@ static int create_and_configure_origin(
return error;
}
-static bool should_checkout(
+static int should_checkout(
+ bool *out,
git_repository *repo,
bool is_bare,
- const git_checkout_options *opts)
+ const git_clone_options *opts)
{
- if (is_bare)
- return false;
+ int error;
- if (!opts)
- return false;
+ if (!opts || is_bare ||
+ opts->checkout_opts.checkout_strategy == GIT_CHECKOUT_NONE) {
+ *out = false;
+ return 0;
+ }
- if (opts->checkout_strategy == GIT_CHECKOUT_NONE)
- return false;
+ if ((error = git_repository_head_unborn(repo)) < 0)
+ return error;
- return !git_repository_head_unborn(repo);
+ *out = !error;
+ return 0;
}
-static int checkout_branch(git_repository *repo, git_remote *remote, const git_checkout_options *co_opts, const char *branch, const char *reflog_message)
+static int checkout_branch(
+ git_repository *repo,
+ git_remote *remote,
+ const git_clone_options *opts,
+ const char *reflog_message)
{
+ bool checkout;
int error;
- if (branch)
- error = update_head_to_branch(repo, remote, branch, reflog_message);
+ if (opts->checkout_branch)
+ error = update_head_to_branch(repo, remote, opts->checkout_branch, reflog_message);
/* Point HEAD to the same ref as the remote's head */
else
error = update_head_to_remote(repo, remote, reflog_message);
- if (!error && should_checkout(repo, git_repository_is_bare(repo), co_opts))
- error = git_checkout_head(repo, co_opts);
+ if (error < 0)
+ return error;
+
+ if ((error = should_checkout(&checkout, repo, git_repository_is_bare(repo), opts)) < 0)
+ return error;
+
+ if (checkout)
+ error = git_checkout_head(repo, &opts->checkout_opts);
return error;
}
@@ -396,16 +412,13 @@ static int checkout_branch(git_repository *repo, git_remote *remote, const git_c
static int clone_into(
git_repository *repo,
git_remote *_remote,
- const git_fetch_options *opts,
- const git_checkout_options *co_opts,
- const char *branch)
+ const git_clone_options *opts)
{
- int error;
git_str reflog_message = GIT_STR_INIT;
git_remote_connect_options connect_opts = GIT_REMOTE_CONNECT_OPTIONS_INIT;
- git_fetch_options fetch_opts;
git_remote *remote;
git_oid_t oid_type;
+ int error;
GIT_ASSERT_ARG(repo);
GIT_ASSERT_ARG(_remote);
@@ -418,11 +431,7 @@ static int clone_into(
if ((error = git_remote_dup(&remote, _remote)) < 0)
return error;
- memcpy(&fetch_opts, opts, sizeof(git_fetch_options));
- fetch_opts.update_fetchhead = 0;
- fetch_opts.download_tags = GIT_REMOTE_DOWNLOAD_TAGS_ALL;
-
- if ((error = git_remote_connect_options__from_fetch_opts(&connect_opts, remote, &fetch_opts)) < 0)
+ if ((error = git_remote_connect_options__from_fetch_opts(&connect_opts, remote, &opts->fetch_opts)) < 0)
goto cleanup;
git_str_printf(&reflog_message, "clone: from %s", git_remote_url(remote));
@@ -440,10 +449,10 @@ static int clone_into(
(error = git_repository__set_objectformat(repo, oid_type)) < 0)
goto cleanup;
- if ((error = git_remote_fetch(remote, NULL, &fetch_opts, git_str_cstr(&reflog_message))) != 0)
+ if ((error = git_remote_fetch(remote, NULL, &opts->fetch_opts, git_str_cstr(&reflog_message))) != 0)
goto cleanup;
- error = checkout_branch(repo, remote, co_opts, branch, git_str_cstr(&reflog_message));
+ error = checkout_branch(repo, remote, opts, git_str_cstr(&reflog_message));
cleanup:
git_remote_free(remote);
@@ -453,37 +462,142 @@ static int clone_into(
return error;
}
-int git_clone__should_clone_local(const char *url_or_path, git_clone_local_t local)
+static bool can_link(const char *src, const char *dst, int link)
+{
+#ifdef GIT_WIN32
+ GIT_UNUSED(src);
+ GIT_UNUSED(dst);
+ GIT_UNUSED(link);
+ return false;
+#else
+
+ struct stat st_src, st_dst;
+
+ if (!link)
+ return false;
+
+ if (p_stat(src, &st_src) < 0)
+ return false;
+
+ if (p_stat(dst, &st_dst) < 0)
+ return false;
+
+ return st_src.st_dev == st_dst.st_dev;
+#endif
+}
+
+static int clone_local_into(
+ git_repository *repo,
+ git_remote *remote,
+ const git_clone_options *opts)
+{
+ int error, flags;
+ git_repository *src;
+ git_str src_odb = GIT_STR_INIT, dst_odb = GIT_STR_INIT, src_path = GIT_STR_INIT;
+ git_str reflog_message = GIT_STR_INIT;
+ bool link = (opts && opts->local != GIT_CLONE_LOCAL_NO_LINKS);
+
+ GIT_ASSERT_ARG(repo);
+ GIT_ASSERT_ARG(remote);
+
+ if (!git_repository_is_empty(repo)) {
+ git_error_set(GIT_ERROR_INVALID, "the repository is not empty");
+ return -1;
+ }
+
+ /*
+ * Let's figure out what path we should use for the source
+ * repo, if it's not rooted, the path should be relative to
+ * the repository's worktree/gitdir.
+ */
+ if ((error = git_fs_path_from_url_or_path(&src_path, git_remote_url(remote))) < 0)
+ return error;
+
+ /* Copy .git/objects/ from the source to the target */
+ if ((error = git_repository_open(&src, git_str_cstr(&src_path))) < 0) {
+ git_str_dispose(&src_path);
+ return error;
+ }
+
+ if (git_repository__item_path(&src_odb, src, GIT_REPOSITORY_ITEM_OBJECTS) < 0 ||
+ git_repository__item_path(&dst_odb, repo, GIT_REPOSITORY_ITEM_OBJECTS) < 0) {
+ error = -1;
+ goto cleanup;
+ }
+
+ flags = 0;
+ if (can_link(git_repository_path(src), git_repository_path(repo), link))
+ flags |= GIT_CPDIR_LINK_FILES;
+
+ error = git_futils_cp_r(git_str_cstr(&src_odb), git_str_cstr(&dst_odb),
+ flags, GIT_OBJECT_DIR_MODE);
+
+ /*
+ * can_link() doesn't catch all variations, so if we hit an
+ * error and did want to link, let's try again without trying
+ * to link.
+ */
+ if (error < 0 && link) {
+ flags &= ~GIT_CPDIR_LINK_FILES;
+ error = git_futils_cp_r(git_str_cstr(&src_odb), git_str_cstr(&dst_odb),
+ flags, GIT_OBJECT_DIR_MODE);
+ }
+
+ if (error < 0)
+ goto cleanup;
+
+ git_str_printf(&reflog_message, "clone: from %s", git_remote_url(remote));
+
+ if ((error = git_remote_fetch(remote, NULL, &opts->fetch_opts, git_str_cstr(&reflog_message))) != 0)
+ goto cleanup;
+
+ error = checkout_branch(repo, remote, opts, git_str_cstr(&reflog_message));
+
+cleanup:
+ git_str_dispose(&reflog_message);
+ git_str_dispose(&src_path);
+ git_str_dispose(&src_odb);
+ git_str_dispose(&dst_odb);
+ git_repository_free(src);
+ return error;
+}
+
+int git_clone__should_clone_local(
+ bool *out,
+ const char *url_or_path,
+ git_clone_local_t local)
{
git_str fromurl = GIT_STR_INIT;
- const char *path = url_or_path;
- bool is_url, is_local;
+
+ *out = false;
if (local == GIT_CLONE_NO_LOCAL)
return 0;
- if ((is_url = git_fs_path_is_local_file_url(url_or_path)) != 0) {
- if (git_fs_path_fromurl(&fromurl, url_or_path) < 0) {
- is_local = -1;
- goto done;
- }
+ if (git_net_str_is_url(url_or_path)) {
+ /* If GIT_CLONE_LOCAL_AUTO is specified, any url should
+ * be treated as remote */
+ if (local == GIT_CLONE_LOCAL_AUTO ||
+ !git_fs_path_is_local_file_url(url_or_path))
+ return 0;
- path = fromurl.ptr;
- }
+ if (git_fs_path_fromurl(&fromurl, url_or_path) < 0)
+ return -1;
- is_local = (!is_url || local != GIT_CLONE_LOCAL_AUTO) &&
- git_fs_path_isdir(path);
+ *out = git_fs_path_isdir(git_str_cstr(&fromurl));
+ git_str_dispose(&fromurl);
+ } else {
+ *out = git_fs_path_isdir(url_or_path);
+ }
-done:
- git_str_dispose(&fromurl);
- return is_local;
+ return 0;
}
-static int git__clone(
+static int clone_repo(
git_repository **out,
const char *url,
const char *local_path,
- const git_clone_options *_options,
+ const git_clone_options *given_opts,
int use_existing)
{
int error = 0;
@@ -497,11 +611,17 @@ static int git__clone(
GIT_ASSERT_ARG(url);
GIT_ASSERT_ARG(local_path);
- if (_options)
- memcpy(&options, _options, sizeof(git_clone_options));
+ if (given_opts)
+ memcpy(&options, given_opts, sizeof(git_clone_options));
GIT_ERROR_CHECK_VERSION(&options, GIT_CLONE_OPTIONS_VERSION, "git_clone_options");
+ /* enforce some behavior on fetch */
+ options.fetch_opts.update_fetchhead = 0;
+
+ if (!options.fetch_opts.depth)
+ options.fetch_opts.download_tags = GIT_REMOTE_DOWNLOAD_TAGS_ALL;
+
/* Only clone to a new directory or an empty directory */
if (git_fs_path_exists(local_path) && !use_existing && !git_fs_path_is_empty_dir(local_path)) {
git_error_set(GIT_ERROR_INVALID,
@@ -522,33 +642,31 @@ static int git__clone(
return error;
if (!(error = create_and_configure_origin(&origin, repo, url, &options))) {
- int clone_local = git_clone__should_clone_local(url, options.local);
- int link = options.local != GIT_CLONE_LOCAL_NO_LINKS;
-
- if (clone_local == 1)
- error = clone_local_into(
- repo, origin, &options.fetch_opts, &options.checkout_opts,
- options.checkout_branch, link);
- else if (clone_local == 0)
- error = clone_into(
- repo, origin, &options.fetch_opts, &options.checkout_opts,
- options.checkout_branch);
+ bool clone_local;
+
+ if ((error = git_clone__should_clone_local(&clone_local, url, options.local)) < 0) {
+ git_remote_free(origin);
+ return error;
+ }
+
+ if (clone_local)
+ error = clone_local_into(repo, origin, &options);
else
- error = -1;
+ error = clone_into(repo, origin, &options);
git_remote_free(origin);
}
if (error != 0) {
- git_error_state last_error = {0};
- git_error_state_capture(&last_error, error);
+ git_error *last_error;
+ git_error_save(&last_error);
git_repository_free(repo);
repo = NULL;
(void)git_futils_rmdir_r(local_path, NULL, rmdir_flags);
- git_error_state_restore(&last_error);
+ git_error_restore(last_error);
}
*out = repo;
@@ -559,18 +677,18 @@ int git_clone(
git_repository **out,
const char *url,
const char *local_path,
- const git_clone_options *_options)
+ const git_clone_options *options)
{
- return git__clone(out, url, local_path, _options, 0);
+ return clone_repo(out, url, local_path, options, 0);
}
int git_clone__submodule(
git_repository **out,
const char *url,
const char *local_path,
- const git_clone_options *_options)
+ const git_clone_options *options)
{
- return git__clone(out, url, local_path, _options, 1);
+ return clone_repo(out, url, local_path, options, 1);
}
int git_clone_options_init(git_clone_options *opts, unsigned int version)
@@ -586,99 +704,3 @@ int git_clone_init_options(git_clone_options *opts, unsigned int version)
return git_clone_options_init(opts, version);
}
#endif
-
-static bool can_link(const char *src, const char *dst, int link)
-{
-#ifdef GIT_WIN32
- GIT_UNUSED(src);
- GIT_UNUSED(dst);
- GIT_UNUSED(link);
- return false;
-#else
-
- struct stat st_src, st_dst;
-
- if (!link)
- return false;
-
- if (p_stat(src, &st_src) < 0)
- return false;
-
- if (p_stat(dst, &st_dst) < 0)
- return false;
-
- return st_src.st_dev == st_dst.st_dev;
-#endif
-}
-
-static int clone_local_into(git_repository *repo, git_remote *remote, const git_fetch_options *fetch_opts, const git_checkout_options *co_opts, const char *branch, int link)
-{
- int error, flags;
- git_repository *src;
- git_str src_odb = GIT_STR_INIT, dst_odb = GIT_STR_INIT, src_path = GIT_STR_INIT;
- git_str reflog_message = GIT_STR_INIT;
-
- GIT_ASSERT_ARG(repo);
- GIT_ASSERT_ARG(remote);
-
- if (!git_repository_is_empty(repo)) {
- git_error_set(GIT_ERROR_INVALID, "the repository is not empty");
- return -1;
- }
-
- /*
- * Let's figure out what path we should use for the source
- * repo, if it's not rooted, the path should be relative to
- * the repository's worktree/gitdir.
- */
- if ((error = git_fs_path_from_url_or_path(&src_path, git_remote_url(remote))) < 0)
- return error;
-
- /* Copy .git/objects/ from the source to the target */
- if ((error = git_repository_open(&src, git_str_cstr(&src_path))) < 0) {
- git_str_dispose(&src_path);
- return error;
- }
-
- if (git_repository__item_path(&src_odb, src, GIT_REPOSITORY_ITEM_OBJECTS) < 0 ||
- git_repository__item_path(&dst_odb, repo, GIT_REPOSITORY_ITEM_OBJECTS) < 0) {
- error = -1;
- goto cleanup;
- }
-
- flags = 0;
- if (can_link(git_repository_path(src), git_repository_path(repo), link))
- flags |= GIT_CPDIR_LINK_FILES;
-
- error = git_futils_cp_r(git_str_cstr(&src_odb), git_str_cstr(&dst_odb),
- flags, GIT_OBJECT_DIR_MODE);
-
- /*
- * can_link() doesn't catch all variations, so if we hit an
- * error and did want to link, let's try again without trying
- * to link.
- */
- if (error < 0 && link) {
- flags &= ~GIT_CPDIR_LINK_FILES;
- error = git_futils_cp_r(git_str_cstr(&src_odb), git_str_cstr(&dst_odb),
- flags, GIT_OBJECT_DIR_MODE);
- }
-
- if (error < 0)
- goto cleanup;
-
- git_str_printf(&reflog_message, "clone: from %s", git_remote_url(remote));
-
- if ((error = git_remote_fetch(remote, NULL, fetch_opts, git_str_cstr(&reflog_message))) != 0)
- goto cleanup;
-
- error = checkout_branch(repo, remote, co_opts, branch, git_str_cstr(&reflog_message));
-
-cleanup:
- git_str_dispose(&reflog_message);
- git_str_dispose(&src_path);
- git_str_dispose(&src_odb);
- git_str_dispose(&dst_odb);
- git_repository_free(src);
- return error;
-}
diff --git a/src/libgit2/clone.h b/src/libgit2/clone.h
index 7d73cabd53c..fde796f91bd 100644
--- a/src/libgit2/clone.h
+++ b/src/libgit2/clone.h
@@ -15,6 +15,9 @@ extern int git_clone__submodule(git_repository **out,
const char *url, const char *local_path,
const git_clone_options *_options);
-extern int git_clone__should_clone_local(const char *url, git_clone_local_t local);
+extern int git_clone__should_clone_local(
+ bool *out,
+ const char *url,
+ git_clone_local_t local);
#endif
diff --git a/src/libgit2/commit.c b/src/libgit2/commit.c
index d85fefb3d48..10df43623d2 100644
--- a/src/libgit2/commit.c
+++ b/src/libgit2/commit.c
@@ -22,6 +22,7 @@
#include "object.h"
#include "array.h"
#include "oidarray.h"
+#include "grafts.h"
void git_commit__free(void *_commit)
{
@@ -427,10 +428,6 @@ static int commit_parse(
buffer += tree_len;
}
- /*
- * TODO: commit grafts!
- */
-
while (git_object__parse_oid_header(&parent_id,
&buffer, buffer_end, "parent ",
opts->oid_type) == 0) {
@@ -532,16 +529,41 @@ int git_commit__parse_raw(
return commit_parse(commit, data, size, &parse_options);
}
+static int assign_commit_parents_from_graft(git_commit *commit, git_commit_graft *graft) {
+ size_t idx;
+ git_oid *oid;
+
+ git_array_clear(commit->parent_ids);
+ git_array_init_to_size(commit->parent_ids, git_array_size(graft->parents));
+ git_array_foreach(graft->parents, idx, oid) {
+ git_oid *id = git_array_alloc(commit->parent_ids);
+ GIT_ERROR_CHECK_ALLOC(id);
+
+ git_oid_cpy(id, oid);
+ }
+
+ return 0;
+}
+
int git_commit__parse_ext(
git_commit *commit,
git_odb_object *odb_obj,
git_commit__parse_options *parse_opts)
{
- return commit_parse(
- commit,
- git_odb_object_data(odb_obj),
- git_odb_object_size(odb_obj),
- parse_opts);
+ git_repository *repo = git_object_owner((git_object *)commit);
+ git_commit_graft *graft;
+ int error;
+
+ if ((error = commit_parse(commit, git_odb_object_data(odb_obj),
+ git_odb_object_size(odb_obj), parse_opts)) < 0)
+ return error;
+
+ /* Perform necessary grafts */
+ if (git_grafts_get(&graft, repo->grafts, git_odb_object_id(odb_obj)) != 0 &&
+ git_grafts_get(&graft, repo->shallow_grafts, git_odb_object_id(odb_obj)) != 0)
+ return 0;
+
+ return assign_commit_parents_from_graft(commit, graft);
}
#define GIT_COMMIT_GETTER(_rvalue, _name, _return, _invalid) \
@@ -1064,6 +1086,83 @@ int git_commit_create_with_signature(
return error;
}
+int git_commit_create_from_stage(
+ git_oid *out,
+ git_repository *repo,
+ const char *message,
+ const git_commit_create_options *given_opts)
+{
+ git_commit_create_options opts = GIT_COMMIT_CREATE_OPTIONS_INIT;
+ git_signature *default_signature = NULL;
+ const git_signature *author, *committer;
+ git_index *index = NULL;
+ git_diff *diff = NULL;
+ git_oid tree_id;
+ git_tree *head_tree = NULL, *tree = NULL;
+ git_commitarray parents = { 0 };
+ int error = -1;
+
+ GIT_ASSERT_ARG(out && repo);
+
+ if (given_opts)
+ memcpy(&opts, given_opts, sizeof(git_commit_create_options));
+
+ author = opts.author;
+ committer = opts.committer;
+
+ if (!author || !committer) {
+ if (git_signature_default(&default_signature, repo) < 0)
+ goto done;
+
+ if (!author)
+ author = default_signature;
+
+ if (!committer)
+ committer = default_signature;
+ }
+
+ if (git_repository_index(&index, repo) < 0)
+ goto done;
+
+ if (!opts.allow_empty_commit) {
+ error = git_repository_head_tree(&head_tree, repo);
+
+ if (error && error != GIT_EUNBORNBRANCH)
+ goto done;
+
+ error = -1;
+
+ if (git_diff_tree_to_index(&diff, repo, head_tree, index, NULL) < 0)
+ goto done;
+
+ if (git_diff_num_deltas(diff) == 0) {
+ git_error_set(GIT_ERROR_REPOSITORY,
+ "no changes are staged for commit");
+ error = GIT_EUNCHANGED;
+ goto done;
+ }
+ }
+
+ if (git_index_write_tree(&tree_id, index) < 0 ||
+ git_tree_lookup(&tree, repo, &tree_id) < 0 ||
+ git_repository_commit_parents(&parents, repo) < 0)
+ goto done;
+
+ error = git_commit_create(out, repo, "HEAD", author, committer,
+ opts.message_encoding, message,
+ tree, parents.count,
+ (const git_commit **)parents.commits);
+
+done:
+ git_commitarray_dispose(&parents);
+ git_signature_free(default_signature);
+ git_tree_free(tree);
+ git_tree_free(head_tree);
+ git_diff_free(diff);
+ git_index_free(index);
+ return error;
+}
+
int git_commit_committer_with_mailmap(
git_signature **out, const git_commit *commit, const git_mailmap *mailmap)
{
@@ -1075,3 +1174,18 @@ int git_commit_author_with_mailmap(
{
return git_mailmap_resolve_signature(out, mailmap, commit->author);
}
+
+void git_commitarray_dispose(git_commitarray *array)
+{
+ size_t i;
+
+ if (array == NULL)
+ return;
+
+ for (i = 0; i < array->count; i++)
+ git_commit_free(array->commits[i]);
+
+ git__free((git_commit **)array->commits);
+
+ memset(array, 0, sizeof(*array));
+}
diff --git a/src/libgit2/commit_graph.c b/src/libgit2/commit_graph.c
index bf557f7ad66..f62b873cc01 100644
--- a/src/libgit2/commit_graph.c
+++ b/src/libgit2/commit_graph.c
@@ -13,7 +13,6 @@
#include "futils.h"
#include "hash.h"
#include "oidarray.h"
-#include "oidmap.h"
#include "pack.h"
#include "repository.h"
#include "revwalk.h"
@@ -25,6 +24,7 @@
#define COMMIT_GRAPH_SIGNATURE 0x43475048 /* "CGPH" */
#define COMMIT_GRAPH_VERSION 1
#define COMMIT_GRAPH_OBJECT_ID_VERSION 1
+
struct git_commit_graph_header {
uint32_t signature;
uint8_t version;
@@ -138,19 +138,22 @@ static int commit_graph_parse_oid_lookup(
struct git_commit_graph_chunk *chunk_oid_lookup)
{
uint32_t i;
- unsigned char *oid, *prev_oid, zero_oid[GIT_OID_SHA1_SIZE] = {0};
+ unsigned char *oid, *prev_oid, zero_oid[GIT_OID_MAX_SIZE] = {0};
+ size_t oid_size;
+
+ oid_size = git_oid_size(file->oid_type);
if (chunk_oid_lookup->offset == 0)
return commit_graph_error("missing OID Lookup chunk");
if (chunk_oid_lookup->length == 0)
return commit_graph_error("empty OID Lookup chunk");
- if (chunk_oid_lookup->length != file->num_commits * GIT_OID_SHA1_SIZE)
+ if (chunk_oid_lookup->length != file->num_commits * oid_size)
return commit_graph_error("OID Lookup chunk has wrong length");
file->oid_lookup = oid = (unsigned char *)(data + chunk_oid_lookup->offset);
prev_oid = zero_oid;
- for (i = 0; i < file->num_commits; ++i, oid += GIT_OID_SHA1_SIZE) {
- if (git_oid_raw_cmp(prev_oid, oid, GIT_OID_SHA1_SIZE) >= 0)
+ for (i = 0; i < file->num_commits; ++i, oid += oid_size) {
+ if (git_oid_raw_cmp(prev_oid, oid, oid_size) >= 0)
return commit_graph_error("OID Lookup index is non-monotonic");
prev_oid = oid;
}
@@ -163,11 +166,13 @@ static int commit_graph_parse_commit_data(
const unsigned char *data,
struct git_commit_graph_chunk *chunk_commit_data)
{
+ size_t oid_size = git_oid_size(file->oid_type);
+
if (chunk_commit_data->offset == 0)
return commit_graph_error("missing Commit Data chunk");
if (chunk_commit_data->length == 0)
return commit_graph_error("empty Commit Data chunk");
- if (chunk_commit_data->length != file->num_commits * (GIT_OID_SHA1_SIZE + 16))
+ if (chunk_commit_data->length != file->num_commits * (oid_size + 16))
return commit_graph_error("Commit Data chunk has wrong length");
file->commit_data = data + chunk_commit_data->offset;
@@ -209,7 +214,9 @@ int git_commit_graph_file_parse(
GIT_ASSERT_ARG(file);
- if (size < sizeof(struct git_commit_graph_header) + GIT_OID_SHA1_SIZE)
+ checksum_size = git_oid_size(file->oid_type);
+
+ if (size < sizeof(struct git_commit_graph_header) + checksum_size)
return commit_graph_error("commit-graph is too short");
hdr = ((struct git_commit_graph_header *)data);
@@ -226,8 +233,7 @@ int git_commit_graph_file_parse(
* headers, and a special zero chunk.
*/
last_chunk_offset = sizeof(struct git_commit_graph_header) + (1 + hdr->chunks) * 12;
- trailer_offset = size - GIT_OID_SHA1_SIZE;
- checksum_size = GIT_HASH_SHA1_SIZE;
+ trailer_offset = size - checksum_size;
if (trailer_offset < last_chunk_offset)
return commit_graph_error("wrong commit-graph size");
@@ -295,25 +301,35 @@ int git_commit_graph_file_parse(
return 0;
}
-int git_commit_graph_new(git_commit_graph **cgraph_out, const char *objects_dir, bool open_file)
+int git_commit_graph_new(
+ git_commit_graph **cgraph_out,
+ const char *objects_dir,
+ bool open_file,
+ git_oid_t oid_type)
{
git_commit_graph *cgraph = NULL;
int error = 0;
GIT_ASSERT_ARG(cgraph_out);
GIT_ASSERT_ARG(objects_dir);
+ GIT_ASSERT_ARG(oid_type);
cgraph = git__calloc(1, sizeof(git_commit_graph));
GIT_ERROR_CHECK_ALLOC(cgraph);
+ cgraph->oid_type = oid_type;
+
error = git_str_joinpath(&cgraph->filename, objects_dir, "info/commit-graph");
if (error < 0)
goto error;
if (open_file) {
- error = git_commit_graph_file_open(&cgraph->file, git_str_cstr(&cgraph->filename));
+ error = git_commit_graph_file_open(&cgraph->file,
+ git_str_cstr(&cgraph->filename), oid_type);
+
if (error < 0)
goto error;
+
cgraph->checked = 1;
}
@@ -326,14 +342,18 @@ int git_commit_graph_new(git_commit_graph **cgraph_out, const char *objects_dir,
}
int git_commit_graph_validate(git_commit_graph *cgraph) {
- unsigned char checksum[GIT_HASH_SHA1_SIZE];
- size_t checksum_size = GIT_HASH_SHA1_SIZE;
- size_t trailer_offset = cgraph->file->graph_map.len - checksum_size;
+ unsigned char checksum[GIT_HASH_MAX_SIZE];
+ git_hash_algorithm_t checksum_type;
+ size_t checksum_size, trailer_offset;
+
+ checksum_type = git_oid_algorithm(cgraph->oid_type);
+ checksum_size = git_hash_size(checksum_type);
+ trailer_offset = cgraph->file->graph_map.len - checksum_size;
if (cgraph->file->graph_map.len < checksum_size)
return commit_graph_error("map length too small");
- if (git_hash_buf(checksum, cgraph->file->graph_map.data, trailer_offset, GIT_HASH_ALGORITHM_SHA1) < 0)
+ if (git_hash_buf(checksum, cgraph->file->graph_map.data, trailer_offset, checksum_type) < 0)
return commit_graph_error("could not calculate signature");
if (memcmp(checksum, cgraph->file->checksum, checksum_size) != 0)
return commit_graph_error("index signature mismatch");
@@ -341,16 +361,41 @@ int git_commit_graph_validate(git_commit_graph *cgraph) {
return 0;
}
-int git_commit_graph_open(git_commit_graph **cgraph_out, const char *objects_dir)
+int git_commit_graph_open(
+ git_commit_graph **cgraph_out,
+ const char *objects_dir
+#ifdef GIT_EXPERIMENTAL_SHA256
+ , const git_commit_graph_open_options *opts
+#endif
+ )
{
- int error = git_commit_graph_new(cgraph_out, objects_dir, true);
- if (!error) {
+ git_oid_t oid_type;
+ int error;
+
+#ifdef GIT_EXPERIMENTAL_SHA256
+ GIT_ERROR_CHECK_VERSION(opts,
+ GIT_COMMIT_GRAPH_OPEN_OPTIONS_VERSION,
+ "git_commit_graph_open_options");
+
+ oid_type = opts && opts->oid_type ? opts->oid_type : GIT_OID_DEFAULT;
+ GIT_ASSERT_ARG(git_oid_type_is_valid(oid_type));
+#else
+ oid_type = GIT_OID_SHA1;
+#endif
+
+ error = git_commit_graph_new(cgraph_out, objects_dir, true,
+ oid_type);
+
+ if (!error)
return git_commit_graph_validate(*cgraph_out);
- }
+
return error;
}
-int git_commit_graph_file_open(git_commit_graph_file **file_out, const char *path)
+int git_commit_graph_file_open(
+ git_commit_graph_file **file_out,
+ const char *path,
+ git_oid_t oid_type)
{
git_commit_graph_file *file;
git_file fd = -1;
@@ -379,6 +424,8 @@ int git_commit_graph_file_open(git_commit_graph_file **file_out, const char *pat
file = git__calloc(1, sizeof(git_commit_graph_file));
GIT_ERROR_CHECK_ALLOC(file);
+ file->oid_type = oid_type;
+
error = git_futils_mmap_ro(&file->graph_map, fd, 0, cgraph_size);
p_close(fd);
if (error < 0) {
@@ -395,7 +442,9 @@ int git_commit_graph_file_open(git_commit_graph_file **file_out, const char *pat
return 0;
}
-int git_commit_graph_get_file(git_commit_graph_file **file_out, git_commit_graph *cgraph)
+int git_commit_graph_get_file(
+ git_commit_graph_file **file_out,
+ git_commit_graph *cgraph)
{
if (!cgraph->checked) {
int error = 0;
@@ -405,7 +454,8 @@ int git_commit_graph_get_file(git_commit_graph_file **file_out, git_commit_graph
cgraph->checked = 1;
/* Best effort */
- error = git_commit_graph_file_open(&result, git_str_cstr(&cgraph->filename));
+ error = git_commit_graph_file_open(&result,
+ git_str_cstr(&cgraph->filename), cgraph->oid_type);
if (error < 0)
return error;
@@ -441,6 +491,7 @@ static int git_commit_graph_entry_get_byindex(
size_t pos)
{
const unsigned char *commit_data;
+ size_t oid_size = git_oid_size(file->oid_type);
GIT_ASSERT_ARG(e);
GIT_ASSERT_ARG(file);
@@ -450,15 +501,15 @@ static int git_commit_graph_entry_get_byindex(
return GIT_ENOTFOUND;
}
- commit_data = file->commit_data + pos * (GIT_OID_SHA1_SIZE + 4 * sizeof(uint32_t));
- git_oid__fromraw(&e->tree_oid, commit_data, GIT_OID_SHA1);
- e->parent_indices[0] = ntohl(*((uint32_t *)(commit_data + GIT_OID_SHA1_SIZE)));
+ commit_data = file->commit_data + pos * (oid_size + 4 * sizeof(uint32_t));
+ git_oid_from_raw(&e->tree_oid, commit_data, file->oid_type);
+ e->parent_indices[0] = ntohl(*((uint32_t *)(commit_data + oid_size)));
e->parent_indices[1] = ntohl(
- *((uint32_t *)(commit_data + GIT_OID_SHA1_SIZE + sizeof(uint32_t))));
+ *((uint32_t *)(commit_data + oid_size + sizeof(uint32_t))));
e->parent_count = (e->parent_indices[0] != GIT_COMMIT_GRAPH_MISSING_PARENT)
+ (e->parent_indices[1] != GIT_COMMIT_GRAPH_MISSING_PARENT);
- e->generation = ntohl(*((uint32_t *)(commit_data + GIT_OID_SHA1_SIZE + 2 * sizeof(uint32_t))));
- e->commit_time = ntohl(*((uint32_t *)(commit_data + GIT_OID_SHA1_SIZE + 3 * sizeof(uint32_t))));
+ e->generation = ntohl(*((uint32_t *)(commit_data + oid_size + 2 * sizeof(uint32_t))));
+ e->commit_time = ntohl(*((uint32_t *)(commit_data + oid_size + 3 * sizeof(uint32_t))));
e->commit_time |= (e->generation & UINT64_C(0x3)) << UINT64_C(32);
e->generation >>= 2u;
@@ -485,7 +536,7 @@ static int git_commit_graph_entry_get_byindex(
}
}
- git_oid__fromraw(&e->sha1, &file->oid_lookup[pos * GIT_OID_SHA1_SIZE], GIT_OID_SHA1);
+ git_oid_from_raw(&e->sha1, &file->oid_lookup[pos * oid_size], file->oid_type);
return 0;
}
@@ -494,8 +545,8 @@ bool git_commit_graph_file_needs_refresh(const git_commit_graph_file *file, cons
git_file fd = -1;
struct stat st;
ssize_t bytes_read;
- unsigned char checksum[GIT_HASH_SHA1_SIZE];
- size_t checksum_size = GIT_HASH_SHA1_SIZE;
+ unsigned char checksum[GIT_HASH_MAX_SIZE];
+ size_t checksum_size = git_oid_size(file->oid_type);
/* TODO: properly open the file without access time using O_NOATIME */
fd = git_futils_open_ro(path);
@@ -530,35 +581,40 @@ int git_commit_graph_entry_find(
int pos, found = 0;
uint32_t hi, lo;
const unsigned char *current = NULL;
+ size_t oid_size, oid_hexsize;
GIT_ASSERT_ARG(e);
GIT_ASSERT_ARG(file);
GIT_ASSERT_ARG(short_oid);
+ oid_size = git_oid_size(file->oid_type);
+ oid_hexsize = git_oid_hexsize(file->oid_type);
+
hi = ntohl(file->oid_fanout[(int)short_oid->id[0]]);
lo = ((short_oid->id[0] == 0x0) ? 0 : ntohl(file->oid_fanout[(int)short_oid->id[0] - 1]));
- pos = git_pack__lookup_id(file->oid_lookup, GIT_OID_SHA1_SIZE, lo, hi, short_oid->id, GIT_OID_SHA1);
+ pos = git_pack__lookup_id(file->oid_lookup, oid_size, lo, hi,
+ short_oid->id, file->oid_type);
if (pos >= 0) {
/* An object matching exactly the oid was found */
found = 1;
- current = file->oid_lookup + (pos * GIT_OID_SHA1_SIZE);
+ current = file->oid_lookup + (pos * oid_size);
} else {
/* No object was found */
/* pos refers to the object with the "closest" oid to short_oid */
pos = -1 - pos;
if (pos < (int)file->num_commits) {
- current = file->oid_lookup + (pos * GIT_OID_SHA1_SIZE);
+ current = file->oid_lookup + (pos * oid_size);
if (!git_oid_raw_ncmp(short_oid->id, current, len))
found = 1;
}
}
- if (found && len != GIT_OID_SHA1_HEXSIZE && pos + 1 < (int)file->num_commits) {
+ if (found && len != oid_hexsize && pos + 1 < (int)file->num_commits) {
/* Check for ambiguousity */
- const unsigned char *next = current + GIT_OID_SHA1_SIZE;
+ const unsigned char *next = current + oid_size;
if (!git_oid_raw_ncmp(short_oid->id, next, len))
found = 2;
@@ -637,11 +693,46 @@ static int packed_commit__cmp(const void *a_, const void *b_)
return git_oid_cmp(&a->sha1, &b->sha1);
}
-int git_commit_graph_writer_new(git_commit_graph_writer **out, const char *objects_info_dir)
+int git_commit_graph_writer_options_init(
+ git_commit_graph_writer_options *opts,
+ unsigned int version)
{
- git_commit_graph_writer *w = git__calloc(1, sizeof(git_commit_graph_writer));
+ GIT_INIT_STRUCTURE_FROM_TEMPLATE(
+ opts,
+ version,
+ git_commit_graph_writer_options,
+ GIT_COMMIT_GRAPH_WRITER_OPTIONS_INIT);
+ return 0;
+}
+
+int git_commit_graph_writer_new(
+ git_commit_graph_writer **out,
+ const char *objects_info_dir,
+ const git_commit_graph_writer_options *opts
+ )
+{
+ git_commit_graph_writer *w;
+ git_oid_t oid_type;
+
+#ifdef GIT_EXPERIMENTAL_SHA256
+ GIT_ERROR_CHECK_VERSION(opts,
+ GIT_COMMIT_GRAPH_WRITER_OPTIONS_VERSION,
+ "git_commit_graph_writer_options");
+
+ oid_type = opts && opts->oid_type ? opts->oid_type : GIT_OID_DEFAULT;
+ GIT_ASSERT_ARG(git_oid_type_is_valid(oid_type));
+#else
+ GIT_UNUSED(opts);
+ oid_type = GIT_OID_SHA1;
+#endif
+
+ GIT_ASSERT_ARG(out && objects_info_dir);
+
+ w = git__calloc(1, sizeof(git_commit_graph_writer));
GIT_ERROR_CHECK_ALLOC(w);
+ w->oid_type = oid_type;
+
if (git_str_sets(&w->objects_info_dir, objects_info_dir) < 0) {
git__free(w);
return -1;
@@ -667,7 +758,7 @@ void git_commit_graph_writer_free(git_commit_graph_writer *w)
git_vector_foreach (&w->commits, i, packed_commit)
packed_commit_free(packed_commit);
- git_vector_free(&w->commits);
+ git_vector_dispose(&w->commits);
git_str_dispose(&w->objects_info_dir);
git__free(w);
}
@@ -712,9 +803,9 @@ static int object_entry__cb(const git_oid *id, void *data)
}
int git_commit_graph_writer_add_index_file(
- git_commit_graph_writer *w,
- git_repository *repo,
- const char *idx_path)
+ git_commit_graph_writer *w,
+ git_repository *repo,
+ const char *idx_path)
{
int error;
struct git_pack_file *p = NULL;
@@ -776,6 +867,8 @@ enum generation_number_commit_state {
GENERATION_NUMBER_COMMIT_STATE_VISITED = 3
};
+GIT_HASHMAP_OID_SETUP(git_commit_graph_oidmap, struct packed_commit *);
+
static int compute_generation_numbers(git_vector *commits)
{
git_array_t(size_t) index_stack = GIT_ARRAY_INIT;
@@ -783,17 +876,14 @@ static int compute_generation_numbers(git_vector *commits)
size_t *parent_idx;
enum generation_number_commit_state *commit_states = NULL;
struct packed_commit *child_packed_commit;
- git_oidmap *packed_commit_map = NULL;
+ git_commit_graph_oidmap packed_commit_map = GIT_HASHMAP_INIT;
int error = 0;
/* First populate the parent indices fields */
- error = git_oidmap_new(&packed_commit_map);
- if (error < 0)
- goto cleanup;
git_vector_foreach (commits, i, child_packed_commit) {
child_packed_commit->index = i;
- error = git_oidmap_set(
- packed_commit_map, &child_packed_commit->sha1, child_packed_commit);
+ error = git_commit_graph_oidmap_put(&packed_commit_map,
+ &child_packed_commit->sha1, child_packed_commit);
if (error < 0)
goto cleanup;
}
@@ -811,8 +901,7 @@ static int compute_generation_numbers(git_vector *commits)
goto cleanup;
}
git_array_foreach (child_packed_commit->parents, parent_i, parent_id) {
- parent_packed_commit = git_oidmap_get(packed_commit_map, parent_id);
- if (!parent_packed_commit) {
+ if (git_commit_graph_oidmap_get(&parent_packed_commit, &packed_commit_map, parent_id) != 0) {
git_error_set(GIT_ERROR_ODB,
"parent commit %s not found in commit graph",
git_oid_tostr_s(parent_id));
@@ -912,7 +1001,7 @@ static int compute_generation_numbers(git_vector *commits)
}
cleanup:
- git_oidmap_free(packed_commit_map);
+ git_commit_graph_oidmap_dispose(&packed_commit_map);
git__free(commit_states);
git_array_clear(index_stack);
@@ -966,9 +1055,12 @@ static int commit_graph_write_hash(const char *buf, size_t size, void *data)
struct commit_graph_write_hash_context *ctx = data;
int error;
- error = git_hash_update(ctx->ctx, buf, size);
- if (error < 0)
- return error;
+ if (ctx->ctx) {
+ error = git_hash_update(ctx->ctx, buf, size);
+
+ if (error < 0)
+ return error;
+ }
return ctx->write_cb(buf, size, ctx->cb_data);
}
@@ -979,9 +1071,9 @@ static void packed_commit_free_dup(void *packed_commit)
}
static int commit_graph_write(
- git_commit_graph_writer *w,
- commit_graph_write_cb write_cb,
- void *cb_data)
+ git_commit_graph_writer *w,
+ commit_graph_write_cb write_cb,
+ void *cb_data)
{
int error = 0;
size_t i;
@@ -993,8 +1085,9 @@ static int commit_graph_write(
off64_t offset;
git_str oid_lookup = GIT_STR_INIT, commit_data = GIT_STR_INIT,
extra_edge_list = GIT_STR_INIT;
- unsigned char checksum[GIT_HASH_SHA1_SIZE];
- size_t checksum_size;
+ unsigned char checksum[GIT_HASH_MAX_SIZE];
+ git_hash_algorithm_t checksum_type;
+ size_t checksum_size, oid_size;
git_hash_ctx ctx;
struct commit_graph_write_hash_context hash_cb_data = {0};
@@ -1007,8 +1100,11 @@ static int commit_graph_write(
hash_cb_data.cb_data = cb_data;
hash_cb_data.ctx = &ctx;
- checksum_size = GIT_HASH_SHA1_SIZE;
- error = git_hash_ctx_init(&ctx, GIT_HASH_ALGORITHM_SHA1);
+ oid_size = git_oid_size(w->oid_type);
+ checksum_type = git_oid_algorithm(w->oid_type);
+ checksum_size = git_hash_size(checksum_type);
+
+ error = git_hash_ctx_init(&ctx, checksum_type);
if (error < 0)
return error;
cb_data = &hash_cb_data;
@@ -1035,7 +1131,7 @@ static int commit_graph_write(
git_vector_foreach (&w->commits, i, packed_commit) {
error = git_str_put(&oid_lookup,
(const char *)&packed_commit->sha1.id,
- GIT_OID_SHA1_SIZE);
+ oid_size);
if (error < 0)
goto cleanup;
@@ -1052,7 +1148,7 @@ static int commit_graph_write(
error = git_str_put(&commit_data,
(const char *)&packed_commit->tree_oid.id,
- GIT_OID_SHA1_SIZE);
+ oid_size);
if (error < 0)
goto cleanup;
@@ -1160,6 +1256,9 @@ static int commit_graph_write(
error = git_hash_final(checksum, &ctx);
if (error < 0)
goto cleanup;
+
+ hash_cb_data.ctx = NULL;
+
error = write_cb((char *)checksum, checksum_size, cb_data);
if (error < 0)
goto cleanup;
@@ -1178,30 +1277,13 @@ static int commit_graph_write_filebuf(const char *buf, size_t size, void *data)
return git_filebuf_write(f, buf, size);
}
-int git_commit_graph_writer_options_init(
- git_commit_graph_writer_options *opts,
- unsigned int version)
-{
- GIT_INIT_STRUCTURE_FROM_TEMPLATE(
- opts,
- version,
- git_commit_graph_writer_options,
- GIT_COMMIT_GRAPH_WRITER_OPTIONS_INIT);
- return 0;
-}
-
-int git_commit_graph_writer_commit(
- git_commit_graph_writer *w,
- git_commit_graph_writer_options *opts)
+int git_commit_graph_writer_commit(git_commit_graph_writer *w)
{
int error;
int filebuf_flags = GIT_FILEBUF_DO_NOT_BUFFER;
git_str commit_graph_path = GIT_STR_INIT;
git_filebuf output = GIT_FILEBUF_INIT;
- /* TODO: support options and fill in defaults. */
- GIT_UNUSED(opts);
-
error = git_str_joinpath(
&commit_graph_path, git_str_cstr(&w->objects_info_dir), "commit-graph");
if (error < 0)
@@ -1225,18 +1307,14 @@ int git_commit_graph_writer_commit(
int git_commit_graph_writer_dump(
git_buf *cgraph,
- git_commit_graph_writer *w,
- git_commit_graph_writer_options *opts)
+ git_commit_graph_writer *w)
{
- GIT_BUF_WRAP_PRIVATE(cgraph, git_commit_graph__writer_dump, w, opts);
+ GIT_BUF_WRAP_PRIVATE(cgraph, git_commit_graph__writer_dump, w);
}
int git_commit_graph__writer_dump(
git_str *cgraph,
- git_commit_graph_writer *w,
- git_commit_graph_writer_options *opts)
+ git_commit_graph_writer *w)
{
- /* TODO: support options. */
- GIT_UNUSED(opts);
return commit_graph_write(w, commit_graph_write_buf, cgraph);
}
diff --git a/src/libgit2/commit_graph.h b/src/libgit2/commit_graph.h
index 517abb2390b..a06f3f86219 100644
--- a/src/libgit2/commit_graph.h
+++ b/src/libgit2/commit_graph.h
@@ -30,6 +30,9 @@
typedef struct git_commit_graph_file {
git_map graph_map;
+ /* The type of object IDs in the commit graph file. */
+ git_oid_t oid_type;
+
/* The OID Fanout table. */
const uint32_t *oid_fanout;
/* The total number of commits in the graph. */
@@ -84,10 +87,10 @@ typedef struct git_commit_graph_entry {
/* The index within the Extra Edge List of any parent after the first two. */
size_t extra_parents_index;
- /* The SHA-1 hash of the root tree of the commit. */
+ /* The object ID of the root tree of the commit. */
git_oid tree_oid;
- /* The SHA-1 hash of the requested commit. */
+ /* The object ID hash of the requested commit. */
git_oid sha1;
} git_commit_graph_entry;
@@ -99,18 +102,28 @@ struct git_commit_graph {
/* The underlying commit-graph file. */
git_commit_graph_file *file;
+ /* The object ID types in the commit graph. */
+ git_oid_t oid_type;
+
/* Whether the commit-graph file was already checked for validity. */
bool checked;
};
/** Create a new commit-graph, optionally opening the underlying file. */
-int git_commit_graph_new(git_commit_graph **cgraph_out, const char *objects_dir, bool open_file);
+int git_commit_graph_new(
+ git_commit_graph **cgraph_out,
+ const char *objects_dir,
+ bool open_file,
+ git_oid_t oid_type);
/** Validate the checksum of a commit graph */
int git_commit_graph_validate(git_commit_graph *cgraph);
/** Open and validate a commit-graph file. */
-int git_commit_graph_file_open(git_commit_graph_file **file_out, const char *path);
+int git_commit_graph_file_open(
+ git_commit_graph_file **file_out,
+ const char *path,
+ git_oid_t oid_type);
/*
* Attempt to get the git_commit_graph's commit-graph file. This object is
@@ -134,14 +147,16 @@ struct git_commit_graph_writer {
*/
git_str objects_info_dir;
+ /* The object ID type of the commit graph. */
+ git_oid_t oid_type;
+
/* The list of packed commits. */
git_vector commits;
};
int git_commit_graph__writer_dump(
git_str *cgraph,
- git_commit_graph_writer *w,
- git_commit_graph_writer_options *opts);
+ git_commit_graph_writer *w);
/*
* Returns whether the git_commit_graph_file needs to be reloaded since the
diff --git a/src/libgit2/commit_list.c b/src/libgit2/commit_list.c
index 12b329b251e..7f00c483fac 100644
--- a/src/libgit2/commit_list.c
+++ b/src/libgit2/commit_list.c
@@ -43,13 +43,18 @@ int git_commit_list_time_cmp(const void *a, const void *b)
return 0;
}
-git_commit_list *git_commit_list_insert(git_commit_list_node *item, git_commit_list **list_p)
-{
+git_commit_list *git_commit_list_create(git_commit_list_node *item, git_commit_list *next) {
git_commit_list *new_list = git__malloc(sizeof(git_commit_list));
if (new_list != NULL) {
new_list->item = item;
- new_list->next = *list_p;
+ new_list->next = next;
}
+ return new_list;
+}
+
+git_commit_list *git_commit_list_insert(git_commit_list_node *item, git_commit_list **list_p)
+{
+ git_commit_list *new_list = git_commit_list_create(item, *list_p);
*list_p = new_list;
return new_list;
}
@@ -125,7 +130,7 @@ static int commit_quick_parse(
git_oid *parent_oid;
git_commit *commit;
git_commit__parse_options parse_opts = {
- GIT_OID_SHA1,
+ walk->repo->oid_type,
GIT_COMMIT_PARSE_QUICK
};
size_t i;
@@ -176,7 +181,9 @@ int git_commit_list_parse(git_revwalk *walk, git_commit_list_node *commit)
if (cgraph_file) {
git_commit_graph_entry e;
- error = git_commit_graph_entry_find(&e, cgraph_file, &commit->oid, GIT_OID_SHA1_SIZE);
+ error = git_commit_graph_entry_find(&e, cgraph_file,
+ &commit->oid, git_oid_size(walk->repo->oid_type));
+
if (error == 0 && git__is_uint16(e.parent_count)) {
size_t i;
commit->generation = (uint32_t)e.generation;
diff --git a/src/libgit2/commit_list.h b/src/libgit2/commit_list.h
index aad39f3513b..e2dbd2aaed3 100644
--- a/src/libgit2/commit_list.h
+++ b/src/libgit2/commit_list.h
@@ -49,6 +49,7 @@ git_commit_list_node *git_commit_list_alloc_node(git_revwalk *walk);
int git_commit_list_generation_cmp(const void *a, const void *b);
int git_commit_list_time_cmp(const void *a, const void *b);
void git_commit_list_free(git_commit_list **list_p);
+git_commit_list *git_commit_list_create(git_commit_list_node *item, git_commit_list *next);
git_commit_list *git_commit_list_insert(git_commit_list_node *item, git_commit_list **list_p);
git_commit_list *git_commit_list_insert_by_date(git_commit_list_node *item, git_commit_list **list_p);
int git_commit_list_parse(git_revwalk *walk, git_commit_list_node *commit);
diff --git a/src/libgit2/config.c b/src/libgit2/config.c
index 6d15a8db6d4..b16d981d869 100644
--- a/src/libgit2/config.c
+++ b/src/libgit2/config.c
@@ -22,83 +22,112 @@
#include
+/*
+ * A refcounted instance of a config_backend that can be shared across
+ * a configuration instance, any snapshots, and individual configuration
+ * levels (from `git_config_open_level`).
+ */
+typedef struct {
+ git_refcount rc;
+ git_config_backend *backend;
+} backend_instance;
+
+/*
+ * An entry in the readers or writers vector in the configuration.
+ * This is kept separate from the refcounted instance so that different
+ * views of the configuration can have different notions of levels or
+ * write orders.
+ *
+ * (eg, a standard configuration has a priority ordering of writers, a
+ * snapshot has *no* writers, and an individual level has a single
+ * writer.)
+ */
+typedef struct {
+ backend_instance *instance;
+ git_config_level_t level;
+ int write_order;
+} backend_entry;
+
void git_config_entry_free(git_config_entry *entry)
{
+ git_config_backend_entry *be;
+
if (!entry)
return;
- entry->free(entry);
+ be = (git_config_backend_entry *)entry;
+ be->free(be);
}
-typedef struct {
- git_refcount rc;
-
- git_config_backend *backend;
- git_config_level_t level;
-} backend_internal;
-
-static void backend_internal_free(backend_internal *internal)
+static void backend_instance_free(backend_instance *instance)
{
git_config_backend *backend;
- backend = internal->backend;
+ backend = instance->backend;
backend->free(backend);
- git__free(internal);
+ git__free(instance);
}
-static void config_free(git_config *cfg)
+static void config_free(git_config *config)
{
size_t i;
- backend_internal *internal;
+ backend_entry *entry;
- for (i = 0; i < cfg->backends.length; ++i) {
- internal = git_vector_get(&cfg->backends, i);
- GIT_REFCOUNT_DEC(internal, backend_internal_free);
+ git_vector_foreach(&config->readers, i, entry) {
+ GIT_REFCOUNT_DEC(entry->instance, backend_instance_free);
+ git__free(entry);
}
- git_vector_free(&cfg->backends);
-
- git__memzero(cfg, sizeof(*cfg));
- git__free(cfg);
+ git_vector_dispose(&config->readers);
+ git_vector_dispose(&config->writers);
+ git__free(config);
}
-void git_config_free(git_config *cfg)
+void git_config_free(git_config *config)
{
- if (cfg == NULL)
+ if (config == NULL)
return;
- GIT_REFCOUNT_DEC(cfg, config_free);
+ GIT_REFCOUNT_DEC(config, config_free);
}
-static int config_backend_cmp(const void *a, const void *b)
+static int reader_cmp(const void *_a, const void *_b)
{
- const backend_internal *bk_a = (const backend_internal *)(a);
- const backend_internal *bk_b = (const backend_internal *)(b);
+ const backend_entry *a = _a;
+ const backend_entry *b = _b;
- return bk_b->level - bk_a->level;
+ return b->level - a->level;
}
-int git_config_new(git_config **out)
+static int writer_cmp(const void *_a, const void *_b)
{
- git_config *cfg;
+ const backend_entry *a = _a;
+ const backend_entry *b = _b;
- cfg = git__malloc(sizeof(git_config));
- GIT_ERROR_CHECK_ALLOC(cfg);
+ return b->write_order - a->write_order;
+}
+
+int git_config_new(git_config **out)
+{
+ git_config *config;
- memset(cfg, 0x0, sizeof(git_config));
+ config = git__calloc(1, sizeof(git_config));
+ GIT_ERROR_CHECK_ALLOC(config);
- if (git_vector_init(&cfg->backends, 3, config_backend_cmp) < 0) {
- git__free(cfg);
+ if (git_vector_init(&config->readers, 8, reader_cmp) < 0 ||
+ git_vector_init(&config->writers, 8, writer_cmp) < 0) {
+ config_free(config);
return -1;
}
- *out = cfg;
- GIT_REFCOUNT_INC(cfg);
+ GIT_REFCOUNT_INC(config);
+
+ *out = config;
return 0;
}
int git_config_add_file_ondisk(
- git_config *cfg,
+ git_config *config,
const char *path,
git_config_level_t level,
const git_repository *repo,
@@ -108,7 +137,7 @@ int git_config_add_file_ondisk(
struct stat st;
int res;
- GIT_ASSERT_ARG(cfg);
+ GIT_ASSERT_ARG(config);
GIT_ASSERT_ARG(path);
res = p_stat(path, &st);
@@ -120,7 +149,7 @@ int git_config_add_file_ondisk(
if (git_config_backend_from_file(&file, path) < 0)
return -1;
- if ((res = git_config_add_backend(cfg, file, level, repo, force)) < 0) {
+ if ((res = git_config_add_backend(config, file, level, repo, force)) < 0) {
/*
* free manually; the file is not owned by the config
* instance yet and will not be freed on cleanup
@@ -154,7 +183,7 @@ int git_config_snapshot(git_config **out, git_config *in)
{
int error = 0;
size_t i;
- backend_internal *internal;
+ backend_entry *entry;
git_config *config;
*out = NULL;
@@ -162,18 +191,20 @@ int git_config_snapshot(git_config **out, git_config *in)
if (git_config_new(&config) < 0)
return -1;
- git_vector_foreach(&in->backends, i, internal) {
+ git_vector_foreach(&in->readers, i, entry) {
git_config_backend *b;
- if ((error = internal->backend->snapshot(&b, internal->backend)) < 0)
+ if ((error = entry->instance->backend->snapshot(&b, entry->instance->backend)) < 0)
break;
- if ((error = git_config_add_backend(config, b, internal->level, NULL, 0)) < 0) {
+ if ((error = git_config_add_backend(config, b, entry->level, NULL, 0)) < 0) {
b->free(b);
break;
}
}
+ git_config_set_writeorder(config, NULL, 0);
+
if (error < 0)
git_config_free(config);
else
@@ -183,141 +214,162 @@ int git_config_snapshot(git_config **out, git_config *in)
}
static int find_backend_by_level(
- backend_internal **out,
- const git_config *cfg,
+ backend_instance **out,
+ const git_config *config,
git_config_level_t level)
{
- int pos = -1;
- backend_internal *internal;
+ backend_entry *entry, *found = NULL;
size_t i;
- /* when passing GIT_CONFIG_HIGHEST_LEVEL, the idea is to get the config backend
- * which has the highest level. As config backends are stored in a vector
- * sorted by decreasing order of level, getting the backend at position 0
- * will do the job.
+ /*
+ * when passing GIT_CONFIG_HIGHEST_LEVEL, the idea is to get the
+ * config backend which has the highest level. As config backends
+ * are stored in a vector sorted by decreasing order of level,
+ * getting the backend at position 0 will do the job.
*/
if (level == GIT_CONFIG_HIGHEST_LEVEL) {
- pos = 0;
+ found = git_vector_get(&config->readers, 0);
} else {
- git_vector_foreach(&cfg->backends, i, internal) {
- if (internal->level == level)
- pos = (int)i;
+ git_vector_foreach(&config->readers, i, entry) {
+ if (entry->level == level) {
+ found = entry;
+ break;
+ }
}
}
- if (pos == -1) {
+ if (!found) {
git_error_set(GIT_ERROR_CONFIG,
- "no configuration exists for the given level '%i'", (int)level);
+ "no configuration exists for the given level '%d'", level);
return GIT_ENOTFOUND;
}
- *out = git_vector_get(&cfg->backends, pos);
-
+ *out = found->instance;
return 0;
}
-static int duplicate_level(void **old_raw, void *new_raw)
+static int duplicate_level(void **_old, void *_new)
{
- backend_internal **old = (backend_internal **)old_raw;
+ backend_entry **old = (backend_entry **)_old;
- GIT_UNUSED(new_raw);
+ GIT_UNUSED(_new);
- git_error_set(GIT_ERROR_CONFIG, "there already exists a configuration for the given level (%i)", (int)(*old)->level);
+ git_error_set(GIT_ERROR_CONFIG, "configuration at level %d already exists", (*old)->level);
return GIT_EEXISTS;
}
static void try_remove_existing_backend(
- git_config *cfg,
+ git_config *config,
git_config_level_t level)
{
- int pos = -1;
- backend_internal *internal;
+ backend_entry *entry, *found = NULL;
size_t i;
- git_vector_foreach(&cfg->backends, i, internal) {
- if (internal->level == level)
- pos = (int)i;
+ git_vector_foreach(&config->readers, i, entry) {
+ if (entry->level == level) {
+ git_vector_remove(&config->readers, i);
+ found = entry;
+ break;
+ }
}
- if (pos == -1)
+ if (!found)
return;
- internal = git_vector_get(&cfg->backends, pos);
-
- if (git_vector_remove(&cfg->backends, pos) < 0)
- return;
+ git_vector_foreach(&config->writers, i, entry) {
+ if (entry->level == level) {
+ git_vector_remove(&config->writers, i);
+ break;
+ }
+ }
- GIT_REFCOUNT_DEC(internal, backend_internal_free);
+ GIT_REFCOUNT_DEC(found->instance, backend_instance_free);
+ git__free(found);
}
-static int git_config__add_internal(
- git_config *cfg,
- backend_internal *internal,
+static int git_config__add_instance(
+ git_config *config,
+ backend_instance *instance,
git_config_level_t level,
int force)
{
+ backend_entry *entry;
int result;
/* delete existing config backend for level if it exists */
if (force)
- try_remove_existing_backend(cfg, level);
+ try_remove_existing_backend(config, level);
- if ((result = git_vector_insert_sorted(&cfg->backends,
- internal, &duplicate_level)) < 0)
- return result;
+ entry = git__malloc(sizeof(backend_entry));
+ GIT_ERROR_CHECK_ALLOC(entry);
- git_vector_sort(&cfg->backends);
- internal->backend->cfg = cfg;
+ entry->instance = instance;
+ entry->level = level;
+ entry->write_order = level;
- GIT_REFCOUNT_INC(internal);
+ if ((result = git_vector_insert_sorted(&config->readers,
+ entry, &duplicate_level)) < 0 ||
+ (result = git_vector_insert_sorted(&config->writers,
+ entry, NULL)) < 0) {
+ git__free(entry);
+ return result;
+ }
+
+ GIT_REFCOUNT_INC(entry->instance);
return 0;
}
-int git_config_open_global(git_config **cfg_out, git_config *cfg)
+int git_config_open_global(git_config **out, git_config *config)
{
- if (!git_config_open_level(cfg_out, cfg, GIT_CONFIG_LEVEL_XDG))
+ int error;
+
+ error = git_config_open_level(out, config, GIT_CONFIG_LEVEL_XDG);
+
+ if (error == 0)
return 0;
+ else if (error != GIT_ENOTFOUND)
+ return error;
- return git_config_open_level(cfg_out, cfg, GIT_CONFIG_LEVEL_GLOBAL);
+ return git_config_open_level(out, config, GIT_CONFIG_LEVEL_GLOBAL);
}
int git_config_open_level(
- git_config **cfg_out,
- const git_config *cfg_parent,
+ git_config **out,
+ const git_config *parent,
git_config_level_t level)
{
- git_config *cfg;
- backend_internal *internal;
+ git_config *config;
+ backend_instance *instance;
int res;
- if ((res = find_backend_by_level(&internal, cfg_parent, level)) < 0)
+ if ((res = find_backend_by_level(&instance, parent, level)) < 0)
return res;
- if ((res = git_config_new(&cfg)) < 0)
+ if ((res = git_config_new(&config)) < 0)
return res;
- if ((res = git_config__add_internal(cfg, internal, level, true)) < 0) {
- git_config_free(cfg);
+ if ((res = git_config__add_instance(config, instance, level, true)) < 0) {
+ git_config_free(config);
return res;
}
- *cfg_out = cfg;
+ *out = config;
return 0;
}
int git_config_add_backend(
- git_config *cfg,
+ git_config *config,
git_config_backend *backend,
git_config_level_t level,
const git_repository *repo,
int force)
{
- backend_internal *internal;
+ backend_instance *instance;
int result;
- GIT_ASSERT_ARG(cfg);
+ GIT_ASSERT_ARG(config);
GIT_ASSERT_ARG(backend);
GIT_ERROR_CHECK_VERSION(backend, GIT_CONFIG_BACKEND_VERSION, "git_config_backend");
@@ -325,22 +377,50 @@ int git_config_add_backend(
if ((result = backend->open(backend, level, repo)) < 0)
return result;
- internal = git__malloc(sizeof(backend_internal));
- GIT_ERROR_CHECK_ALLOC(internal);
-
- memset(internal, 0x0, sizeof(backend_internal));
+ instance = git__calloc(1, sizeof(backend_instance));
+ GIT_ERROR_CHECK_ALLOC(instance);
- internal->backend = backend;
- internal->level = level;
+ instance->backend = backend;
+ instance->backend->cfg = config;
- if ((result = git_config__add_internal(cfg, internal, level, force)) < 0) {
- git__free(internal);
+ if ((result = git_config__add_instance(config, instance, level, force)) < 0) {
+ git__free(instance);
return result;
}
return 0;
}
+int git_config_set_writeorder(
+ git_config *config,
+ git_config_level_t *levels,
+ size_t len)
+{
+ backend_entry *entry;
+ size_t i, j;
+
+ GIT_ASSERT(len < INT_MAX);
+
+ git_vector_foreach(&config->readers, i, entry) {
+ bool found = false;
+
+ for (j = 0; j < len; j++) {
+ if (levels[j] == entry->level) {
+ entry->write_order = (int)j;
+ found = true;
+ break;
+ }
+ }
+
+ if (!found)
+ entry->write_order = -1;
+ }
+
+ git_vector_sort(&config->writers);
+
+ return 0;
+}
+
/*
* Loop over all the variables
*/
@@ -348,37 +428,24 @@ int git_config_add_backend(
typedef struct {
git_config_iterator parent;
git_config_iterator *current;
- const git_config *cfg;
+ const git_config *config;
git_regexp regex;
size_t i;
} all_iter;
-static int find_next_backend(size_t *out, const git_config *cfg, size_t i)
-{
- backend_internal *internal;
-
- for (; i > 0; --i) {
- internal = git_vector_get(&cfg->backends, i - 1);
- if (!internal || !internal->backend)
- continue;
-
- *out = i;
- return 0;
- }
-
- return -1;
-}
-
-static int all_iter_next(git_config_entry **entry, git_config_iterator *_iter)
+static int all_iter_next(
+ git_config_backend_entry **out,
+ git_config_iterator *_iter)
{
all_iter *iter = (all_iter *) _iter;
- backend_internal *internal;
+ backend_entry *entry;
git_config_backend *backend;
- size_t i;
+ git_config_backend_entry *be;
int error = 0;
if (iter->current != NULL &&
- (error = iter->current->next(entry, iter->current)) == 0) {
+ (error = iter->current->next(&be, iter->current)) == 0) {
+ *out = be;
return 0;
}
@@ -386,25 +453,32 @@ static int all_iter_next(git_config_entry **entry, git_config_iterator *_iter)
return error;
do {
- if (find_next_backend(&i, iter->cfg, iter->i) < 0)
+ if (iter->i == 0)
return GIT_ITEROVER;
- internal = git_vector_get(&iter->cfg->backends, i - 1);
- backend = internal->backend;
- iter->i = i - 1;
+ entry = git_vector_get(&iter->config->readers, iter->i - 1);
+ GIT_ASSERT(entry && entry->instance && entry->instance->backend);
+
+ backend = entry->instance->backend;
+ iter->i--;
if (iter->current)
iter->current->free(iter->current);
iter->current = NULL;
error = backend->iterator(&iter->current, backend);
+
if (error == GIT_ENOTFOUND)
continue;
if (error < 0)
return error;
- error = iter->current->next(entry, iter->current);
+ if ((error = iter->current->next(&be, iter->current)) == 0) {
+ *out = be;
+ return 0;
+ }
+
/* If this backend is empty, then keep going */
if (error == GIT_ITEROVER)
continue;
@@ -416,18 +490,20 @@ static int all_iter_next(git_config_entry **entry, git_config_iterator *_iter)
return GIT_ITEROVER;
}
-static int all_iter_glob_next(git_config_entry **entry, git_config_iterator *_iter)
+static int all_iter_glob_next(
+ git_config_backend_entry **entry,
+ git_config_iterator *_iter)
{
int error;
all_iter *iter = (all_iter *) _iter;
/*
* We use the "normal" function to grab the next one across
- * backends and then apply the regex
+ * readers and then apply the regex
*/
while ((error = all_iter_next(entry, _iter)) == 0) {
/* skip non-matching keys if regexp was provided */
- if (git_regexp_match(&iter->regex, (*entry)->name) != 0)
+ if (git_regexp_match(&iter->regex, (*entry)->entry.name) != 0)
continue;
/* and simply return if we like the entry's name */
@@ -455,7 +531,7 @@ static void all_iter_glob_free(git_config_iterator *_iter)
all_iter_free(_iter);
}
-int git_config_iterator_new(git_config_iterator **out, const git_config *cfg)
+int git_config_iterator_new(git_config_iterator **out, const git_config *config)
{
all_iter *iter;
@@ -465,21 +541,21 @@ int git_config_iterator_new(git_config_iterator **out, const git_config *cfg)
iter->parent.free = all_iter_free;
iter->parent.next = all_iter_next;
- iter->i = cfg->backends.length;
- iter->cfg = cfg;
+ iter->i = config->readers.length;
+ iter->config = config;
*out = (git_config_iterator *) iter;
return 0;
}
-int git_config_iterator_glob_new(git_config_iterator **out, const git_config *cfg, const char *regexp)
+int git_config_iterator_glob_new(git_config_iterator **out, const git_config *config, const char *regexp)
{
all_iter *iter;
int result;
if (regexp == NULL)
- return git_config_iterator_new(out, cfg);
+ return git_config_iterator_new(out, config);
iter = git__calloc(1, sizeof(all_iter));
GIT_ERROR_CHECK_ALLOC(iter);
@@ -491,8 +567,8 @@ int git_config_iterator_glob_new(git_config_iterator **out, const git_config *cf
iter->parent.next = all_iter_glob_next;
iter->parent.free = all_iter_glob_free;
- iter->i = cfg->backends.length;
- iter->cfg = cfg;
+ iter->i = config->readers.length;
+ iter->config = config;
*out = (git_config_iterator *) iter;
@@ -500,9 +576,9 @@ int git_config_iterator_glob_new(git_config_iterator **out, const git_config *cf
}
int git_config_foreach(
- const git_config *cfg, git_config_foreach_cb cb, void *payload)
+ const git_config *config, git_config_foreach_cb cb, void *payload)
{
- return git_config_foreach_match(cfg, NULL, cb, payload);
+ return git_config_foreach_match(config, NULL, cb, payload);
}
int git_config_backend_foreach_match(
@@ -511,7 +587,7 @@ int git_config_backend_foreach_match(
git_config_foreach_cb cb,
void *payload)
{
- git_config_entry *entry;
+ git_config_backend_entry *entry;
git_config_iterator *iter;
git_regexp regex;
int error = 0;
@@ -529,11 +605,11 @@ int git_config_backend_foreach_match(
while (!(iter->next(&entry, iter) < 0)) {
/* skip non-matching keys if regexp was provided */
- if (regexp && git_regexp_match(®ex, entry->name) != 0)
+ if (regexp && git_regexp_match(®ex, entry->entry.name) != 0)
continue;
/* abort iterator on non-zero return value */
- if ((error = cb(entry, payload)) != 0) {
+ if ((error = cb(&entry->entry, payload)) != 0) {
git_error_set_after_callback(error);
break;
}
@@ -548,7 +624,7 @@ int git_config_backend_foreach_match(
}
int git_config_foreach_match(
- const git_config *cfg,
+ const git_config *config,
const char *regexp,
git_config_foreach_cb cb,
void *payload)
@@ -557,7 +633,7 @@ int git_config_foreach_match(
git_config_iterator *iter;
git_config_entry *entry;
- if ((error = git_config_iterator_glob_new(&iter, cfg, regexp)) < 0)
+ if ((error = git_config_iterator_glob_new(&iter, config, regexp)) < 0)
return error;
while (!(error = git_config_next(&entry, iter))) {
@@ -579,72 +655,59 @@ int git_config_foreach_match(
* Setters
**************/
-typedef enum {
- BACKEND_USE_SET,
- BACKEND_USE_DELETE
-} backend_use;
-
-static const char *uses[] = {
- "set",
- "delete"
-};
-
-static int get_backend_for_use(git_config_backend **out,
- git_config *cfg, const char *name, backend_use use)
-{
+ static backend_instance *get_writer_instance(git_config *config)
+ {
+ backend_entry *entry;
size_t i;
- backend_internal *backend;
- *out = NULL;
+ git_vector_foreach(&config->writers, i, entry) {
+ if (entry->instance->backend->readonly)
+ continue;
- if (git_vector_length(&cfg->backends) == 0) {
- git_error_set(GIT_ERROR_CONFIG,
- "cannot %s value for '%s' when no config backends exist",
- uses[use], name);
- return GIT_ENOTFOUND;
- }
+ if (entry->write_order < 0)
+ continue;
- git_vector_foreach(&cfg->backends, i, backend) {
- if (!backend->backend->readonly) {
- *out = backend->backend;
- return 0;
- }
+ return entry->instance;
}
- git_error_set(GIT_ERROR_CONFIG,
- "cannot %s value for '%s' when all config backends are readonly",
- uses[use], name);
- return GIT_ENOTFOUND;
+ return NULL;
+ }
+
+static git_config_backend *get_writer(git_config *config)
+{
+ backend_instance *instance = get_writer_instance(config);
+
+ return instance ? instance->backend : NULL;
}
-int git_config_delete_entry(git_config *cfg, const char *name)
+int git_config_delete_entry(git_config *config, const char *name)
{
git_config_backend *backend;
- if (get_backend_for_use(&backend, cfg, name, BACKEND_USE_DELETE) < 0)
- return GIT_ENOTFOUND;
+ if ((backend = get_writer(config)) == NULL)
+ return GIT_EREADONLY;
return backend->del(backend, name);
}
-int git_config_set_int64(git_config *cfg, const char *name, int64_t value)
+int git_config_set_int64(git_config *config, const char *name, int64_t value)
{
char str_value[32]; /* All numbers should fit in here */
p_snprintf(str_value, sizeof(str_value), "%" PRId64, value);
- return git_config_set_string(cfg, name, str_value);
+ return git_config_set_string(config, name, str_value);
}
-int git_config_set_int32(git_config *cfg, const char *name, int32_t value)
+int git_config_set_int32(git_config *config, const char *name, int32_t value)
{
- return git_config_set_int64(cfg, name, (int64_t)value);
+ return git_config_set_int64(config, name, (int64_t)value);
}
-int git_config_set_bool(git_config *cfg, const char *name, int value)
+int git_config_set_bool(git_config *config, const char *name, int value)
{
- return git_config_set_string(cfg, name, value ? "true" : "false");
+ return git_config_set_string(config, name, value ? "true" : "false");
}
-int git_config_set_string(git_config *cfg, const char *name, const char *value)
+int git_config_set_string(git_config *config, const char *name, const char *value)
{
int error;
git_config_backend *backend;
@@ -654,13 +717,15 @@ int git_config_set_string(git_config *cfg, const char *name, const char *value)
return -1;
}
- if (get_backend_for_use(&backend, cfg, name, BACKEND_USE_SET) < 0)
- return GIT_ENOTFOUND;
+ if ((backend = get_writer(config)) == NULL) {
+ git_error_set(GIT_ERROR_CONFIG, "cannot set '%s': the configuration is read-only", name);
+ return GIT_EREADONLY;
+ }
error = backend->set(backend, name, value);
- if (!error && GIT_REFCOUNT_OWNER(cfg) != NULL)
- git_repository__configmap_lookup_cache_clear(GIT_REFCOUNT_OWNER(cfg));
+ if (!error && GIT_REFCOUNT_OWNER(config) != NULL)
+ git_repository__configmap_lookup_cache_clear(GIT_REFCOUNT_OWNER(config));
return error;
}
@@ -714,16 +779,18 @@ enum {
static int get_entry(
git_config_entry **out,
- const git_config *cfg,
+ const git_config *config,
const char *name,
bool normalize_name,
int want_errors)
{
+ backend_entry *entry;
+ git_config_backend *backend;
+ git_config_backend_entry *be;
int res = GIT_ENOTFOUND;
const char *key = name;
char *normalized = NULL;
size_t i;
- backend_internal *internal;
*out = NULL;
@@ -734,21 +801,24 @@ static int get_entry(
}
res = GIT_ENOTFOUND;
- git_vector_foreach(&cfg->backends, i, internal) {
- if (!internal || !internal->backend)
- continue;
+ git_vector_foreach(&config->readers, i, entry) {
+ GIT_ASSERT(entry->instance && entry->instance->backend);
+
+ backend = entry->instance->backend;
+ res = backend->get(backend, key, &be);
- res = internal->backend->get(internal->backend, key, out);
- if (res != GIT_ENOTFOUND)
+ if (res != GIT_ENOTFOUND) {
+ *out = &be->entry;
break;
+ }
}
git__free(normalized);
cleanup:
- if (res == GIT_ENOTFOUND)
+ if (res == GIT_ENOTFOUND) {
res = (want_errors > GET_ALL_ERRORS) ? 0 : config_error_notfound(name);
- else if (res && (want_errors == GET_NO_ERRORS)) {
+ } else if (res && (want_errors == GET_NO_ERRORS)) {
git_error_clear();
res = 0;
}
@@ -757,24 +827,24 @@ static int get_entry(
}
int git_config_get_entry(
- git_config_entry **out, const git_config *cfg, const char *name)
+ git_config_entry **out, const git_config *config, const char *name)
{
- return get_entry(out, cfg, name, true, GET_ALL_ERRORS);
+ return get_entry(out, config, name, true, GET_ALL_ERRORS);
}
int git_config__lookup_entry(
git_config_entry **out,
- const git_config *cfg,
+ const git_config *config,
const char *key,
bool no_errors)
{
return get_entry(
- out, cfg, key, false, no_errors ? GET_NO_ERRORS : GET_NO_MISSING);
+ out, config, key, false, no_errors ? GET_NO_ERRORS : GET_NO_MISSING);
}
int git_config_get_mapped(
int *out,
- const git_config *cfg,
+ const git_config *config,
const char *name,
const git_configmap *maps,
size_t map_n)
@@ -782,7 +852,7 @@ int git_config_get_mapped(
git_config_entry *entry;
int ret;
- if ((ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS)) < 0)
+ if ((ret = get_entry(&entry, config, name, true, GET_ALL_ERRORS)) < 0)
return ret;
ret = git_config_lookup_map_value(out, maps, map_n, entry->value);
@@ -791,12 +861,12 @@ int git_config_get_mapped(
return ret;
}
-int git_config_get_int64(int64_t *out, const git_config *cfg, const char *name)
+int git_config_get_int64(int64_t *out, const git_config *config, const char *name)
{
git_config_entry *entry;
int ret;
- if ((ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS)) < 0)
+ if ((ret = get_entry(&entry, config, name, true, GET_ALL_ERRORS)) < 0)
return ret;
ret = git_config_parse_int64(out, entry->value);
@@ -805,12 +875,12 @@ int git_config_get_int64(int64_t *out, const git_config *cfg, const char *name)
return ret;
}
-int git_config_get_int32(int32_t *out, const git_config *cfg, const char *name)
+int git_config_get_int32(int32_t *out, const git_config *config, const char *name)
{
git_config_entry *entry;
int ret;
- if ((ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS)) < 0)
+ if ((ret = get_entry(&entry, config, name, true, GET_ALL_ERRORS)) < 0)
return ret;
ret = git_config_parse_int32(out, entry->value);
@@ -819,12 +889,12 @@ int git_config_get_int32(int32_t *out, const git_config *cfg, const char *name)
return ret;
}
-int git_config_get_bool(int *out, const git_config *cfg, const char *name)
+int git_config_get_bool(int *out, const git_config *config, const char *name)
{
git_config_entry *entry;
int ret;
- if ((ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS)) < 0)
+ if ((ret = get_entry(&entry, config, name, true, GET_ALL_ERRORS)) < 0)
return ret;
ret = git_config_parse_bool(out, entry->value);
@@ -833,16 +903,15 @@ int git_config_get_bool(int *out, const git_config *cfg, const char *name)
return ret;
}
-static int is_readonly(const git_config *cfg)
+static int is_readonly(const git_config *config)
{
+ backend_entry *entry;
size_t i;
- backend_internal *internal;
- git_vector_foreach(&cfg->backends, i, internal) {
- if (!internal || !internal->backend)
- continue;
+ git_vector_foreach(&config->writers, i, entry) {
+ GIT_ASSERT(entry->instance && entry->instance->backend);
- if (!internal->backend->readonly)
+ if (!entry->instance->backend->readonly)
return 0;
}
@@ -873,21 +942,21 @@ int git_config_parse_path(git_buf *out, const char *value)
int git_config_get_path(
git_buf *out,
- const git_config *cfg,
+ const git_config *config,
const char *name)
{
- GIT_BUF_WRAP_PRIVATE(out, git_config__get_path, cfg, name);
+ GIT_BUF_WRAP_PRIVATE(out, git_config__get_path, config, name);
}
int git_config__get_path(
git_str *out,
- const git_config *cfg,
+ const git_config *config,
const char *name)
{
git_config_entry *entry;
int error;
- if ((error = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS)) < 0)
+ if ((error = get_entry(&entry, config, name, true, GET_ALL_ERRORS)) < 0)
return error;
error = git_config__parse_path(out, entry->value);
@@ -897,17 +966,17 @@ int git_config__get_path(
}
int git_config_get_string(
- const char **out, const git_config *cfg, const char *name)
+ const char **out, const git_config *config, const char *name)
{
git_config_entry *entry;
int ret;
- if (!is_readonly(cfg)) {
+ if (!is_readonly(config)) {
git_error_set(GIT_ERROR_CONFIG, "get_string called on a live config object");
return -1;
}
- ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS);
+ ret = get_entry(&entry, config, name, true, GET_ALL_ERRORS);
*out = !ret ? (entry->value ? entry->value : "") : NULL;
git_config_entry_free(entry);
@@ -916,22 +985,22 @@ int git_config_get_string(
}
int git_config_get_string_buf(
- git_buf *out, const git_config *cfg, const char *name)
+ git_buf *out, const git_config *config, const char *name)
{
- GIT_BUF_WRAP_PRIVATE(out, git_config__get_string_buf, cfg, name);
+ GIT_BUF_WRAP_PRIVATE(out, git_config__get_string_buf, config, name);
}
int git_config__get_string_buf(
- git_str *out, const git_config *cfg, const char *name)
+ git_str *out, const git_config *config, const char *name)
{
git_config_entry *entry;
int ret;
const char *str;
GIT_ASSERT_ARG(out);
- GIT_ASSERT_ARG(cfg);
+ GIT_ASSERT_ARG(config);
- ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS);
+ ret = get_entry(&entry, config, name, true, GET_ALL_ERRORS);
str = !ret ? (entry->value ? entry->value : "") : NULL;
if (str)
@@ -943,12 +1012,12 @@ int git_config__get_string_buf(
}
char *git_config__get_string_force(
- const git_config *cfg, const char *key, const char *fallback_value)
+ const git_config *config, const char *key, const char *fallback_value)
{
git_config_entry *entry;
char *ret;
- get_entry(&entry, cfg, key, false, GET_NO_ERRORS);
+ get_entry(&entry, config, key, false, GET_NO_ERRORS);
ret = (entry && entry->value) ? git__strdup(entry->value) : fallback_value ? git__strdup(fallback_value) : NULL;
git_config_entry_free(entry);
@@ -956,12 +1025,12 @@ char *git_config__get_string_force(
}
int git_config__get_bool_force(
- const git_config *cfg, const char *key, int fallback_value)
+ const git_config *config, const char *key, int fallback_value)
{
int val = fallback_value;
git_config_entry *entry;
- get_entry(&entry, cfg, key, false, GET_NO_ERRORS);
+ get_entry(&entry, config, key, false, GET_NO_ERRORS);
if (entry && git_config_parse_bool(&val, entry->value) < 0)
git_error_clear();
@@ -971,12 +1040,12 @@ int git_config__get_bool_force(
}
int git_config__get_int_force(
- const git_config *cfg, const char *key, int fallback_value)
+ const git_config *config, const char *key, int fallback_value)
{
int32_t val = (int32_t)fallback_value;
git_config_entry *entry;
- get_entry(&entry, cfg, key, false, GET_NO_ERRORS);
+ get_entry(&entry, config, key, false, GET_NO_ERRORS);
if (entry && git_config_parse_int32(&val, entry->value) < 0)
git_error_clear();
@@ -986,21 +1055,21 @@ int git_config__get_int_force(
}
int git_config_get_multivar_foreach(
- const git_config *cfg, const char *name, const char *regexp,
+ const git_config *config, const char *name, const char *regexp,
git_config_foreach_cb cb, void *payload)
{
int err, found;
git_config_iterator *iter;
- git_config_entry *entry;
+ git_config_backend_entry *be;
- if ((err = git_config_multivar_iterator_new(&iter, cfg, name, regexp)) < 0)
+ if ((err = git_config_multivar_iterator_new(&iter, config, name, regexp)) < 0)
return err;
found = 0;
- while ((err = iter->next(&entry, iter)) == 0) {
+ while ((err = iter->next(&be, iter)) == 0) {
found = 1;
- if ((err = cb(entry, payload)) != 0) {
+ if ((err = cb(&be->entry, payload)) != 0) {
git_error_set_after_callback(err);
break;
}
@@ -1024,19 +1093,21 @@ typedef struct {
int have_regex;
} multivar_iter;
-static int multivar_iter_next(git_config_entry **entry, git_config_iterator *_iter)
+static int multivar_iter_next(
+ git_config_backend_entry **entry,
+ git_config_iterator *_iter)
{
multivar_iter *iter = (multivar_iter *) _iter;
int error = 0;
while ((error = iter->iter->next(entry, iter->iter)) == 0) {
- if (git__strcmp(iter->name, (*entry)->name))
+ if (git__strcmp(iter->name, (*entry)->entry.name))
continue;
if (!iter->have_regex)
return 0;
- if (git_regexp_match(&iter->regex, (*entry)->value) == 0)
+ if (git_regexp_match(&iter->regex, (*entry)->entry.value) == 0)
return 0;
}
@@ -1055,13 +1126,13 @@ static void multivar_iter_free(git_config_iterator *_iter)
git__free(iter);
}
-int git_config_multivar_iterator_new(git_config_iterator **out, const git_config *cfg, const char *name, const char *regexp)
+int git_config_multivar_iterator_new(git_config_iterator **out, const git_config *config, const char *name, const char *regexp)
{
multivar_iter *iter = NULL;
git_config_iterator *inner = NULL;
int error;
- if ((error = git_config_iterator_new(&inner, cfg)) < 0)
+ if ((error = git_config_iterator_new(&inner, config)) < 0)
return error;
iter = git__calloc(1, sizeof(multivar_iter));
@@ -1092,29 +1163,38 @@ int git_config_multivar_iterator_new(git_config_iterator **out, const git_config
return error;
}
-int git_config_set_multivar(git_config *cfg, const char *name, const char *regexp, const char *value)
+int git_config_set_multivar(git_config *config, const char *name, const char *regexp, const char *value)
{
git_config_backend *backend;
- if (get_backend_for_use(&backend, cfg, name, BACKEND_USE_DELETE) < 0)
- return GIT_ENOTFOUND;
+ if ((backend = get_writer(config)) == NULL) {
+ git_error_set(GIT_ERROR_CONFIG, "cannot set '%s': the configuration is read-only", name);
+ return GIT_EREADONLY;
+ }
return backend->set_multivar(backend, name, regexp, value);
}
-int git_config_delete_multivar(git_config *cfg, const char *name, const char *regexp)
+int git_config_delete_multivar(git_config *config, const char *name, const char *regexp)
{
git_config_backend *backend;
- if (get_backend_for_use(&backend, cfg, name, BACKEND_USE_DELETE) < 0)
- return GIT_ENOTFOUND;
+ if ((backend = get_writer(config)) == NULL)
+ return GIT_EREADONLY;
return backend->del_multivar(backend, name, regexp);
}
int git_config_next(git_config_entry **entry, git_config_iterator *iter)
{
- return iter->next(entry, iter);
+ git_config_backend_entry *be;
+ int error;
+
+ if ((error = iter->next(&be, iter)) != 0)
+ return error;
+
+ *entry = &be->entry;
+ return 0;
}
void git_config_iterator_free(git_config_iterator *iter)
@@ -1174,9 +1254,12 @@ int git_config__find_programdata(git_str *path)
GIT_FS_PATH_OWNER_CURRENT_USER |
GIT_FS_PATH_OWNER_ADMINISTRATOR;
bool is_safe;
+ int error;
- if (git_sysdir_find_programdata_file(path, GIT_CONFIG_FILENAME_PROGRAMDATA) < 0 ||
- git_fs_path_owner_is(&is_safe, path->ptr, owner_level) < 0)
+ if ((error = git_sysdir_find_programdata_file(path, GIT_CONFIG_FILENAME_PROGRAMDATA)) < 0)
+ return error;
+
+ if (git_fs_path_owner_is(&is_safe, path->ptr, owner_level) < 0)
return -1;
if (!is_safe) {
@@ -1215,79 +1298,77 @@ int git_config__global_location(git_str *buf)
int git_config_open_default(git_config **out)
{
int error;
- git_config *cfg = NULL;
+ git_config *config = NULL;
git_str buf = GIT_STR_INIT;
- if ((error = git_config_new(&cfg)) < 0)
+ if ((error = git_config_new(&config)) < 0)
return error;
if (!git_config__find_global(&buf) ||
!git_config__global_location(&buf)) {
- error = git_config_add_file_ondisk(cfg, buf.ptr,
+ error = git_config_add_file_ondisk(config, buf.ptr,
GIT_CONFIG_LEVEL_GLOBAL, NULL, 0);
}
if (!error && !git_config__find_xdg(&buf))
- error = git_config_add_file_ondisk(cfg, buf.ptr,
+ error = git_config_add_file_ondisk(config, buf.ptr,
GIT_CONFIG_LEVEL_XDG, NULL, 0);
if (!error && !git_config__find_system(&buf))
- error = git_config_add_file_ondisk(cfg, buf.ptr,
+ error = git_config_add_file_ondisk(config, buf.ptr,
GIT_CONFIG_LEVEL_SYSTEM, NULL, 0);
if (!error && !git_config__find_programdata(&buf))
- error = git_config_add_file_ondisk(cfg, buf.ptr,
+ error = git_config_add_file_ondisk(config, buf.ptr,
GIT_CONFIG_LEVEL_PROGRAMDATA, NULL, 0);
git_str_dispose(&buf);
if (error) {
- git_config_free(cfg);
- cfg = NULL;
+ git_config_free(config);
+ config = NULL;
}
- *out = cfg;
+ *out = config;
return error;
}
-int git_config_lock(git_transaction **out, git_config *cfg)
+int git_config_lock(git_transaction **out, git_config *config)
{
+ backend_instance *instance;
int error;
- git_config_backend *backend;
- backend_internal *internal;
- GIT_ASSERT_ARG(cfg);
+ GIT_ASSERT_ARG(config);
- internal = git_vector_get(&cfg->backends, 0);
- if (!internal || !internal->backend) {
- git_error_set(GIT_ERROR_CONFIG, "cannot lock; the config has no backends");
- return -1;
+ if ((instance = get_writer_instance(config)) == NULL) {
+ git_error_set(GIT_ERROR_CONFIG, "cannot lock: the configuration is read-only");
+ return GIT_EREADONLY;
}
- backend = internal->backend;
- if ((error = backend->lock(backend)) < 0)
+ if ((error = instance->backend->lock(instance->backend)) < 0 ||
+ (error = git_transaction_config_new(out, config, instance)) < 0)
return error;
- return git_transaction_config_new(out, cfg);
+ GIT_REFCOUNT_INC(instance);
+ return 0;
}
-int git_config_unlock(git_config *cfg, int commit)
+int git_config_unlock(
+ git_config *config,
+ void *data,
+ int commit)
{
- git_config_backend *backend;
- backend_internal *internal;
-
- GIT_ASSERT_ARG(cfg);
+ backend_instance *instance = data;
+ int error;
- internal = git_vector_get(&cfg->backends, 0);
- if (!internal || !internal->backend) {
- git_error_set(GIT_ERROR_CONFIG, "cannot lock; the config has no backends");
- return -1;
- }
+ GIT_ASSERT_ARG(config && data);
+ GIT_UNUSED(config);
- backend = internal->backend;
+ error = instance->backend->unlock(instance->backend, commit);
+ GIT_REFCOUNT_DEC(instance, backend_instance_free);
- return backend->unlock(backend, commit);
+ return error;
}
/***********
@@ -1444,7 +1525,7 @@ static int normalize_section(char *start, char *end)
for (scan = start; *scan; ++scan) {
if (end && scan >= end)
break;
- if (isalnum(*scan))
+ if (git__isalnum(*scan))
*scan = (char)git__tolower(*scan);
else if (*scan != '-' || scan == start)
return GIT_EINVALIDSPEC;
@@ -1506,19 +1587,32 @@ static int rename_config_entries_cb(
int error = 0;
struct rename_data *data = (struct rename_data *)payload;
size_t base_len = git_str_len(data->name);
+ git_str value = GIT_STR_INIT;
+
+ if (base_len > 0) {
+ if ((error = git_str_puts(data->name,
+ entry->name + data->old_len)) < 0 ||
+ (error = git_config_set_multivar(
+ data->config, git_str_cstr(data->name), "^$",
+ entry->value)) < 0)
+ goto cleanup;
+ }
- if (base_len > 0 &&
- !(error = git_str_puts(data->name, entry->name + data->old_len)))
- {
- error = git_config_set_string(
- data->config, git_str_cstr(data->name), entry->value);
+ git_str_putc(&value, '^');
+ git_str_puts_escape_regex(&value, entry->value);
+ git_str_putc(&value, '$');
- git_str_truncate(data->name, base_len);
+ if (git_str_oom(&value)) {
+ error = -1;
+ goto cleanup;
}
- if (!error)
- error = git_config_delete_entry(data->config, entry->name);
+ error = git_config_delete_multivar(
+ data->config, entry->name, git_str_cstr(&value));
+ cleanup:
+ git_str_truncate(data->name, base_len);
+ git_str_dispose(&value);
return error;
}
diff --git a/src/libgit2/config.cmake.in b/src/libgit2/config.cmake.in
new file mode 100644
index 00000000000..6d15e05882f
--- /dev/null
+++ b/src/libgit2/config.cmake.in
@@ -0,0 +1,3 @@
+include(CMakeFindDependencyMacro)
+
+include("${CMAKE_CURRENT_LIST_DIR}/@LIBGIT2_TARGETS_EXPORT_NAME@.cmake")
\ No newline at end of file
diff --git a/src/libgit2/config.h b/src/libgit2/config.h
index 01b84b157f7..5003cbf9c1f 100644
--- a/src/libgit2/config.h
+++ b/src/libgit2/config.h
@@ -24,7 +24,8 @@
struct git_config {
git_refcount rc;
- git_vector backends;
+ git_vector readers;
+ git_vector writers;
};
extern int git_config__global_location(git_str *buf);
@@ -94,17 +95,21 @@ int git_config_lookup_map_enum(git_configmap_t *type_out,
size_t map_n, int enum_val);
/**
- * Unlock the backend with the highest priority
+ * Unlock the given backend that was previously locked.
*
* Unlocking will allow other writers to update the configuration
* file. Optionally, any changes performed since the lock will be
* applied to the configuration.
*
- * @param cfg the configuration
+ * @param config the config instance
+ * @param data the config data passed to git_transaction_new
* @param commit boolean which indicates whether to commit any changes
* done since locking
* @return 0 or an error code
*/
-GIT_EXTERN(int) git_config_unlock(git_config *cfg, int commit);
+GIT_EXTERN(int) git_config_unlock(
+ git_config *config,
+ void *data,
+ int commit);
#endif
diff --git a/src/libgit2/config_backend.h b/src/libgit2/config_backend.h
index dbb19051484..786c5de1a75 100644
--- a/src/libgit2/config_backend.h
+++ b/src/libgit2/config_backend.h
@@ -37,15 +37,6 @@ extern int git_config_backend_from_file(git_config_backend **out, const char *pa
*/
extern int git_config_backend_snapshot(git_config_backend **out, git_config_backend *source);
-/**
- * Create an in-memory configuration file backend
- *
- * @param out the new backend
- * @param cfg the configuration that is to be parsed
- * @param len the length of the string pointed to by `cfg`
- */
-extern int git_config_backend_from_string(git_config_backend **out, const char *cfg, size_t len);
-
GIT_INLINE(int) git_config_backend_open(git_config_backend *cfg, unsigned int level, const git_repository *repo)
{
return cfg->open(cfg, level, repo);
@@ -60,7 +51,14 @@ GIT_INLINE(void) git_config_backend_free(git_config_backend *cfg)
GIT_INLINE(int) git_config_backend_get_string(
git_config_entry **out, git_config_backend *cfg, const char *name)
{
- return cfg->get(cfg, name, out);
+ git_config_backend_entry *be;
+ int error;
+
+ if ((error = cfg->get(cfg, name, &be)) < 0)
+ return error;
+
+ *out = &be->entry;
+ return 0;
}
GIT_INLINE(int) git_config_backend_set_string(
diff --git a/src/libgit2/config_cache.c b/src/libgit2/config_cache.c
index 4bb91f52b9f..05d9d5828e0 100644
--- a/src/libgit2/config_cache.c
+++ b/src/libgit2/config_cache.c
@@ -64,11 +64,10 @@ static git_configmap _configmap_logallrefupdates[] = {
{GIT_CONFIGMAP_STRING, "always", GIT_LOGALLREFUPDATES_ALWAYS},
};
-/*
- * Generic map for integer values
- */
-static git_configmap _configmap_int[] = {
+static git_configmap _configmap_abbrev[] = {
{GIT_CONFIGMAP_INT32, NULL, 0},
+ {GIT_CONFIGMAP_FALSE, NULL, GIT_ABBREV_FALSE},
+ {GIT_CONFIGMAP_STRING, "auto", GIT_ABBREV_DEFAULT}
};
static struct map_data _configmaps[] = {
@@ -79,7 +78,7 @@ static struct map_data _configmaps[] = {
{"core.filemode", NULL, 0, GIT_FILEMODE_DEFAULT },
{"core.ignorestat", NULL, 0, GIT_IGNORESTAT_DEFAULT },
{"core.trustctime", NULL, 0, GIT_TRUSTCTIME_DEFAULT },
- {"core.abbrev", _configmap_int, 1, GIT_ABBREV_DEFAULT },
+ {"core.abbrev", _configmap_abbrev, ARRAY_SIZE(_configmap_abbrev), GIT_ABBREV_DEFAULT },
{"core.precomposeunicode", NULL, 0, GIT_PRECOMPOSE_DEFAULT },
{"core.safecrlf", _configmap_safecrlf, ARRAY_SIZE(_configmap_safecrlf), GIT_SAFE_CRLF_DEFAULT},
{"core.logallrefupdates", _configmap_logallrefupdates, ARRAY_SIZE(_configmap_logallrefupdates), GIT_LOGALLREFUPDATES_DEFAULT},
diff --git a/src/libgit2/config_entries.c b/src/libgit2/config_entries.c
deleted file mode 100644
index 66aae096d2d..00000000000
--- a/src/libgit2/config_entries.c
+++ /dev/null
@@ -1,237 +0,0 @@
-/*
- * Copyright (C) the libgit2 contributors. All rights reserved.
- *
- * This file is part of libgit2, distributed under the GNU GPL v2 with
- * a Linking Exception. For full terms see the included COPYING file.
- */
-
-#include "config_entries.h"
-
-typedef struct config_entry_list {
- struct config_entry_list *next;
- struct config_entry_list *last;
- git_config_entry *entry;
-} config_entry_list;
-
-typedef struct {
- git_config_entry *entry;
- bool multivar;
-} config_entry_map_head;
-
-typedef struct config_entries_iterator {
- git_config_iterator parent;
- git_config_entries *entries;
- config_entry_list *head;
-} config_entries_iterator;
-
-struct git_config_entries {
- git_refcount rc;
- git_strmap *map;
- config_entry_list *list;
-};
-
-int git_config_entries_new(git_config_entries **out)
-{
- git_config_entries *entries;
- int error;
-
- entries = git__calloc(1, sizeof(git_config_entries));
- GIT_ERROR_CHECK_ALLOC(entries);
- GIT_REFCOUNT_INC(entries);
-
- if ((error = git_strmap_new(&entries->map)) < 0)
- git__free(entries);
- else
- *out = entries;
-
- return error;
-}
-
-int git_config_entries_dup_entry(git_config_entries *entries, const git_config_entry *entry)
-{
- git_config_entry *duplicated;
- int error;
-
- duplicated = git__calloc(1, sizeof(git_config_entry));
- GIT_ERROR_CHECK_ALLOC(duplicated);
-
- duplicated->name = git__strdup(entry->name);
- GIT_ERROR_CHECK_ALLOC(duplicated->name);
-
- if (entry->value) {
- duplicated->value = git__strdup(entry->value);
- GIT_ERROR_CHECK_ALLOC(duplicated->value);
- }
- duplicated->level = entry->level;
- duplicated->include_depth = entry->include_depth;
-
- if ((error = git_config_entries_append(entries, duplicated)) < 0)
- goto out;
-
-out:
- if (error && duplicated) {
- git__free((char *) duplicated->name);
- git__free((char *) duplicated->value);
- git__free(duplicated);
- }
- return error;
-}
-
-int git_config_entries_dup(git_config_entries **out, git_config_entries *entries)
-{
- git_config_entries *result = NULL;
- config_entry_list *head;
- int error;
-
- if ((error = git_config_entries_new(&result)) < 0)
- goto out;
-
- for (head = entries->list; head; head = head->next)
- if ((git_config_entries_dup_entry(result, head->entry)) < 0)
- goto out;
-
- *out = result;
- result = NULL;
-
-out:
- git_config_entries_free(result);
- return error;
-}
-
-void git_config_entries_incref(git_config_entries *entries)
-{
- GIT_REFCOUNT_INC(entries);
-}
-
-static void config_entries_free(git_config_entries *entries)
-{
- config_entry_list *list = NULL, *next;
- config_entry_map_head *head;
-
- git_strmap_foreach_value(entries->map, head,
- git__free((char *) head->entry->name); git__free(head)
- );
- git_strmap_free(entries->map);
-
- list = entries->list;
- while (list != NULL) {
- next = list->next;
- git__free((char *) list->entry->value);
- git__free(list->entry);
- git__free(list);
- list = next;
- }
-
- git__free(entries);
-}
-
-void git_config_entries_free(git_config_entries *entries)
-{
- if (entries)
- GIT_REFCOUNT_DEC(entries, config_entries_free);
-}
-
-int git_config_entries_append(git_config_entries *entries, git_config_entry *entry)
-{
- config_entry_list *list_head;
- config_entry_map_head *map_head;
-
- if ((map_head = git_strmap_get(entries->map, entry->name)) != NULL) {
- map_head->multivar = true;
- /*
- * This is a micro-optimization for configuration files
- * with a lot of same keys. As for multivars the entry's
- * key will be the same for all entries, we can just free
- * all except the first entry's name and just re-use it.
- */
- git__free((char *) entry->name);
- entry->name = map_head->entry->name;
- } else {
- map_head = git__calloc(1, sizeof(*map_head));
- if ((git_strmap_set(entries->map, entry->name, map_head)) < 0)
- return -1;
- }
- map_head->entry = entry;
-
- list_head = git__calloc(1, sizeof(config_entry_list));
- GIT_ERROR_CHECK_ALLOC(list_head);
- list_head->entry = entry;
-
- if (entries->list)
- entries->list->last->next = list_head;
- else
- entries->list = list_head;
- entries->list->last = list_head;
-
- return 0;
-}
-
-int git_config_entries_get(git_config_entry **out, git_config_entries *entries, const char *key)
-{
- config_entry_map_head *entry;
- if ((entry = git_strmap_get(entries->map, key)) == NULL)
- return GIT_ENOTFOUND;
- *out = entry->entry;
- return 0;
-}
-
-int git_config_entries_get_unique(git_config_entry **out, git_config_entries *entries, const char *key)
-{
- config_entry_map_head *entry;
-
- if ((entry = git_strmap_get(entries->map, key)) == NULL)
- return GIT_ENOTFOUND;
-
- if (entry->multivar) {
- git_error_set(GIT_ERROR_CONFIG, "entry is not unique due to being a multivar");
- return -1;
- }
-
- if (entry->entry->include_depth) {
- git_error_set(GIT_ERROR_CONFIG, "entry is not unique due to being included");
- return -1;
- }
-
- *out = entry->entry;
-
- return 0;
-}
-
-static void config_iterator_free(git_config_iterator *iter)
-{
- config_entries_iterator *it = (config_entries_iterator *) iter;
- git_config_entries_free(it->entries);
- git__free(it);
-}
-
-static int config_iterator_next(
- git_config_entry **entry,
- git_config_iterator *iter)
-{
- config_entries_iterator *it = (config_entries_iterator *) iter;
-
- if (!it->head)
- return GIT_ITEROVER;
-
- *entry = it->head->entry;
- it->head = it->head->next;
-
- return 0;
-}
-
-int git_config_entries_iterator_new(git_config_iterator **out, git_config_entries *entries)
-{
- config_entries_iterator *it;
-
- it = git__calloc(1, sizeof(config_entries_iterator));
- GIT_ERROR_CHECK_ALLOC(it);
- it->parent.next = config_iterator_next;
- it->parent.free = config_iterator_free;
- it->head = entries->list;
- it->entries = entries;
-
- git_config_entries_incref(entries);
- *out = &it->parent;
-
- return 0;
-}
diff --git a/src/libgit2/config_entries.h b/src/libgit2/config_entries.h
deleted file mode 100644
index 832379e7466..00000000000
--- a/src/libgit2/config_entries.h
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * Copyright (C) the libgit2 contributors. All rights reserved.
- *
- * This file is part of libgit2, distributed under the GNU GPL v2 with
- * a Linking Exception. For full terms see the included COPYING file.
- */
-
-#include "common.h"
-
-#include "git2/sys/config.h"
-#include "config.h"
-
-typedef struct git_config_entries git_config_entries;
-
-int git_config_entries_new(git_config_entries **out);
-int git_config_entries_dup(git_config_entries **out, git_config_entries *entries);
-int git_config_entries_dup_entry(git_config_entries *entries, const git_config_entry *entry);
-void git_config_entries_incref(git_config_entries *entries);
-void git_config_entries_free(git_config_entries *entries);
-/* Add or append the new config option */
-int git_config_entries_append(git_config_entries *entries, git_config_entry *entry);
-int git_config_entries_get(git_config_entry **out, git_config_entries *entries, const char *key);
-int git_config_entries_get_unique(git_config_entry **out, git_config_entries *entries, const char *key);
-int git_config_entries_iterator_new(git_config_iterator **out, git_config_entries *entries);
diff --git a/src/libgit2/config_file.c b/src/libgit2/config_file.c
index 932ca76014e..510f6fd0b77 100644
--- a/src/libgit2/config_file.c
+++ b/src/libgit2/config_file.c
@@ -13,7 +13,7 @@
#include "array.h"
#include "str.h"
#include "config_backend.h"
-#include "config_entries.h"
+#include "config_list.h"
#include "config_parse.h"
#include "filebuf.h"
#include "regexp.h"
@@ -24,9 +24,11 @@
/* Max depth for [include] directives */
#define MAX_INCLUDE_DEPTH 10
+#define CONFIG_FILE_TYPE "file"
+
typedef struct config_file {
git_futils_filestamp stamp;
- unsigned char checksum[GIT_HASH_SHA1_SIZE];
+ unsigned char checksum[GIT_HASH_SHA256_SIZE];
char *path;
git_array_t(struct config_file) includes;
} config_file;
@@ -34,7 +36,7 @@ typedef struct config_file {
typedef struct {
git_config_backend parent;
git_mutex values_mutex;
- git_config_entries *entries;
+ git_config_list *config_list;
const git_repository *repo;
git_config_level_t level;
@@ -50,13 +52,13 @@ typedef struct {
typedef struct {
const git_repository *repo;
config_file *file;
- git_config_entries *entries;
+ git_config_list *config_list;
git_config_level_t level;
unsigned int depth;
} config_file_parse_data;
-static int config_file_read(git_config_entries *entries, const git_repository *repo, config_file *file, git_config_level_t level, int depth);
-static int config_file_read_buffer(git_config_entries *entries, const git_repository *repo, config_file *file, git_config_level_t level, int depth, const char *buf, size_t buflen);
+static int config_file_read(git_config_list *config_list, const git_repository *repo, config_file *file, git_config_level_t level, int depth);
+static int config_file_read_buffer(git_config_list *config_list, const git_repository *repo, config_file *file, git_config_level_t level, int depth, const char *buf, size_t buflen);
static int config_file_write(config_file_backend *cfg, const char *orig_key, const char *key, const git_regexp *preg, const char *value);
static char *escape_value(const char *ptr);
@@ -65,7 +67,7 @@ static char *escape_value(const char *ptr);
* refcount. This is its own function to make sure we use the mutex to
* avoid the map pointer from changing under us.
*/
-static int config_file_entries_take(git_config_entries **out, config_file_backend *b)
+static int config_file_take_list(git_config_list **out, config_file_backend *b)
{
int error;
@@ -74,8 +76,8 @@ static int config_file_entries_take(git_config_entries **out, config_file_backen
return error;
}
- git_config_entries_incref(b->entries);
- *out = b->entries;
+ git_config_list_incref(b->config_list);
+ *out = b->config_list;
git_mutex_unlock(&b->values_mutex);
@@ -106,7 +108,7 @@ static int config_file_open(git_config_backend *cfg, git_config_level_t level, c
b->level = level;
b->repo = repo;
- if ((res = git_config_entries_new(&b->entries)) < 0)
+ if ((res = git_config_list_new(&b->config_list)) < 0)
return res;
if (!git_fs_path_exists(b->file.path))
@@ -121,9 +123,9 @@ static int config_file_open(git_config_backend *cfg, git_config_level_t level, c
if (p_access(b->file.path, R_OK) < 0)
return GIT_ENOTFOUND;
- if (res < 0 || (res = config_file_read(b->entries, repo, &b->file, level, 0)) < 0) {
- git_config_entries_free(b->entries);
- b->entries = NULL;
+ if (res < 0 || (res = config_file_read(b->config_list, repo, &b->file, level, 0)) < 0) {
+ git_config_list_free(b->config_list);
+ b->config_list = NULL;
}
return res;
@@ -133,7 +135,7 @@ static int config_file_is_modified(int *modified, config_file *file)
{
config_file *include;
git_str buf = GIT_STR_INIT;
- unsigned char checksum[GIT_HASH_SHA1_SIZE];
+ unsigned char checksum[GIT_HASH_SHA256_SIZE];
uint32_t i;
int error = 0;
@@ -145,10 +147,10 @@ static int config_file_is_modified(int *modified, config_file *file)
if ((error = git_futils_readbuffer(&buf, file->path)) < 0)
goto out;
- if ((error = git_hash_buf(checksum, buf.ptr, buf.size, GIT_HASH_ALGORITHM_SHA1)) < 0)
+ if ((error = git_hash_buf(checksum, buf.ptr, buf.size, GIT_HASH_ALGORITHM_SHA256)) < 0)
goto out;
- if (memcmp(checksum, file->checksum, GIT_HASH_SHA1_SIZE) != 0) {
+ if (memcmp(checksum, file->checksum, GIT_HASH_SHA256_SIZE) != 0) {
*modified = 1;
goto out;
}
@@ -175,10 +177,10 @@ static void config_file_clear_includes(config_file_backend *cfg)
git_array_clear(cfg->file.includes);
}
-static int config_file_set_entries(git_config_backend *cfg, git_config_entries *entries)
+static int config_file_set_entries(git_config_backend *cfg, git_config_list *config_list)
{
config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent);
- git_config_entries *old = NULL;
+ git_config_list *old = NULL;
int error;
if (b->parent.readonly) {
@@ -191,40 +193,40 @@ static int config_file_set_entries(git_config_backend *cfg, git_config_entries *
goto out;
}
- old = b->entries;
- b->entries = entries;
+ old = b->config_list;
+ b->config_list = config_list;
git_mutex_unlock(&b->values_mutex);
out:
- git_config_entries_free(old);
+ git_config_list_free(old);
return error;
}
static int config_file_refresh_from_buffer(git_config_backend *cfg, const char *buf, size_t buflen)
{
config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent);
- git_config_entries *entries = NULL;
+ git_config_list *config_list = NULL;
int error;
config_file_clear_includes(b);
- if ((error = git_config_entries_new(&entries)) < 0 ||
- (error = config_file_read_buffer(entries, b->repo, &b->file,
+ if ((error = git_config_list_new(&config_list)) < 0 ||
+ (error = config_file_read_buffer(config_list, b->repo, &b->file,
b->level, 0, buf, buflen)) < 0 ||
- (error = config_file_set_entries(cfg, entries)) < 0)
+ (error = config_file_set_entries(cfg, config_list)) < 0)
goto out;
- entries = NULL;
+ config_list = NULL;
out:
- git_config_entries_free(entries);
+ git_config_list_free(config_list);
return error;
}
static int config_file_refresh(git_config_backend *cfg)
{
config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent);
- git_config_entries *entries = NULL;
+ git_config_list *config_list = NULL;
int error, modified;
if (cfg->readonly)
@@ -238,14 +240,14 @@ static int config_file_refresh(git_config_backend *cfg)
config_file_clear_includes(b);
- if ((error = git_config_entries_new(&entries)) < 0 ||
- (error = config_file_read(entries, b->repo, &b->file, b->level, 0)) < 0 ||
- (error = config_file_set_entries(cfg, entries)) < 0)
+ if ((error = git_config_list_new(&config_list)) < 0 ||
+ (error = config_file_read(config_list, b->repo, &b->file, b->level, 0)) < 0 ||
+ (error = config_file_set_entries(cfg, config_list)) < 0)
goto out;
- entries = NULL;
+ config_list = NULL;
out:
- git_config_entries_free(entries);
+ git_config_list_free(config_list);
return (error == GIT_ENOTFOUND) ? 0 : error;
}
@@ -258,7 +260,7 @@ static void config_file_free(git_config_backend *_backend)
return;
config_file_clear(&backend->file);
- git_config_entries_free(backend->entries);
+ git_config_list_free(backend->config_list);
git_mutex_free(&backend->values_mutex);
git__free(backend);
}
@@ -268,19 +270,19 @@ static int config_file_iterator(
struct git_config_backend *backend)
{
config_file_backend *b = GIT_CONTAINER_OF(backend, config_file_backend, parent);
- git_config_entries *dupped = NULL, *entries = NULL;
+ git_config_list *dupped = NULL, *config_list = NULL;
int error;
if ((error = config_file_refresh(backend)) < 0 ||
- (error = config_file_entries_take(&entries, b)) < 0 ||
- (error = git_config_entries_dup(&dupped, entries)) < 0 ||
- (error = git_config_entries_iterator_new(iter, dupped)) < 0)
+ (error = config_file_take_list(&config_list, b)) < 0 ||
+ (error = git_config_list_dup(&dupped, config_list)) < 0 ||
+ (error = git_config_list_iterator_new(iter, dupped)) < 0)
goto out;
out:
- /* Let iterator delete duplicated entries when it's done */
- git_config_entries_free(entries);
- git_config_entries_free(dupped);
+ /* Let iterator delete duplicated config_list when it's done */
+ git_config_list_free(config_list);
+ git_config_list_free(dupped);
return error;
}
@@ -292,24 +294,24 @@ static int config_file_snapshot(git_config_backend **out, git_config_backend *ba
static int config_file_set(git_config_backend *cfg, const char *name, const char *value)
{
config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent);
- git_config_entries *entries;
- git_config_entry *existing;
+ git_config_list *config_list;
+ git_config_list_entry *existing;
char *key, *esc_value = NULL;
int error;
if ((error = git_config__normalize_name(name, &key)) < 0)
return error;
- if ((error = config_file_entries_take(&entries, b)) < 0)
+ if ((error = config_file_take_list(&config_list, b)) < 0)
return error;
/* Check whether we'd be modifying an included or multivar key */
- if ((error = git_config_entries_get_unique(&existing, entries, key)) < 0) {
+ if ((error = git_config_list_get_unique(&existing, config_list, key)) < 0) {
if (error != GIT_ENOTFOUND)
goto out;
error = 0;
- } else if ((!existing->value && !value) ||
- (existing->value && value && !strcmp(existing->value, value))) {
+ } else if ((!existing->base.entry.value && !value) ||
+ (existing->base.entry.value && value && !strcmp(existing->base.entry.value, value))) {
/* don't update if old and new values already match */
error = 0;
goto out;
@@ -325,43 +327,37 @@ static int config_file_set(git_config_backend *cfg, const char *name, const char
goto out;
out:
- git_config_entries_free(entries);
+ git_config_list_free(config_list);
git__free(esc_value);
git__free(key);
return error;
}
-/* release the map containing the entry as an equivalent to freeing it */
-static void config_file_entry_free(git_config_entry *entry)
-{
- git_config_entries *entries = (git_config_entries *) entry->payload;
- git_config_entries_free(entries);
-}
-
/*
* Internal function that actually gets the value in string form
*/
-static int config_file_get(git_config_backend *cfg, const char *key, git_config_entry **out)
+static int config_file_get(
+ git_config_backend *cfg,
+ const char *key,
+ git_config_backend_entry **out)
{
config_file_backend *h = GIT_CONTAINER_OF(cfg, config_file_backend, parent);
- git_config_entries *entries = NULL;
- git_config_entry *entry;
+ git_config_list *config_list = NULL;
+ git_config_list_entry *entry;
int error = 0;
if (!h->parent.readonly && ((error = config_file_refresh(cfg)) < 0))
return error;
- if ((error = config_file_entries_take(&entries, h)) < 0)
+ if ((error = config_file_take_list(&config_list, h)) < 0)
return error;
- if ((error = (git_config_entries_get(&entry, entries, key))) < 0) {
- git_config_entries_free(entries);
+ if ((error = (git_config_list_get(&entry, config_list, key))) < 0) {
+ git_config_list_free(config_list);
return error;
}
- entry->free = config_file_entry_free;
- entry->payload = entries;
- *out = entry;
+ *out = &entry->base;
return 0;
}
@@ -396,29 +392,29 @@ static int config_file_set_multivar(
static int config_file_delete(git_config_backend *cfg, const char *name)
{
config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent);
- git_config_entries *entries = NULL;
- git_config_entry *entry;
+ git_config_list *config_list = NULL;
+ git_config_list_entry *entry;
char *key = NULL;
int error;
if ((error = git_config__normalize_name(name, &key)) < 0)
goto out;
- if ((error = config_file_entries_take(&entries, b)) < 0)
+ if ((error = config_file_take_list(&config_list, b)) < 0)
goto out;
/* Check whether we'd be modifying an included or multivar key */
- if ((error = git_config_entries_get_unique(&entry, entries, key)) < 0) {
+ if ((error = git_config_list_get_unique(&entry, config_list, key)) < 0) {
if (error == GIT_ENOTFOUND)
git_error_set(GIT_ERROR_CONFIG, "could not find key '%s' to delete", name);
goto out;
}
- if ((error = config_file_write(b, name, entry->name, NULL, NULL)) < 0)
+ if ((error = config_file_write(b, name, entry->base.entry.name, NULL, NULL)) < 0)
goto out;
out:
- git_config_entries_free(entries);
+ git_config_list_free(config_list);
git__free(key);
return error;
}
@@ -426,8 +422,8 @@ static int config_file_delete(git_config_backend *cfg, const char *name)
static int config_file_delete_multivar(git_config_backend *cfg, const char *name, const char *regexp)
{
config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent);
- git_config_entries *entries = NULL;
- git_config_entry *entry = NULL;
+ git_config_list *config_list = NULL;
+ git_config_list_entry *entry = NULL;
git_regexp preg = GIT_REGEX_INIT;
char *key = NULL;
int result;
@@ -435,10 +431,10 @@ static int config_file_delete_multivar(git_config_backend *cfg, const char *name
if ((result = git_config__normalize_name(name, &key)) < 0)
goto out;
- if ((result = config_file_entries_take(&entries, b)) < 0)
+ if ((result = config_file_take_list(&config_list, b)) < 0)
goto out;
- if ((result = git_config_entries_get(&entry, entries, key)) < 0) {
+ if ((result = git_config_list_get(&entry, config_list, key)) < 0) {
if (result == GIT_ENOTFOUND)
git_error_set(GIT_ERROR_CONFIG, "could not find key '%s' to delete", name);
goto out;
@@ -451,7 +447,7 @@ static int config_file_delete_multivar(git_config_backend *cfg, const char *name
goto out;
out:
- git_config_entries_free(entries);
+ git_config_list_free(config_list);
git__free(key);
git_regexp_dispose(&preg);
return result;
@@ -591,7 +587,7 @@ static int parse_include(config_file_parse_data *parse_data, const char *file)
git_array_init(include->includes);
include->path = git_str_detach(&path);
- result = config_file_read(parse_data->entries, parse_data->repo, include,
+ result = config_file_read(parse_data->config_list, parse_data->repo, include,
parse_data->level, parse_data->depth+1);
if (result == GIT_ENOTFOUND) {
@@ -776,7 +772,7 @@ static int read_on_variable(
{
config_file_parse_data *parse_data = (config_file_parse_data *)data;
git_str buf = GIT_STR_INIT;
- git_config_entry *entry;
+ git_config_list_entry *entry;
const char *c;
int result = 0;
@@ -799,30 +795,45 @@ static int read_on_variable(
if (git_str_oom(&buf))
return -1;
- entry = git__calloc(1, sizeof(git_config_entry));
+ entry = git__calloc(1, sizeof(git_config_list_entry));
GIT_ERROR_CHECK_ALLOC(entry);
- entry->name = git_str_detach(&buf);
- entry->value = var_value ? git__strdup(var_value) : NULL;
- entry->level = parse_data->level;
- entry->include_depth = parse_data->depth;
- if ((result = git_config_entries_append(parse_data->entries, entry)) < 0)
+ entry->base.entry.name = git_str_detach(&buf);
+ GIT_ERROR_CHECK_ALLOC(entry->base.entry.name);
+
+ if (var_value) {
+ entry->base.entry.value = git__strdup(var_value);
+ GIT_ERROR_CHECK_ALLOC(entry->base.entry.value);
+ }
+
+ entry->base.entry.backend_type = git_config_list_add_string(parse_data->config_list, CONFIG_FILE_TYPE);
+ GIT_ERROR_CHECK_ALLOC(entry->base.entry.backend_type);
+
+ entry->base.entry.origin_path = git_config_list_add_string(parse_data->config_list, parse_data->file->path);
+ GIT_ERROR_CHECK_ALLOC(entry->base.entry.origin_path);
+
+ entry->base.entry.level = parse_data->level;
+ entry->base.entry.include_depth = parse_data->depth;
+ entry->base.free = git_config_list_entry_free;
+ entry->config_list = parse_data->config_list;
+
+ if ((result = git_config_list_append(parse_data->config_list, entry)) < 0)
return result;
result = 0;
/* Add or append the new config option */
- if (!git__strcmp(entry->name, "include.path"))
- result = parse_include(parse_data, entry->value);
- else if (!git__prefixcmp(entry->name, "includeif.") &&
- !git__suffixcmp(entry->name, ".path"))
- result = parse_conditional_include(parse_data, entry->name, entry->value);
+ if (!git__strcmp(entry->base.entry.name, "include.path"))
+ result = parse_include(parse_data, entry->base.entry.value);
+ else if (!git__prefixcmp(entry->base.entry.name, "includeif.") &&
+ !git__suffixcmp(entry->base.entry.name, ".path"))
+ result = parse_conditional_include(parse_data, entry->base.entry.name, entry->base.entry.value);
return result;
}
static int config_file_read_buffer(
- git_config_entries *entries,
+ git_config_list *config_list,
const git_repository *repo,
config_file *file,
git_config_level_t level,
@@ -851,7 +862,7 @@ static int config_file_read_buffer(
parse_data.repo = repo;
parse_data.file = file;
- parse_data.entries = entries;
+ parse_data.config_list = config_list;
parse_data.level = level;
parse_data.depth = depth;
@@ -862,7 +873,7 @@ static int config_file_read_buffer(
}
static int config_file_read(
- git_config_entries *entries,
+ git_config_list *config_list,
const git_repository *repo,
config_file *file,
git_config_level_t level,
@@ -881,10 +892,10 @@ static int config_file_read(
goto out;
git_futils_filestamp_set_from_stat(&file->stamp, &st);
- if ((error = git_hash_buf(file->checksum, contents.ptr, contents.size, GIT_HASH_ALGORITHM_SHA1)) < 0)
+ if ((error = git_hash_buf(file->checksum, contents.ptr, contents.size, GIT_HASH_ALGORITHM_SHA256)) < 0)
goto out;
- if ((error = config_file_read_buffer(entries, repo, file, level, depth,
+ if ((error = config_file_read_buffer(config_list, repo, file, level, depth,
contents.ptr, contents.size)) < 0)
goto out;
@@ -1116,7 +1127,12 @@ static int write_on_eof(
/*
* This is pretty much the parsing, except we write out anything we don't have
*/
-static int config_file_write(config_file_backend *cfg, const char *orig_key, const char *key, const git_regexp *preg, const char *value)
+static int config_file_write(
+ config_file_backend *cfg,
+ const char *orig_key,
+ const char *key,
+ const git_regexp *preg,
+ const char *value)
{
char *orig_section = NULL, *section = NULL, *orig_name, *name, *ldot;
@@ -1131,8 +1147,9 @@ static int config_file_write(config_file_backend *cfg, const char *orig_key, con
if (cfg->locked) {
error = git_str_puts(&contents, git_str_cstr(&cfg->locked_content) == NULL ? "" : git_str_cstr(&cfg->locked_content));
} else {
- if ((error = git_filebuf_open(&file, cfg->file.path, GIT_FILEBUF_HASH_CONTENTS,
- GIT_CONFIG_FILE_MODE)) < 0)
+ if ((error = git_filebuf_open(&file, cfg->file.path,
+ GIT_FILEBUF_HASH_SHA256,
+ GIT_CONFIG_FILE_MODE)) < 0)
goto done;
/* We need to read in our own config file */
diff --git a/src/libgit2/config_list.c b/src/libgit2/config_list.c
new file mode 100644
index 00000000000..0e6559795c2
--- /dev/null
+++ b/src/libgit2/config_list.c
@@ -0,0 +1,285 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include "config_list.h"
+#include "hashmap_str.h"
+
+typedef struct config_entry_list {
+ struct config_entry_list *next;
+ struct config_entry_list *last;
+ git_config_list_entry *entry;
+} config_entry_list;
+
+typedef struct {
+ git_config_list_entry *entry;
+ bool multivar;
+} config_entry_map_head;
+
+typedef struct config_list_iterator {
+ git_config_iterator parent;
+ git_config_list *list;
+ config_entry_list *head;
+} config_list_iterator;
+
+GIT_HASHMAP_STR_SETUP(git_config_list_pathmap, char *);
+GIT_HASHMAP_STR_SETUP(git_config_list_headmap, config_entry_map_head *);
+
+struct git_config_list {
+ git_refcount rc;
+
+ /* Interned strings - paths to config files or backend types */
+ git_config_list_pathmap strings;
+
+ /* Config entries */
+ git_config_list_headmap map;
+ config_entry_list *entries;
+};
+
+int git_config_list_new(git_config_list **out)
+{
+ git_config_list *config_list;
+
+ config_list = git__calloc(1, sizeof(git_config_list));
+ GIT_ERROR_CHECK_ALLOC(config_list);
+ GIT_REFCOUNT_INC(config_list);
+
+ *out = config_list;
+ return 0;
+}
+
+int git_config_list_dup_entry(git_config_list *config_list, const git_config_entry *entry)
+{
+ git_config_list_entry *duplicated;
+ int error;
+
+ duplicated = git__calloc(1, sizeof(git_config_list_entry));
+ GIT_ERROR_CHECK_ALLOC(duplicated);
+
+ duplicated->base.entry.name = git__strdup(entry->name);
+ GIT_ERROR_CHECK_ALLOC(duplicated->base.entry.name);
+
+ if (entry->value) {
+ duplicated->base.entry.value = git__strdup(entry->value);
+ GIT_ERROR_CHECK_ALLOC(duplicated->base.entry.value);
+ }
+
+ duplicated->base.entry.backend_type = git_config_list_add_string(config_list, entry->backend_type);
+ GIT_ERROR_CHECK_ALLOC(duplicated->base.entry.backend_type);
+
+ if (entry->origin_path) {
+ duplicated->base.entry.origin_path = git_config_list_add_string(config_list, entry->origin_path);
+ GIT_ERROR_CHECK_ALLOC(duplicated->base.entry.origin_path);
+ }
+
+ duplicated->base.entry.level = entry->level;
+ duplicated->base.entry.include_depth = entry->include_depth;
+ duplicated->base.free = git_config_list_entry_free;
+ duplicated->config_list = config_list;
+
+ if ((error = git_config_list_append(config_list, duplicated)) < 0)
+ goto out;
+
+out:
+ if (error && duplicated) {
+ git__free((char *) duplicated->base.entry.name);
+ git__free((char *) duplicated->base.entry.value);
+ git__free(duplicated);
+ }
+ return error;
+}
+
+int git_config_list_dup(git_config_list **out, git_config_list *config_list)
+{
+ git_config_list *result = NULL;
+ config_entry_list *head;
+ int error;
+
+ if ((error = git_config_list_new(&result)) < 0)
+ goto out;
+
+ for (head = config_list->entries; head; head = head->next)
+ if ((git_config_list_dup_entry(result, &head->entry->base.entry)) < 0)
+ goto out;
+
+ *out = result;
+ result = NULL;
+
+out:
+ git_config_list_free(result);
+ return error;
+}
+
+void git_config_list_incref(git_config_list *config_list)
+{
+ GIT_REFCOUNT_INC(config_list);
+}
+
+static void config_list_free(git_config_list *config_list)
+{
+ config_entry_list *entry_list = NULL, *next;
+ config_entry_map_head *head;
+ char *str;
+ git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
+
+ while (git_config_list_pathmap_iterate(&iter, NULL, &str, &config_list->strings) == 0)
+ git__free(str);
+
+ git_config_list_pathmap_dispose(&config_list->strings);
+
+ iter = GIT_HASHMAP_ITER_INIT;
+ while (git_config_list_headmap_iterate(&iter, NULL, &head, &config_list->map) == 0) {
+ git__free((char *) head->entry->base.entry.name);
+ git__free(head);
+ }
+ git_config_list_headmap_dispose(&config_list->map);
+
+ entry_list = config_list->entries;
+ while (entry_list != NULL) {
+ next = entry_list->next;
+ git__free((char *) entry_list->entry->base.entry.value);
+ git__free(entry_list->entry);
+ git__free(entry_list);
+ entry_list = next;
+ }
+
+ git__free(config_list);
+}
+
+void git_config_list_free(git_config_list *config_list)
+{
+ if (config_list)
+ GIT_REFCOUNT_DEC(config_list, config_list_free);
+}
+
+int git_config_list_append(git_config_list *config_list, git_config_list_entry *entry)
+{
+ config_entry_list *list_head;
+ config_entry_map_head *map_head;
+
+ if (git_config_list_headmap_get(&map_head, &config_list->map, entry->base.entry.name) == 0) {
+ map_head->multivar = true;
+ /*
+ * This is a micro-optimization for configuration files
+ * with a lot of same keys. As for multivars the entry's
+ * key will be the same for all list, we can just free
+ * all except the first entry's name and just re-use it.
+ */
+ git__free((char *) entry->base.entry.name);
+ entry->base.entry.name = map_head->entry->base.entry.name;
+ } else {
+ map_head = git__calloc(1, sizeof(*map_head));
+ if ((git_config_list_headmap_put(&config_list->map, entry->base.entry.name, map_head)) < 0)
+ return -1;
+ }
+ map_head->entry = entry;
+
+ list_head = git__calloc(1, sizeof(config_entry_list));
+ GIT_ERROR_CHECK_ALLOC(list_head);
+ list_head->entry = entry;
+
+ if (config_list->entries)
+ config_list->entries->last->next = list_head;
+ else
+ config_list->entries = list_head;
+ config_list->entries->last = list_head;
+
+ return 0;
+}
+
+int git_config_list_get(git_config_list_entry **out, git_config_list *config_list, const char *key)
+{
+ config_entry_map_head *entry;
+
+ if (git_config_list_headmap_get(&entry, &config_list->map, key) != 0)
+ return GIT_ENOTFOUND;
+
+ *out = entry->entry;
+ return 0;
+}
+
+int git_config_list_get_unique(git_config_list_entry **out, git_config_list *config_list, const char *key)
+{
+ config_entry_map_head *entry;
+
+ if (git_config_list_headmap_get(&entry, &config_list->map, key) != 0)
+ return GIT_ENOTFOUND;
+
+ if (entry->multivar) {
+ git_error_set(GIT_ERROR_CONFIG, "entry is not unique due to being a multivar");
+ return -1;
+ }
+
+ if (entry->entry->base.entry.include_depth) {
+ git_error_set(GIT_ERROR_CONFIG, "entry is not unique due to being included");
+ return -1;
+ }
+
+ *out = entry->entry;
+ return 0;
+}
+
+static void config_iterator_free(git_config_iterator *iter)
+{
+ config_list_iterator *it = (config_list_iterator *) iter;
+ git_config_list_free(it->list);
+ git__free(it);
+}
+
+static int config_iterator_next(
+ git_config_backend_entry **entry,
+ git_config_iterator *iter)
+{
+ config_list_iterator *it = (config_list_iterator *) iter;
+
+ if (!it->head)
+ return GIT_ITEROVER;
+
+ *entry = &it->head->entry->base;
+ it->head = it->head->next;
+
+ return 0;
+}
+
+int git_config_list_iterator_new(git_config_iterator **out, git_config_list *config_list)
+{
+ config_list_iterator *it;
+
+ it = git__calloc(1, sizeof(config_list_iterator));
+ GIT_ERROR_CHECK_ALLOC(it);
+ it->parent.next = config_iterator_next;
+ it->parent.free = config_iterator_free;
+ it->head = config_list->entries;
+ it->list = config_list;
+
+ git_config_list_incref(config_list);
+ *out = &it->parent;
+
+ return 0;
+}
+
+/* release the map containing the entry as an equivalent to freeing it */
+void git_config_list_entry_free(git_config_backend_entry *e)
+{
+ git_config_list_entry *entry = (git_config_list_entry *)e;
+ git_config_list_free(entry->config_list);
+}
+
+const char *git_config_list_add_string(
+ git_config_list *config_list,
+ const char *str)
+{
+ char *s;
+
+ if (git_config_list_pathmap_get(&s, &config_list->strings, str) == 0)
+ return s;
+
+ if ((s = git__strdup(str)) == NULL ||
+ git_config_list_pathmap_put(&config_list->strings, s, s) < 0)
+ return NULL;
+
+ return s;
+}
diff --git a/src/libgit2/config_list.h b/src/libgit2/config_list.h
new file mode 100644
index 00000000000..091a59b9079
--- /dev/null
+++ b/src/libgit2/config_list.h
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include "common.h"
+
+#include "git2/sys/config.h"
+#include "config.h"
+
+typedef struct git_config_list git_config_list;
+
+typedef struct {
+ git_config_backend_entry base;
+ git_config_list *config_list;
+} git_config_list_entry;
+
+int git_config_list_new(git_config_list **out);
+int git_config_list_dup(git_config_list **out, git_config_list *list);
+int git_config_list_dup_entry(git_config_list *list, const git_config_entry *entry);
+void git_config_list_incref(git_config_list *list);
+void git_config_list_free(git_config_list *list);
+/* Add or append the new config option */
+int git_config_list_append(git_config_list *list, git_config_list_entry *entry);
+int git_config_list_get(git_config_list_entry **out, git_config_list *list, const char *key);
+int git_config_list_get_unique(git_config_list_entry **out, git_config_list *list, const char *key);
+int git_config_list_iterator_new(git_config_iterator **out, git_config_list *list);
+const char *git_config_list_add_string(git_config_list *list, const char *str);
+
+void git_config_list_entry_free(git_config_backend_entry *entry);
diff --git a/src/libgit2/config_mem.c b/src/libgit2/config_mem.c
index 560229cf534..3c159073f2d 100644
--- a/src/libgit2/config_mem.c
+++ b/src/libgit2/config_mem.c
@@ -9,16 +9,29 @@
#include "config_backend.h"
#include "config_parse.h"
-#include "config_entries.h"
+#include "config_list.h"
+#include "strlist.h"
typedef struct {
git_config_backend parent;
- git_config_entries *entries;
+
+ char *backend_type;
+ char *origin_path;
+
+ git_config_list *config_list;
+
+ /* Configuration data in the config file format */
git_str cfg;
+
+ /* Array of key=value pairs */
+ char **values;
+ size_t values_len;
} config_memory_backend;
typedef struct {
- git_config_entries *entries;
+ const char *backend_type;
+ const char *origin_path;
+ git_config_list *config_list;
git_config_level_t level;
} config_memory_parse_data;
@@ -39,7 +52,7 @@ static int read_variable_cb(
{
config_memory_parse_data *parse_data = (config_memory_parse_data *) payload;
git_str buf = GIT_STR_INIT;
- git_config_entry *entry;
+ git_config_list_entry *entry;
const char *c;
int result;
@@ -62,35 +75,46 @@ static int read_variable_cb(
if (git_str_oom(&buf))
return -1;
- entry = git__calloc(1, sizeof(git_config_entry));
+ entry = git__calloc(1, sizeof(git_config_list_entry));
GIT_ERROR_CHECK_ALLOC(entry);
- entry->name = git_str_detach(&buf);
- entry->value = var_value ? git__strdup(var_value) : NULL;
- entry->level = parse_data->level;
- entry->include_depth = 0;
-
- if ((result = git_config_entries_append(parse_data->entries, entry)) < 0)
+ entry->base.entry.name = git_str_detach(&buf);
+ entry->base.entry.value = var_value ? git__strdup(var_value) : NULL;
+ entry->base.entry.level = parse_data->level;
+ entry->base.entry.include_depth = 0;
+ entry->base.entry.backend_type = parse_data->backend_type;
+ entry->base.entry.origin_path = parse_data->origin_path;
+ entry->base.free = git_config_list_entry_free;
+ entry->config_list = parse_data->config_list;
+
+ if ((result = git_config_list_append(parse_data->config_list, entry)) < 0)
return result;
return result;
}
-static int config_memory_open(git_config_backend *backend, git_config_level_t level, const git_repository *repo)
+static int parse_config(
+ config_memory_backend *memory_backend,
+ git_config_level_t level)
{
- config_memory_backend *memory_backend = (config_memory_backend *) backend;
git_config_parser parser = GIT_PARSE_CTX_INIT;
config_memory_parse_data parse_data;
int error;
- GIT_UNUSED(repo);
-
- if ((error = git_config_parser_init(&parser, "in-memory", memory_backend->cfg.ptr,
- memory_backend->cfg.size)) < 0)
+ if ((error = git_config_parser_init(&parser, "in-memory",
+ memory_backend->cfg.ptr, memory_backend->cfg.size)) < 0)
goto out;
- parse_data.entries = memory_backend->entries;
+
+ parse_data.backend_type = git_config_list_add_string(
+ memory_backend->config_list, memory_backend->backend_type);
+ parse_data.origin_path = memory_backend->origin_path ?
+ git_config_list_add_string(memory_backend->config_list,
+ memory_backend->origin_path) :
+ NULL;
+ parse_data.config_list = memory_backend->config_list;
parse_data.level = level;
- if ((error = git_config_parse(&parser, NULL, read_variable_cb, NULL, NULL, &parse_data)) < 0)
+ if ((error = git_config_parse(&parser, NULL, read_variable_cb,
+ NULL, NULL, &parse_data)) < 0)
goto out;
out:
@@ -98,10 +122,85 @@ static int config_memory_open(git_config_backend *backend, git_config_level_t le
return error;
}
-static int config_memory_get(git_config_backend *backend, const char *key, git_config_entry **out)
+static int parse_values(
+ config_memory_backend *memory_backend,
+ git_config_level_t level)
+{
+ git_config_list_entry *entry;
+ const char *eql, *backend_type, *origin_path;
+ size_t name_len, i;
+
+ backend_type = git_config_list_add_string(
+ memory_backend->config_list, memory_backend->backend_type);
+ GIT_ERROR_CHECK_ALLOC(backend_type);
+
+ origin_path = memory_backend->origin_path ?
+ git_config_list_add_string(memory_backend->config_list,
+ memory_backend->origin_path) :
+ NULL;
+
+ for (i = 0; i < memory_backend->values_len; i++) {
+ eql = strchr(memory_backend->values[i], '=');
+ name_len = eql - memory_backend->values[i];
+
+ if (name_len == 0) {
+ git_error_set(GIT_ERROR_CONFIG, "empty config key");
+ return -1;
+ }
+
+ entry = git__calloc(1, sizeof(git_config_list_entry));
+ GIT_ERROR_CHECK_ALLOC(entry);
+
+ entry->base.entry.name = git__strndup(memory_backend->values[i], name_len);
+ GIT_ERROR_CHECK_ALLOC(entry->base.entry.name);
+
+ if (eql) {
+ entry->base.entry.value = git__strdup(eql + 1);
+ GIT_ERROR_CHECK_ALLOC(entry->base.entry.value);
+ }
+
+ entry->base.entry.level = level;
+ entry->base.entry.include_depth = 0;
+ entry->base.entry.backend_type = backend_type;
+ entry->base.entry.origin_path = origin_path;
+ entry->base.free = git_config_list_entry_free;
+ entry->config_list = memory_backend->config_list;
+
+ if (git_config_list_append(memory_backend->config_list, entry) < 0)
+ return -1;
+ }
+
+ return 0;
+}
+
+static int config_memory_open(git_config_backend *backend, git_config_level_t level, const git_repository *repo)
+{
+ config_memory_backend *memory_backend = (config_memory_backend *) backend;
+
+ GIT_UNUSED(repo);
+
+ if (memory_backend->cfg.size > 0 &&
+ parse_config(memory_backend, level) < 0)
+ return -1;
+
+ if (memory_backend->values_len > 0 &&
+ parse_values(memory_backend, level) < 0)
+ return -1;
+
+ return 0;
+}
+
+static int config_memory_get(git_config_backend *backend, const char *key, git_config_backend_entry **out)
{
config_memory_backend *memory_backend = (config_memory_backend *) backend;
- return git_config_entries_get(out, memory_backend->entries, key);
+ git_config_list_entry *entry;
+ int error;
+
+ if ((error = git_config_list_get(&entry, memory_backend->config_list, key)) != 0)
+ return error;
+
+ *out = &entry->base;
+ return 0;
}
static int config_memory_iterator(
@@ -109,18 +208,18 @@ static int config_memory_iterator(
git_config_backend *backend)
{
config_memory_backend *memory_backend = (config_memory_backend *) backend;
- git_config_entries *entries;
+ git_config_list *config_list;
int error;
- if ((error = git_config_entries_dup(&entries, memory_backend->entries)) < 0)
+ if ((error = git_config_list_dup(&config_list, memory_backend->config_list)) < 0)
goto out;
- if ((error = git_config_entries_iterator_new(iter, entries)) < 0)
+ if ((error = git_config_list_iterator_new(iter, config_list)) < 0)
goto out;
out:
- /* Let iterator delete duplicated entries when it's done */
- git_config_entries_free(entries);
+ /* Let iterator delete duplicated config_list when it's done */
+ git_config_list_free(config_list);
return error;
}
@@ -177,28 +276,24 @@ static void config_memory_free(git_config_backend *_backend)
if (backend == NULL)
return;
- git_config_entries_free(backend->entries);
+ git__free(backend->origin_path);
+ git__free(backend->backend_type);
+ git_config_list_free(backend->config_list);
+ git_strlist_free(backend->values, backend->values_len);
git_str_dispose(&backend->cfg);
git__free(backend);
}
-int git_config_backend_from_string(git_config_backend **out, const char *cfg, size_t len)
+static config_memory_backend *config_backend_new(
+ git_config_backend_memory_options *opts)
{
config_memory_backend *backend;
- backend = git__calloc(1, sizeof(config_memory_backend));
- GIT_ERROR_CHECK_ALLOC(backend);
+ if ((backend = git__calloc(1, sizeof(config_memory_backend))) == NULL)
+ return NULL;
- if (git_config_entries_new(&backend->entries) < 0) {
- git__free(backend);
- return -1;
- }
-
- if (git_str_set(&backend->cfg, cfg, len) < 0) {
- git_config_entries_free(backend->entries);
- git__free(backend);
- return -1;
- }
+ if (git_config_list_new(&backend->config_list) < 0)
+ goto on_error;
backend->parent.version = GIT_CONFIG_BACKEND_VERSION;
backend->parent.readonly = 1;
@@ -214,7 +309,66 @@ int git_config_backend_from_string(git_config_backend **out, const char *cfg, si
backend->parent.snapshot = git_config_backend_snapshot;
backend->parent.free = config_memory_free;
+ backend->backend_type = git__strdup(opts && opts->backend_type ?
+ opts->backend_type : "in-memory");
+
+ if (backend->backend_type == NULL)
+ goto on_error;
+
+ if (opts && opts->origin_path &&
+ (backend->origin_path = git__strdup(opts->origin_path)) == NULL)
+ goto on_error;
+
+ return backend;
+
+on_error:
+ git_config_list_free(backend->config_list);
+ git__free(backend->origin_path);
+ git__free(backend->backend_type);
+ git__free(backend);
+ return NULL;
+}
+
+int git_config_backend_from_string(
+ git_config_backend **out,
+ const char *cfg,
+ size_t len,
+ git_config_backend_memory_options *opts)
+{
+ config_memory_backend *backend;
+
+ if ((backend = config_backend_new(opts)) == NULL)
+ return -1;
+
+ if (git_str_set(&backend->cfg, cfg, len) < 0) {
+ git_config_list_free(backend->config_list);
+ git__free(backend);
+ return -1;
+ }
+
*out = (git_config_backend *)backend;
+ return 0;
+}
+
+int git_config_backend_from_values(
+ git_config_backend **out,
+ const char **values,
+ size_t len,
+ git_config_backend_memory_options *opts)
+{
+ config_memory_backend *backend;
+ if ((backend = config_backend_new(opts)) == NULL)
+ return -1;
+
+ if (git_strlist_copy(&backend->values, values, len) < 0) {
+ git_config_list_free(backend->config_list);
+ git__free(backend);
+ return -1;
+ }
+
+ backend->values_len = len;
+
+ *out = (git_config_backend *)backend;
return 0;
}
diff --git a/src/libgit2/config_parse.c b/src/libgit2/config_parse.c
index 06931368e7b..7f933db4885 100644
--- a/src/libgit2/config_parse.c
+++ b/src/libgit2/config_parse.c
@@ -25,9 +25,9 @@ static void set_parse_error(git_config_parser *reader, int col, const char *erro
}
-GIT_INLINE(int) config_keychar(int c)
+GIT_INLINE(int) config_keychar(char c)
{
- return isalnum(c) || c == '-';
+ return git__isalnum(c) || c == '-';
}
static int strip_comments(char *line, int in_quotes)
@@ -158,9 +158,10 @@ static int parse_subsection_header(git_config_parser *reader, const char *line,
static int parse_section_header(git_config_parser *reader, char **section_out)
{
char *name, *name_end;
- int name_length, c, pos;
+ int name_length, pos;
int result;
char *line;
+ char c;
size_t line_len;
git_parse_advance_ws(&reader->ctx);
@@ -279,8 +280,7 @@ static int skip_bom(git_parse_ctx *parser)
*/
/* '\"' -> '"' etc */
-static int unescape_line(
- char **out, bool *is_multi, const char *ptr, int quote_count)
+static int unescape_line(char **out, bool *is_multi, const char *ptr, int *quote_count)
{
char *str, *fixed, *esc;
size_t ptr_len = strlen(ptr), alloc_len;
@@ -296,7 +296,8 @@ static int unescape_line(
while (*ptr != '\0') {
if (*ptr == '"') {
- quote_count++;
+ if (quote_count)
+ (*quote_count)++;
} else if (*ptr != '\\') {
*fixed++ = *ptr;
} else {
@@ -358,7 +359,7 @@ static int parse_multiline_variable(git_config_parser *reader, git_str *value, i
goto next;
if ((error = unescape_line(&proc_line, &multiline,
- line, in_quotes)) < 0)
+ line, &in_quotes)) < 0)
goto out;
/* Add this line to the multiline var */
@@ -382,7 +383,7 @@ static int parse_multiline_variable(git_config_parser *reader, git_str *value, i
GIT_INLINE(bool) is_namechar(char c)
{
- return isalnum(c) || c == '-';
+ return git__isalnum(c) || c == '-';
}
static int parse_name(
@@ -445,7 +446,7 @@ static int parse_variable(git_config_parser *reader, char **var_name, char **var
while (git__isspace(value_start[0]))
value_start++;
- if ((error = unescape_line(&value, &multiline, value_start, 0)) < 0)
+ if ((error = unescape_line(&value, &multiline, value_start, NULL)) < 0)
goto out;
if (multiline) {
diff --git a/src/libgit2/config_snapshot.c b/src/libgit2/config_snapshot.c
index e295d2f7f28..d20984f512d 100644
--- a/src/libgit2/config_snapshot.c
+++ b/src/libgit2/config_snapshot.c
@@ -8,12 +8,12 @@
#include "config_backend.h"
#include "config.h"
-#include "config_entries.h"
+#include "config_list.h"
typedef struct {
git_config_backend parent;
git_mutex values_mutex;
- git_config_entries *entries;
+ git_config_list *config_list;
git_config_backend *source;
} config_snapshot_backend;
@@ -28,31 +28,27 @@ static int config_snapshot_iterator(
struct git_config_backend *backend)
{
config_snapshot_backend *b = GIT_CONTAINER_OF(backend, config_snapshot_backend, parent);
- git_config_entries *entries = NULL;
+ git_config_list *config_list = NULL;
int error;
- if ((error = git_config_entries_dup(&entries, b->entries)) < 0 ||
- (error = git_config_entries_iterator_new(iter, entries)) < 0)
+ if ((error = git_config_list_dup(&config_list, b->config_list)) < 0 ||
+ (error = git_config_list_iterator_new(iter, config_list)) < 0)
goto out;
out:
- /* Let iterator delete duplicated entries when it's done */
- git_config_entries_free(entries);
+ /* Let iterator delete duplicated config_list when it's done */
+ git_config_list_free(config_list);
return error;
}
-/* release the map containing the entry as an equivalent to freeing it */
-static void config_snapshot_entry_free(git_config_entry *entry)
-{
- git_config_entries *entries = (git_config_entries *) entry->payload;
- git_config_entries_free(entries);
-}
-
-static int config_snapshot_get(git_config_backend *cfg, const char *key, git_config_entry **out)
+static int config_snapshot_get(
+ git_config_backend *cfg,
+ const char *key,
+ git_config_backend_entry **out)
{
config_snapshot_backend *b = GIT_CONTAINER_OF(cfg, config_snapshot_backend, parent);
- git_config_entries *entries = NULL;
- git_config_entry *entry;
+ git_config_list *config_list = NULL;
+ git_config_list_entry *entry;
int error = 0;
if (git_mutex_lock(&b->values_mutex) < 0) {
@@ -60,19 +56,16 @@ static int config_snapshot_get(git_config_backend *cfg, const char *key, git_con
return -1;
}
- entries = b->entries;
- git_config_entries_incref(entries);
+ config_list = b->config_list;
+ git_config_list_incref(config_list);
git_mutex_unlock(&b->values_mutex);
- if ((error = (git_config_entries_get(&entry, entries, key))) < 0) {
- git_config_entries_free(entries);
+ if ((error = (git_config_list_get(&entry, config_list, key))) < 0) {
+ git_config_list_free(config_list);
return error;
}
- entry->free = config_snapshot_entry_free;
- entry->payload = entries;
- *out = entry;
-
+ *out = &entry->base;
return 0;
}
@@ -135,7 +128,7 @@ static void config_snapshot_free(git_config_backend *_backend)
if (backend == NULL)
return;
- git_config_entries_free(backend->entries);
+ git_config_list_free(backend->config_list);
git_mutex_free(&backend->values_mutex);
git__free(backend);
}
@@ -143,7 +136,7 @@ static void config_snapshot_free(git_config_backend *_backend)
static int config_snapshot_open(git_config_backend *cfg, git_config_level_t level, const git_repository *repo)
{
config_snapshot_backend *b = GIT_CONTAINER_OF(cfg, config_snapshot_backend, parent);
- git_config_entries *entries = NULL;
+ git_config_list *config_list = NULL;
git_config_iterator *it = NULL;
git_config_entry *entry;
int error;
@@ -152,12 +145,12 @@ static int config_snapshot_open(git_config_backend *cfg, git_config_level_t leve
GIT_UNUSED(level);
GIT_UNUSED(repo);
- if ((error = git_config_entries_new(&entries)) < 0 ||
+ if ((error = git_config_list_new(&config_list)) < 0 ||
(error = b->source->iterator(&it, b->source)) < 0)
goto out;
while ((error = git_config_next(&entry, it)) == 0)
- if ((error = git_config_entries_dup_entry(entries, entry)) < 0)
+ if ((error = git_config_list_dup_entry(config_list, entry)) < 0)
goto out;
if (error < 0) {
@@ -166,12 +159,12 @@ static int config_snapshot_open(git_config_backend *cfg, git_config_level_t leve
error = 0;
}
- b->entries = entries;
+ b->config_list = config_list;
out:
git_config_iterator_free(it);
if (error)
- git_config_entries_free(entries);
+ git_config_list_free(config_list);
return error;
}
diff --git a/src/libgit2/describe.c b/src/libgit2/describe.c
index 3f73d87d63f..dfbe7b4ab0b 100644
--- a/src/libgit2/describe.c
+++ b/src/libgit2/describe.c
@@ -14,7 +14,6 @@
#include "buf.h"
#include "commit.h"
#include "commit_list.h"
-#include "oidmap.h"
#include "refs.h"
#include "repository.h"
#include "revwalk.h"
@@ -22,6 +21,7 @@
#include "tag.h"
#include "vector.h"
#include "wildmatch.h"
+#include "hashmap_oid.h"
/* Ported from https://github.com/git/git/blob/89dde7882f71f846ccd0359756d27bebc31108de/builtin/describe.c */
@@ -32,20 +32,22 @@ struct commit_name {
git_oid sha1;
char *path;
- /* Khash workaround. They original key has to still be reachable */
+ /* The original key for the hashmap */
git_oid peeled;
};
-static void *oidmap_value_bykey(git_oidmap *map, const git_oid *key)
-{
- return git_oidmap_get(map, key);
-}
+GIT_HASHMAP_OID_SETUP(git_describe_oidmap, struct commit_name *);
static struct commit_name *find_commit_name(
- git_oidmap *names,
+ git_describe_oidmap *names,
const git_oid *peeled)
{
- return (struct commit_name *)(oidmap_value_bykey(names, peeled));
+ struct commit_name *result;
+
+ if (git_describe_oidmap_get(&result, names, peeled) == 0)
+ return result;
+
+ return NULL;
}
static int replace_name(
@@ -92,7 +94,7 @@ static int replace_name(
static int add_to_known_names(
git_repository *repo,
- git_oidmap *names,
+ git_describe_oidmap *names,
const char *path,
const git_oid *peeled,
unsigned int prio,
@@ -121,7 +123,7 @@ static int add_to_known_names(
e->path = git__strdup(path);
git_oid_cpy(&e->peeled, peeled);
- if (!found && git_oidmap_set(names, &e->peeled, e) < 0)
+ if (!found && git_describe_oidmap_put(names, &e->peeled, e) < 0)
return -1;
}
else
@@ -174,7 +176,7 @@ struct get_name_data
{
git_describe_options *opts;
git_repository *repo;
- git_oidmap *names;
+ git_describe_oidmap names;
git_describe_result *result;
};
@@ -240,7 +242,7 @@ static int get_name(const char *refname, void *payload)
else
prio = 0;
- add_to_known_names(data->repo, data->names,
+ add_to_known_names(data->repo, &data->names,
all ? refname + strlen(GIT_REFS_DIR) : refname + strlen(GIT_REFS_TAGS_DIR),
&peeled, prio, &sha1);
return 0;
@@ -363,12 +365,15 @@ static int find_unique_abbrev_size(
size_t size = abbreviated_size;
git_odb *odb;
git_oid dummy;
+ size_t hexsize;
int error;
if ((error = git_repository_odb__weakptr(&odb, repo)) < 0)
return error;
- while (size < GIT_OID_SHA1_HEXSIZE) {
+ hexsize = git_oid_hexsize(repo->oid_type);
+
+ while (size < hexsize) {
if ((error = git_odb_exists_prefix(&dummy, odb, oid_in, size)) == 0) {
*out = (int) size;
return 0;
@@ -383,7 +388,7 @@ static int find_unique_abbrev_size(
}
/* If we didn't find any shorter prefix, we have to do the whole thing */
- *out = GIT_OID_SHA1_HEXSIZE;
+ *out = (int)hexsize;
return 0;
}
@@ -397,7 +402,7 @@ static int show_suffix(
{
int error, size = 0;
- char hex_oid[GIT_OID_SHA1_HEXSIZE];
+ char hex_oid[GIT_OID_MAX_HEXSIZE];
if ((error = find_unique_abbrev_size(&size, repo, id, abbrev_size)) < 0)
return error;
@@ -414,7 +419,7 @@ static int show_suffix(
#define MAX_CANDIDATES_TAGS FLAG_BITS - 1
static int describe_not_found(const git_oid *oid, const char *message_format) {
- char oid_str[GIT_OID_SHA1_HEXSIZE + 1];
+ char oid_str[GIT_OID_MAX_HEXSIZE + 1];
git_oid_tostr(oid_str, sizeof(oid_str), oid);
git_error_set(GIT_ERROR_DESCRIBE, message_format, oid_str);
@@ -448,7 +453,7 @@ static int describe(
git_oid_cpy(&data->result->commit_id, git_commit_id(commit));
- n = find_commit_name(data->names, git_commit_id(commit));
+ n = find_commit_name(&data->names, git_commit_id(commit));
if (n && (tags || all || n->prio == 2)) {
/*
* Exact match to an existing ref.
@@ -489,7 +494,7 @@ static int describe(
git_commit_list_node *c = (git_commit_list_node *)git_pqueue_pop(&list);
seen_commits++;
- n = find_commit_name(data->names, &c->oid);
+ n = find_commit_name(&data->names, &c->oid);
if (n) {
if (!tags && !all && n->prio < 2) {
@@ -525,7 +530,7 @@ static int describe(
if (annotated_cnt && (git_pqueue_size(&list) == 0)) {
/*
if (debug) {
- char oid_str[GIT_OID_SHA1_HEXSIZE + 1];
+ char oid_str[GIT_OID_MAX_HEXSIZE + 1];
git_oid_tostr(oid_str, sizeof(oid_str), &c->oid);
fprintf(stderr, "finished search at %s\n", oid_str);
@@ -592,7 +597,7 @@ static int describe(
"head", "lightweight", "annotated",
};
- char oid_str[GIT_OID_SHA1_HEXSIZE + 1];
+ char oid_str[GIT_OID_MAX_HEXSIZE + 1];
if (debug) {
for (cur_match = 0; cur_match < match_cnt; cur_match++) {
@@ -624,7 +629,7 @@ static int describe(
git__free(match);
}
}
- git_vector_free(&all_matches);
+ git_vector_dispose(&all_matches);
git_pqueue_free(&list);
git_revwalk_free(walk);
return error;
@@ -650,11 +655,12 @@ int git_describe_commit(
git_object *committish,
git_describe_options *opts)
{
- struct get_name_data data;
+ struct get_name_data data = {0};
struct commit_name *name;
git_commit *commit;
- int error = -1;
git_describe_options normalized;
+ git_hashmap_iter_t iter = GIT_HASHMAP_INIT;
+ int error = -1;
GIT_ASSERT_ARG(result);
GIT_ASSERT_ARG(committish);
@@ -674,9 +680,6 @@ int git_describe_commit(
"git_describe_options");
data.opts = &normalized;
- if ((error = git_oidmap_new(&data.names)) < 0)
- return error;
-
/** TODO: contains to be implemented */
if ((error = git_object_peel((git_object **)(&commit), committish, GIT_OBJECT_COMMIT)) < 0)
@@ -687,7 +690,7 @@ int git_describe_commit(
get_name, &data)) < 0)
goto cleanup;
- if (git_oidmap_size(data.names) == 0 && !normalized.show_commit_oid_as_fallback) {
+ if (git_describe_oidmap_size(&data.names) == 0 && !normalized.show_commit_oid_as_fallback) {
git_error_set(GIT_ERROR_DESCRIBE, "cannot describe - "
"no reference found, cannot describe anything.");
error = -1;
@@ -700,13 +703,13 @@ int git_describe_commit(
cleanup:
git_commit_free(commit);
- git_oidmap_foreach_value(data.names, name, {
+ while (git_describe_oidmap_iterate(&iter, NULL, &name, &data.names) == 0) {
git_tag_free(name->tag);
git__free(name->path);
git__free(name);
- });
+ }
- git_oidmap_free(data.names);
+ git_describe_oidmap_dispose(&data.names);
if (error < 0)
git_describe_result_free(data.result);
@@ -816,7 +819,7 @@ static int git_describe__format(
/* If we didn't find *any* tags, we fall back to the commit's id */
if (result->fallback_to_id) {
- char hex_oid[GIT_OID_SHA1_HEXSIZE + 1] = {0};
+ char hex_oid[GIT_OID_MAX_HEXSIZE + 1] = {0};
int size = 0;
if ((error = find_unique_abbrev_size(
diff --git a/src/libgit2/diff.c b/src/libgit2/diff.c
index 20a18c4b9b0..80027ba30a0 100644
--- a/src/libgit2/diff.c
+++ b/src/libgit2/diff.c
@@ -16,11 +16,13 @@
#include "diff_generate.h"
#include "git2/version.h"
-#include "git2/email.h"
+#include "git2/sys/email.h"
struct patch_id_args {
+ git_diff *diff;
git_hash_ctx ctx;
git_oid result;
+ git_oid_t oid_type;
int first_file;
};
@@ -280,17 +282,19 @@ int git_diff_find_options_init(
return 0;
}
-static int flush_hunk(git_oid *result, git_hash_ctx *ctx)
+static int flush_hunk(git_oid *result, struct patch_id_args *args)
{
+ git_hash_ctx *ctx = &args->ctx;
git_oid hash;
unsigned short carry = 0;
- int error, i;
+ size_t i;
+ int error;
if ((error = git_hash_final(hash.id, ctx)) < 0 ||
(error = git_hash_init(ctx)) < 0)
return error;
- for (i = 0; i < GIT_OID_SHA1_SIZE; i++) {
+ for (i = 0; i < git_oid_size(args->oid_type); i++) {
carry += result->id[i] + hash.id[i];
result->id[i] = (unsigned char)carry;
carry >>= 8;
@@ -338,7 +342,7 @@ static int diff_patchid_print_callback_to_buf(
if (line->origin == GIT_DIFF_LINE_FILE_HDR &&
!args->first_file &&
- (error = flush_hunk(&args->result, &args->ctx) < 0))
+ (error = flush_hunk(&args->result, args) < 0))
goto out;
if ((error = git_hash_update(&args->ctx, buf.ptr, buf.size)) < 0)
@@ -362,14 +366,19 @@ int git_diff_patchid_options_init(git_diff_patchid_options *opts, unsigned int v
int git_diff_patchid(git_oid *out, git_diff *diff, git_diff_patchid_options *opts)
{
struct patch_id_args args;
+ git_hash_algorithm_t algorithm;
int error;
GIT_ERROR_CHECK_VERSION(
opts, GIT_DIFF_PATCHID_OPTIONS_VERSION, "git_diff_patchid_options");
+ algorithm = git_oid_algorithm(diff->opts.oid_type);
+
memset(&args, 0, sizeof(args));
+ args.diff = diff;
args.first_file = 1;
- if ((error = git_hash_ctx_init(&args.ctx, GIT_HASH_ALGORITHM_SHA1)) < 0)
+ args.oid_type = diff->opts.oid_type;
+ if ((error = git_hash_ctx_init(&args.ctx, algorithm)) < 0)
goto out;
if ((error = git_diff_print(diff,
@@ -378,11 +387,11 @@ int git_diff_patchid(git_oid *out, git_diff *diff, git_diff_patchid_options *opt
&args)) < 0)
goto out;
- if ((error = (flush_hunk(&args.result, &args.ctx))) < 0)
+ if ((error = (flush_hunk(&args.result, &args))) < 0)
goto out;
#ifdef GIT_EXPERIMENTAL_SHA256
- args.result.type = GIT_OID_SHA1;
+ args.result.type = diff->opts.oid_type;
#endif
git_oid_cpy(out, &args.result);
diff --git a/src/libgit2/diff.h b/src/libgit2/diff.h
index 2cc35e65b7c..c79a279e379 100644
--- a/src/libgit2/diff.h
+++ b/src/libgit2/diff.h
@@ -30,15 +30,15 @@ typedef enum {
} git_diff_origin_t;
struct git_diff {
- git_refcount rc;
+ git_refcount rc;
git_repository *repo;
- git_attr_session attrsession;
+ git_attr_session attrsession;
git_diff_origin_t type;
- git_diff_options opts;
- git_vector deltas; /* vector of git_diff_delta */
+ git_diff_options opts;
+ git_vector deltas; /* vector of git_diff_delta */
git_pool pool;
- git_iterator_t old_src;
- git_iterator_t new_src;
+ git_iterator_t old_src;
+ git_iterator_t new_src;
git_diff_perfdata perf;
int (*strcomp)(const char *, const char *);
@@ -64,4 +64,14 @@ extern int git_diff_delta__casecmp(const void *a, const void *b);
extern int git_diff__entry_cmp(const void *a, const void *b);
extern int git_diff__entry_icmp(const void *a, const void *b);
+#ifndef GIT_EXPERIMENTAL_SHA256
+
+int git_diff_from_buffer_ext(
+ git_diff **out,
+ const char *content,
+ size_t content_len,
+ git_diff_parse_options *opts);
+
+#endif
+
#endif
diff --git a/src/libgit2/diff_driver.c b/src/libgit2/diff_driver.c
index 5f25fdb442b..7055575e766 100644
--- a/src/libgit2/diff_driver.c
+++ b/src/libgit2/diff_driver.c
@@ -11,11 +11,11 @@
#include "common.h"
#include "diff.h"
-#include "strmap.h"
#include "map.h"
#include "config.h"
#include "regexp.h"
#include "repository.h"
+#include "userdiff.h"
typedef enum {
DIFF_DRIVER_AUTO = 0,
@@ -43,10 +43,10 @@ struct git_diff_driver {
char name[GIT_FLEX_ARRAY];
};
-#include "userdiff.h"
+GIT_HASHMAP_STR_SETUP(git_diff_driver_map, git_diff_driver *);
struct git_diff_driver_registry {
- git_strmap *drivers;
+ git_diff_driver_map map;
};
#define FORCE_DIFFABLE (GIT_DIFF_FORCE_TEXT | GIT_DIFF_FORCE_BINARY)
@@ -57,28 +57,21 @@ static git_diff_driver diff_driver_text = { DIFF_DRIVER_TEXT, GIT_DIFF_FORCE
git_diff_driver_registry *git_diff_driver_registry_new(void)
{
- git_diff_driver_registry *reg =
- git__calloc(1, sizeof(git_diff_driver_registry));
- if (!reg)
- return NULL;
-
- if (git_strmap_new(®->drivers) < 0) {
- git_diff_driver_registry_free(reg);
- return NULL;
- }
-
- return reg;
+ return git__calloc(1, sizeof(git_diff_driver_registry));
}
void git_diff_driver_registry_free(git_diff_driver_registry *reg)
{
git_diff_driver *drv;
+ git_hashmap_iter_t iter = 0;
if (!reg)
return;
- git_strmap_foreach_value(reg->drivers, drv, git_diff_driver_free(drv));
- git_strmap_free(reg->drivers);
+ while (git_diff_driver_map_iterate(&iter, NULL, &drv, ®->map) == 0)
+ git_diff_driver_free(drv);
+
+ git_diff_driver_map_dispose(®->map);
git__free(reg);
}
@@ -215,7 +208,7 @@ static int git_diff_driver_builtin(
(error = git_regexp_compile(&drv->word_pattern, ddef->words, ddef->flags)) < 0)
goto done;
- if ((error = git_strmap_set(reg->drivers, drv->name, drv)) < 0)
+ if ((error = git_diff_driver_map_put(®->map, drv->name, drv)) < 0)
goto done;
done:
@@ -242,7 +235,7 @@ static int git_diff_driver_load(
if ((reg = git_repository_driver_registry(repo)) == NULL)
return -1;
- if ((drv = git_strmap_get(reg->drivers, driver_name)) != NULL) {
+ if (git_diff_driver_map_get(&drv, ®->map, driver_name) == 0) {
*out = drv;
return 0;
}
@@ -331,7 +324,7 @@ static int git_diff_driver_load(
goto done;
/* store driver in registry */
- if ((error = git_strmap_set(reg->drivers, drv->name, drv)) < 0)
+ if ((error = git_diff_driver_map_put(®->map, drv->name, drv)) < 0)
goto done;
*out = drv;
diff --git a/src/libgit2/diff_driver.h b/src/libgit2/diff_driver.h
index 03711e89e8b..ca0a7ae1e84 100644
--- a/src/libgit2/diff_driver.h
+++ b/src/libgit2/diff_driver.h
@@ -11,14 +11,14 @@
#include "attr_file.h"
#include "str.h"
+#include "hashmap.h"
+typedef struct git_diff_driver git_diff_driver;
typedef struct git_diff_driver_registry git_diff_driver_registry;
git_diff_driver_registry *git_diff_driver_registry_new(void);
void git_diff_driver_registry_free(git_diff_driver_registry *);
-typedef struct git_diff_driver git_diff_driver;
-
int git_diff_driver_lookup(git_diff_driver **, git_repository *,
git_attr_session *attrsession, const char *);
void git_diff_driver_free(git_diff_driver *);
diff --git a/src/libgit2/diff_file.c b/src/libgit2/diff_file.c
index c2d08675ab0..a792834caca 100644
--- a/src/libgit2/diff_file.c
+++ b/src/libgit2/diff_file.c
@@ -112,7 +112,7 @@ int git_diff_file_content__init_from_diff(
case GIT_DELTA_DELETED:
has_data = use_old; break;
case GIT_DELTA_UNTRACKED:
- has_data = !use_old &&
+ has_data = (use_old == (diff->opts.flags & GIT_DIFF_REVERSE)) &&
(diff->opts.flags & GIT_DIFF_SHOW_UNTRACKED_CONTENT) != 0;
break;
case GIT_DELTA_UNREADABLE:
@@ -144,7 +144,7 @@ int git_diff_file_content__init_from_src(
if (!src->blob && !src->buf) {
fc->flags |= GIT_DIFF_FLAG__NO_DATA;
- git_oid_clear(&fc->file->id, GIT_OID_SHA1);
+ git_oid_clear(&fc->file->id, opts->oid_type);
} else {
fc->flags |= GIT_DIFF_FLAG__LOADED;
fc->file->flags |= GIT_DIFF_FLAG_VALID_ID;
@@ -154,7 +154,7 @@ int git_diff_file_content__init_from_src(
git_blob_dup((git_blob **)&fc->blob, (git_blob *) src->blob);
fc->file->size = git_blob_rawsize(src->blob);
git_oid_cpy(&fc->file->id, git_blob_id(src->blob));
- fc->file->id_abbrev = GIT_OID_SHA1_HEXSIZE;
+ fc->file->id_abbrev = (uint16_t)git_oid_hexsize(repo->oid_type);
fc->map.len = (size_t)fc->file->size;
fc->map.data = (char *)git_blob_rawcontent(src->blob);
@@ -162,10 +162,10 @@ int git_diff_file_content__init_from_src(
fc->flags |= GIT_DIFF_FLAG__FREE_BLOB;
} else {
int error;
- if ((error = git_odb__hash(&fc->file->id, src->buf, src->buflen, GIT_OBJECT_BLOB, GIT_OID_SHA1)) < 0)
+ if ((error = git_odb__hash(&fc->file->id, src->buf, src->buflen, GIT_OBJECT_BLOB, opts->oid_type)) < 0)
return error;
fc->file->size = src->buflen;
- fc->file->id_abbrev = GIT_OID_SHA1_HEXSIZE;
+ fc->file->id_abbrev = (uint16_t)git_oid_hexsize(opts->oid_type);
fc->map.len = src->buflen;
fc->map.data = (char *)src->buf;
@@ -178,7 +178,7 @@ int git_diff_file_content__init_from_src(
static int diff_file_content_commit_to_str(
git_diff_file_content *fc, bool check_status)
{
- char oid[GIT_OID_SHA1_HEXSIZE+1];
+ char oid[GIT_OID_MAX_HEXSIZE+1];
git_str content = GIT_STR_INIT;
const char *status = "";
@@ -420,7 +420,7 @@ static int diff_file_content_load_workdir(
if (!error && (fc->file->flags & GIT_DIFF_FLAG_VALID_ID) == 0) {
error = git_odb__hash(
&fc->file->id, fc->map.data, fc->map.len,
- GIT_OBJECT_BLOB, GIT_OID_SHA1);
+ GIT_OBJECT_BLOB, diff_opts->oid_type);
fc->file->flags |= GIT_DIFF_FLAG_VALID_ID;
}
diff --git a/src/libgit2/diff_generate.c b/src/libgit2/diff_generate.c
index a88ce8c3230..654145e34a6 100644
--- a/src/libgit2/diff_generate.c
+++ b/src/libgit2/diff_generate.c
@@ -61,8 +61,8 @@ static git_diff_delta *diff_delta__alloc(
}
delta->status = status;
- git_oid_clear(&delta->old_file.id, GIT_OID_SHA1);
- git_oid_clear(&delta->new_file.id, GIT_OID_SHA1);
+ git_oid_clear(&delta->old_file.id, diff->base.opts.oid_type);
+ git_oid_clear(&delta->new_file.id, diff->base.opts.oid_type);
return delta;
}
@@ -149,10 +149,13 @@ static int diff_delta__from_one(
const git_index_entry *entry = nitem;
bool has_old = false;
git_diff_delta *delta;
+ git_oid_t oid_type;
const char *matched_pathspec;
GIT_ASSERT_ARG((oitem != NULL) ^ (nitem != NULL));
+ oid_type = diff->base.opts.oid_type;
+
if (oitem) {
entry = oitem;
has_old = true;
@@ -186,20 +189,23 @@ static int diff_delta__from_one(
GIT_ASSERT(status != GIT_DELTA_MODIFIED);
delta->nfiles = 1;
+ git_oid_clear(&delta->old_file.id, diff->base.opts.oid_type);
+ git_oid_clear(&delta->new_file.id, diff->base.opts.oid_type);
+
if (has_old) {
delta->old_file.mode = entry->mode;
delta->old_file.size = entry->file_size;
delta->old_file.flags |= GIT_DIFF_FLAG_EXISTS;
git_oid_cpy(&delta->old_file.id, &entry->id);
- git_oid_clear(&delta->new_file.id, GIT_OID_SHA1);
- delta->old_file.id_abbrev = GIT_OID_SHA1_HEXSIZE;
+ git_oid_clear(&delta->new_file.id, oid_type);
+ delta->old_file.id_abbrev = (uint16_t)git_oid_hexsize(oid_type);
} else /* ADDED, IGNORED, UNTRACKED */ {
delta->new_file.mode = entry->mode;
delta->new_file.size = entry->file_size;
delta->new_file.flags |= GIT_DIFF_FLAG_EXISTS;
- git_oid_clear(&delta->old_file.id, GIT_OID_SHA1);
+ git_oid_clear(&delta->old_file.id, oid_type);
git_oid_cpy(&delta->new_file.id, &entry->id);
- delta->new_file.id_abbrev = GIT_OID_SHA1_HEXSIZE;
+ delta->new_file.id_abbrev = (uint16_t)git_oid_hexsize(oid_type);
}
delta->old_file.flags |= GIT_DIFF_FLAG_VALID_ID;
@@ -225,6 +231,9 @@ static int diff_delta__from_two(
const git_oid *old_id = &old_entry->id;
git_diff_delta *delta;
const char *canonical_path = old_entry->path;
+ git_oid_t oid_type;
+
+ oid_type = diff->base.opts.oid_type;
if (status == GIT_DELTA_UNMODIFIED &&
DIFF_FLAG_ISNT_SET(diff, GIT_DIFF_INCLUDE_UNMODIFIED))
@@ -254,14 +263,14 @@ static int diff_delta__from_two(
delta->old_file.size = old_entry->file_size;
delta->old_file.mode = old_mode;
git_oid_cpy(&delta->old_file.id, old_id);
- delta->old_file.id_abbrev = GIT_OID_SHA1_HEXSIZE;
+ delta->old_file.id_abbrev = (uint16_t)git_oid_hexsize(oid_type);
delta->old_file.flags |= GIT_DIFF_FLAG_VALID_ID |
GIT_DIFF_FLAG_EXISTS;
}
if (!git_index_entry_is_conflict(new_entry)) {
git_oid_cpy(&delta->new_file.id, new_id);
- delta->new_file.id_abbrev = GIT_OID_SHA1_HEXSIZE;
+ delta->new_file.id_abbrev = (uint16_t)git_oid_hexsize(oid_type);
delta->new_file.size = new_entry->file_size;
delta->new_file.mode = new_mode;
delta->old_file.flags |= GIT_DIFF_FLAG_EXISTS;
@@ -420,7 +429,7 @@ static void diff_generated_free(git_diff *d)
git_diff_generated *diff = (git_diff_generated *)d;
git_attr_session__free(&diff->base.attrsession);
- git_vector_free_deep(&diff->base.deltas);
+ git_vector_dispose_deep(&diff->base.deltas);
git_pathspec__vfree(&diff->pathspec);
git_pool_clear(&diff->base.pool);
@@ -490,6 +499,14 @@ static int diff_generated_apply_options(
return -1;
}
+ if (!diff->base.opts.oid_type) {
+ diff->base.opts.oid_type = repo->oid_type;
+ } else if (diff->base.opts.oid_type != repo->oid_type) {
+ git_error_set(GIT_ERROR_INVALID,
+ "specified object ID type does not match repository object ID type");
+ return -1;
+ }
+
/* flag INCLUDE_TYPECHANGE_TREES implies INCLUDE_TYPECHANGE */
if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_INCLUDE_TYPECHANGE_TREES))
diff->base.opts.flags |= GIT_DIFF_INCLUDE_TYPECHANGE;
@@ -603,7 +620,7 @@ int git_diff__oid_for_file(
entry.mode = mode;
entry.file_size = (uint32_t)size;
entry.path = (char *)path;
- git_oid_clear(&entry.id, GIT_OID_SHA1);
+ git_oid_clear(&entry.id, diff->opts.oid_type);
return git_diff__oid_for_entry(out, diff, &entry, mode, NULL);
}
@@ -624,7 +641,7 @@ int git_diff__oid_for_entry(
GIT_ASSERT(d->type == GIT_DIFF_TYPE_GENERATED);
diff = (git_diff_generated *)d;
- git_oid_clear(out, GIT_OID_SHA1);
+ git_oid_clear(out, diff->base.opts.oid_type);
if (git_repository_workdir_path(&full_path, diff->base.repo, entry.path) < 0)
return -1;
@@ -660,7 +677,8 @@ int git_diff__oid_for_entry(
git_error_clear();
}
} else if (S_ISLNK(mode)) {
- error = git_odb__hashlink(out, full_path.ptr, GIT_OID_SHA1);
+ error = git_odb__hashlink(out, full_path.ptr,
+ diff->base.opts.oid_type);
diff->base.perf.oid_calculations++;
} else if (!git__is_sizet(entry.file_size)) {
git_error_set(GIT_ERROR_NOMEMORY, "file size overflow (for 32-bits) on '%s'",
@@ -676,7 +694,8 @@ int git_diff__oid_for_entry(
else {
error = git_odb__hashfd_filtered(
out, fd, (size_t)entry.file_size,
- GIT_OBJECT_BLOB, GIT_OID_SHA1, fl);
+ GIT_OBJECT_BLOB, diff->base.opts.oid_type,
+ fl);
p_close(fd);
diff->base.perf.oid_calculations++;
}
@@ -710,7 +729,7 @@ typedef struct {
git_iterator *new_iter;
const git_index_entry *oitem;
const git_index_entry *nitem;
- git_strmap *submodule_cache;
+ git_submodule_cache *submodule_cache;
bool submodule_cache_initialized;
} diff_in_progress;
@@ -726,7 +745,7 @@ static int maybe_modified_submodule(
git_submodule *sub;
unsigned int sm_status = 0;
git_submodule_ignore_t ign = diff->base.opts.ignore_submodules;
- git_strmap *submodule_cache = NULL;
+ git_submodule_cache *submodule_cache = NULL;
*status = GIT_DELTA_UNMODIFIED;
@@ -785,7 +804,7 @@ static int maybe_modified(
git_diff_generated *diff,
diff_in_progress *info)
{
- git_oid noid = GIT_OID_SHA1_ZERO;
+ git_oid noid;
git_delta_t status = GIT_DELTA_MODIFIED;
const git_index_entry *oitem = info->oitem;
const git_index_entry *nitem = info->nitem;
@@ -796,6 +815,8 @@ static int maybe_modified(
const char *matched_pathspec;
int error = 0;
+ git_oid_clear(&noid, diff->base.opts.oid_type);
+
if (!diff_pathspec_match(&matched_pathspec, diff, oitem))
return 0;
@@ -1700,11 +1721,11 @@ int git_diff__commit(
*out = NULL;
if ((parents = git_commit_parentcount(commit)) > 1) {
- char commit_oidstr[GIT_OID_SHA1_HEXSIZE + 1];
+ char commit_oidstr[GIT_OID_MAX_HEXSIZE + 1];
error = -1;
git_error_set(GIT_ERROR_INVALID, "commit %s is a merge commit",
- git_oid_tostr(commit_oidstr, GIT_OID_SHA1_HEXSIZE + 1, git_commit_id(commit)));
+ git_oid_tostr(commit_oidstr, GIT_OID_MAX_HEXSIZE + 1, git_commit_id(commit)));
goto on_error;
}
diff --git a/src/libgit2/diff_parse.c b/src/libgit2/diff_parse.c
index 75e41a5443b..25dcd8e1100 100644
--- a/src/libgit2/diff_parse.c
+++ b/src/libgit2/diff_parse.c
@@ -20,16 +20,16 @@ static void diff_parsed_free(git_diff *d)
git_vector_foreach(&diff->patches, i, patch)
git_patch_free(patch);
- git_vector_free(&diff->patches);
+ git_vector_dispose(&diff->patches);
- git_vector_free(&diff->base.deltas);
+ git_vector_dispose(&diff->base.deltas);
git_pool_clear(&diff->base.pool);
git__memzero(diff, sizeof(*diff));
git__free(diff);
}
-static git_diff_parsed *diff_parsed_alloc(void)
+static git_diff_parsed *diff_parsed_alloc(git_oid_t oid_type)
{
git_diff_parsed *diff;
@@ -51,6 +51,7 @@ static git_diff_parsed *diff_parsed_alloc(void)
}
diff->base.opts.flags &= ~GIT_DIFF_IGNORE_CASE;
+ diff->base.opts.oid_type = oid_type;
if (git_pool_init(&diff->base.pool, 1) < 0 ||
git_vector_init(&diff->patches, 0, NULL) < 0 ||
@@ -68,18 +69,34 @@ int git_diff_from_buffer(
git_diff **out,
const char *content,
size_t content_len)
+{
+ return git_diff_from_buffer_ext(out, content, content_len, NULL);
+}
+
+int git_diff_from_buffer_ext(
+ git_diff **out,
+ const char *content,
+ size_t content_len,
+ git_diff_parse_options *opts)
{
git_diff_parsed *diff;
git_patch *patch;
git_patch_parse_ctx *ctx = NULL;
+ git_patch_options patch_opts = GIT_PATCH_OPTIONS_INIT;
+ git_oid_t oid_type;
int error = 0;
*out = NULL;
- diff = diff_parsed_alloc();
+ oid_type = (opts && opts->oid_type) ? opts->oid_type :
+ GIT_OID_DEFAULT;
+
+ patch_opts.oid_type = oid_type;
+
+ diff = diff_parsed_alloc(oid_type);
GIT_ERROR_CHECK_ALLOC(diff);
- ctx = git_patch_parse_ctx_init(content, content_len, NULL);
+ ctx = git_patch_parse_ctx_init(content, content_len, &patch_opts);
GIT_ERROR_CHECK_ALLOC(ctx);
while (ctx->parse_ctx.remain_len) {
diff --git a/src/libgit2/diff_print.c b/src/libgit2/diff_print.c
index 3077e11e157..0ffba0d55d8 100644
--- a/src/libgit2/diff_print.c
+++ b/src/libgit2/diff_print.c
@@ -15,6 +15,7 @@
#include "zstream.h"
#include "blob.h"
#include "delta.h"
+#include "repository.h"
#include "git2/sys/diff.h"
typedef struct {
@@ -29,6 +30,8 @@ typedef struct {
const char *new_prefix;
uint32_t flags;
int id_strlen;
+ unsigned int sent_file_header;
+ git_oid_t oid_type;
int (*strcomp)(const char *, const char *);
} diff_print_info;
@@ -46,16 +49,15 @@ static int diff_print_info_init__common(
pi->payload = payload;
pi->buf = out;
+ GIT_ASSERT(pi->oid_type);
+
if (!pi->id_strlen) {
if (!repo)
pi->id_strlen = GIT_ABBREV_DEFAULT;
- else if (git_repository__configmap_lookup(&pi->id_strlen, repo, GIT_CONFIGMAP_ABBREV) < 0)
+ else if (git_repository__abbrev_length(&pi->id_strlen, repo) < 0)
return -1;
}
- if (pi->id_strlen > GIT_OID_SHA1_HEXSIZE)
- pi->id_strlen = GIT_OID_SHA1_HEXSIZE;
-
memset(&pi->line, 0, sizeof(pi->line));
pi->line.old_lineno = -1;
pi->line.new_lineno = -1;
@@ -78,6 +80,7 @@ static int diff_print_info_init_fromdiff(
if (diff) {
pi->flags = diff->opts.flags;
+ pi->oid_type = diff->opts.oid_type;
pi->id_strlen = diff->opts.id_abbrev;
pi->old_prefix = diff->opts.old_prefix;
pi->new_prefix = diff->opts.new_prefix;
@@ -101,6 +104,7 @@ static int diff_print_info_init_frompatch(
memset(pi, 0, sizeof(diff_print_info));
pi->flags = patch->diff_opts.flags;
+ pi->oid_type = patch->diff_opts.oid_type;
pi->id_strlen = patch->diff_opts.id_abbrev;
pi->old_prefix = patch->diff_opts.old_prefix;
pi->new_prefix = patch->diff_opts.new_prefix;
@@ -212,7 +216,10 @@ static int diff_print_one_raw(
git_str *out = pi->buf;
int id_abbrev;
char code = git_diff_status_char(delta->status);
- char start_oid[GIT_OID_SHA1_HEXSIZE+1], end_oid[GIT_OID_SHA1_HEXSIZE+1];
+ char start_oid[GIT_OID_MAX_HEXSIZE + 1],
+ end_oid[GIT_OID_MAX_HEXSIZE + 1];
+ size_t oid_hexsize;
+ bool id_is_abbrev;
GIT_UNUSED(progress);
@@ -231,12 +238,21 @@ static int diff_print_one_raw(
return -1;
}
+#ifdef GIT_EXPERIMENTAL_SHA256
+ GIT_ASSERT(delta->old_file.id.type == delta->new_file.id.type);
+ oid_hexsize = git_oid_hexsize(delta->old_file.id.type);
+#else
+ oid_hexsize = GIT_OID_SHA1_HEXSIZE;
+#endif
+
+ id_is_abbrev = (pi->id_strlen > 0 &&
+ (size_t)pi->id_strlen <= oid_hexsize);
+
git_oid_tostr(start_oid, pi->id_strlen + 1, &delta->old_file.id);
git_oid_tostr(end_oid, pi->id_strlen + 1, &delta->new_file.id);
- git_str_printf(
- out, (pi->id_strlen <= GIT_OID_SHA1_HEXSIZE) ?
- ":%06o %06o %s... %s... %c" : ":%06o %06o %s %s %c",
+ git_str_printf(out,
+ id_is_abbrev ? ":%06o %06o %s... %s... %c" : ":%06o %06o %s %s %c",
delta->old_file.mode, delta->new_file.mode, start_oid, end_oid, code);
if (delta->similarity > 0)
@@ -273,7 +289,8 @@ static int diff_print_oid_range(
git_str *out, const git_diff_delta *delta, int id_strlen,
bool print_index)
{
- char start_oid[GIT_OID_SHA1_HEXSIZE+1], end_oid[GIT_OID_SHA1_HEXSIZE+1];
+ char start_oid[GIT_OID_MAX_HEXSIZE + 1],
+ end_oid[GIT_OID_MAX_HEXSIZE + 1];
if (delta->old_file.mode &&
id_strlen > delta->old_file.id_abbrev) {
@@ -560,6 +577,30 @@ static int diff_print_patch_file_binary(
return error;
}
+GIT_INLINE(int) should_force_header(const git_diff_delta *delta)
+{
+ if (delta->old_file.mode != delta->new_file.mode)
+ return 1;
+
+ if (delta->status == GIT_DELTA_RENAMED || delta->status == GIT_DELTA_COPIED)
+ return 1;
+
+ return 0;
+}
+
+GIT_INLINE(int) flush_file_header(const git_diff_delta *delta, diff_print_info *pi)
+{
+ if (pi->sent_file_header)
+ return 0;
+
+ pi->line.origin = GIT_DIFF_LINE_FILE_HDR;
+ pi->line.content = git_str_cstr(pi->buf);
+ pi->line.content_len = git_str_len(pi->buf);
+ pi->sent_file_header = 1;
+
+ return pi->print_cb(delta, NULL, &pi->line, pi->payload);
+}
+
static int diff_print_patch_file(
const git_diff_delta *delta, float progress, void *data)
{
@@ -590,15 +631,22 @@ static int diff_print_patch_file(
(pi->flags & GIT_DIFF_SHOW_UNTRACKED_CONTENT) == 0))
return 0;
+ pi->sent_file_header = 0;
+
if ((error = git_diff_delta__format_file_header(pi->buf, delta, oldpfx, newpfx,
id_strlen, print_index)) < 0)
return error;
- pi->line.origin = GIT_DIFF_LINE_FILE_HDR;
- pi->line.content = git_str_cstr(pi->buf);
- pi->line.content_len = git_str_len(pi->buf);
+ /*
+ * pi->buf now contains the file header data. Go ahead and send it
+ * if there's useful data in there, like similarity. Otherwise, we
+ * should queue it to send when we see the first hunk. This prevents
+ * us from sending a header when all hunks were ignored.
+ */
+ if (should_force_header(delta) && (error = flush_file_header(delta, pi)) < 0)
+ return error;
- return pi->print_cb(delta, NULL, &pi->line, pi->payload);
+ return 0;
}
static int diff_print_patch_binary(
@@ -613,6 +661,16 @@ static int diff_print_patch_binary(
pi->new_prefix ? pi->new_prefix : DIFF_NEW_PREFIX_DEFAULT;
int error;
+ if ((error = flush_file_header(delta, pi)) < 0)
+ return error;
+
+ /*
+ * If the caller only wants the header, we just needed to make sure to
+ * call flush_file_header
+ */
+ if (pi->format == GIT_DIFF_FORMAT_PATCH_HEADER)
+ return 0;
+
git_str_clear(pi->buf);
if ((error = diff_print_patch_file_binary(
@@ -632,10 +690,21 @@ static int diff_print_patch_hunk(
void *data)
{
diff_print_info *pi = data;
+ int error;
if (S_ISDIR(d->new_file.mode))
return 0;
+ if ((error = flush_file_header(d, pi)) < 0)
+ return error;
+
+ /*
+ * If the caller only wants the header, we just needed to make sure to
+ * call flush_file_header
+ */
+ if (pi->format == GIT_DIFF_FORMAT_PATCH_HEADER)
+ return 0;
+
pi->line.origin = GIT_DIFF_LINE_HUNK_HDR;
pi->line.content = h->header;
pi->line.content_len = h->header_len;
@@ -650,10 +719,14 @@ static int diff_print_patch_line(
void *data)
{
diff_print_info *pi = data;
+ int error;
if (S_ISDIR(delta->new_file.mode))
return 0;
+ if ((error = flush_file_header(delta, pi)) < 0)
+ return error;
+
return pi->print_cb(delta, hunk, line, pi->payload);
}
@@ -686,6 +759,8 @@ int git_diff_print(
break;
case GIT_DIFF_FORMAT_PATCH_HEADER:
print_file = diff_print_patch_file;
+ print_binary = diff_print_patch_binary;
+ print_hunk = diff_print_patch_hunk;
break;
case GIT_DIFF_FORMAT_RAW:
print_file = diff_print_one_raw;
diff --git a/src/libgit2/diff_tform.c b/src/libgit2/diff_tform.c
index 8c0c1b7fc5e..33ed2d11cda 100644
--- a/src/libgit2/diff_tform.c
+++ b/src/libgit2/diff_tform.c
@@ -190,7 +190,7 @@ int git_diff__merge(
git_pool_strdup_safe(&onto->pool, onto->opts.new_prefix);
}
- git_vector_free_deep(&onto_new);
+ git_vector_dispose_deep(&onto_new);
git_pool_clear(&onto_pool);
return error;
@@ -364,7 +364,7 @@ static int insert_delete_side_of_split(
memset(&deleted->new_file, 0, sizeof(deleted->new_file));
deleted->new_file.path = deleted->old_file.path;
deleted->new_file.flags |= GIT_DIFF_FLAG_VALID_ID;
- git_oid_clear(&deleted->new_file.id, GIT_OID_SHA1);
+ git_oid_clear(&deleted->new_file.id, diff->opts.oid_type);
return git_vector_insert(onto, deleted);
}
@@ -398,7 +398,7 @@ static int apply_splits_and_deletes(
memset(&delta->old_file, 0, sizeof(delta->old_file));
delta->old_file.path = delta->new_file.path;
delta->old_file.flags |= GIT_DIFF_FLAG_VALID_ID;
- git_oid_clear(&delta->old_file.id, GIT_OID_SHA1);
+ git_oid_clear(&delta->old_file.id, diff->opts.oid_type);
}
/* clean up delta before inserting into new list */
@@ -424,13 +424,13 @@ static int apply_splits_and_deletes(
/* swap new delta list into place */
git_vector_swap(&diff->deltas, &onto);
- git_vector_free(&onto);
+ git_vector_dispose(&onto);
git_vector_sort(&diff->deltas);
return 0;
on_error:
- git_vector_free_deep(&onto);
+ git_vector_dispose_deep(&onto);
return -1;
}
@@ -653,6 +653,23 @@ static int calc_self_similarity(
return 0;
}
+static void handle_non_blob(
+ git_diff *diff,
+ const git_diff_find_options *opts,
+ size_t delta_idx)
+{
+ git_diff_delta *delta = GIT_VECTOR_GET(&diff->deltas, delta_idx);
+
+ /* skip things that are blobs */
+ if (GIT_MODE_ISBLOB(delta->old_file.mode))
+ return;
+
+ /* honor "remove unmodified" flag for non-blobs (eg submodules) */
+ if (delta->status == GIT_DELTA_UNMODIFIED &&
+ FLAG_SET(opts, GIT_DIFF_FIND_REMOVE_UNMODIFIED))
+ delta->flags |= GIT_DIFF_FLAG__TO_DELETE;
+}
+
static bool is_rename_target(
git_diff *diff,
const git_diff_find_options *opts,
@@ -810,7 +827,8 @@ int git_diff_find_similar(
git_diff_find_options opts = GIT_DIFF_FIND_OPTIONS_INIT;
size_t num_deltas, num_srcs = 0, num_tgts = 0;
size_t tried_srcs = 0, tried_tgts = 0;
- size_t num_rewrites = 0, num_updates = 0, num_bumped = 0;
+ size_t num_rewrites = 0, num_updates = 0, num_bumped = 0,
+ num_to_delete = 0;
size_t sigcache_size;
void **sigcache = NULL; /* cache of similarity metric file signatures */
diff_find_match *tgt2src = NULL;
@@ -844,6 +862,8 @@ int git_diff_find_similar(
* mark them for splitting if break-rewrites is enabled
*/
git_vector_foreach(&diff->deltas, t, tgt) {
+ handle_non_blob(diff, &opts, t);
+
if (is_rename_source(diff, &opts, t, sigcache))
++num_srcs;
@@ -852,11 +872,14 @@ int git_diff_find_similar(
if ((tgt->flags & GIT_DIFF_FLAG__TO_SPLIT) != 0)
num_rewrites++;
+
+ if ((tgt->flags & GIT_DIFF_FLAG__TO_DELETE) != 0)
+ num_to_delete++;
}
- /* if there are no candidate srcs or tgts, we're done */
+ /* If there are no candidate srcs or tgts, no need to find matches */
if (!num_srcs || !num_tgts)
- goto cleanup;
+ goto split_and_delete;
src2tgt = git__calloc(num_deltas, sizeof(diff_find_match));
GIT_ERROR_CHECK_ALLOC(src2tgt);
@@ -997,7 +1020,7 @@ int git_diff_find_similar(
memset(&src->new_file, 0, sizeof(src->new_file));
src->new_file.path = src->old_file.path;
src->new_file.flags |= GIT_DIFF_FLAG_VALID_ID;
- git_oid_clear(&src->new_file.id, GIT_OID_SHA1);
+ git_oid_clear(&src->new_file.id, diff->opts.oid_type);
num_updates++;
@@ -1023,7 +1046,7 @@ int git_diff_find_similar(
memset(&src->old_file, 0, sizeof(src->old_file));
src->old_file.path = src->new_file.path;
src->old_file.flags |= GIT_DIFF_FLAG_VALID_ID;
- git_oid_clear(&src->old_file.id, GIT_OID_SHA1);
+ git_oid_clear(&src->old_file.id, diff->opts.oid_type);
src->flags &= ~GIT_DIFF_FLAG__TO_SPLIT;
num_rewrites--;
@@ -1093,15 +1116,20 @@ int git_diff_find_similar(
}
}
+split_and_delete:
/*
* Actually split and delete entries as needed
*/
- if (num_rewrites > 0 || num_updates > 0)
+ if (num_rewrites > 0 || num_updates > 0 || num_to_delete > 0) {
+ size_t apply_len = diff->deltas.length -
+ num_rewrites - num_to_delete;
+
error = apply_splits_and_deletes(
- diff, diff->deltas.length - num_rewrites,
+ diff, apply_len,
FLAG_SET(&opts, GIT_DIFF_BREAK_REWRITES) &&
!FLAG_SET(&opts, GIT_DIFF_BREAK_REWRITES_FOR_RENAMES_ONLY));
+ }
cleanup:
git__free(tgt2src);
diff --git a/src/libgit2/diff_xdiff.h b/src/libgit2/diff_xdiff.h
index 9b303e9dc45..327dc7c4ab3 100644
--- a/src/libgit2/diff_xdiff.h
+++ b/src/libgit2/diff_xdiff.h
@@ -10,7 +10,7 @@
#include "common.h"
#include "diff.h"
-#include "xdiff/xdiff.h"
+#include "xdiff.h"
#include "patch_generate.h"
/* xdiff cannot cope with large files. these files should not be passed to
diff --git a/src/libgit2/email.c b/src/libgit2/email.c
index 0a75021c8db..c1470c16323 100644
--- a/src/libgit2/email.c
+++ b/src/libgit2/email.c
@@ -16,6 +16,7 @@
#include "git2/email.h"
#include "git2/patch.h"
+#include "git2/sys/email.h"
#include "git2/version.h"
/*
@@ -130,11 +131,12 @@ static int append_header(
const git_signature *author,
git_email_create_options *opts)
{
- char id[GIT_OID_SHA1_HEXSIZE];
+ char id[GIT_OID_MAX_HEXSIZE + 1];
int error;
- if ((error = git_oid_fmt(id, commit_id)) < 0 ||
- (error = git_str_printf(out, "From %.*s %s\n", GIT_OID_SHA1_HEXSIZE, id, EMAIL_TIMESTAMP)) < 0 ||
+ git_oid_tostr(id, GIT_OID_MAX_HEXSIZE + 1, commit_id);
+
+ if ((error = git_str_printf(out, "From %s %s\n", id, EMAIL_TIMESTAMP)) < 0 ||
(error = git_str_printf(out, "From: %s <%s>\n", author->name, author->email)) < 0 ||
(error = append_date(out, &author->when)) < 0 ||
(error = append_subject(out, patch_idx, patch_count, summary, opts)) < 0)
diff --git a/src/libgit2/errors.c b/src/libgit2/errors.c
deleted file mode 100644
index 3614b9ce5f5..00000000000
--- a/src/libgit2/errors.c
+++ /dev/null
@@ -1,238 +0,0 @@
-/*
- * Copyright (C) the libgit2 contributors. All rights reserved.
- *
- * This file is part of libgit2, distributed under the GNU GPL v2 with
- * a Linking Exception. For full terms see the included COPYING file.
- */
-
-#include "common.h"
-
-#include "threadstate.h"
-#include "posix.h"
-#include "str.h"
-#include "libgit2.h"
-
-/********************************************
- * New error handling
- ********************************************/
-
-static git_error g_git_oom_error = {
- "Out of memory",
- GIT_ERROR_NOMEMORY
-};
-
-static git_error g_git_uninitialized_error = {
- "libgit2 has not been initialized; you must call git_libgit2_init",
- GIT_ERROR_INVALID
-};
-
-static void set_error_from_buffer(int error_class)
-{
- git_error *error = &GIT_THREADSTATE->error_t;
- git_str *buf = &GIT_THREADSTATE->error_buf;
-
- error->message = buf->ptr;
- error->klass = error_class;
-
- GIT_THREADSTATE->last_error = error;
-}
-
-static void set_error(int error_class, char *string)
-{
- git_str *buf = &GIT_THREADSTATE->error_buf;
-
- git_str_clear(buf);
- if (string) {
- git_str_puts(buf, string);
- git__free(string);
- }
-
- set_error_from_buffer(error_class);
-}
-
-void git_error_set_oom(void)
-{
- GIT_THREADSTATE->last_error = &g_git_oom_error;
-}
-
-void git_error_set(int error_class, const char *fmt, ...)
-{
- va_list ap;
-
- va_start(ap, fmt);
- git_error_vset(error_class, fmt, ap);
- va_end(ap);
-}
-
-void git_error_vset(int error_class, const char *fmt, va_list ap)
-{
-#ifdef GIT_WIN32
- DWORD win32_error_code = (error_class == GIT_ERROR_OS) ? GetLastError() : 0;
-#endif
- int error_code = (error_class == GIT_ERROR_OS) ? errno : 0;
- git_str *buf = &GIT_THREADSTATE->error_buf;
-
- git_str_clear(buf);
- if (fmt) {
- git_str_vprintf(buf, fmt, ap);
- if (error_class == GIT_ERROR_OS)
- git_str_PUTS(buf, ": ");
- }
-
- if (error_class == GIT_ERROR_OS) {
-#ifdef GIT_WIN32
- char * win32_error = git_win32_get_error_message(win32_error_code);
- if (win32_error) {
- git_str_puts(buf, win32_error);
- git__free(win32_error);
-
- SetLastError(0);
- }
- else
-#endif
- if (error_code)
- git_str_puts(buf, strerror(error_code));
-
- if (error_code)
- errno = 0;
- }
-
- if (!git_str_oom(buf))
- set_error_from_buffer(error_class);
-}
-
-int git_error_set_str(int error_class, const char *string)
-{
- git_str *buf = &GIT_THREADSTATE->error_buf;
-
- GIT_ASSERT_ARG(string);
-
- git_str_clear(buf);
- git_str_puts(buf, string);
-
- if (git_str_oom(buf))
- return -1;
-
- set_error_from_buffer(error_class);
- return 0;
-}
-
-void git_error_clear(void)
-{
- if (GIT_THREADSTATE->last_error != NULL) {
- set_error(0, NULL);
- GIT_THREADSTATE->last_error = NULL;
- }
-
- errno = 0;
-#ifdef GIT_WIN32
- SetLastError(0);
-#endif
-}
-
-const git_error *git_error_last(void)
-{
- /* If the library is not initialized, return a static error. */
- if (!git_libgit2_init_count())
- return &g_git_uninitialized_error;
-
- return GIT_THREADSTATE->last_error;
-}
-
-int git_error_state_capture(git_error_state *state, int error_code)
-{
- git_error *error = GIT_THREADSTATE->last_error;
- git_str *error_buf = &GIT_THREADSTATE->error_buf;
-
- memset(state, 0, sizeof(git_error_state));
-
- if (!error_code)
- return 0;
-
- state->error_code = error_code;
- state->oom = (error == &g_git_oom_error);
-
- if (error) {
- state->error_msg.klass = error->klass;
-
- if (state->oom)
- state->error_msg.message = g_git_oom_error.message;
- else
- state->error_msg.message = git_str_detach(error_buf);
- }
-
- git_error_clear();
- return error_code;
-}
-
-int git_error_state_restore(git_error_state *state)
-{
- int ret = 0;
-
- git_error_clear();
-
- if (state && state->error_msg.message) {
- if (state->oom)
- git_error_set_oom();
- else
- set_error(state->error_msg.klass, state->error_msg.message);
-
- ret = state->error_code;
- memset(state, 0, sizeof(git_error_state));
- }
-
- return ret;
-}
-
-void git_error_state_free(git_error_state *state)
-{
- if (!state)
- return;
-
- if (!state->oom)
- git__free(state->error_msg.message);
-
- memset(state, 0, sizeof(git_error_state));
-}
-
-int git_error_system_last(void)
-{
-#ifdef GIT_WIN32
- return GetLastError();
-#else
- return errno;
-#endif
-}
-
-void git_error_system_set(int code)
-{
-#ifdef GIT_WIN32
- SetLastError(code);
-#else
- errno = code;
-#endif
-}
-
-/* Deprecated error values and functions */
-
-#ifndef GIT_DEPRECATE_HARD
-const git_error *giterr_last(void)
-{
- return git_error_last();
-}
-
-void giterr_clear(void)
-{
- git_error_clear();
-}
-
-void giterr_set_str(int error_class, const char *string)
-{
- git_error_set_str(error_class, string);
-}
-
-void giterr_set_oom(void)
-{
- git_error_set_oom();
-}
-#endif
diff --git a/src/libgit2/fetch.c b/src/libgit2/fetch.c
index 003b5198ae8..3769f951176 100644
--- a/src/libgit2/fetch.c
+++ b/src/libgit2/fetch.c
@@ -17,9 +17,9 @@
#include "remote.h"
#include "refspec.h"
#include "pack.h"
-#include "netops.h"
#include "repository.h"
#include "refs.h"
+#include "transports/smart.h"
static int maybe_want(git_remote *remote, git_remote_head *head, git_refspec *tagspec, git_remote_autotag_option_t tagopt)
{
@@ -59,8 +59,12 @@ static int mark_local(git_remote *remote)
return -1;
git_vector_foreach(&remote->refs, i, head) {
- /* If we have the object, mark it so we don't ask for it */
- if (git_odb_exists(odb, &head->oid))
+ /* If we have the object, mark it so we don't ask for it.
+ However if we are unshallowing or changing history
+ depth, we need to ask for it even though the head
+ exists locally. */
+ if (remote->nego.depth == GIT_FETCH_DEPTH_FULL &&
+ git_odb_exists(odb, &head->oid))
head->local = 1;
else
remote->need_pack = 1;
@@ -76,7 +80,7 @@ static int maybe_want_oid(git_remote *remote, git_refspec *spec)
oid_head = git__calloc(1, sizeof(git_remote_head));
GIT_ERROR_CHECK_ALLOC(oid_head);
- git_oid__fromstr(&oid_head->oid, spec->src, GIT_OID_SHA1);
+ git_oid_from_string(&oid_head->oid, spec->src, remote->repo->oid_type);
if (spec->dst) {
oid_head->name = git__strdup(spec->dst);
@@ -137,7 +141,7 @@ static int filter_wants(git_remote *remote, const git_fetch_options *opts)
/* Handle explicitly specified OID specs */
git_vector_foreach(&remote->active_refspecs, i, spec) {
- if (!git_oid__is_hexstr(spec->src, GIT_OID_SHA1))
+ if (!git_oid__is_hexstr(spec->src, remote->repo->oid_type))
continue;
if (!(remote_caps & oid_mask)) {
@@ -166,9 +170,15 @@ static int filter_wants(git_remote *remote, const git_fetch_options *opts)
int git_fetch_negotiate(git_remote *remote, const git_fetch_options *opts)
{
git_transport *t = remote->transport;
+ int error;
remote->need_pack = 0;
+ if (opts) {
+ GIT_ASSERT_ARG(opts->depth >= 0);
+ remote->nego.depth = opts->depth;
+ }
+
if (filter_wants(remote, opts) < 0)
return -1;
@@ -180,20 +190,40 @@ int git_fetch_negotiate(git_remote *remote, const git_fetch_options *opts)
* Now we have everything set up so we can start tell the
* server what we want and what we have.
*/
- return t->negotiate_fetch(t,
+ remote->nego.refs = (const git_remote_head * const *)remote->refs.contents;
+ remote->nego.refs_len = remote->refs.length;
+
+ if (git_repository__shallow_roots(&remote->nego.shallow_roots,
+ &remote->nego.shallow_roots_len,
+ remote->repo) < 0)
+ return -1;
+
+ error = t->negotiate_fetch(t,
remote->repo,
- (const git_remote_head * const *)remote->refs.contents,
- remote->refs.length);
+ &remote->nego);
+
+ git__free(remote->nego.shallow_roots);
+
+ return error;
}
int git_fetch_download_pack(git_remote *remote)
{
+ git_oidarray shallow_roots = { NULL };
git_transport *t = remote->transport;
+ int error;
if (!remote->need_pack)
return 0;
- return t->download_pack(t, remote->repo, &remote->stats);
+ if ((error = t->download_pack(t, remote->repo, &remote->stats)) != 0 ||
+ (error = t->shallow_roots(&shallow_roots, t)) != 0)
+ return error;
+
+ error = git_repository__shallow_roots_write(remote->repo, &shallow_roots);
+
+ git_oidarray_dispose(&shallow_roots);
+ return error;
}
int git_fetch_options_init(git_fetch_options *opts, unsigned int version)
diff --git a/src/libgit2/fetch.h b/src/libgit2/fetch.h
index 10b6731f0a2..493366dedf1 100644
--- a/src/libgit2/fetch.h
+++ b/src/libgit2/fetch.h
@@ -11,8 +11,6 @@
#include "git2/remote.h"
-#include "netops.h"
-
int git_fetch_negotiate(git_remote *remote, const git_fetch_options *opts);
int git_fetch_download_pack(git_remote *remote);
diff --git a/src/libgit2/fetchhead.c b/src/libgit2/fetchhead.c
index 0ebfe5c439b..08be282a521 100644
--- a/src/libgit2/fetchhead.c
+++ b/src/libgit2/fetchhead.c
@@ -105,15 +105,14 @@ static int fetchhead_ref_write(
git_filebuf *file,
git_fetchhead_ref *fetchhead_ref)
{
- char oid[GIT_OID_SHA1_HEXSIZE + 1];
+ char oid[GIT_OID_MAX_HEXSIZE + 1];
const char *type, *name;
int head = 0;
GIT_ASSERT_ARG(file);
GIT_ASSERT_ARG(fetchhead_ref);
- git_oid_fmt(oid, &fetchhead_ref->oid);
- oid[GIT_OID_SHA1_HEXSIZE] = '\0';
+ git_oid_tostr(oid, GIT_OID_MAX_HEXSIZE + 1, &fetchhead_ref->oid);
if (git__prefixcmp(fetchhead_ref->ref_name, GIT_REFS_HEADS_DIR) == 0) {
type = "branch ";
@@ -174,7 +173,8 @@ static int fetchhead_ref_parse(
git_str *ref_name,
const char **remote_url,
char *line,
- size_t line_num)
+ size_t line_num,
+ git_oid_t oid_type)
{
char *oid_str, *is_merge_str, *desc, *name = NULL;
const char *type = NULL;
@@ -196,13 +196,13 @@ static int fetchhead_ref_parse(
*is_merge = 1;
}
- if (strlen(oid_str) != GIT_OID_SHA1_HEXSIZE) {
+ if (strlen(oid_str) != git_oid_hexsize(oid_type)) {
git_error_set(GIT_ERROR_FETCHHEAD,
"invalid object ID in FETCH_HEAD line %"PRIuZ, line_num);
return -1;
}
- if (git_oid__fromstr(oid, oid_str, GIT_OID_SHA1) < 0) {
+ if (git_oid_from_string(oid, oid_str, oid_type) < 0) {
const git_error *oid_err = git_error_last();
const char *err_msg = oid_err ? oid_err->message : "invalid object ID";
@@ -269,7 +269,8 @@ static int fetchhead_ref_parse(
return error;
}
-int git_repository_fetchhead_foreach(git_repository *repo,
+int git_repository_fetchhead_foreach(
+ git_repository *repo,
git_repository_fetchhead_foreach_cb cb,
void *payload)
{
@@ -296,8 +297,9 @@ int git_repository_fetchhead_foreach(git_repository *repo,
while ((line = git__strsep(&buffer, "\n")) != NULL) {
++line_num;
- if ((error = fetchhead_ref_parse(
- &oid, &is_merge, &name, &remote_url, line, line_num)) < 0)
+ if ((error = fetchhead_ref_parse(&oid, &is_merge, &name,
+ &remote_url, line, line_num,
+ repo->oid_type)) < 0)
goto done;
if (git_str_len(&name) > 0)
diff --git a/src/libgit2/filter.c b/src/libgit2/filter.c
index 80a3cae67bc..9e0910c8c26 100644
--- a/src/libgit2/filter.c
+++ b/src/libgit2/filter.c
@@ -239,7 +239,7 @@ static void git_filter_global_shutdown(void)
git__free(fdef);
}
- git_vector_free(&filter_registry.filters);
+ git_vector_dispose(&filter_registry.filters);
git_rwlock_wrunlock(&filter_registry.lock);
git_rwlock_free(&filter_registry.lock);
@@ -908,7 +908,7 @@ static int buffered_stream_close(git_writestream *s)
{
struct buffered_stream *buffered_stream = (struct buffered_stream *)s;
git_str *writebuf;
- git_error_state error_state = {0};
+ git_error *last_error;
int error;
GIT_ASSERT_ARG(buffered_stream);
@@ -946,9 +946,9 @@ static int buffered_stream_close(git_writestream *s)
} else {
/* close stream before erroring out taking care
* to preserve the original error */
- git_error_state_capture(&error_state, error);
+ git_error_save(&last_error);
buffered_stream->target->close(buffered_stream->target);
- git_error_state_restore(&error_state);
+ git_error_restore(last_error);
return error;
}
@@ -1106,7 +1106,7 @@ static void filter_streams_free(git_vector *streams)
git_vector_foreach(streams, i, stream)
stream->free(stream);
- git_vector_free(streams);
+ git_vector_dispose(streams);
}
int git_filter_list_stream_file(
diff --git a/src/libgit2/git2.rc b/src/libgit2/git2.rc
index d273afd7066..07592d15220 100644
--- a/src/libgit2/git2.rc
+++ b/src/libgit2/git2.rc
@@ -10,7 +10,7 @@
#endif
#ifndef LIBGIT2_COMMENTS
-# define LIBGIT2_COMMENTS "For more information visit http://libgit2.github.com/"
+# define LIBGIT2_COMMENTS "For more information visit https://libgit2.org/"
#endif
#ifdef __GNUC__
@@ -25,8 +25,8 @@ VS_VERSION_INFO VERSIONINFO
#else
VS_VERSION_INFO VERSIONINFO MOVEABLE IMPURE LOADONCALL DISCARDABLE
#endif
- FILEVERSION LIBGIT2_VER_MAJOR,LIBGIT2_VER_MINOR,LIBGIT2_VER_REVISION,LIBGIT2_VER_PATCH
- PRODUCTVERSION LIBGIT2_VER_MAJOR,LIBGIT2_VER_MINOR,LIBGIT2_VER_REVISION,LIBGIT2_VER_PATCH
+ FILEVERSION LIBGIT2_VERSION_MAJOR,LIBGIT2_VERSION_MINOR,LIBGIT2_VERSION_REVISION,LIBGIT2_VERSION_PATCH
+ PRODUCTVERSION LIBGIT2_VERSION_MAJOR,LIBGIT2_VERSION_MINOR,LIBGIT2_VERSION_REVISION,LIBGIT2_VERSION_PATCH
FILEFLAGSMASK VS_FFI_FILEFLAGSMASK
#ifdef _DEBUG
FILEFLAGS VS_FF_DEBUG
diff --git a/src/libgit2/grafts.c b/src/libgit2/grafts.c
new file mode 100644
index 00000000000..d31b4efddf9
--- /dev/null
+++ b/src/libgit2/grafts.c
@@ -0,0 +1,270 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include "grafts.h"
+
+#include "futils.h"
+#include "oid.h"
+#include "oidarray.h"
+#include "parse.h"
+#include "hashmap_oid.h"
+
+GIT_HASHMAP_OID_SETUP(git_grafts_oidmap, git_commit_graft *);
+
+struct git_grafts {
+ /* Map of `git_commit_graft`s */
+ git_grafts_oidmap commits;
+
+ /* Type of object IDs */
+ git_oid_t oid_type;
+
+ /* File backing the graft. NULL if it's an in-memory graft */
+ char *path;
+ unsigned char path_checksum[GIT_HASH_SHA256_SIZE];
+};
+
+int git_grafts_new(git_grafts **out, git_oid_t oid_type)
+{
+ git_grafts *grafts;
+
+ GIT_ASSERT_ARG(out && oid_type);
+
+ grafts = git__calloc(1, sizeof(*grafts));
+ GIT_ERROR_CHECK_ALLOC(grafts);
+
+ grafts->oid_type = oid_type;
+
+ *out = grafts;
+ return 0;
+}
+
+int git_grafts_open(
+ git_grafts **out,
+ const char *path,
+ git_oid_t oid_type)
+{
+ git_grafts *grafts = NULL;
+ int error;
+
+ GIT_ASSERT_ARG(out && path && oid_type);
+
+ if ((error = git_grafts_new(&grafts, oid_type)) < 0)
+ goto error;
+
+ grafts->path = git__strdup(path);
+ GIT_ERROR_CHECK_ALLOC(grafts->path);
+
+ if ((error = git_grafts_refresh(grafts)) < 0)
+ goto error;
+
+ *out = grafts;
+
+error:
+ if (error < 0)
+ git_grafts_free(grafts);
+
+ return error;
+}
+
+int git_grafts_open_or_refresh(
+ git_grafts **out,
+ const char *path,
+ git_oid_t oid_type)
+{
+ GIT_ASSERT_ARG(out && path && oid_type);
+
+ return *out ? git_grafts_refresh(*out) : git_grafts_open(out, path, oid_type);
+}
+
+void git_grafts_free(git_grafts *grafts)
+{
+ if (!grafts)
+ return;
+ git__free(grafts->path);
+ git_grafts_clear(grafts);
+ git_grafts_oidmap_dispose(&grafts->commits);
+ git__free(grafts);
+}
+
+void git_grafts_clear(git_grafts *grafts)
+{
+ git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
+ git_commit_graft *graft;
+
+ if (!grafts)
+ return;
+
+ while (git_grafts_oidmap_iterate(&iter, NULL, &graft, &grafts->commits) == 0) {
+ git__free(graft->parents.ptr);
+ git__free(graft);
+ }
+
+ git_grafts_oidmap_clear(&grafts->commits);
+}
+
+int git_grafts_refresh(git_grafts *grafts)
+{
+ git_str contents = GIT_STR_INIT;
+ int error, updated = 0;
+
+ GIT_ASSERT_ARG(grafts);
+
+ if (!grafts->path)
+ return 0;
+
+ if ((error = git_futils_readbuffer_updated(&contents, grafts->path,
+ grafts->path_checksum, &updated)) < 0) {
+
+ if (error == GIT_ENOTFOUND) {
+ git_grafts_clear(grafts);
+ error = 0;
+ }
+
+ goto cleanup;
+ }
+
+ if (!updated) {
+ goto cleanup;
+ }
+
+ if ((error = git_grafts_parse(grafts, contents.ptr, contents.size)) < 0)
+ goto cleanup;
+
+cleanup:
+ git_str_dispose(&contents);
+ return error;
+}
+
+int git_grafts_parse(git_grafts *grafts, const char *buf, size_t len)
+{
+ git_array_oid_t parents = GIT_ARRAY_INIT;
+ git_parse_ctx parser;
+ int error;
+
+ git_grafts_clear(grafts);
+
+ if ((error = git_parse_ctx_init(&parser, buf, len)) < 0)
+ goto error;
+
+ for (; parser.remain_len; git_parse_advance_line(&parser)) {
+ git_oid graft_oid;
+
+ if ((error = git_parse_advance_oid(&graft_oid, &parser, grafts->oid_type)) < 0) {
+ git_error_set(GIT_ERROR_GRAFTS, "invalid graft OID at line %" PRIuZ, parser.line_num);
+ goto error;
+ }
+
+ while (parser.line_len && git_parse_advance_expected(&parser, "\n", 1) != 0) {
+ git_oid *id = git_array_alloc(parents);
+ GIT_ERROR_CHECK_ALLOC(id);
+
+ if ((error = git_parse_advance_expected(&parser, " ", 1)) < 0 ||
+ (error = git_parse_advance_oid(id, &parser, grafts->oid_type)) < 0) {
+ git_error_set(GIT_ERROR_GRAFTS, "invalid parent OID at line %" PRIuZ, parser.line_num);
+ goto error;
+ }
+ }
+
+ if ((error = git_grafts_add(grafts, &graft_oid, parents)) < 0)
+ goto error;
+
+ git_array_clear(parents);
+ }
+
+error:
+ git_array_clear(parents);
+ return error;
+}
+
+int git_grafts_add(git_grafts *grafts, const git_oid *oid, git_array_oid_t parents)
+{
+ git_commit_graft *graft;
+ git_oid *parent_oid;
+ int error;
+ size_t i;
+
+ GIT_ASSERT_ARG(grafts && oid);
+
+ graft = git__calloc(1, sizeof(*graft));
+ GIT_ERROR_CHECK_ALLOC(graft);
+
+ git_array_init_to_size(graft->parents, git_array_size(parents));
+ git_array_foreach(parents, i, parent_oid) {
+ git_oid *id = git_array_alloc(graft->parents);
+ GIT_ERROR_CHECK_ALLOC(id);
+
+ git_oid_cpy(id, parent_oid);
+ }
+ git_oid_cpy(&graft->oid, oid);
+
+ if ((error = git_grafts_remove(grafts, &graft->oid)) < 0 && error != GIT_ENOTFOUND)
+ goto cleanup;
+
+ if ((error = git_grafts_oidmap_put(&grafts->commits, &graft->oid, graft)) < 0)
+ goto cleanup;
+
+ return 0;
+
+cleanup:
+ git_array_clear(graft->parents);
+ git__free(graft);
+ return error;
+}
+
+int git_grafts_remove(git_grafts *grafts, const git_oid *oid)
+{
+ git_commit_graft *graft;
+ int error;
+
+ GIT_ASSERT_ARG(grafts && oid);
+
+ if (git_grafts_oidmap_get(&graft, &grafts->commits, oid) != 0)
+ return GIT_ENOTFOUND;
+
+ if ((error = git_grafts_oidmap_remove(&grafts->commits, oid)) < 0)
+ return error;
+
+ git__free(graft->parents.ptr);
+ git__free(graft);
+
+ return 0;
+}
+
+int git_grafts_get(git_commit_graft **out, git_grafts *grafts, const git_oid *oid)
+{
+ GIT_ASSERT_ARG(out && grafts && oid);
+ return git_grafts_oidmap_get(out, &grafts->commits, oid);
+}
+
+int git_grafts_oids(git_oid **out, size_t *out_len, git_grafts *grafts)
+{
+ git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
+ git_array_oid_t array = GIT_ARRAY_INIT;
+ const git_oid *oid;
+ size_t existing;
+
+ GIT_ASSERT_ARG(out && grafts);
+
+ if ((existing = git_grafts_oidmap_size(&grafts->commits)) > 0)
+ git_array_init_to_size(array, existing);
+
+ while (git_grafts_oidmap_iterate(&iter, &oid, NULL, &grafts->commits) == 0) {
+ git_oid *cpy = git_array_alloc(array);
+ GIT_ERROR_CHECK_ALLOC(cpy);
+ git_oid_cpy(cpy, oid);
+ }
+
+ *out = array.ptr;
+ *out_len = array.size;
+
+ return 0;
+}
+
+size_t git_grafts_size(git_grafts *grafts)
+{
+ return git_grafts_oidmap_size(&grafts->commits);
+}
diff --git a/src/libgit2/grafts.h b/src/libgit2/grafts.h
new file mode 100644
index 00000000000..ab59f56b07c
--- /dev/null
+++ b/src/libgit2/grafts.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_graft_h__
+#define INCLUDE_graft_h__
+
+#include "common.h"
+#include "oidarray.h"
+
+/** graft commit */
+typedef struct {
+ git_oid oid;
+ git_array_oid_t parents;
+} git_commit_graft;
+
+typedef struct git_grafts git_grafts;
+
+int git_grafts_new(git_grafts **out, git_oid_t oid_type);
+int git_grafts_open(git_grafts **out, const char *path, git_oid_t oid_type);
+int git_grafts_open_or_refresh(git_grafts **out, const char *path, git_oid_t oid_type);
+void git_grafts_free(git_grafts *grafts);
+void git_grafts_clear(git_grafts *grafts);
+
+int git_grafts_refresh(git_grafts *grafts);
+int git_grafts_parse(git_grafts *grafts, const char *buf, size_t len);
+int git_grafts_add(git_grafts *grafts, const git_oid *oid, git_array_oid_t parents);
+int git_grafts_remove(git_grafts *grafts, const git_oid *oid);
+int git_grafts_get(git_commit_graft **out, git_grafts *grafts, const git_oid *oid);
+int git_grafts_oids(git_oid **out, size_t *out_len, git_grafts *grafts);
+size_t git_grafts_size(git_grafts *grafts);
+
+#endif
diff --git a/src/libgit2/graph.c b/src/libgit2/graph.c
index 35e914f7462..3cce7fd1185 100644
--- a/src/libgit2/graph.c
+++ b/src/libgit2/graph.c
@@ -243,7 +243,7 @@ int git_graph_reachable_from_any(
done:
git_commit_list_free(&result);
- git_vector_free(&list);
+ git_vector_dispose(&list);
git_revwalk_free(walk);
return error;
}
diff --git a/src/libgit2/hashmap_oid.h b/src/libgit2/hashmap_oid.h
new file mode 100644
index 00000000000..cb1143cc760
--- /dev/null
+++ b/src/libgit2/hashmap_oid.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_hashmap_oid_h__
+#define INCLUDE_hashmap_oid_h__
+
+#include "hashmap.h"
+
+GIT_INLINE(uint32_t) git_hashmap_oid_hashcode(const git_oid *oid)
+{
+ uint32_t hash;
+ memcpy(&hash, oid->id, sizeof(uint32_t));
+ return hash;
+}
+
+#define GIT_HASHMAP_OID_STRUCT(name, val_t) \
+ GIT_HASHMAP_STRUCT(name, const git_oid *, val_t)
+#define GIT_HASHMAP_OID_PROTOTYPES(name, val_t) \
+ GIT_HASHMAP_PROTOTYPES(name, const git_oid *, val_t)
+#define GIT_HASHMAP_OID_FUNCTIONS(name, scope, val_t) \
+ GIT_HASHMAP_FUNCTIONS(name, scope, const git_oid *, val_t, git_hashmap_oid_hashcode, git_oid_equal)
+
+#define GIT_HASHMAP_OID_SETUP(name, val_t) \
+ GIT_HASHMAP_OID_STRUCT(name, val_t) \
+ GIT_HASHMAP_OID_FUNCTIONS(name, GIT_HASHMAP_INLINE, val_t)
+
+#endif
diff --git a/src/libgit2/ident.c b/src/libgit2/ident.c
index bf9a4998e55..97110c66410 100644
--- a/src/libgit2/ident.c
+++ b/src/libgit2/ident.c
@@ -42,7 +42,7 @@ static int ident_find_id(
static int ident_insert_id(
git_str *to, const git_str *from, const git_filter_source *src)
{
- char oid[GIT_OID_SHA1_HEXSIZE+1];
+ char oid[GIT_OID_MAX_HEXSIZE + 1];
const char *id_start, *id_end, *from_end = from->ptr + from->size;
size_t need_size;
@@ -57,7 +57,7 @@ static int ident_insert_id(
return GIT_PASSTHROUGH;
need_size = (size_t)(id_start - from->ptr) +
- 5 /* "$Id: " */ + GIT_OID_SHA1_HEXSIZE + 2 /* " $" */ +
+ 5 /* "$Id: " */ + GIT_OID_MAX_HEXSIZE + 2 /* " $" */ +
(size_t)(from_end - id_end);
if (git_str_grow(to, need_size) < 0)
@@ -65,7 +65,7 @@ static int ident_insert_id(
git_str_set(to, from->ptr, (size_t)(id_start - from->ptr));
git_str_put(to, "$Id: ", 5);
- git_str_put(to, oid, GIT_OID_SHA1_HEXSIZE);
+ git_str_puts(to, oid);
git_str_put(to, " $", 2);
git_str_put(to, id_end, (size_t)(from_end - id_end));
diff --git a/src/libgit2/idxmap.c b/src/libgit2/idxmap.c
deleted file mode 100644
index bc23608f2df..00000000000
--- a/src/libgit2/idxmap.c
+++ /dev/null
@@ -1,157 +0,0 @@
-/*
- * Copyright (C) the libgit2 contributors. All rights reserved.
- *
- * This file is part of libgit2, distributed under the GNU GPL v2 with
- * a Linking Exception. For full terms see the included COPYING file.
- */
-
-#include "idxmap.h"
-
-#define kmalloc git__malloc
-#define kcalloc git__calloc
-#define krealloc git__realloc
-#define kreallocarray git__reallocarray
-#define kfree git__free
-#include "khash.h"
-
-__KHASH_TYPE(idx, const git_index_entry *, git_index_entry *)
-__KHASH_TYPE(idxicase, const git_index_entry *, git_index_entry *)
-
-/* This is __ac_X31_hash_string but with tolower and it takes the entry's stage into account */
-static kh_inline khint_t idxentry_hash(const git_index_entry *e)
-{
- const char *s = e->path;
- khint_t h = (khint_t)git__tolower(*s);
- if (h) for (++s ; *s; ++s) h = (h << 5) - h + (khint_t)git__tolower(*s);
- return h + GIT_INDEX_ENTRY_STAGE(e);
-}
-
-#define idxentry_equal(a, b) (GIT_INDEX_ENTRY_STAGE(a) == GIT_INDEX_ENTRY_STAGE(b) && strcmp(a->path, b->path) == 0)
-#define idxentry_icase_equal(a, b) (GIT_INDEX_ENTRY_STAGE(a) == GIT_INDEX_ENTRY_STAGE(b) && strcasecmp(a->path, b->path) == 0)
-
-__KHASH_IMPL(idx, static kh_inline, const git_index_entry *, git_index_entry *, 1, idxentry_hash, idxentry_equal)
-__KHASH_IMPL(idxicase, static kh_inline, const git_index_entry *, git_index_entry *, 1, idxentry_hash, idxentry_icase_equal)
-
-int git_idxmap_new(git_idxmap **out)
-{
- *out = kh_init(idx);
- GIT_ERROR_CHECK_ALLOC(*out);
-
- return 0;
-}
-
-int git_idxmap_icase_new(git_idxmap_icase **out)
-{
- *out = kh_init(idxicase);
- GIT_ERROR_CHECK_ALLOC(*out);
-
- return 0;
-}
-
-void git_idxmap_free(git_idxmap *map)
-{
- kh_destroy(idx, map);
-}
-
-void git_idxmap_icase_free(git_idxmap_icase *map)
-{
- kh_destroy(idxicase, map);
-}
-
-void git_idxmap_clear(git_idxmap *map)
-{
- kh_clear(idx, map);
-}
-
-void git_idxmap_icase_clear(git_idxmap_icase *map)
-{
- kh_clear(idxicase, map);
-}
-
-int git_idxmap_resize(git_idxmap *map, size_t size)
-{
- if (!git__is_uint32(size) ||
- kh_resize(idx, map, (khiter_t)size) < 0) {
- git_error_set_oom();
- return -1;
- }
- return 0;
-}
-
-int git_idxmap_icase_resize(git_idxmap_icase *map, size_t size)
-{
- if (!git__is_uint32(size) ||
- kh_resize(idxicase, map, (khiter_t)size) < 0) {
- git_error_set_oom();
- return -1;
- }
- return 0;
-}
-
-void *git_idxmap_get(git_idxmap *map, const git_index_entry *key)
-{
- size_t idx = kh_get(idx, map, key);
- if (idx == kh_end(map) || !kh_exist(map, idx))
- return NULL;
- return kh_val(map, idx);
-}
-
-int git_idxmap_set(git_idxmap *map, const git_index_entry *key, void *value)
-{
- size_t idx;
- int rval;
-
- idx = kh_put(idx, map, key, &rval);
- if (rval < 0)
- return -1;
-
- if (rval == 0)
- kh_key(map, idx) = key;
-
- kh_val(map, idx) = value;
-
- return 0;
-}
-
-int git_idxmap_icase_set(git_idxmap_icase *map, const git_index_entry *key, void *value)
-{
- size_t idx;
- int rval;
-
- idx = kh_put(idxicase, map, key, &rval);
- if (rval < 0)
- return -1;
-
- if (rval == 0)
- kh_key(map, idx) = key;
-
- kh_val(map, idx) = value;
-
- return 0;
-}
-
-void *git_idxmap_icase_get(git_idxmap_icase *map, const git_index_entry *key)
-{
- size_t idx = kh_get(idxicase, map, key);
- if (idx == kh_end(map) || !kh_exist(map, idx))
- return NULL;
- return kh_val(map, idx);
-}
-
-int git_idxmap_delete(git_idxmap *map, const git_index_entry *key)
-{
- khiter_t idx = kh_get(idx, map, key);
- if (idx == kh_end(map))
- return GIT_ENOTFOUND;
- kh_del(idx, map, idx);
- return 0;
-}
-
-int git_idxmap_icase_delete(git_idxmap_icase *map, const git_index_entry *key)
-{
- khiter_t idx = kh_get(idxicase, map, key);
- if (idx == kh_end(map))
- return GIT_ENOTFOUND;
- kh_del(idxicase, map, idx);
- return 0;
-}
diff --git a/src/libgit2/idxmap.h b/src/libgit2/idxmap.h
deleted file mode 100644
index 76170ef328a..00000000000
--- a/src/libgit2/idxmap.h
+++ /dev/null
@@ -1,177 +0,0 @@
-/*
- * Copyright (C) the libgit2 contributors. All rights reserved.
- *
- * This file is part of libgit2, distributed under the GNU GPL v2 with
- * a Linking Exception. For full terms see the included COPYING file.
- */
-#ifndef INCLUDE_idxmap_h__
-#define INCLUDE_idxmap_h__
-
-#include "common.h"
-
-#include "git2/index.h"
-
-/** A map with `git_index_entry`s as key. */
-typedef struct kh_idx_s git_idxmap;
-/** A map with case-insensitive `git_index_entry`s as key */
-typedef struct kh_idxicase_s git_idxmap_icase;
-
-/**
- * Allocate a new index entry map.
- *
- * @param out Pointer to the map that shall be allocated.
- * @return 0 on success, an error code if allocation has failed.
- */
-int git_idxmap_new(git_idxmap **out);
-
-/**
- * Allocate a new case-insensitive index entry map.
- *
- * @param out Pointer to the map that shall be allocated.
- * @return 0 on success, an error code if allocation has failed.
- */
-int git_idxmap_icase_new(git_idxmap_icase **out);
-
-/**
- * Free memory associated with the map.
- *
- * Note that this function will _not_ free values added to this
- * map.
- *
- * @param map Pointer to the map that is to be free'd. May be
- * `NULL`.
- */
-void git_idxmap_free(git_idxmap *map);
-
-/**
- * Free memory associated with the map.
- *
- * Note that this function will _not_ free values added to this
- * map.
- *
- * @param map Pointer to the map that is to be free'd. May be
- * `NULL`.
- */
-void git_idxmap_icase_free(git_idxmap_icase *map);
-
-/**
- * Clear all entries from the map.
- *
- * This function will remove all entries from the associated map.
- * Memory associated with it will not be released, though.
- *
- * @param map Pointer to the map that shall be cleared. May be
- * `NULL`.
- */
-void git_idxmap_clear(git_idxmap *map);
-
-/**
- * Clear all entries from the map.
- *
- * This function will remove all entries from the associated map.
- * Memory associated with it will not be released, though.
- *
- * @param map Pointer to the map that shall be cleared. May be
- * `NULL`.
- */
-void git_idxmap_icase_clear(git_idxmap_icase *map);
-
-/**
- * Resize the map by allocating more memory.
- *
- * @param map map that shall be resized
- * @param size count of entries that the map shall hold
- * @return `0` if the map was successfully resized, a negative
- * error code otherwise
- */
-int git_idxmap_resize(git_idxmap *map, size_t size);
-
-/**
- * Resize the map by allocating more memory.
- *
- * @param map map that shall be resized
- * @param size count of entries that the map shall hold
- * @return `0` if the map was successfully resized, a negative
- * error code otherwise
- */
-int git_idxmap_icase_resize(git_idxmap_icase *map, size_t size);
-
-/**
- * Return value associated with the given key.
- *
- * @param map map to search key in
- * @param key key to search for; the index entry will be searched
- * for by its case-sensitive path
- * @return value associated with the given key or NULL if the key was not found
- */
-void *git_idxmap_get(git_idxmap *map, const git_index_entry *key);
-
-/**
- * Return value associated with the given key.
- *
- * @param map map to search key in
- * @param key key to search for; the index entry will be searched
- * for by its case-insensitive path
- * @return value associated with the given key or NULL if the key was not found
- */
-void *git_idxmap_icase_get(git_idxmap_icase *map, const git_index_entry *key);
-
-/**
- * Set the entry for key to value.
- *
- * If the map has no corresponding entry for the given key, a new
- * entry will be created with the given value. If an entry exists
- * already, its value will be updated to match the given value.
- *
- * @param map map to create new entry in
- * @param key key to set
- * @param value value to associate the key with; may be NULL
- * @return zero if the key was successfully set, a negative error
- * code otherwise
- */
-int git_idxmap_set(git_idxmap *map, const git_index_entry *key, void *value);
-
-/**
- * Set the entry for key to value.
- *
- * If the map has no corresponding entry for the given key, a new
- * entry will be created with the given value. If an entry exists
- * already, its value will be updated to match the given value.
- *
- * @param map map to create new entry in
- * @param key key to set
- * @param value value to associate the key with; may be NULL
- * @return zero if the key was successfully set, a negative error
- * code otherwise
- */
-int git_idxmap_icase_set(git_idxmap_icase *map, const git_index_entry *key, void *value);
-
-/**
- * Delete an entry from the map.
- *
- * Delete the given key and its value from the map. If no such
- * key exists, this will do nothing.
- *
- * @param map map to delete key in
- * @param key key to delete
- * @return `0` if the key has been deleted, GIT_ENOTFOUND if no
- * such key was found, a negative code in case of an
- * error
- */
-int git_idxmap_delete(git_idxmap *map, const git_index_entry *key);
-
-/**
- * Delete an entry from the map.
- *
- * Delete the given key and its value from the map. If no such
- * key exists, this will do nothing.
- *
- * @param map map to delete key in
- * @param key key to delete
- * @return `0` if the key has been deleted, GIT_ENOTFOUND if no
- * such key was found, a negative code in case of an
- * error
- */
-int git_idxmap_icase_delete(git_idxmap_icase *map, const git_index_entry *key);
-
-#endif
diff --git a/src/libgit2/ignore.c b/src/libgit2/ignore.c
index cee58d7f15f..13a67343f6a 100644
--- a/src/libgit2/ignore.c
+++ b/src/libgit2/ignore.c
@@ -296,6 +296,8 @@ int git_ignore__for_path(
{
int error = 0;
const char *workdir = git_repository_workdir(repo);
+ git_attr_cache *attrcache;
+ const char *excludes_file = NULL;
git_str infopath = GIT_STR_INIT;
GIT_ASSERT_ARG(repo);
@@ -358,10 +360,12 @@ int git_ignore__for_path(
}
/* load core.excludesfile */
- if (git_repository_attr_cache(repo)->cfg_excl_file != NULL)
+ attrcache = git_repository_attr_cache(repo);
+ excludes_file = git_attr_cache_excludesfile(attrcache);
+
+ if (excludes_file != NULL)
error = push_ignore_file(
- ignores, &ignores->ign_global, NULL,
- git_repository_attr_cache(repo)->cfg_excl_file);
+ ignores, &ignores->ign_global, NULL, excludes_file);
cleanup:
git_str_dispose(&infopath);
@@ -428,13 +432,13 @@ void git_ignore__free(git_ignores *ignores)
git_attr_file__free(file);
ignores->ign_path.contents[i] = NULL;
}
- git_vector_free(&ignores->ign_path);
+ git_vector_dispose(&ignores->ign_path);
git_vector_foreach(&ignores->ign_global, i, file) {
git_attr_file__free(file);
ignores->ign_global.contents[i] = NULL;
}
- git_vector_free(&ignores->ign_global);
+ git_vector_dispose(&ignores->ign_global);
git_str_dispose(&ignores->dir);
}
diff --git a/src/libgit2/index.c b/src/libgit2/index.c
index 1821f6027f7..2f1f1b8d588 100644
--- a/src/libgit2/index.c
+++ b/src/libgit2/index.c
@@ -17,10 +17,10 @@
#include "pathspec.h"
#include "ignore.h"
#include "blob.h"
-#include "idxmap.h"
#include "diff.h"
#include "varint.h"
#include "path.h"
+#include "index_map.h"
#include "git2/odb.h"
#include "git2/oid.h"
@@ -32,8 +32,6 @@ static int index_apply_to_wd_diff(git_index *index, int action, const git_strarr
unsigned int flags,
git_index_matched_path_cb cb, void *payload);
-#define minimal_entry_size (offsetof(struct entry_short, path))
-
static const size_t INDEX_HEADER_SIZE = 12;
static const unsigned int INDEX_VERSION_NUMBER_DEFAULT = 2;
@@ -65,7 +63,7 @@ struct entry_time {
uint32_t nanoseconds;
};
-struct entry_short {
+struct entry_common {
struct entry_time ctime;
struct entry_time mtime;
uint32_t dev;
@@ -74,25 +72,35 @@ struct entry_short {
uint32_t uid;
uint32_t gid;
uint32_t file_size;
- unsigned char oid[GIT_OID_SHA1_SIZE];
- uint16_t flags;
- char path[1]; /* arbitrary length */
};
-struct entry_long {
- struct entry_time ctime;
- struct entry_time mtime;
- uint32_t dev;
- uint32_t ino;
- uint32_t mode;
- uint32_t uid;
- uint32_t gid;
- uint32_t file_size;
- unsigned char oid[GIT_OID_SHA1_SIZE];
- uint16_t flags;
- uint16_t flags_extended;
- char path[1]; /* arbitrary length */
-};
+#define entry_short(oid_size) \
+ struct { \
+ struct entry_common common; \
+ unsigned char oid[oid_size]; \
+ uint16_t flags; \
+ char path[1]; /* arbitrary length */ \
+ }
+
+#define entry_long(oid_size) \
+ struct { \
+ struct entry_common common; \
+ unsigned char oid[oid_size]; \
+ uint16_t flags; \
+ uint16_t flags_extended; \
+ char path[1]; /* arbitrary length */ \
+ }
+
+typedef entry_short(GIT_OID_SHA1_SIZE) index_entry_short_sha1;
+typedef entry_long(GIT_OID_SHA1_SIZE) index_entry_long_sha1;
+
+#ifdef GIT_EXPERIMENTAL_SHA256
+typedef entry_short(GIT_OID_SHA256_SIZE) index_entry_short_sha256;
+typedef entry_long(GIT_OID_SHA256_SIZE) index_entry_long_sha256;
+#endif
+
+#undef entry_short
+#undef entry_long
struct entry_srch_key {
const char *path;
@@ -115,40 +123,16 @@ struct reuc_entry_internal {
bool git_index__enforce_unsaved_safety = false;
/* local declarations */
-static int read_extension(size_t *read_len, git_index *index, const char *buffer, size_t buffer_size);
+static int read_extension(size_t *read_len, git_index *index, size_t checksum_size, const char *buffer, size_t buffer_size);
static int read_header(struct index_header *dest, const void *buffer);
static int parse_index(git_index *index, const char *buffer, size_t buffer_size);
static bool is_index_extended(git_index *index);
-static int write_index(unsigned char checksum[GIT_HASH_SHA1_SIZE], size_t *checksum_size, git_index *index, git_filebuf *file);
+static int write_index(unsigned char checksum[GIT_HASH_MAX_SIZE], size_t *checksum_size, git_index *index, git_filebuf *file);
static void index_entry_free(git_index_entry *entry);
static void index_entry_reuc_free(git_index_reuc_entry *reuc);
-GIT_INLINE(int) index_map_set(git_idxmap *map, git_index_entry *e, bool ignore_case)
-{
- if (ignore_case)
- return git_idxmap_icase_set((git_idxmap_icase *) map, e, e);
- else
- return git_idxmap_set(map, e, e);
-}
-
-GIT_INLINE(int) index_map_delete(git_idxmap *map, git_index_entry *e, bool ignore_case)
-{
- if (ignore_case)
- return git_idxmap_icase_delete((git_idxmap_icase *) map, e);
- else
- return git_idxmap_delete(map, e);
-}
-
-GIT_INLINE(int) index_map_resize(git_idxmap *map, size_t count, bool ignore_case)
-{
- if (ignore_case)
- return git_idxmap_icase_resize((git_idxmap_icase *) map, count);
- else
- return git_idxmap_resize(map, count);
-}
-
int git_index_entry_srch(const void *key, const void *array_member)
{
const struct entry_srch_key *srch_key = key;
@@ -380,6 +364,7 @@ GIT_INLINE(int) index_find(
void git_index__set_ignore_case(git_index *index, bool ignore_case)
{
index->ignore_case = ignore_case;
+ index->entries_map.ignore_case = ignore_case;
if (ignore_case) {
index->entries_cmp_path = git__strcasecmp_cb;
@@ -401,16 +386,26 @@ void git_index__set_ignore_case(git_index *index, bool ignore_case)
git_vector_sort(&index->reuc);
}
-int git_index_open(git_index **index_out, const char *index_path)
+int git_index_open_ext(
+ git_index **index_out,
+ const char *index_path,
+ const git_index_options *opts)
{
git_index *index;
int error = -1;
GIT_ASSERT_ARG(index_out);
+ GIT_ERROR_CHECK_VERSION(opts, GIT_INDEX_OPTIONS_VERSION, "git_index_options");
+
+ if (opts && opts->oid_type)
+ GIT_ASSERT_ARG(git_oid_type_is_valid(opts->oid_type));
index = git__calloc(1, sizeof(git_index));
GIT_ERROR_CHECK_ALLOC(index);
+ index->oid_type = opts && opts->oid_type ? opts->oid_type :
+ GIT_OID_DEFAULT;
+
if (git_pool_init(&index->tree_pool, 1) < 0)
goto fail;
@@ -425,7 +420,6 @@ int git_index_open(git_index **index_out, const char *index_path)
}
if (git_vector_init(&index->entries, 32, git_index_entry_cmp) < 0 ||
- git_idxmap_new(&index->entries_map) < 0 ||
git_vector_init(&index->names, 8, conflict_name_cmp) < 0 ||
git_vector_init(&index->reuc, 8, reuc_cmp) < 0 ||
git_vector_init(&index->deleted, 8, git_index_entry_cmp) < 0)
@@ -451,9 +445,19 @@ int git_index_open(git_index **index_out, const char *index_path)
return error;
}
+int git_index_open(git_index **index_out, const char *index_path)
+{
+ return git_index_open_ext(index_out, index_path, NULL);
+}
+
int git_index_new(git_index **out)
{
- return git_index_open(out, NULL);
+ return git_index_open_ext(out, NULL, NULL);
+}
+
+int git_index_new_ext(git_index **out, const git_index_options *opts)
+{
+ return git_index_open_ext(out, NULL, opts);
}
static void index_free(git_index *index)
@@ -465,11 +469,11 @@ static void index_free(git_index *index)
return;
git_index_clear(index);
- git_idxmap_free(index->entries_map);
- git_vector_free(&index->entries);
- git_vector_free(&index->names);
- git_vector_free(&index->reuc);
- git_vector_free(&index->deleted);
+ git_index_entrymap_dispose(&index->entries_map);
+ git_vector_dispose(&index->entries);
+ git_vector_dispose(&index->names);
+ git_vector_dispose(&index->reuc);
+ git_vector_dispose(&index->deleted);
git__free(index->index_file_path);
@@ -510,7 +514,7 @@ static int index_remove_entry(git_index *index, size_t pos)
if (entry != NULL) {
git_tree_cache_invalidate_path(index->tree, entry->path);
- index_map_delete(index->entries_map, entry, index->ignore_case);
+ git_index_entrymap_remove(&index->entries_map, entry);
}
error = git_vector_remove(&index->entries, pos);
@@ -538,7 +542,8 @@ int git_index_clear(git_index *index)
index->tree = NULL;
git_pool_clear(&index->tree_pool);
- git_idxmap_clear(index->entries_map);
+ git_index_entrymap_clear(&index->entries_map);
+
while (!error && index->entries.length > 0)
error = index_remove_entry(index, index->entries.length - 1);
@@ -620,8 +625,8 @@ static int compare_checksum(git_index *index)
{
int fd;
ssize_t bytes_read;
- unsigned char checksum[GIT_HASH_SHA1_SIZE];
- size_t checksum_size = GIT_HASH_SHA1_SIZE;
+ unsigned char checksum[GIT_HASH_MAX_SIZE];
+ size_t checksum_size = git_oid_size(index->oid_type);
if ((fd = p_open(index->index_file_path, O_RDONLY)) < 0)
return fd;
@@ -749,8 +754,10 @@ static int truncate_racily_clean(git_index *index)
diff_opts.pathspec.count = paths.length;
diff_opts.pathspec.strings = (char **)paths.contents;
- if ((error = git_diff_index_to_workdir(&diff, INDEX_OWNER(index), index, &diff_opts)) < 0)
+ if ((error = git_diff_index_to_workdir(&diff, INDEX_OWNER(index), index, &diff_opts)) < 0) {
+ git_vector_dispose(&paths);
return error;
+ }
git_vector_foreach(&diff->deltas, i, delta) {
entry = (git_index_entry *)git_index_get_bypath(index, delta->old_file.path, 0);
@@ -766,7 +773,7 @@ static int truncate_racily_clean(git_index *index)
done:
git_diff_free(diff);
- git_vector_free(&paths);
+ git_vector_dispose(&paths);
return 0;
}
@@ -867,14 +874,9 @@ const git_index_entry *git_index_get_bypath(
key.path = path;
GIT_INDEX_ENTRY_STAGE_SET(&key, stage);
- if (index->ignore_case)
- value = git_idxmap_icase_get((git_idxmap_icase *) index->entries_map, &key);
- else
- value = git_idxmap_get(index->entries_map, &key);
-
- if (!value) {
- git_error_set(GIT_ERROR_INDEX, "index does not contain '%s'", path);
- return NULL;
+ if (git_index_entrymap_get(&value, &index->entries_map, &key) != 0) {
+ git_error_set(GIT_ERROR_INDEX, "index does not contain '%s'", path);
+ return NULL;
}
return value;
@@ -885,7 +887,7 @@ void git_index_entry__init_from_stat(
{
entry->ctime.seconds = (int32_t)st->st_ctime;
entry->mtime.seconds = (int32_t)st->st_mtime;
-#if defined(GIT_USE_NSEC)
+#if defined(GIT_NSEC)
entry->mtime.nanoseconds = st->st_mtime_nsec;
entry->ctime.nanoseconds = st->st_ctime_nsec;
#endif
@@ -1148,10 +1150,13 @@ static int has_dir_name(git_index *index,
size_t len, pos;
for (;;) {
- if (*--slash == '/')
- break;
+ slash--;
+
if (slash <= entry->path)
return 0;
+
+ if (*slash == '/')
+ break;
}
len = slash - name;
@@ -1413,7 +1418,7 @@ static int index_insert(
* check for dups, this is actually cheaper in the long run.)
*/
if ((error = git_vector_insert_sorted(&index->entries, entry, index_no_dups)) < 0 ||
- (error = index_map_set(index->entries_map, entry, index->ignore_case)) < 0)
+ (error = git_index_entrymap_put(&index->entries_map, entry)) < 0)
goto out;
}
@@ -1572,15 +1577,17 @@ int git_index_add_bypath(git_index *index, const char *path)
if (ret == GIT_EDIRECTORY) {
git_submodule *sm;
- git_error_state err;
+ git_error *last_error;
- git_error_state_capture(&err, ret);
+ git_error_save(&last_error);
ret = git_submodule_lookup(&sm, INDEX_OWNER(index), path);
- if (ret == GIT_ENOTFOUND)
- return git_error_state_restore(&err);
+ if (ret == GIT_ENOTFOUND) {
+ git_error_restore(last_error);
+ return GIT_EDIRECTORY;
+ }
- git_error_state_free(&err);
+ git_error_free(last_error);
/*
* EEXISTS means that there is a repository at that path, but it's not known
@@ -1640,8 +1647,7 @@ int git_index__fill(git_index *index, const git_vector *source_entries)
return 0;
if (git_vector_size_hint(&index->entries, source_entries->length) < 0 ||
- index_map_resize(index->entries_map, (size_t)(source_entries->length * 1.3),
- index->ignore_case) < 0)
+ git_index_entrymap_resize(&index->entries_map, (size_t)(source_entries->length * 1.3)) < 0)
return -1;
git_vector_foreach(source_entries, i, source_entry) {
@@ -1654,10 +1660,8 @@ int git_index__fill(git_index *index, const git_vector *source_entries)
entry->flags_extended |= GIT_INDEX_ENTRY_UPTODATE;
entry->mode = git_index__create_mode(entry->mode);
- if ((error = git_vector_insert(&index->entries, entry)) < 0)
- break;
-
- if ((error = index_map_set(index->entries_map, entry, index->ignore_case)) < 0)
+ if ((error = git_vector_insert(&index->entries, entry)) < 0 ||
+ (error = git_index_entrymap_put(&index->entries_map, entry)) < 0)
break;
index->dirty = 1;
@@ -1700,7 +1704,7 @@ int git_index_remove(git_index *index, const char *path, int stage)
remove_key.path = path;
GIT_INDEX_ENTRY_STAGE_SET(&remove_key, stage);
- index_map_delete(index->entries_map, &remove_key, index->ignore_case);
+ git_index_entrymap_remove(&index->entries_map, &remove_key);
if (index_find(&position, index, path, 0, stage) < 0) {
git_error_set(
@@ -2306,6 +2310,7 @@ static int index_error_invalid(const char *message)
static int read_reuc(git_index *index, const char *buffer, size_t size)
{
const char *endptr;
+ size_t oid_size = git_oid_size(index->oid_type);
size_t len;
int i;
@@ -2354,16 +2359,16 @@ static int read_reuc(git_index *index, const char *buffer, size_t size)
for (i = 0; i < 3; i++) {
if (!lost->mode[i])
continue;
- if (size < GIT_OID_SHA1_SIZE) {
+ if (size < oid_size) {
index_entry_reuc_free(lost);
return index_error_invalid("reading reuc entry oid");
}
- if (git_oid__fromraw(&lost->oid[i], (const unsigned char *) buffer, GIT_OID_SHA1) < 0)
+ if (git_oid_from_raw(&lost->oid[i], (const unsigned char *) buffer, index->oid_type) < 0)
return -1;
- size -= GIT_OID_SHA1_SIZE;
- buffer += GIT_OID_SHA1_SIZE;
+ size -= oid_size;
+ buffer += oid_size;
}
/* entry was read successfully - insert into reuc vector */
@@ -2433,73 +2438,157 @@ static int read_conflict_names(git_index *index, const char *buffer, size_t size
return 0;
}
-static size_t index_entry_size(size_t path_len, size_t varint_len, uint32_t flags)
+GIT_INLINE(size_t) index_entry_path_offset(
+ git_oid_t oid_type,
+ uint32_t flags)
+{
+ if (oid_type == GIT_OID_SHA1)
+ return (flags & GIT_INDEX_ENTRY_EXTENDED) ?
+ offsetof(index_entry_long_sha1, path) :
+ offsetof(index_entry_short_sha1, path);
+
+#ifdef GIT_EXPERIMENTAL_SHA256
+ else if (oid_type == GIT_OID_SHA256)
+ return (flags & GIT_INDEX_ENTRY_EXTENDED) ?
+ offsetof(index_entry_long_sha256, path) :
+ offsetof(index_entry_short_sha256, path);
+#endif
+
+ git_error_set(GIT_ERROR_INTERNAL, "invalid oid type");
+ return 0;
+}
+
+GIT_INLINE(size_t) index_entry_flags_offset(git_oid_t oid_type)
+{
+ if (oid_type == GIT_OID_SHA1)
+ return offsetof(index_entry_long_sha1, flags_extended);
+
+#ifdef GIT_EXPERIMENTAL_SHA256
+ else if (oid_type == GIT_OID_SHA256)
+ return offsetof(index_entry_long_sha256, flags_extended);
+#endif
+
+ git_error_set(GIT_ERROR_INTERNAL, "invalid oid type");
+ return 0;
+}
+
+static size_t index_entry_size(
+ size_t path_len,
+ size_t varint_len,
+ git_oid_t oid_type,
+ uint32_t flags)
{
+ size_t offset, size;
+
+ if (!(offset = index_entry_path_offset(oid_type, flags)))
+ return 0;
+
if (varint_len) {
- if (flags & GIT_INDEX_ENTRY_EXTENDED)
- return offsetof(struct entry_long, path) + path_len + 1 + varint_len;
- else
- return offsetof(struct entry_short, path) + path_len + 1 + varint_len;
+ if (GIT_ADD_SIZET_OVERFLOW(&size, offset, path_len) ||
+ GIT_ADD_SIZET_OVERFLOW(&size, size, 1) ||
+ GIT_ADD_SIZET_OVERFLOW(&size, size, varint_len))
+ return 0;
} else {
-#define entry_size(type,len) ((offsetof(type, path) + (len) + 8) & ~7)
- if (flags & GIT_INDEX_ENTRY_EXTENDED)
- return entry_size(struct entry_long, path_len);
- else
- return entry_size(struct entry_short, path_len);
-#undef entry_size
+ if (GIT_ADD_SIZET_OVERFLOW(&size, offset, path_len) ||
+ GIT_ADD_SIZET_OVERFLOW(&size, size, 8))
+ return 0;
+
+ size &= ~7;
}
+
+ return size;
}
static int read_entry(
git_index_entry **out,
size_t *out_size,
git_index *index,
+ size_t checksum_size,
const void *buffer,
size_t buffer_size,
const char *last)
{
- size_t path_length, entry_size;
+ size_t path_length, path_offset, entry_size;
const char *path_ptr;
- struct entry_short source;
+ struct entry_common *source_common;
+ index_entry_short_sha1 source_sha1;
+#ifdef GIT_EXPERIMENTAL_SHA256
+ index_entry_short_sha256 source_sha256;
+#endif
git_index_entry entry = {{0}};
bool compressed = index->version >= INDEX_VERSION_NUMBER_COMP;
char *tmp_path = NULL;
- size_t checksum_size = GIT_HASH_SHA1_SIZE;
+
+ size_t minimal_entry_size = index_entry_path_offset(index->oid_type, 0);
if (checksum_size + minimal_entry_size > buffer_size)
return -1;
/* buffer is not guaranteed to be aligned */
- memcpy(&source, buffer, sizeof(struct entry_short));
-
- entry.ctime.seconds = (git_time_t)ntohl(source.ctime.seconds);
- entry.ctime.nanoseconds = ntohl(source.ctime.nanoseconds);
- entry.mtime.seconds = (git_time_t)ntohl(source.mtime.seconds);
- entry.mtime.nanoseconds = ntohl(source.mtime.nanoseconds);
- entry.dev = ntohl(source.dev);
- entry.ino = ntohl(source.ino);
- entry.mode = ntohl(source.mode);
- entry.uid = ntohl(source.uid);
- entry.gid = ntohl(source.gid);
- entry.file_size = ntohl(source.file_size);
- entry.flags = ntohs(source.flags);
-
- if (git_oid__fromraw(&entry.id, source.oid, GIT_OID_SHA1) < 0)
+ switch (index->oid_type) {
+ case GIT_OID_SHA1:
+ source_common = &source_sha1.common;
+ memcpy(&source_sha1, buffer, sizeof(source_sha1));
+ break;
+#ifdef GIT_EXPERIMENTAL_SHA256
+ case GIT_OID_SHA256:
+ source_common = &source_sha256.common;
+ memcpy(&source_sha256, buffer, sizeof(source_sha256));
+ break;
+#endif
+ default:
+ GIT_ASSERT(!"invalid oid type");
+ }
+
+ entry.ctime.seconds = (git_time_t)ntohl(source_common->ctime.seconds);
+ entry.ctime.nanoseconds = ntohl(source_common->ctime.nanoseconds);
+ entry.mtime.seconds = (git_time_t)ntohl(source_common->mtime.seconds);
+ entry.mtime.nanoseconds = ntohl(source_common->mtime.nanoseconds);
+ entry.dev = ntohl(source_common->dev);
+ entry.ino = ntohl(source_common->ino);
+ entry.mode = ntohl(source_common->mode);
+ entry.uid = ntohl(source_common->uid);
+ entry.gid = ntohl(source_common->gid);
+ entry.file_size = ntohl(source_common->file_size);
+
+ switch (index->oid_type) {
+ case GIT_OID_SHA1:
+ if (git_oid_from_raw(&entry.id, source_sha1.oid,
+ GIT_OID_SHA1) < 0)
+ return -1;
+ entry.flags = ntohs(source_sha1.flags);
+ break;
+#ifdef GIT_EXPERIMENTAL_SHA256
+ case GIT_OID_SHA256:
+ if (git_oid_from_raw(&entry.id, source_sha256.oid,
+ GIT_OID_SHA256) < 0)
+ return -1;
+ entry.flags = ntohs(source_sha256.flags);
+ break;
+#endif
+ default:
+ GIT_ASSERT(!"invalid oid type");
+ }
+
+ if (!(path_offset = index_entry_path_offset(index->oid_type, entry.flags)))
return -1;
+
if (entry.flags & GIT_INDEX_ENTRY_EXTENDED) {
uint16_t flags_raw;
size_t flags_offset;
- flags_offset = offsetof(struct entry_long, flags_extended);
- memcpy(&flags_raw, (const char *) buffer + flags_offset,
- sizeof(flags_raw));
+ if (!(flags_offset = index_entry_flags_offset(index->oid_type)))
+ return -1;
+
+ memcpy(&flags_raw, (const char *)buffer + flags_offset, sizeof(flags_raw));
flags_raw = ntohs(flags_raw);
memcpy(&entry.flags_extended, &flags_raw, sizeof(flags_raw));
- path_ptr = (const char *) buffer + offsetof(struct entry_long, path);
- } else
- path_ptr = (const char *) buffer + offsetof(struct entry_short, path);
+ path_ptr = (const char *)buffer + path_offset;
+ } else {
+ path_ptr = (const char *)buffer + path_offset;
+ }
if (!compressed) {
path_length = entry.flags & GIT_INDEX_ENTRY_NAMEMASK;
@@ -2511,12 +2600,12 @@ static int read_entry(
path_end = memchr(path_ptr, '\0', buffer_size);
if (path_end == NULL)
- return -1;
+ return index_error_invalid("invalid path name");
path_length = path_end - path_ptr;
}
- entry_size = index_entry_size(path_length, 0, entry.flags);
+ entry_size = index_entry_size(path_length, 0, index->oid_type, entry.flags);
entry.path = (char *)path_ptr;
} else {
size_t varint_len, last_len, prefix_len, suffix_len, path_len;
@@ -2542,15 +2631,18 @@ static int read_entry(
memcpy(tmp_path, last, prefix_len);
memcpy(tmp_path + prefix_len, path_ptr + varint_len, suffix_len + 1);
- entry_size = index_entry_size(suffix_len, varint_len, entry.flags);
+
+ entry_size = index_entry_size(suffix_len, varint_len, index->oid_type, entry.flags);
entry.path = tmp_path;
}
if (entry_size == 0)
return -1;
- if (checksum_size + entry_size > buffer_size)
+ if (checksum_size + entry_size > buffer_size) {
+ git_error_set(GIT_ERROR_INTERNAL, "invalid index checksum");
return -1;
+ }
if (index_entry_dup(out, index, &entry) < 0) {
git__free(tmp_path);
@@ -2579,11 +2671,10 @@ static int read_header(struct index_header *dest, const void *buffer)
return 0;
}
-static int read_extension(size_t *read_len, git_index *index, const char *buffer, size_t buffer_size)
+static int read_extension(size_t *read_len, git_index *index, size_t checksum_size, const char *buffer, size_t buffer_size)
{
struct index_extension dest;
size_t total_size;
- size_t checksum_size = GIT_HASH_SHA1_SIZE;
/* buffer is not guaranteed to be aligned */
memcpy(&dest, buffer, sizeof(struct index_extension));
@@ -2602,7 +2693,7 @@ static int read_extension(size_t *read_len, git_index *index, const char *buffer
if (dest.signature[0] >= 'A' && dest.signature[0] <= 'Z') {
/* tree cache */
if (memcmp(dest.signature, INDEX_EXT_TREECACHE_SIG, 4) == 0) {
- if (git_tree_cache_read(&index->tree, buffer + 8, dest.extension_size, &index->tree_pool) < 0)
+ if (git_tree_cache_read(&index->tree, buffer + 8, dest.extension_size, index->oid_type, &index->tree_pool) < 0)
return -1;
} else if (memcmp(dest.signature, INDEX_EXT_UNMERGED_SIG, 4) == 0) {
if (read_reuc(index, buffer + 8, dest.extension_size) < 0)
@@ -2630,8 +2721,9 @@ static int parse_index(git_index *index, const char *buffer, size_t buffer_size)
int error = 0;
unsigned int i;
struct index_header header = { 0 };
- unsigned char checksum[GIT_HASH_SHA1_SIZE];
- size_t checksum_size = GIT_HASH_SHA1_SIZE;
+ unsigned char checksum[GIT_HASH_MAX_SIZE];
+ unsigned char zero_checksum[GIT_HASH_MAX_SIZE] = { 0 };
+ size_t checksum_size = git_hash_size(git_oid_algorithm(index->oid_type));
const char *last = NULL;
const char *empty = "";
@@ -2646,9 +2738,12 @@ static int parse_index(git_index *index, const char *buffer, size_t buffer_size)
if (buffer_size < INDEX_HEADER_SIZE + checksum_size)
return index_error_invalid("insufficient buffer space");
- /* Precalculate the SHA1 of the files's contents -- we'll match it to
- * the provided SHA1 in the footer */
- git_hash_buf(checksum, buffer, buffer_size - checksum_size, GIT_HASH_ALGORITHM_SHA1);
+ /*
+ * Precalculate the hash of the files's contents -- we'll match
+ * it to the provided checksum in the footer.
+ */
+ git_hash_buf(checksum, buffer, buffer_size - checksum_size,
+ git_oid_algorithm(index->oid_type));
/* Parse header */
if ((error = read_header(&header, buffer)) < 0)
@@ -2662,7 +2757,7 @@ static int parse_index(git_index *index, const char *buffer, size_t buffer_size)
GIT_ASSERT(!index->entries.length);
- if ((error = index_map_resize(index->entries_map, header.entry_count, index->ignore_case)) < 0)
+ if ((error = git_index_entrymap_resize(&index->entries_map, header.entry_count)) < 0)
return error;
/* Parse all the entries */
@@ -2670,7 +2765,7 @@ static int parse_index(git_index *index, const char *buffer, size_t buffer_size)
git_index_entry *entry = NULL;
size_t entry_size;
- if ((error = read_entry(&entry, &entry_size, index, buffer, buffer_size, last)) < 0) {
+ if ((error = read_entry(&entry, &entry_size, index, checksum_size, buffer, buffer_size, last)) < 0) {
error = index_error_invalid("invalid entry");
goto done;
}
@@ -2680,7 +2775,7 @@ static int parse_index(git_index *index, const char *buffer, size_t buffer_size)
goto done;
}
- if ((error = index_map_set(index->entries_map, entry, index->ignore_case)) < 0) {
+ if ((error = git_index_entrymap_put(&index->entries_map, entry)) < 0) {
index_entry_free(entry);
goto done;
}
@@ -2701,7 +2796,7 @@ static int parse_index(git_index *index, const char *buffer, size_t buffer_size)
while (buffer_size > checksum_size) {
size_t extension_size;
- if ((error = read_extension(&extension_size, index, buffer, buffer_size)) < 0) {
+ if ((error = read_extension(&extension_size, index, checksum_size, buffer, buffer_size)) < 0) {
goto done;
}
@@ -2714,8 +2809,14 @@ static int parse_index(git_index *index, const char *buffer, size_t buffer_size)
goto done;
}
- /* 160-bit SHA-1 over the content of the index file before this checksum. */
- if (memcmp(checksum, buffer, checksum_size) != 0) {
+ /*
+ * SHA-1 or SHA-256 (depending on the repository's object format)
+ * over the content of the index file before this checksum.
+ * Note: checksum may be 0 if the index was written by a client
+ * where index.skipHash was set to true.
+ */
+ if (memcmp(zero_checksum, buffer, checksum_size) != 0 &&
+ memcmp(checksum, buffer, checksum_size) != 0) {
error = index_error_invalid(
"calculated checksum does not match expected");
goto done;
@@ -2754,16 +2855,40 @@ static bool is_index_extended(git_index *index)
return (extended > 0);
}
-static int write_disk_entry(git_filebuf *file, git_index_entry *entry, const char *last)
+static int write_disk_entry(
+ git_index *index,
+ git_filebuf *file,
+ git_index_entry *entry,
+ const char *last)
{
void *mem = NULL;
- struct entry_short ondisk;
- size_t path_len, disk_size;
+ struct entry_common *ondisk_common;
+ size_t path_len, path_offset, disk_size;
int varint_len = 0;
char *path;
const char *path_start = entry->path;
size_t same_len = 0;
+ index_entry_short_sha1 ondisk_sha1;
+ index_entry_long_sha1 ondisk_ext_sha1;
+#ifdef GIT_EXPERIMENTAL_SHA256
+ index_entry_short_sha256 ondisk_sha256;
+ index_entry_long_sha256 ondisk_ext_sha256;
+#endif
+
+ switch (index->oid_type) {
+ case GIT_OID_SHA1:
+ ondisk_common = &ondisk_sha1.common;
+ break;
+#ifdef GIT_EXPERIMENTAL_SHA256
+ case GIT_OID_SHA256:
+ ondisk_common = &ondisk_sha256.common;
+ break;
+#endif
+ default:
+ GIT_ASSERT(!"invalid oid type");
+ }
+
path_len = ((struct entry_internal *)entry)->pathlen;
if (last) {
@@ -2780,9 +2905,9 @@ static int write_disk_entry(git_filebuf *file, git_index_entry *entry, const cha
varint_len = git_encode_varint(NULL, 0, strlen(last) - same_len);
}
- disk_size = index_entry_size(path_len, varint_len, entry->flags);
+ disk_size = index_entry_size(path_len, varint_len, index->oid_type, entry->flags);
- if (git_filebuf_reserve(file, &mem, disk_size) < 0)
+ if (!disk_size || git_filebuf_reserve(file, &mem, disk_size) < 0)
return -1;
memset(mem, 0x0, disk_size);
@@ -2797,35 +2922,77 @@ static int write_disk_entry(git_filebuf *file, git_index_entry *entry, const cha
*
* In 2038 I will be either too dead or too rich to care about this
*/
- ondisk.ctime.seconds = htonl((uint32_t)entry->ctime.seconds);
- ondisk.mtime.seconds = htonl((uint32_t)entry->mtime.seconds);
- ondisk.ctime.nanoseconds = htonl(entry->ctime.nanoseconds);
- ondisk.mtime.nanoseconds = htonl(entry->mtime.nanoseconds);
- ondisk.dev = htonl(entry->dev);
- ondisk.ino = htonl(entry->ino);
- ondisk.mode = htonl(entry->mode);
- ondisk.uid = htonl(entry->uid);
- ondisk.gid = htonl(entry->gid);
- ondisk.file_size = htonl((uint32_t)entry->file_size);
- git_oid_raw_cpy(ondisk.oid, entry->id.id, GIT_OID_SHA1_SIZE);
- ondisk.flags = htons(entry->flags);
+ ondisk_common->ctime.seconds = htonl((uint32_t)entry->ctime.seconds);
+ ondisk_common->mtime.seconds = htonl((uint32_t)entry->mtime.seconds);
+ ondisk_common->ctime.nanoseconds = htonl(entry->ctime.nanoseconds);
+ ondisk_common->mtime.nanoseconds = htonl(entry->mtime.nanoseconds);
+ ondisk_common->dev = htonl(entry->dev);
+ ondisk_common->ino = htonl(entry->ino);
+ ondisk_common->mode = htonl(entry->mode);
+ ondisk_common->uid = htonl(entry->uid);
+ ondisk_common->gid = htonl(entry->gid);
+ ondisk_common->file_size = htonl((uint32_t)entry->file_size);
+
+ switch (index->oid_type) {
+ case GIT_OID_SHA1:
+ git_oid_raw_cpy(ondisk_sha1.oid, entry->id.id, GIT_OID_SHA1_SIZE);
+ ondisk_sha1.flags = htons(entry->flags);
+ break;
+#ifdef GIT_EXPERIMENTAL_SHA256
+ case GIT_OID_SHA256:
+ git_oid_raw_cpy(ondisk_sha256.oid, entry->id.id, GIT_OID_SHA256_SIZE);
+ ondisk_sha256.flags = htons(entry->flags);
+ break;
+#endif
+ default:
+ GIT_ASSERT(!"invalid oid type");
+ }
+
+ path_offset = index_entry_path_offset(index->oid_type, entry->flags);
if (entry->flags & GIT_INDEX_ENTRY_EXTENDED) {
- const size_t path_offset = offsetof(struct entry_long, path);
- struct entry_long ondisk_ext;
- memcpy(&ondisk_ext, &ondisk, sizeof(struct entry_short));
- ondisk_ext.flags_extended = htons(entry->flags_extended &
+ struct entry_common *ondisk_ext;
+ uint16_t flags_extended = htons(entry->flags_extended &
GIT_INDEX_ENTRY_EXTENDED_FLAGS);
- memcpy(mem, &ondisk_ext, path_offset);
- path = (char *)mem + path_offset;
- disk_size -= path_offset;
+
+ switch (index->oid_type) {
+ case GIT_OID_SHA1:
+ memcpy(&ondisk_ext_sha1, &ondisk_sha1,
+ sizeof(index_entry_short_sha1));
+ ondisk_ext_sha1.flags_extended = flags_extended;
+ ondisk_ext = &ondisk_ext_sha1.common;
+ break;
+#ifdef GIT_EXPERIMENTAL_SHA256
+ case GIT_OID_SHA256:
+ memcpy(&ondisk_ext_sha256, &ondisk_sha256,
+ sizeof(index_entry_short_sha256));
+ ondisk_ext_sha256.flags_extended = flags_extended;
+ ondisk_ext = &ondisk_ext_sha256.common;
+ break;
+#endif
+ default:
+ GIT_ASSERT(!"invalid oid type");
+ }
+
+ memcpy(mem, ondisk_ext, path_offset);
} else {
- const size_t path_offset = offsetof(struct entry_short, path);
- memcpy(mem, &ondisk, path_offset);
- path = (char *)mem + path_offset;
- disk_size -= path_offset;
+ switch (index->oid_type) {
+ case GIT_OID_SHA1:
+ memcpy(mem, &ondisk_sha1, path_offset);
+ break;
+#ifdef GIT_EXPERIMENTAL_SHA256
+ case GIT_OID_SHA256:
+ memcpy(mem, &ondisk_sha256, path_offset);
+ break;
+#endif
+ default:
+ GIT_ASSERT(!"invalid oid type");
+ }
}
+ path = (char *)mem + path_offset;
+ disk_size -= path_offset;
+
if (last) {
varint_len = git_encode_varint((unsigned char *) path,
disk_size, strlen(last) - same_len);
@@ -2877,14 +3044,14 @@ static int write_entries(git_index *index, git_filebuf *file)
last = "";
git_vector_foreach(entries, i, entry) {
- if ((error = write_disk_entry(file, entry, last)) < 0)
+ if ((error = write_disk_entry(index, file, entry, last)) < 0)
break;
if (index->version >= INDEX_VERSION_NUMBER_COMP)
last = entry->path;
}
done:
- git_vector_free(&case_sorted);
+ git_vector_dispose(&case_sorted);
return error;
}
@@ -2955,8 +3122,9 @@ static int write_name_extension(git_index *index, git_filebuf *file)
return error;
}
-static int create_reuc_extension_data(git_str *reuc_buf, git_index_reuc_entry *reuc)
+static int create_reuc_extension_data(git_str *reuc_buf, git_index *index, git_index_reuc_entry *reuc)
{
+ size_t oid_size = git_oid_size(index->oid_type);
int i;
int error = 0;
@@ -2970,7 +3138,7 @@ static int create_reuc_extension_data(git_str *reuc_buf, git_index_reuc_entry *r
}
for (i = 0; i < 3; i++) {
- if (reuc->mode[i] && (error = git_str_put(reuc_buf, (char *)&reuc->oid[i].id, GIT_OID_SHA1_SIZE)) < 0)
+ if (reuc->mode[i] && (error = git_str_put(reuc_buf, (char *)&reuc->oid[i].id, oid_size)) < 0)
return error;
}
@@ -2987,7 +3155,7 @@ static int write_reuc_extension(git_index *index, git_filebuf *file)
int error = 0;
git_vector_foreach(out, i, reuc) {
- if ((error = create_reuc_extension_data(&reuc_buf, reuc)) < 0)
+ if ((error = create_reuc_extension_data(&reuc_buf, index, reuc)) < 0)
goto done;
}
@@ -3036,7 +3204,7 @@ static void clear_uptodate(git_index *index)
}
static int write_index(
- unsigned char checksum[GIT_HASH_SHA1_SIZE],
+ unsigned char checksum[GIT_HASH_MAX_SIZE],
size_t *checksum_size,
git_index *index,
git_filebuf *file)
@@ -3048,7 +3216,9 @@ static int write_index(
GIT_ASSERT_ARG(index);
GIT_ASSERT_ARG(file);
- *checksum_size = GIT_HASH_SHA1_SIZE;
+ GIT_ASSERT(index->oid_type);
+
+ *checksum_size = git_hash_size(git_oid_algorithm(index->oid_type));
if (index->version <= INDEX_VERSION_NUMBER_EXT) {
is_extended = is_index_extended(index);
@@ -3157,14 +3327,11 @@ int git_index_read_tree(git_index *index, const git_tree *tree)
{
int error = 0;
git_vector entries = GIT_VECTOR_INIT;
- git_idxmap *entries_map;
+ git_index_entrymap entries_map = GIT_INDEX_ENTRYMAP_INIT;
read_tree_data data;
size_t i;
git_index_entry *e;
- if (git_idxmap_new(&entries_map) < 0)
- return -1;
-
git_vector_set_cmp(&entries, index->entries._cmp); /* match sort */
data.index = index;
@@ -3180,11 +3347,11 @@ int git_index_read_tree(git_index *index, const git_tree *tree)
if ((error = git_tree_walk(tree, GIT_TREEWALK_POST, read_tree_cb, &data)) < 0)
goto cleanup;
- if ((error = index_map_resize(entries_map, entries.length, index->ignore_case)) < 0)
+ if ((error = git_index_entrymap_resize(&entries_map, entries.length)) < 0)
goto cleanup;
git_vector_foreach(&entries, i, e) {
- if ((error = index_map_set(entries_map, e, index->ignore_case)) < 0) {
+ if ((error = git_index_entrymap_put(&entries_map, e)) < 0) {
git_error_set(GIT_ERROR_INDEX, "failed to insert entry into map");
return error;
}
@@ -3194,22 +3361,22 @@ int git_index_read_tree(git_index *index, const git_tree *tree)
git_vector_sort(&entries);
- if ((error = git_index_clear(index)) < 0) {
- /* well, this isn't good */;
- } else {
- git_vector_swap(&entries, &index->entries);
- entries_map = git_atomic_swap(index->entries_map, entries_map);
- }
+ if ((error = git_index_clear(index)) < 0)
+ goto cleanup;
+
+ git_vector_swap(&entries, &index->entries);
+ git_index_entrymap_swap(&entries_map, &index->entries_map);
index->dirty = 1;
cleanup:
- git_vector_free(&entries);
- git_idxmap_free(entries_map);
+ git_vector_dispose(&entries);
+ git_index_entrymap_dispose(&entries_map);
+
if (error < 0)
return error;
- error = git_tree_cache_read_tree(&index->tree, tree, &index->tree_pool);
+ error = git_tree_cache_read_tree(&index->tree, tree, index->oid_type, &index->tree_pool);
return error;
}
@@ -3221,7 +3388,7 @@ static int git_index_read_iterator(
{
git_vector new_entries = GIT_VECTOR_INIT,
remove_entries = GIT_VECTOR_INIT;
- git_idxmap *new_entries_map = NULL;
+ git_index_entrymap new_entries_map = GIT_INDEX_ENTRYMAP_INIT;
git_iterator *index_iterator = NULL;
git_iterator_options opts = GIT_ITERATOR_OPTIONS_INIT;
const git_index_entry *old_entry, *new_entry;
@@ -3232,12 +3399,11 @@ static int git_index_read_iterator(
GIT_ASSERT((new_iterator->flags & GIT_ITERATOR_DONT_IGNORE_CASE));
if ((error = git_vector_init(&new_entries, new_length_hint, index->entries._cmp)) < 0 ||
- (error = git_vector_init(&remove_entries, index->entries.length, NULL)) < 0 ||
- (error = git_idxmap_new(&new_entries_map)) < 0)
+ (error = git_vector_init(&remove_entries, index->entries.length, NULL)) < 0)
goto done;
- if (new_length_hint && (error = index_map_resize(new_entries_map, new_length_hint,
- index->ignore_case)) < 0)
+ if (new_length_hint &&
+ (error = git_index_entrymap_resize(&new_entries_map, new_length_hint)) < 0)
goto done;
opts.flags = GIT_ITERATOR_DONT_IGNORE_CASE |
@@ -3302,8 +3468,7 @@ static int git_index_read_iterator(
if (add_entry) {
if ((error = git_vector_insert(&new_entries, add_entry)) == 0)
- error = index_map_set(new_entries_map, add_entry,
- index->ignore_case);
+ error = git_index_entrymap_put(&new_entries_map, add_entry);
}
if (remove_entry && error >= 0)
@@ -3332,7 +3497,7 @@ static int git_index_read_iterator(
goto done;
git_vector_swap(&new_entries, &index->entries);
- new_entries_map = git_atomic_swap(index->entries_map, new_entries_map);
+ git_index_entrymap_swap(&index->entries_map, &new_entries_map);
git_vector_foreach(&remove_entries, i, entry) {
if (index->tree)
@@ -3347,9 +3512,9 @@ static int git_index_read_iterator(
error = 0;
done:
- git_idxmap_free(new_entries_map);
- git_vector_free(&new_entries);
- git_vector_free(&remove_entries);
+ git_index_entrymap_dispose(&new_entries_map);
+ git_vector_dispose(&new_entries);
+ git_vector_dispose(&remove_entries);
git_iterator_free(index_iterator);
return error;
}
@@ -3397,7 +3562,6 @@ int git_index_add_all(
{
int error;
git_repository *repo;
- git_iterator *wditer = NULL;
git_pathspec ps;
bool no_fnmatch = (flags & GIT_INDEX_ADD_DISABLE_PATHSPEC_MATCH) != 0;
@@ -3423,7 +3587,6 @@ int git_index_add_all(
git_error_set_after_callback(error);
cleanup:
- git_iterator_free(wditer);
git_pathspec__clear(&ps);
return error;
@@ -3511,7 +3674,8 @@ static int index_apply_to_wd_diff(git_index *index, int action, const git_strarr
GIT_DIFF_RECURSE_UNTRACKED_DIRS;
if (flags == GIT_INDEX_ADD_FORCE)
- opts.flags |= GIT_DIFF_INCLUDE_IGNORED;
+ opts.flags |= GIT_DIFF_INCLUDE_IGNORED |
+ GIT_DIFF_RECURSE_IGNORED_DIRS;
}
if ((error = git_diff_index_to_workdir(&diff, repo, index, &opts)) < 0)
@@ -3651,7 +3815,7 @@ int git_index_snapshot_new(git_vector *snap, git_index *index)
void git_index_snapshot_release(git_vector *snap, git_index *index)
{
- git_vector_free(snap);
+ git_vector_dispose(snap);
git_atomic32_dec(&index->readers);
@@ -3669,19 +3833,23 @@ int git_indexwriter_init(
git_indexwriter *writer,
git_index *index)
{
- int error;
+ int filebuf_hash, error;
GIT_REFCOUNT_INC(index);
writer->index = index;
+ filebuf_hash = git_filebuf_hash_flags(git_oid_algorithm(index->oid_type));
+ GIT_ASSERT(filebuf_hash);
+
if (!index->index_file_path)
return create_index_error(-1,
"failed to write index: The index is in-memory only");
- if ((error = git_filebuf_open(
- &writer->file, index->index_file_path, GIT_FILEBUF_HASH_CONTENTS, GIT_INDEX_FILE_MODE)) < 0) {
-
+ if ((error = git_filebuf_open(&writer->file,
+ index->index_file_path,
+ git_filebuf_hash_flags(filebuf_hash),
+ GIT_INDEX_FILE_MODE)) < 0) {
if (error == GIT_ELOCKED)
git_error_set(GIT_ERROR_INDEX, "the index is locked; this might be due to a concurrent or crashed process");
@@ -3713,7 +3881,7 @@ int git_indexwriter_init_for_operation(
int git_indexwriter_commit(git_indexwriter *writer)
{
- unsigned char checksum[GIT_HASH_SHA1_SIZE];
+ unsigned char checksum[GIT_HASH_MAX_SIZE];
size_t checksum_size;
int error;
diff --git a/src/libgit2/index.h b/src/libgit2/index.h
index 71bb096f738..588fe434adf 100644
--- a/src/libgit2/index.h
+++ b/src/libgit2/index.h
@@ -12,14 +12,18 @@
#include "futils.h"
#include "filebuf.h"
#include "vector.h"
-#include "idxmap.h"
#include "tree-cache.h"
+#include "index_map.h"
#include "git2/odb.h"
#include "git2/index.h"
#define GIT_INDEX_FILE "index"
#define GIT_INDEX_FILE_MODE 0666
+/* Helper to create index options based on repository options */
+#define GIT_INDEX_OPTIONS_FOR_REPO(r) \
+ { GIT_INDEX_OPTIONS_VERSION, r ? r->oid_type : 0 }
+
extern bool git_index__enforce_unsaved_safety;
struct git_index {
@@ -27,14 +31,16 @@ struct git_index {
char *index_file_path;
git_futils_filestamp stamp;
- unsigned char checksum[GIT_HASH_SHA1_SIZE];
+ unsigned char checksum[GIT_HASH_MAX_SIZE];
git_vector entries;
- git_idxmap *entries_map;
+ git_index_entrymap entries_map;
git_vector deleted; /* deleted entries if readers > 0 */
git_atomic32 readers; /* number of active iterators */
+ git_oid_t oid_type;
+
unsigned int on_disk:1;
unsigned int ignore_case:1;
unsigned int distrust_filemode:1;
@@ -83,7 +89,7 @@ GIT_INLINE(bool) git_index_time_eq(const git_index_time *one, const git_index_ti
if (one->seconds != two->seconds)
return false;
-#ifdef GIT_USE_NSEC
+#ifdef GIT_NSEC
if (one->nanoseconds != two->nanoseconds)
return false;
#endif
@@ -104,7 +110,7 @@ GIT_INLINE(bool) git_index_entry_newer_than_index(
return false;
/* If the timestamp is the same or newer than the index, it's racy */
-#if defined(GIT_USE_NSEC)
+#if defined(GIT_NSEC)
if ((int32_t)index->stamp.mtime.tv_sec < entry->mtime.seconds)
return true;
else if ((int32_t)index->stamp.mtime.tv_sec > entry->mtime.seconds)
@@ -191,4 +197,19 @@ extern int git_indexwriter_commit(git_indexwriter *writer);
*/
extern void git_indexwriter_cleanup(git_indexwriter *writer);
+/* SHA256 support */
+
+#ifndef GIT_EXPERIMENTAL_SHA256
+
+int git_index_open_ext(
+ git_index **index_out,
+ const char *index_path,
+ const git_index_options *opts);
+
+GIT_EXTERN(int) git_index_new_ext(
+ git_index **index_out,
+ const git_index_options *opts);
+
+#endif
+
#endif
diff --git a/src/libgit2/index_map.c b/src/libgit2/index_map.c
new file mode 100644
index 00000000000..4c50ca7ab63
--- /dev/null
+++ b/src/libgit2/index_map.c
@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include "common.h"
+#include "hashmap.h"
+#include "index_map.h"
+
+typedef git_index_entrymap git_index_entrymap_default;
+typedef git_index_entrymap git_index_entrymap_icase;
+
+/* This is __ac_X31_hash_string but with tolower and it takes the entry's stage into account */
+GIT_INLINE(uint32_t) git_index_entrymap_hash(const git_index_entry *e)
+{
+ const char *s = e->path;
+ uint32_t h = (uint32_t)git__tolower(*s);
+ if (h) {
+ for (++s ; *s; ++s)
+ h = (h << 5) - h + (uint32_t)git__tolower(*s);
+ }
+ return h + GIT_INDEX_ENTRY_STAGE(e);
+}
+
+#define git_index_entrymap_equal_default(a, b) (GIT_INDEX_ENTRY_STAGE(a) == GIT_INDEX_ENTRY_STAGE(b) && strcmp(a->path, b->path) == 0)
+#define git_index_entrymap_equal_icase(a, b) (GIT_INDEX_ENTRY_STAGE(a) == GIT_INDEX_ENTRY_STAGE(b) && strcasecmp(a->path, b->path) == 0)
+
+GIT_HASHMAP_FUNCTIONS(git_index_entrymap_default, GIT_HASHMAP_INLINE, git_index_entry *, git_index_entry *, git_index_entrymap_hash, git_index_entrymap_equal_default)
+GIT_HASHMAP_FUNCTIONS(git_index_entrymap_icase, GIT_HASHMAP_INLINE, git_index_entry *, git_index_entry *, git_index_entrymap_hash, git_index_entrymap_equal_icase)
+
+int git_index_entrymap_put(git_index_entrymap *map, git_index_entry *e)
+{
+ if (map->ignore_case)
+ return git_index_entrymap_icase_put((git_index_entrymap_icase *)map, e, e);
+ else
+ return git_index_entrymap_default_put((git_index_entrymap_default *)map, e, e);
+}
+
+int git_index_entrymap_get(git_index_entry **out, git_index_entrymap *map, git_index_entry *e)
+{
+ if (map->ignore_case)
+ return git_index_entrymap_icase_get(out, (git_index_entrymap_icase *)map, e);
+ else
+ return git_index_entrymap_default_get(out, (git_index_entrymap_default *)map, e);
+}
+
+int git_index_entrymap_remove(git_index_entrymap *map, git_index_entry *e)
+{
+ if (map->ignore_case)
+ return git_index_entrymap_icase_remove((git_index_entrymap_icase *)map, e);
+ else
+ return git_index_entrymap_default_remove((git_index_entrymap_default *)map, e);
+}
+
+int git_index_entrymap_resize(git_index_entrymap *map, size_t count)
+{
+ if (count > UINT32_MAX) {
+ git_error_set(GIT_ERROR_INDEX, "index map is out of bounds");
+ return -1;
+ }
+
+ if (map->ignore_case)
+ return git_index_entrymap_icase__resize((git_index_entrymap_icase *)map, (uint32_t)count);
+ else
+ return git_index_entrymap_default__resize((git_index_entrymap_default *)map, (uint32_t)count);
+}
+
+void git_index_entrymap_swap(git_index_entrymap *a, git_index_entrymap *b)
+{
+ git_index_entrymap t;
+
+ if (a != b) {
+ memcpy(&t, a, sizeof(t));
+ memcpy(a, b, sizeof(t));
+ memcpy(b, &t, sizeof(t));
+ }
+}
+
+void git_index_entrymap_clear(git_index_entrymap *map)
+{
+ if (map->ignore_case)
+ git_index_entrymap_icase_clear((git_index_entrymap_icase *)map);
+ else
+ git_index_entrymap_default_clear((git_index_entrymap_default *)map);
+}
+
+void git_index_entrymap_dispose(git_index_entrymap *map)
+{
+ if (map->ignore_case)
+ git_index_entrymap_icase_dispose((git_index_entrymap_icase *)map);
+ else
+ git_index_entrymap_default_dispose((git_index_entrymap_default *)map);
+}
diff --git a/src/libgit2/index_map.h b/src/libgit2/index_map.h
new file mode 100644
index 00000000000..177a3f196c6
--- /dev/null
+++ b/src/libgit2/index_map.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_index_map_h__
+#define INCLUDE_index_map_h__
+
+#include "common.h"
+#include "hashmap.h"
+
+typedef struct {
+ unsigned int ignore_case;
+ GIT_HASHMAP_STRUCT_MEMBERS(git_index_entry *, git_index_entry *)
+} git_index_entrymap;
+
+#define GIT_INDEX_ENTRYMAP_INIT { 0 }
+
+extern int git_index_entrymap_get(git_index_entry **out, git_index_entrymap *map, git_index_entry *e);
+extern int git_index_entrymap_put(git_index_entrymap *map, git_index_entry *e);
+extern int git_index_entrymap_remove(git_index_entrymap *map, git_index_entry *e);
+extern int git_index_entrymap_resize(git_index_entrymap *map, size_t count);
+extern void git_index_entrymap_swap(git_index_entrymap *a, git_index_entrymap *b);
+extern void git_index_entrymap_clear(git_index_entrymap *map);
+extern void git_index_entrymap_dispose(git_index_entrymap *map);
+
+#endif
diff --git a/src/libgit2/indexer.c b/src/libgit2/indexer.c
index fa55fb5eafe..cdd2b243134 100644
--- a/src/libgit2/indexer.c
+++ b/src/libgit2/indexer.c
@@ -20,14 +20,16 @@
#include "filebuf.h"
#include "oid.h"
#include "oidarray.h"
-#include "oidmap.h"
#include "zstream.h"
#include "object.h"
+#include "hashmap_oid.h"
size_t git_indexer__max_objects = UINT32_MAX;
#define UINT31_MAX (0x7FFFFFFF)
+GIT_HASHMAP_OID_SETUP(git_indexer_oidmap, git_oid *);
+
struct entry {
git_oid oid;
uint32_t crc;
@@ -63,7 +65,7 @@ struct git_indexer {
char objbuf[8*1024];
/* OIDs referenced from pack objects. Used for verification. */
- git_oidmap *expected_oids;
+ git_indexer_oidmap expected_oids;
/* Needed to look up objects which we want to inject to fix a thin pack */
git_odb *odb;
@@ -169,9 +171,12 @@ static int indexer_new(
if (in_opts)
memcpy(&opts, in_opts, sizeof(opts));
+ if (oid_type)
+ GIT_ASSERT_ARG(git_oid_type_is_valid(oid_type));
+
idx = git__calloc(1, sizeof(git_indexer));
GIT_ERROR_CHECK_ALLOC(idx);
- idx->oid_type = oid_type;
+ idx->oid_type = oid_type ? oid_type : GIT_OID_DEFAULT;
idx->odb = odb;
idx->progress_cb = opts.progress_cb;
idx->progress_payload = opts.progress_cb_payload;
@@ -181,8 +186,7 @@ static int indexer_new(
checksum_type = indexer_hash_algorithm(idx);
if ((error = git_hash_ctx_init(&idx->hash_ctx, checksum_type)) < 0 ||
- (error = git_hash_ctx_init(&idx->trailer, checksum_type)) < 0 ||
- (error = git_oidmap_new(&idx->expected_oids)) < 0)
+ (error = git_hash_ctx_init(&idx->trailer, checksum_type)) < 0)
goto cleanup;
idx->do_verify = opts.verify;
@@ -232,13 +236,12 @@ static int indexer_new(
int git_indexer_new(
git_indexer **out,
const char *prefix,
- git_oid_t oid_type,
git_indexer_options *opts)
{
return indexer_new(
out,
prefix,
- oid_type,
+ opts ? opts->oid_type : 0,
opts ? opts->mode : 0,
opts ? opts->odb : NULL,
opts);
@@ -316,9 +319,9 @@ static int advance_delta_offset(git_indexer *idx, git_object_t type)
{
git_mwindow *w = NULL;
- GIT_ASSERT_ARG(type == GIT_OBJECT_REF_DELTA || type == GIT_OBJECT_OFS_DELTA);
+ GIT_ASSERT_ARG(type == GIT_PACKFILE_REF_DELTA || type == GIT_PACKFILE_OFS_DELTA);
- if (type == GIT_OBJECT_REF_DELTA) {
+ if (type == GIT_PACKFILE_REF_DELTA) {
idx->off += git_oid_size(idx->oid_type);
} else {
off64_t base_off;
@@ -380,12 +383,12 @@ static int add_expected_oid(git_indexer *idx, const git_oid *oid)
* not have to expect it.
*/
if ((!idx->odb || !git_odb_exists(idx->odb, oid)) &&
- !git_oidmap_exists(idx->pack->idx_cache, oid) &&
- !git_oidmap_exists(idx->expected_oids, oid)) {
+ !git_pack_oidmap_contains(&idx->pack->idx_cache, oid) &&
+ !git_indexer_oidmap_contains(&idx->expected_oids, oid)) {
git_oid *dup = git__malloc(sizeof(*oid));
GIT_ERROR_CHECK_ALLOC(dup);
git_oid_cpy(dup, oid);
- return git_oidmap_set(idx->expected_oids, dup, dup);
+ return git_indexer_oidmap_put(&idx->expected_oids, dup, dup);
}
return 0;
@@ -412,8 +415,8 @@ static int check_object_connectivity(git_indexer *idx, const git_rawobj *obj)
goto out;
}
- if ((expected = git_oidmap_get(idx->expected_oids, &object->cached.oid)) != NULL) {
- git_oidmap_delete(idx->expected_oids, &object->cached.oid);
+ if (git_indexer_oidmap_get(&expected, &idx->expected_oids, &object->cached.oid) == 0) {
+ git_indexer_oidmap_remove(&idx->expected_oids, &object->cached.oid);
git__free(expected);
}
@@ -518,13 +521,19 @@ static int store_object(git_indexer *idx)
git_oid_cpy(&pentry->id, &oid);
pentry->offset = entry_start;
- if (git_oidmap_exists(idx->pack->idx_cache, &pentry->id)) {
- git_error_set(GIT_ERROR_INDEXER, "duplicate object %s found in pack", git_oid_tostr_s(&pentry->id));
+ if (git_pack_oidmap_contains(&idx->pack->idx_cache, &pentry->id)) {
+ const char *idstr = git_oid_tostr_s(&pentry->id);
+
+ if (!idstr)
+ git_error_set(GIT_ERROR_INDEXER, "failed to parse object id");
+ else
+ git_error_set(GIT_ERROR_INDEXER, "duplicate object %s found in pack", idstr);
+
git__free(pentry);
goto on_error;
}
- if ((error = git_oidmap_set(idx->pack->idx_cache, &pentry->id, pentry)) < 0) {
+ if ((error = git_pack_oidmap_put(&idx->pack->idx_cache, &pentry->id, pentry)) < 0) {
git__free(pentry);
git_error_set_oom();
goto on_error;
@@ -553,7 +562,7 @@ static int store_object(git_indexer *idx)
GIT_INLINE(bool) has_entry(git_indexer *idx, git_oid *id)
{
- return git_oidmap_exists(idx->pack->idx_cache, id);
+ return git_pack_oidmap_contains(&idx->pack->idx_cache, id);
}
static int save_entry(git_indexer *idx, struct entry *entry, struct git_pack_entry *pentry, off64_t entry_start)
@@ -569,8 +578,8 @@ static int save_entry(git_indexer *idx, struct entry *entry, struct git_pack_ent
pentry->offset = entry_start;
- if (git_oidmap_exists(idx->pack->idx_cache, &pentry->id) ||
- git_oidmap_set(idx->pack->idx_cache, &pentry->id, pentry) < 0) {
+ if (git_pack_oidmap_contains(&idx->pack->idx_cache, &pentry->id) ||
+ git_pack_oidmap_put(&idx->pack->idx_cache, &pentry->id, pentry) < 0) {
git_error_set(GIT_ERROR_INDEXER, "cannot insert object into pack");
return -1;
}
@@ -804,7 +813,7 @@ static int read_stream_object(git_indexer *idx, git_indexer_progress *stats)
git_hash_init(&idx->hash_ctx);
git_str_clear(&idx->entry_data);
- if (type == GIT_OBJECT_REF_DELTA || type == GIT_OBJECT_OFS_DELTA) {
+ if (type == GIT_PACKFILE_REF_DELTA || type == GIT_PACKFILE_OFS_DELTA) {
error = advance_delta_offset(idx, type);
if (error == GIT_EBUFS) {
idx->off = entry_start;
@@ -905,9 +914,6 @@ int git_indexer_append(git_indexer *idx, const void *data, size_t size, git_inde
return -1;
}
- if (git_oidmap_new(&idx->pack->idx_cache) < 0)
- return -1;
-
idx->pack->has_cache = 1;
if (git_vector_init(&idx->objects, total_objects, objects_cmp) < 0)
return -1;
@@ -1088,7 +1094,7 @@ static int fix_thin_pack(git_indexer *idx, git_indexer_progress *stats)
if (error < 0)
return error;
- if (type == GIT_OBJECT_REF_DELTA) {
+ if (type == GIT_PACKFILE_REF_DELTA) {
found_ref_delta = 1;
break;
}
@@ -1106,7 +1112,7 @@ static int fix_thin_pack(git_indexer *idx, git_indexer_progress *stats)
return -1;
}
- git_oid__fromraw(&base, base_info, idx->oid_type);
+ git_oid_from_raw(&base, base_info, idx->oid_type);
git_mwindow_close(&w);
if (has_entry(idx, &base))
@@ -1232,6 +1238,7 @@ int git_indexer_commit(git_indexer *idx, git_indexer_progress *stats)
git_filebuf index_file = {0};
void *packfile_trailer;
size_t checksum_size;
+ int filebuf_hash;
bool mismatch;
if (!idx->parsed_header) {
@@ -1240,6 +1247,7 @@ int git_indexer_commit(git_indexer *idx, git_indexer_progress *stats)
}
checksum_size = git_hash_size(indexer_hash_algorithm(idx));
+ filebuf_hash = git_filebuf_hash_flags(indexer_hash_algorithm(idx));
GIT_ASSERT(checksum_size);
/* Test for this before resolve_deltas(), as it plays with idx->off */
@@ -1293,9 +1301,9 @@ int git_indexer_commit(git_indexer *idx, git_indexer_progress *stats)
* bail out due to an incomplete and thus corrupt
* packfile.
*/
- if (git_oidmap_size(idx->expected_oids) > 0) {
+ if (git_indexer_oidmap_size(&idx->expected_oids) > 0) {
git_error_set(GIT_ERROR_INDEXER, "packfile is missing %"PRIuZ" objects",
- git_oidmap_size(idx->expected_oids));
+ (size_t)git_indexer_oidmap_size(&idx->expected_oids));
return -1;
}
@@ -1314,8 +1322,7 @@ int git_indexer_commit(git_indexer *idx, git_indexer_progress *stats)
return -1;
if (git_filebuf_open(&index_file, filename.ptr,
- GIT_FILEBUF_HASH_CONTENTS |
- (idx->do_fsync ? GIT_FILEBUF_FSYNC : 0),
+ filebuf_hash | (idx->do_fsync ? GIT_FILEBUF_FSYNC : 0),
idx->mode) < 0)
goto on_error;
@@ -1439,9 +1446,9 @@ int git_indexer_commit(git_indexer *idx, git_indexer_progress *stats)
void git_indexer_free(git_indexer *idx)
{
- const git_oid *key;
- git_oid *value;
- size_t iter;
+ struct git_pack_entry *pentry;
+ git_oid *id;
+ git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
if (idx == NULL)
return;
@@ -1449,28 +1456,24 @@ void git_indexer_free(git_indexer *idx)
if (idx->have_stream)
git_packfile_stream_dispose(&idx->stream);
- git_vector_free_deep(&idx->objects);
+ git_vector_dispose_deep(&idx->objects);
- if (idx->pack->idx_cache) {
- struct git_pack_entry *pentry;
- git_oidmap_foreach_value(idx->pack->idx_cache, pentry, {
- git__free(pentry);
- });
+ while (git_pack_oidmap_iterate(&iter, NULL, &pentry, &idx->pack->idx_cache) == 0)
+ git__free(pentry);
- git_oidmap_free(idx->pack->idx_cache);
- }
+ git_pack_oidmap_dispose(&idx->pack->idx_cache);
- git_vector_free_deep(&idx->deltas);
+ git_vector_dispose_deep(&idx->deltas);
git_packfile_free(idx->pack, !idx->pack_committed);
- iter = 0;
- while (git_oidmap_iterate((void **) &value, idx->expected_oids, &iter, &key) == 0)
- git__free(value);
+ iter = GIT_HASHMAP_ITER_INIT;
+ while (git_indexer_oidmap_iterate(&iter, NULL, &id, &idx->expected_oids) == 0)
+ git__free(id);
git_hash_ctx_cleanup(&idx->trailer);
git_hash_ctx_cleanup(&idx->hash_ctx);
git_str_dispose(&idx->entry_data);
- git_oidmap_free(idx->expected_oids);
+ git_indexer_oidmap_dispose(&idx->expected_oids);
git__free(idx);
}
diff --git a/src/libgit2/iterator.c b/src/libgit2/iterator.c
index 1ee8e25f505..4eca11f7cd1 100644
--- a/src/libgit2/iterator.c
+++ b/src/libgit2/iterator.c
@@ -26,9 +26,10 @@
#define iterator__ignore_dot_git(I) iterator__flag(I,IGNORE_DOT_GIT)
#define iterator__descend_symlinks(I) iterator__flag(I,DESCEND_SYMLINKS)
-
static void iterator_set_ignore_case(git_iterator *iter, bool ignore_case)
{
+ int (*vector_cmp)(const void *a, const void *b);
+
if (ignore_case)
iter->flags |= GIT_ITERATOR_IGNORE_CASE;
else
@@ -39,7 +40,9 @@ static void iterator_set_ignore_case(git_iterator *iter, bool ignore_case)
iter->prefixcomp = ignore_case ? git__prefixcmp_icase : git__prefixcmp;
iter->entry_srch = ignore_case ? git_index_entry_isrch : git_index_entry_srch;
- git_vector_set_cmp(&iter->pathlist, (git_vector_cmp)iter->strcomp);
+ vector_cmp = ignore_case ? git__strcasecmp_cb : git__strcmp_cb;
+
+ git_vector_set_cmp(&iter->pathlist, vector_cmp);
}
static int iterator_range_init(
@@ -299,6 +302,7 @@ typedef enum {
static iterator_pathlist_search_t iterator_pathlist_search(
git_iterator *iter, const char *path, size_t path_len)
{
+ int (*vector_cmp)(const void *a, const void *b);
const char *p;
size_t idx;
int error;
@@ -308,8 +312,10 @@ static iterator_pathlist_search_t iterator_pathlist_search(
git_vector_sort(&iter->pathlist);
- error = git_vector_bsearch2(&idx, &iter->pathlist,
- (git_vector_cmp)iter->strcomp, path);
+ vector_cmp = (iter->flags & GIT_ITERATOR_IGNORE_CASE) != 0 ?
+ git__strcasecmp_cb : git__strcmp_cb;
+
+ error = git_vector_bsearch2(&idx, &iter->pathlist, vector_cmp, path);
/* the given path was found in the pathlist. since the pathlist only
* matches directories when they're suffixed with a '/', analyze the
@@ -690,7 +696,7 @@ static int tree_iterator_frame_pop(tree_iterator *iter)
frame = git_array_pop(iter->frames);
- git_vector_free(&frame->entries);
+ git_vector_dispose(&frame->entries);
git_tree_free(frame->tree);
do {
@@ -703,7 +709,7 @@ static int tree_iterator_frame_pop(tree_iterator *iter)
git_vector_foreach(&frame->similar_trees, i, tree)
git_tree_free(tree);
- git_vector_free(&frame->similar_trees);
+ git_vector_dispose(&frame->similar_trees);
git_str_dispose(&frame->path);
@@ -1036,6 +1042,8 @@ typedef struct {
git_index *index;
git_vector index_snapshot;
+ git_oid_t oid_type;
+
git_array_t(filesystem_iterator_frame) frames;
git_ignores ignores;
@@ -1271,7 +1279,7 @@ static int filesystem_iterator_entry_hash(
int error;
if (S_ISDIR(entry->st.st_mode)) {
- memset(&entry->id, 0, GIT_OID_SHA1_SIZE);
+ memset(&entry->id, 0, git_oid_size(iter->oid_type));
return 0;
}
@@ -1281,7 +1289,7 @@ static int filesystem_iterator_entry_hash(
if (!(error = git_str_joinpath(&fullpath, iter->root, entry->path)) &&
!(error = git_path_validate_str_length(iter->base.repo, &fullpath)))
- error = git_odb__hashfile(&entry->id, fullpath.ptr, GIT_OBJECT_BLOB, GIT_OID_SHA1);
+ error = git_odb__hashfile(&entry->id, fullpath.ptr, GIT_OBJECT_BLOB, iter->oid_type);
git_str_dispose(&fullpath);
return error;
@@ -1493,7 +1501,7 @@ GIT_INLINE(int) filesystem_iterator_frame_pop(filesystem_iterator *iter)
filesystem_iterator_frame_pop_ignores(iter);
git_pool_clear(&frame->entry_pool);
- git_vector_free(&frame->entries);
+ git_vector_dispose(&frame->entries);
return 0;
}
@@ -1512,7 +1520,7 @@ static void filesystem_iterator_set_current(
iter->entry.ctime.seconds = (int32_t)entry->st.st_ctime;
iter->entry.mtime.seconds = (int32_t)entry->st.st_mtime;
-#if defined(GIT_USE_NSEC)
+#if defined(GIT_NSEC)
iter->entry.ctime.nanoseconds = entry->st.st_ctime_nsec;
iter->entry.mtime.nanoseconds = entry->st.st_mtime_nsec;
#else
@@ -1530,7 +1538,7 @@ static void filesystem_iterator_set_current(
if (iter->base.flags & GIT_ITERATOR_INCLUDE_HASH)
git_oid_cpy(&iter->entry.id, &entry->id);
else
- git_oid_clear(&iter->entry.id, GIT_OID_SHA1);
+ git_oid_clear(&iter->entry.id, iter->oid_type);
iter->entry.path = entry->path;
@@ -1975,6 +1983,8 @@ static int iterator_for_filesystem(
(iterator__flag(&iter->base, PRECOMPOSE_UNICODE) ?
GIT_FS_PATH_DIR_PRECOMPOSE_UNICODE : 0);
+ iter->oid_type = options->oid_type;
+
if ((error = filesystem_iterator_init(iter)) < 0)
goto on_error;
@@ -1989,10 +1999,15 @@ static int iterator_for_filesystem(
int git_iterator_for_filesystem(
git_iterator **out,
const char *root,
- git_iterator_options *options)
+ git_iterator_options *given_opts)
{
+ git_iterator_options options = GIT_ITERATOR_OPTIONS_INIT;
+
+ if (given_opts)
+ memcpy(&options, given_opts, sizeof(git_iterator_options));
+
return iterator_for_filesystem(out,
- NULL, root, NULL, NULL, GIT_ITERATOR_FS, options);
+ NULL, root, NULL, NULL, GIT_ITERATOR_FS, &options);
}
int git_iterator_for_workdir_ext(
@@ -2019,6 +2034,12 @@ int git_iterator_for_workdir_ext(
options.flags |= GIT_ITERATOR_HONOR_IGNORES |
GIT_ITERATOR_IGNORE_DOT_GIT;
+ if (!options.oid_type)
+ options.oid_type = repo->oid_type;
+ else if (options.oid_type != repo->oid_type)
+ git_error_set(GIT_ERROR_INVALID,
+ "specified object ID type does not match repository object ID type");
+
return iterator_for_filesystem(out,
repo, repo_workdir, index, tree, GIT_ITERATOR_WORKDIR, &options);
}
@@ -2315,7 +2336,7 @@ void git_iterator_free(git_iterator *iter)
iter->cb->free(iter);
- git_vector_free(&iter->pathlist);
+ git_vector_dispose(&iter->pathlist);
git__free(iter->start);
git__free(iter->end);
diff --git a/src/libgit2/iterator.h b/src/libgit2/iterator.h
index 6bb8489d035..7963ce7e22c 100644
--- a/src/libgit2/iterator.h
+++ b/src/libgit2/iterator.h
@@ -63,6 +63,9 @@ typedef struct {
/* flags, from above */
unsigned int flags;
+
+ /* oid type - necessary for non-workdir filesystem iterators */
+ git_oid_t oid_type;
} git_iterator_options;
#define GIT_ITERATOR_OPTIONS_INIT {0}
diff --git a/src/libgit2/libgit2.c b/src/libgit2/libgit2.c
index f225122e548..37e0bd012fe 100644
--- a/src/libgit2/libgit2.c
+++ b/src/libgit2/libgit2.c
@@ -5,63 +5,32 @@
* a Linking Exception. For full terms see the included COPYING file.
*/
-#include "libgit2.h"
-
#include
#include "alloc.h"
#include "buf.h"
-#include "cache.h"
#include "common.h"
#include "filter.h"
#include "hash.h"
-#include "index.h"
#include "merge_driver.h"
#include "pool.h"
#include "mwindow.h"
-#include "object.h"
-#include "odb.h"
+#include "oid.h"
#include "rand.h"
-#include "refs.h"
#include "runtime.h"
+#include "settings.h"
#include "sysdir.h"
#include "thread.h"
-#include "threadstate.h"
#include "git2/global.h"
#include "streams/registry.h"
#include "streams/mbedtls.h"
#include "streams/openssl.h"
-#include "transports/smart.h"
-#include "transports/http.h"
-#include "transports/ssh.h"
+#include "streams/socket.h"
+#include "transports/ssh_libssh2.h"
#ifdef GIT_WIN32
# include "win32/w32_leakcheck.h"
#endif
-/* Declarations for tuneable settings */
-extern size_t git_mwindow__window_size;
-extern size_t git_mwindow__mapped_limit;
-extern size_t git_mwindow__file_limit;
-extern size_t git_indexer__max_objects;
-extern bool git_disable_pack_keep_file_checks;
-extern int git_odb__packed_priority;
-extern int git_odb__loose_priority;
-
-char *git__user_agent;
-char *git__ssl_ciphers;
-
-static void libgit2_settings_global_shutdown(void)
-{
- git__free(git__user_agent);
- git__free(git__ssl_ciphers);
- git_repository__free_extensions();
-}
-
-static int git_libgit2_settings_global_init(void)
-{
- return git_runtime_shutdown_register(libgit2_settings_global_shutdown);
-}
-
int git_libgit2_init(void)
{
static git_runtime_init_fn init_fns[] = {
@@ -69,30 +38,27 @@ int git_libgit2_init(void)
git_win32_leakcheck_global_init,
#endif
git_allocator_global_init,
- git_threadstate_global_init,
+ git_error_global_init,
git_threads_global_init,
+ git_oid_global_init,
git_rand_global_init,
git_hash_global_init,
git_sysdir_global_init,
git_filter_global_init,
git_merge_driver_global_init,
- git_transport_ssh_global_init,
+ git_transport_ssh_libssh2_global_init,
git_stream_registry_global_init,
+ git_socket_stream_global_init,
git_openssl_stream_global_init,
git_mbedtls_stream_global_init,
git_mwindow_global_init,
git_pool_global_init,
- git_libgit2_settings_global_init
+ git_settings_global_init
};
return git_runtime_init(init_fns, ARRAY_SIZE(init_fns));
}
-int git_libgit2_init_count(void)
-{
- return git_runtime_init_count();
-}
-
int git_libgit2_shutdown(void)
{
return git_runtime_shutdown();
@@ -100,16 +66,16 @@ int git_libgit2_shutdown(void)
int git_libgit2_version(int *major, int *minor, int *rev)
{
- *major = LIBGIT2_VER_MAJOR;
- *minor = LIBGIT2_VER_MINOR;
- *rev = LIBGIT2_VER_REVISION;
+ *major = LIBGIT2_VERSION_MAJOR;
+ *minor = LIBGIT2_VERSION_MINOR;
+ *rev = LIBGIT2_VERSION_REVISION;
return 0;
}
const char *git_libgit2_prerelease(void)
{
- return LIBGIT2_VER_PRERELEASE;
+ return LIBGIT2_VERSION_PRERELEASE;
}
int git_libgit2_features(void)
@@ -121,324 +87,192 @@ int git_libgit2_features(void)
#ifdef GIT_HTTPS
| GIT_FEATURE_HTTPS
#endif
-#if defined(GIT_SSH)
+#ifdef GIT_SSH
| GIT_FEATURE_SSH
#endif
-#if defined(GIT_USE_NSEC)
+#ifdef GIT_NSEC
| GIT_FEATURE_NSEC
+#endif
+ | GIT_FEATURE_HTTP_PARSER
+ | GIT_FEATURE_REGEX
+#ifdef GIT_I18N_ICONV
+ | GIT_FEATURE_I18N
+#endif
+#if defined(GIT_AUTH_NTLM)
+ | GIT_FEATURE_AUTH_NTLM
+#endif
+#if defined(GIT_AUTH_NEGOTIATE)
+ | GIT_FEATURE_AUTH_NEGOTIATE
+#endif
+ | GIT_FEATURE_COMPRESSION
+ | GIT_FEATURE_SHA1
+#ifdef GIT_EXPERIMENTAL_SHA256
+ | GIT_FEATURE_SHA256
#endif
;
}
-static int config_level_to_sysdir(int *out, int config_level)
-{
- switch (config_level) {
- case GIT_CONFIG_LEVEL_SYSTEM:
- *out = GIT_SYSDIR_SYSTEM;
- return 0;
- case GIT_CONFIG_LEVEL_XDG:
- *out = GIT_SYSDIR_XDG;
- return 0;
- case GIT_CONFIG_LEVEL_GLOBAL:
- *out = GIT_SYSDIR_GLOBAL;
- return 0;
- case GIT_CONFIG_LEVEL_PROGRAMDATA:
- *out = GIT_SYSDIR_PROGRAMDATA;
- return 0;
- default:
- break;
- }
-
- git_error_set(
- GIT_ERROR_INVALID, "invalid config path selector %d", config_level);
- return -1;
-}
-
-const char *git_libgit2__user_agent(void)
-{
- return git__user_agent;
-}
-
-const char *git_libgit2__ssl_ciphers(void)
-{
- return git__ssl_ciphers;
-}
-
-int git_libgit2_opts(int key, ...)
+const char *git_libgit2_feature_backend(git_feature_t feature)
{
- int error = 0;
- va_list ap;
-
- va_start(ap, key);
-
- switch (key) {
- case GIT_OPT_SET_MWINDOW_SIZE:
- git_mwindow__window_size = va_arg(ap, size_t);
- break;
-
- case GIT_OPT_GET_MWINDOW_SIZE:
- *(va_arg(ap, size_t *)) = git_mwindow__window_size;
- break;
-
- case GIT_OPT_SET_MWINDOW_MAPPED_LIMIT:
- git_mwindow__mapped_limit = va_arg(ap, size_t);
- break;
-
- case GIT_OPT_GET_MWINDOW_MAPPED_LIMIT:
- *(va_arg(ap, size_t *)) = git_mwindow__mapped_limit;
- break;
-
- case GIT_OPT_SET_MWINDOW_FILE_LIMIT:
- git_mwindow__file_limit = va_arg(ap, size_t);
- break;
-
- case GIT_OPT_GET_MWINDOW_FILE_LIMIT:
- *(va_arg(ap, size_t *)) = git_mwindow__file_limit;
- break;
-
- case GIT_OPT_GET_SEARCH_PATH:
- {
- int sysdir = va_arg(ap, int);
- git_buf *out = va_arg(ap, git_buf *);
- git_str str = GIT_STR_INIT;
- const git_str *tmp;
- int level;
-
- if ((error = git_buf_tostr(&str, out)) < 0 ||
- (error = config_level_to_sysdir(&level, sysdir)) < 0 ||
- (error = git_sysdir_get(&tmp, level)) < 0 ||
- (error = git_str_put(&str, tmp->ptr, tmp->size)) < 0)
- break;
-
- error = git_buf_fromstr(out, &str);
- }
- break;
-
- case GIT_OPT_SET_SEARCH_PATH:
- {
- int level;
-
- if ((error = config_level_to_sysdir(&level, va_arg(ap, int))) >= 0)
- error = git_sysdir_set(level, va_arg(ap, const char *));
- }
- break;
-
- case GIT_OPT_SET_CACHE_OBJECT_LIMIT:
- {
- git_object_t type = (git_object_t)va_arg(ap, int);
- size_t size = va_arg(ap, size_t);
- error = git_cache_set_max_object_size(type, size);
- break;
- }
-
- case GIT_OPT_SET_CACHE_MAX_SIZE:
- git_cache__max_storage = va_arg(ap, ssize_t);
- break;
-
- case GIT_OPT_ENABLE_CACHING:
- git_cache__enabled = (va_arg(ap, int) != 0);
+ switch (feature) {
+ case GIT_FEATURE_THREADS:
+#if defined(GIT_THREADS_PTHREADS)
+ return "pthread";
+#elif defined(GIT_THREADS_WIN32)
+ return "win32";
+#elif defined(GIT_THREADS)
+ GIT_ASSERT_WITH_RETVAL(!"Unknown threads backend", NULL);
+#endif
break;
- case GIT_OPT_GET_CACHED_MEMORY:
- *(va_arg(ap, ssize_t *)) = git_cache__current_storage.val;
- *(va_arg(ap, ssize_t *)) = git_cache__max_storage;
+ case GIT_FEATURE_HTTPS:
+#if defined(GIT_HTTPS_OPENSSL)
+ return "openssl";
+#elif defined(GIT_HTTPS_OPENSSL_DYNAMIC)
+ return "openssl-dynamic";
+#elif defined(GIT_HTTPS_MBEDTLS)
+ return "mbedtls";
+#elif defined(GIT_HTTPS_SECURETRANSPORT)
+ return "securetransport";
+#elif defined(GIT_HTTPS_SCHANNEL)
+ return "schannel";
+#elif defined(GIT_HTTPS_WINHTTP)
+ return "winhttp";
+#elif defined(GIT_HTTPS)
+ GIT_ASSERT_WITH_RETVAL(!"Unknown HTTPS backend", NULL);
+#endif
break;
- case GIT_OPT_GET_TEMPLATE_PATH:
- {
- git_buf *out = va_arg(ap, git_buf *);
- git_str str = GIT_STR_INIT;
- const git_str *tmp;
-
- if ((error = git_buf_tostr(&str, out)) < 0 ||
- (error = git_sysdir_get(&tmp, GIT_SYSDIR_TEMPLATE)) < 0 ||
- (error = git_str_put(&str, tmp->ptr, tmp->size)) < 0)
- break;
-
- error = git_buf_fromstr(out, &str);
- }
+ case GIT_FEATURE_SSH:
+#if defined(GIT_SSH_EXEC)
+ return "exec";
+#elif defined(GIT_SSH_LIBSSH2)
+ return "libssh2";
+#elif defined(GIT_SSH)
+ GIT_ASSERT_WITH_RETVAL(!"Unknown SSH backend", NULL);
+#endif
break;
- case GIT_OPT_SET_TEMPLATE_PATH:
- error = git_sysdir_set(GIT_SYSDIR_TEMPLATE, va_arg(ap, const char *));
+ case GIT_FEATURE_NSEC:
+#if defined(GIT_NSEC_MTIMESPEC)
+ return "mtimespec";
+#elif defined(GIT_NSEC_MTIM)
+ return "mtim";
+#elif defined(GIT_NSEC_MTIME_NSEC)
+ return "mtime_nsec";
+#elif defined(GIT_NSEC_WIN32)
+ return "win32";
+#elif defined(GIT_NSEC)
+ GIT_ASSERT_WITH_RETVAL(!"Unknown high-resolution time backend", NULL);
+#endif
break;
- case GIT_OPT_SET_SSL_CERT_LOCATIONS:
-#ifdef GIT_OPENSSL
- {
- const char *file = va_arg(ap, const char *);
- const char *path = va_arg(ap, const char *);
- error = git_openssl__set_cert_location(file, path);
- }
-#elif defined(GIT_MBEDTLS)
- {
- const char *file = va_arg(ap, const char *);
- const char *path = va_arg(ap, const char *);
- error = git_mbedtls__set_cert_location(file, path);
- }
-#else
- git_error_set(GIT_ERROR_SSL, "TLS backend doesn't support certificate locations");
- error = -1;
+ case GIT_FEATURE_HTTP_PARSER:
+#if defined(GIT_HTTPPARSER_HTTPPARSER)
+ return "httpparser";
+#elif defined(GIT_HTTPPARSER_LLHTTP)
+ return "llhttp";
+#elif defined(GIT_HTTPPARSER_BUILTIN)
+ return "builtin";
#endif
+ GIT_ASSERT_WITH_RETVAL(!"Unknown HTTP parser backend", NULL);
+ break;
+
+ case GIT_FEATURE_REGEX:
+#if defined(GIT_REGEX_REGCOMP_L)
+ return "regcomp_l";
+#elif defined(GIT_REGEX_REGCOMP)
+ return "regcomp";
+#elif defined(GIT_REGEX_PCRE)
+ return "pcre";
+#elif defined(GIT_REGEX_PCRE2)
+ return "pcre2";
+#elif defined(GIT_REGEX_BUILTIN)
+ return "builtin";
+#endif
+ GIT_ASSERT_WITH_RETVAL(!"Unknown regular expression backend", NULL);
break;
- case GIT_OPT_SET_USER_AGENT:
- git__free(git__user_agent);
- git__user_agent = git__strdup(va_arg(ap, const char *));
- if (!git__user_agent) {
- git_error_set_oom();
- error = -1;
- }
+ case GIT_FEATURE_I18N:
+#if defined(GIT_I18N_ICONV)
+ return "iconv";
+#elif defined(GIT_I18N)
+ GIT_ASSERT_WITH_RETVAL(!"Unknown internationalization backend", NULL);
+#endif
break;
- case GIT_OPT_ENABLE_STRICT_OBJECT_CREATION:
- git_object__strict_input_validation = (va_arg(ap, int) != 0);
+ case GIT_FEATURE_AUTH_NTLM:
+#if defined(GIT_AUTH_NTLM_BUILTIN)
+ return "builtin";
+#elif defined(GIT_AUTH_NTLM_SSPI)
+ return "sspi";
+#elif defined(GIT_AUTH_NTLM)
+ GIT_ASSERT_WITH_RETVAL(!"Unknown NTLM backend", NULL);
+#endif
break;
- case GIT_OPT_ENABLE_STRICT_SYMBOLIC_REF_CREATION:
- git_reference__enable_symbolic_ref_target_validation = (va_arg(ap, int) != 0);
+ case GIT_FEATURE_AUTH_NEGOTIATE:
+#if defined(GIT_AUTH_NEGOTIATE_GSSFRAMEWORK)
+ return "gssframework";
+#elif defined(GIT_AUTH_NEGOTIATE_GSSAPI)
+ return "gssapi";
+#elif defined(GIT_AUTH_NEGOTIATE_SSPI)
+ return "sspi";
+#elif defined(GIT_AUTH_NEGOTIATE)
+ GIT_ASSERT_WITH_RETVAL(!"Unknown Negotiate backend", NULL);
+#endif
break;
- case GIT_OPT_SET_SSL_CIPHERS:
-#if (GIT_OPENSSL || GIT_MBEDTLS)
- {
- git__free(git__ssl_ciphers);
- git__ssl_ciphers = git__strdup(va_arg(ap, const char *));
- if (!git__ssl_ciphers) {
- git_error_set_oom();
- error = -1;
- }
- }
+ case GIT_FEATURE_COMPRESSION:
+#if defined(GIT_COMPRESSION_ZLIB)
+ return "zlib";
+#elif defined(GIT_COMPRESSION_BUILTIN)
+ return "builtin";
#else
- git_error_set(GIT_ERROR_SSL, "TLS backend doesn't support custom ciphers");
- error = -1;
+ GIT_ASSERT_WITH_RETVAL(!"Unknown compression backend", NULL);
#endif
break;
- case GIT_OPT_GET_USER_AGENT:
- {
- git_buf *out = va_arg(ap, git_buf *);
- git_str str = GIT_STR_INIT;
-
- if ((error = git_buf_tostr(&str, out)) < 0 ||
- (error = git_str_puts(&str, git__user_agent)) < 0)
- break;
-
- error = git_buf_fromstr(out, &str);
- }
- break;
-
- case GIT_OPT_ENABLE_OFS_DELTA:
- git_smart__ofs_delta_enabled = (va_arg(ap, int) != 0);
- break;
-
- case GIT_OPT_ENABLE_FSYNC_GITDIR:
- git_repository__fsync_gitdir = (va_arg(ap, int) != 0);
- break;
-
- case GIT_OPT_GET_WINDOWS_SHAREMODE:
-#ifdef GIT_WIN32
- *(va_arg(ap, unsigned long *)) = git_win32__createfile_sharemode;
+ case GIT_FEATURE_SHA1:
+#if defined(GIT_SHA1_BUILTIN)
+ return "builtin";
+#elif defined(GIT_SHA1_OPENSSL)
+ return "openssl";
+#elif defined(GIT_SHA1_OPENSSL_FIPS)
+ return "openssl-fips";
+#elif defined(GIT_SHA1_OPENSSL_DYNAMIC)
+ return "openssl-dynamic";
+#elif defined(GIT_SHA1_MBEDTLS)
+ return "mbedtls";
+#elif defined(GIT_SHA1_COMMON_CRYPTO)
+ return "commoncrypto";
+#elif defined(GIT_SHA1_WIN32)
+ return "win32";
+#else
+ GIT_ASSERT_WITH_RETVAL(!"Unknown SHA1 backend", NULL);
#endif
break;
- case GIT_OPT_SET_WINDOWS_SHAREMODE:
-#ifdef GIT_WIN32
- git_win32__createfile_sharemode = va_arg(ap, unsigned long);
+ case GIT_FEATURE_SHA256:
+#if defined(GIT_EXPERIMENTAL_SHA256) && defined(GIT_SHA256_BUILTIN)
+ return "builtin";
+#elif defined(GIT_EXPERIMENTAL_SHA256) && defined(GIT_SHA256_OPENSSL)
+ return "openssl";
+#elif defined(GIT_EXPERIMENTAL_SHA256) && defined(GIT_SHA256_OPENSSL_FIPS)
+ return "openssl-fips";
+#elif defined(GIT_EXPERIMENTAL_SHA256) && defined(GIT_SHA256_OPENSSL_DYNAMIC)
+ return "openssl-dynamic";
+#elif defined(GIT_EXPERIMENTAL_SHA256) && defined(GIT_SHA256_MBEDTLS)
+ return "mbedtls";
+#elif defined(GIT_EXPERIMENTAL_SHA256) && defined(GIT_SHA256_COMMON_CRYPTO)
+ return "commoncrypto";
+#elif defined(GIT_EXPERIMENTAL_SHA256) && defined(GIT_SHA256_WIN32)
+ return "win32";
+#elif defined(GIT_EXPERIMENTAL_SHA256)
+ GIT_ASSERT_WITH_RETVAL(!"Unknown SHA256 backend", NULL);
#endif
break;
-
- case GIT_OPT_ENABLE_STRICT_HASH_VERIFICATION:
- git_odb__strict_hash_verification = (va_arg(ap, int) != 0);
- break;
-
- case GIT_OPT_SET_ALLOCATOR:
- error = git_allocator_setup(va_arg(ap, git_allocator *));
- break;
-
- case GIT_OPT_ENABLE_UNSAVED_INDEX_SAFETY:
- git_index__enforce_unsaved_safety = (va_arg(ap, int) != 0);
- break;
-
- case GIT_OPT_SET_PACK_MAX_OBJECTS:
- git_indexer__max_objects = va_arg(ap, size_t);
- break;
-
- case GIT_OPT_GET_PACK_MAX_OBJECTS:
- *(va_arg(ap, size_t *)) = git_indexer__max_objects;
- break;
-
- case GIT_OPT_DISABLE_PACK_KEEP_FILE_CHECKS:
- git_disable_pack_keep_file_checks = (va_arg(ap, int) != 0);
- break;
-
- case GIT_OPT_ENABLE_HTTP_EXPECT_CONTINUE:
- git_http__expect_continue = (va_arg(ap, int) != 0);
- break;
-
- case GIT_OPT_SET_ODB_PACKED_PRIORITY:
- git_odb__packed_priority = va_arg(ap, int);
- break;
-
- case GIT_OPT_SET_ODB_LOOSE_PRIORITY:
- git_odb__loose_priority = va_arg(ap, int);
- break;
-
- case GIT_OPT_SET_EXTENSIONS:
- {
- const char **extensions = va_arg(ap, const char **);
- size_t len = va_arg(ap, size_t);
- error = git_repository__set_extensions(extensions, len);
- }
- break;
-
- case GIT_OPT_GET_EXTENSIONS:
- {
- git_strarray *out = va_arg(ap, git_strarray *);
- char **extensions;
- size_t len;
-
- if ((error = git_repository__extensions(&extensions, &len)) < 0)
- break;
-
- out->strings = extensions;
- out->count = len;
- }
- break;
-
- case GIT_OPT_GET_OWNER_VALIDATION:
- *(va_arg(ap, int *)) = git_repository__validate_ownership;
- break;
-
- case GIT_OPT_SET_OWNER_VALIDATION:
- git_repository__validate_ownership = (va_arg(ap, int) != 0);
- break;
-
- case GIT_OPT_GET_HOMEDIR:
- {
- git_buf *out = va_arg(ap, git_buf *);
- git_str str = GIT_STR_INIT;
- const git_str *tmp;
-
- if ((error = git_buf_tostr(&str, out)) < 0 ||
- (error = git_sysdir_get(&tmp, GIT_SYSDIR_HOME)) < 0 ||
- (error = git_str_put(&str, tmp->ptr, tmp->size)) < 0)
- break;
-
- error = git_buf_fromstr(out, &str);
- }
- break;
-
- case GIT_OPT_SET_HOMEDIR:
- error = git_sysdir_set(GIT_SYSDIR_HOME, va_arg(ap, const char *));
- break;
-
- default:
- git_error_set(GIT_ERROR_INVALID, "invalid option key");
- error = -1;
}
- va_end(ap);
-
- return error;
+ return NULL;
}
diff --git a/src/libgit2/libgit2.h b/src/libgit2/libgit2.h
deleted file mode 100644
index a898367ae37..00000000000
--- a/src/libgit2/libgit2.h
+++ /dev/null
@@ -1,15 +0,0 @@
-/*
- * Copyright (C) the libgit2 contributors. All rights reserved.
- *
- * This file is part of libgit2, distributed under the GNU GPL v2 with
- * a Linking Exception. For full terms see the included COPYING file.
- */
-#ifndef INCLUDE_libgit2_h__
-#define INCLUDE_libgit2_h__
-
-extern int git_libgit2_init_count(void);
-
-extern const char *git_libgit2__user_agent(void);
-extern const char *git_libgit2__ssl_ciphers(void);
-
-#endif
diff --git a/src/libgit2/mailmap.c b/src/libgit2/mailmap.c
index 4336fe3e549..05c88ff02c1 100644
--- a/src/libgit2/mailmap.c
+++ b/src/libgit2/mailmap.c
@@ -173,7 +173,7 @@ void git_mailmap_free(git_mailmap *mm)
git_vector_foreach(&mm->entries, idx, entry)
mailmap_entry_free(entry);
- git_vector_free(&mm->entries);
+ git_vector_dispose(&mm->entries);
git__free(mm);
}
diff --git a/src/libgit2/merge.c b/src/libgit2/merge.c
index df2cefb2930..eabb4bfa32c 100644
--- a/src/libgit2/merge.c
+++ b/src/libgit2/merge.c
@@ -32,7 +32,6 @@
#include "commit.h"
#include "oidarray.h"
#include "merge_driver.h"
-#include "oidmap.h"
#include "array.h"
#include "git2/types.h"
@@ -124,11 +123,11 @@ static int merge_bases_many(git_commit_list **out, git_revwalk **walk_out, git_r
*out = result;
*walk_out = walk;
- git_vector_free(&list);
+ git_vector_dispose(&list);
return 0;
on_error:
- git_vector_free(&list);
+ git_vector_dispose(&list);
git_revwalk_free(walk);
return error;
}
@@ -511,7 +510,7 @@ static int remove_redundant(git_revwalk *walk, git_vector *commits, uint32_t min
done:
git__free(redundant);
git__free(filled_index);
- git_vector_free(&work);
+ git_vector_dispose(&work);
return error;
}
@@ -570,7 +569,7 @@ int git_merge__bases_many(
if ((error = clear_commit_marks(one, ALL_FLAGS)) < 0 ||
(error = clear_commit_marks_many(twos, ALL_FLAGS)) < 0 ||
(error = remove_redundant(walk, &redundant, minimum_generation)) < 0) {
- git_vector_free(&redundant);
+ git_vector_dispose(&redundant);
return error;
}
@@ -579,7 +578,7 @@ int git_merge__bases_many(
git_commit_list_insert_by_date(two, &result);
}
- git_vector_free(&redundant);
+ git_vector_dispose(&redundant);
}
*out = result;
@@ -611,13 +610,13 @@ int git_repository_mergehead_foreach(
buffer = merge_head_file.ptr;
while ((line = git__strsep(&buffer, "\n")) != NULL) {
- if (strlen(line) != GIT_OID_SHA1_HEXSIZE) {
+ if (strlen(line) != git_oid_hexsize(repo->oid_type)) {
git_error_set(GIT_ERROR_INVALID, "unable to parse OID - invalid length");
error = -1;
goto cleanup;
}
- if ((error = git_oid__fromstr(&oid, line, GIT_OID_SHA1)) < 0)
+ if ((error = git_oid_from_string(&oid, line, repo->oid_type)) < 0)
goto cleanup;
if ((error = cb(&oid, payload)) != 0) {
@@ -1061,7 +1060,7 @@ static int index_entry_similarity_calc(
const git_merge_options *opts)
{
git_blob *blob;
- git_diff_file diff_file = { GIT_OID_SHA1_ZERO };
+ git_diff_file diff_file;
git_object_size_t blobsize;
int error;
@@ -1070,6 +1069,8 @@ static int index_entry_similarity_calc(
*out = NULL;
+ git_oid_clear(&diff_file.id, repo->oid_type);
+
if ((error = git_blob_lookup(&blob, repo, &entry->id)) < 0)
return error;
@@ -1142,24 +1143,28 @@ typedef struct {
size_t first_entry;
} deletes_by_oid_queue;
-static void deletes_by_oid_free(git_oidmap *map) {
+GIT_HASHMAP_OID_SETUP(git_merge_deletes_oidmap, deletes_by_oid_queue *);
+
+static void deletes_by_oid_dispose(git_merge_deletes_oidmap *map)
+{
+ git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
deletes_by_oid_queue *queue;
if (!map)
return;
- git_oidmap_foreach_value(map, queue, {
+ while (git_merge_deletes_oidmap_iterate(&iter, NULL, &queue, map) == 0)
git_array_clear(queue->arr);
- });
- git_oidmap_free(map);
+
+ git_merge_deletes_oidmap_dispose(map);
}
-static int deletes_by_oid_enqueue(git_oidmap *map, git_pool *pool, const git_oid *id, size_t idx)
+static int deletes_by_oid_enqueue(git_merge_deletes_oidmap *map, git_pool *pool, const git_oid *id, size_t idx)
{
deletes_by_oid_queue *queue;
size_t *array_entry;
- if ((queue = git_oidmap_get(map, id)) == NULL) {
+ if (git_merge_deletes_oidmap_get(&queue, map, id) != 0) {
queue = git_pool_malloc(pool, sizeof(deletes_by_oid_queue));
GIT_ERROR_CHECK_ALLOC(queue);
@@ -1167,7 +1172,7 @@ static int deletes_by_oid_enqueue(git_oidmap *map, git_pool *pool, const git_oid
queue->next_pos = 0;
queue->first_entry = idx;
- if (git_oidmap_set(map, id, queue) < 0)
+ if (git_merge_deletes_oidmap_put(map, id, queue) < 0)
return -1;
} else {
array_entry = git_array_alloc(queue->arr);
@@ -1178,13 +1183,14 @@ static int deletes_by_oid_enqueue(git_oidmap *map, git_pool *pool, const git_oid
return 0;
}
-static int deletes_by_oid_dequeue(size_t *idx, git_oidmap *map, const git_oid *id)
+static int deletes_by_oid_dequeue(size_t *idx, git_merge_deletes_oidmap *map, const git_oid *id)
{
deletes_by_oid_queue *queue;
size_t *array_entry;
+ int error;
- if ((queue = git_oidmap_get(map, id)) == NULL)
- return GIT_ENOTFOUND;
+ if ((error = git_merge_deletes_oidmap_get(&queue, map, id)) != 0)
+ return error;
if (queue->next_pos == 0) {
*idx = queue->first_entry;
@@ -1207,15 +1213,10 @@ static int merge_diff_mark_similarity_exact(
{
size_t i, j;
git_merge_diff *conflict_src, *conflict_tgt;
- git_oidmap *ours_deletes_by_oid = NULL, *theirs_deletes_by_oid = NULL;
+ git_merge_deletes_oidmap ours_deletes_by_oid = GIT_HASHMAP_INIT,
+ theirs_deletes_by_oid = GIT_HASHMAP_INIT;
int error = 0;
- if (git_oidmap_new(&ours_deletes_by_oid) < 0 ||
- git_oidmap_new(&theirs_deletes_by_oid) < 0) {
- error = -1;
- goto done;
- }
-
/* Build a map of object ids to conflicts */
git_vector_foreach(&diff_list->conflicts, i, conflict_src) {
/* Items can be the source of a rename iff they have an item in the
@@ -1223,14 +1224,21 @@ static int merge_diff_mark_similarity_exact(
if (!GIT_MERGE_INDEX_ENTRY_EXISTS(conflict_src->ancestor_entry))
continue;
+ /*
+ * Ignore empty files because it has always the same blob sha1
+ * and will lead to incorrect matches between all entries.
+ */
+ if (git_oid_equal(&conflict_src->ancestor_entry.id, &git_oid__empty_blob_sha1))
+ continue;
+
if (!GIT_MERGE_INDEX_ENTRY_EXISTS(conflict_src->our_entry)) {
- error = deletes_by_oid_enqueue(ours_deletes_by_oid, &diff_list->pool, &conflict_src->ancestor_entry.id, i);
+ error = deletes_by_oid_enqueue(&ours_deletes_by_oid, &diff_list->pool, &conflict_src->ancestor_entry.id, i);
if (error < 0)
goto done;
}
if (!GIT_MERGE_INDEX_ENTRY_EXISTS(conflict_src->their_entry)) {
- error = deletes_by_oid_enqueue(theirs_deletes_by_oid, &diff_list->pool, &conflict_src->ancestor_entry.id, i);
+ error = deletes_by_oid_enqueue(&theirs_deletes_by_oid, &diff_list->pool, &conflict_src->ancestor_entry.id, i);
if (error < 0)
goto done;
}
@@ -1241,7 +1249,7 @@ static int merge_diff_mark_similarity_exact(
continue;
if (GIT_MERGE_INDEX_ENTRY_EXISTS(conflict_tgt->our_entry)) {
- if (deletes_by_oid_dequeue(&i, ours_deletes_by_oid, &conflict_tgt->our_entry.id) == 0) {
+ if (deletes_by_oid_dequeue(&i, &ours_deletes_by_oid, &conflict_tgt->our_entry.id) == 0) {
similarity_ours[i].similarity = 100;
similarity_ours[i].other_idx = j;
@@ -1251,7 +1259,7 @@ static int merge_diff_mark_similarity_exact(
}
if (GIT_MERGE_INDEX_ENTRY_EXISTS(conflict_tgt->their_entry)) {
- if (deletes_by_oid_dequeue(&i, theirs_deletes_by_oid, &conflict_tgt->their_entry.id) == 0) {
+ if (deletes_by_oid_dequeue(&i, &theirs_deletes_by_oid, &conflict_tgt->their_entry.id) == 0) {
similarity_theirs[i].similarity = 100;
similarity_theirs[i].other_idx = j;
@@ -1262,8 +1270,8 @@ static int merge_diff_mark_similarity_exact(
}
done:
- deletes_by_oid_free(ours_deletes_by_oid);
- deletes_by_oid_free(theirs_deletes_by_oid);
+ deletes_by_oid_dispose(&ours_deletes_by_oid);
+ deletes_by_oid_dispose(&theirs_deletes_by_oid);
return error;
}
@@ -1857,9 +1865,9 @@ void git_merge_diff_list__free(git_merge_diff_list *diff_list)
if (!diff_list)
return;
- git_vector_free(&diff_list->staged);
- git_vector_free(&diff_list->conflicts);
- git_vector_free(&diff_list->resolved);
+ git_vector_dispose(&diff_list->staged);
+ git_vector_dispose(&diff_list->conflicts);
+ git_vector_dispose(&diff_list->resolved);
git_pool_clear(&diff_list->pool);
git__free(diff_list);
}
@@ -1997,17 +2005,23 @@ static int index_update_reuc(git_index *index, git_merge_diff_list *diff_list)
return 0;
}
-static int index_from_diff_list(git_index **out,
- git_merge_diff_list *diff_list, bool skip_reuc)
+static int index_from_diff_list(
+ git_index **out,
+ git_merge_diff_list *diff_list,
+ git_oid_t oid_type,
+ bool skip_reuc)
{
git_index *index;
size_t i;
git_merge_diff *conflict;
+ git_index_options index_opts = GIT_INDEX_OPTIONS_INIT;
int error = 0;
*out = NULL;
- if ((error = git_index_new(&index)) < 0)
+ index_opts.oid_type = oid_type;
+
+ if ((error = git_index_new_ext(&index, &index_opts)) < 0)
return error;
if ((error = git_index__fill(index, &diff_list->staged)) < 0)
@@ -2157,7 +2171,7 @@ int git_merge__iterators(
}
}
- error = index_from_diff_list(out, diff_list,
+ error = index_from_diff_list(out, diff_list, repo->oid_type,
(opts.flags & GIT_MERGE_SKIP_REUC));
done:
@@ -2184,6 +2198,7 @@ int git_merge_trees(
{
git_iterator *ancestor_iter = NULL, *our_iter = NULL, *their_iter = NULL;
git_iterator_options iter_opts = GIT_ITERATOR_OPTIONS_INIT;
+ git_index_options index_opts = GIT_INDEX_OPTIONS_FOR_REPO(repo);
int error;
GIT_ASSERT_ARG(out);
@@ -2200,8 +2215,8 @@ int git_merge_trees(
result = our_tree;
if (result) {
- if ((error = git_index_new(out)) == 0)
- error = git_index_read_tree(*out, result);
+ if ((error = git_index_new_ext(out, &index_opts)) == 0)
+ error = git_index_read_tree(*out, result);
return error;
}
@@ -2824,7 +2839,7 @@ static int write_merge_msg(
git_str_dispose(&file_path);
- git_vector_free(&matching);
+ git_vector_dispose(&matching);
git__free(entries);
return error;
@@ -3003,7 +3018,7 @@ static int merge_check_index(size_t *conflicts, git_repository *repo, git_index
git_iterator_free(iter_new);
git_diff_free(staged_diff_list);
git_diff_free(index_diff_list);
- git_vector_free(&staged_paths);
+ git_vector_dispose(&staged_paths);
return error;
}
@@ -3100,7 +3115,7 @@ int git_merge__check_result(git_repository *repo, git_index *index_new)
}
done:
- git_vector_free(&paths);
+ git_vector_dispose(&paths);
git_tree_free(head_tree);
git_iterator_free(iter_head);
git_iterator_free(iter_new);
@@ -3341,8 +3356,7 @@ int git_merge(
goto done;
checkout_strategy = given_checkout_opts ?
- given_checkout_opts->checkout_strategy :
- GIT_CHECKOUT_SAFE;
+ given_checkout_opts->checkout_strategy : 0;
if ((error = git_indexwriter_init_for_operation(&indexwriter, repo,
&checkout_strategy)) < 0)
diff --git a/src/libgit2/merge_driver.c b/src/libgit2/merge_driver.c
index 19b35ac0ea6..300964afdea 100644
--- a/src/libgit2/merge_driver.c
+++ b/src/libgit2/merge_driver.c
@@ -218,7 +218,7 @@ int git_merge_driver_global_init(void)
done:
if (error < 0)
- git_vector_free_deep(&merge_driver_registry.drivers);
+ git_vector_dispose_deep(&merge_driver_registry.drivers);
return error;
}
@@ -238,7 +238,7 @@ static void git_merge_driver_global_shutdown(void)
git__free(entry);
}
- git_vector_free(&merge_driver_registry.drivers);
+ git_vector_dispose(&merge_driver_registry.drivers);
git_rwlock_wrunlock(&merge_driver_registry.lock);
git_rwlock_free(&merge_driver_registry.lock);
diff --git a/src/libgit2/merge_file.c b/src/libgit2/merge_file.c
index 732a047b1c9..ffe83cf2a3b 100644
--- a/src/libgit2/merge_file.c
+++ b/src/libgit2/merge_file.c
@@ -19,8 +19,6 @@
#include "git2/index.h"
#include "git2/merge.h"
-#include "xdiff/xdiff.h"
-
/* only examine the first 8000 bytes for binaryness.
* https://github.com/git/git/blob/77bd3ea9f54f1584147b594abc04c26ca516d987/xdiff-interface.c#L197
*/
diff --git a/src/libgit2/midx.c b/src/libgit2/midx.c
index b0905523713..a3f84984ca8 100644
--- a/src/libgit2/midx.c
+++ b/src/libgit2/midx.c
@@ -114,23 +114,16 @@ static int midx_parse_oid_lookup(
const unsigned char *data,
struct git_midx_chunk *chunk_oid_lookup)
{
- uint32_t i;
- unsigned char *oid, *prev_oid, zero_oid[GIT_OID_SHA1_SIZE] = {0};
+ size_t oid_size = git_oid_size(idx->oid_type);
if (chunk_oid_lookup->offset == 0)
return midx_error("missing OID Lookup chunk");
if (chunk_oid_lookup->length == 0)
return midx_error("empty OID Lookup chunk");
- if (chunk_oid_lookup->length != idx->num_objects * GIT_OID_SHA1_SIZE)
+ if (chunk_oid_lookup->length != idx->num_objects * oid_size)
return midx_error("OID Lookup chunk has wrong length");
- idx->oid_lookup = oid = (unsigned char *)(data + chunk_oid_lookup->offset);
- prev_oid = zero_oid;
- for (i = 0; i < idx->num_objects; ++i, oid += GIT_OID_SHA1_SIZE) {
- if (git_oid_raw_cmp(prev_oid, oid, GIT_OID_SHA1_SIZE) >= 0)
- return midx_error("OID Lookup index is non-monotonic");
- prev_oid = oid;
- }
+ idx->oid_lookup = (unsigned char *)(data + chunk_oid_lookup->offset);
return 0;
}
@@ -178,17 +171,20 @@ int git_midx_parse(
struct git_midx_chunk *last_chunk;
uint32_t i;
off64_t last_chunk_offset, chunk_offset, trailer_offset;
- size_t checksum_size;
+ size_t checksum_size, oid_size;
int error;
struct git_midx_chunk chunk_packfile_names = {0},
chunk_oid_fanout = {0},
chunk_oid_lookup = {0},
chunk_object_offsets = {0},
- chunk_object_large_offsets = {0};
+ chunk_object_large_offsets = {0},
+ chunk_unknown = {0};
GIT_ASSERT_ARG(idx);
- if (size < sizeof(struct git_midx_header) + GIT_OID_SHA1_SIZE)
+ oid_size = git_oid_size(idx->oid_type);
+
+ if (size < sizeof(struct git_midx_header) + oid_size)
return midx_error("multi-pack index is too short");
hdr = ((struct git_midx_header *)data);
@@ -209,7 +205,7 @@ int git_midx_parse(
sizeof(struct git_midx_header) +
(1 + hdr->chunks) * 12;
- checksum_size = GIT_HASH_SHA1_SIZE;
+ checksum_size = oid_size;
trailer_offset = size - checksum_size;
if (trailer_offset < last_chunk_offset)
@@ -261,7 +257,9 @@ int git_midx_parse(
break;
default:
- return midx_error("unrecognized chunk ID");
+ chunk_unknown.offset = last_chunk_offset;
+ last_chunk = &chunk_unknown;
+ break;
}
}
last_chunk->length = (size_t)(trailer_offset - last_chunk_offset);
@@ -287,8 +285,9 @@ int git_midx_parse(
}
int git_midx_open(
- git_midx_file **idx_out,
- const char *path)
+ git_midx_file **idx_out,
+ const char *path,
+ git_oid_t oid_type)
{
git_midx_file *idx;
git_file fd = -1;
@@ -296,6 +295,8 @@ int git_midx_open(
struct stat st;
int error;
+ GIT_ASSERT_ARG(idx_out && path && oid_type);
+
/* TODO: properly open the file without access time using O_NOATIME */
fd = git_futils_open_ro(path);
if (fd < 0)
@@ -317,6 +318,8 @@ int git_midx_open(
idx = git__calloc(1, sizeof(git_midx_file));
GIT_ERROR_CHECK_ALLOC(idx);
+ idx->oid_type = oid_type;
+
error = git_str_sets(&idx->filename, path);
if (error < 0)
return error;
@@ -344,7 +347,7 @@ bool git_midx_needs_refresh(
git_file fd = -1;
struct stat st;
ssize_t bytes_read;
- unsigned char checksum[GIT_HASH_SHA1_SIZE];
+ unsigned char checksum[GIT_HASH_MAX_SIZE];
size_t checksum_size;
/* TODO: properly open the file without access time using O_NOATIME */
@@ -364,8 +367,8 @@ bool git_midx_needs_refresh(
return true;
}
- checksum_size = GIT_HASH_SHA1_SIZE;
- bytes_read = p_pread(fd, checksum, checksum_size, st.st_size - GIT_OID_SHA1_SIZE);
+ checksum_size = git_oid_size(idx->oid_type);
+ bytes_read = p_pread(fd, checksum, checksum_size, st.st_size - checksum_size);
p_close(fd);
if (bytes_read != (ssize_t)checksum_size)
@@ -381,7 +384,7 @@ int git_midx_entry_find(
size_t len)
{
int pos, found = 0;
- size_t pack_index;
+ size_t pack_index, oid_size, oid_hexsize;
uint32_t hi, lo;
unsigned char *current = NULL;
const unsigned char *object_offset;
@@ -389,30 +392,33 @@ int git_midx_entry_find(
GIT_ASSERT_ARG(idx);
+ oid_size = git_oid_size(idx->oid_type);
+ oid_hexsize = git_oid_hexsize(idx->oid_type);
+
hi = ntohl(idx->oid_fanout[(int)short_oid->id[0]]);
lo = ((short_oid->id[0] == 0x0) ? 0 : ntohl(idx->oid_fanout[(int)short_oid->id[0] - 1]));
- pos = git_pack__lookup_id(idx->oid_lookup, GIT_OID_SHA1_SIZE, lo, hi, short_oid->id, GIT_OID_SHA1);
+ pos = git_pack__lookup_id(idx->oid_lookup, oid_size, lo, hi, short_oid->id, idx->oid_type);
if (pos >= 0) {
/* An object matching exactly the oid was found */
found = 1;
- current = idx->oid_lookup + (pos * GIT_OID_SHA1_SIZE);
+ current = idx->oid_lookup + (pos * oid_size);
} else {
/* No object was found */
/* pos refers to the object with the "closest" oid to short_oid */
pos = -1 - pos;
if (pos < (int)idx->num_objects) {
- current = idx->oid_lookup + (pos * GIT_OID_SHA1_SIZE);
+ current = idx->oid_lookup + (pos * oid_size);
if (!git_oid_raw_ncmp(short_oid->id, current, len))
found = 1;
}
}
- if (found && len != GIT_OID_SHA1_HEXSIZE && pos + 1 < (int)idx->num_objects) {
+ if (found && len != oid_hexsize && pos + 1 < (int)idx->num_objects) {
/* Check for ambiguousity */
- const unsigned char *next = current + GIT_OID_SHA1_SIZE;
+ const unsigned char *next = current + oid_size;
if (!git_oid_raw_ncmp(short_oid->id, next, len))
found = 2;
@@ -443,7 +449,7 @@ int git_midx_entry_find(
return midx_error("invalid index into the packfile names table");
e->pack_index = pack_index;
e->offset = offset;
- git_oid__fromraw(&e->sha1, current, GIT_OID_SHA1);
+ git_oid_from_raw(&e->sha1, current, idx->oid_type);
return 0;
}
@@ -453,13 +459,15 @@ int git_midx_foreach_entry(
void *data)
{
git_oid oid;
- size_t i;
+ size_t oid_size, i;
int error;
GIT_ASSERT_ARG(idx);
+ oid_size = git_oid_size(idx->oid_type);
+
for (i = 0; i < idx->num_objects; ++i) {
- if ((error = git_oid__fromraw(&oid, &idx->oid_lookup[i * GIT_OID_SHA1_SIZE], GIT_OID_SHA1)) < 0)
+ if ((error = git_oid_from_raw(&oid, &idx->oid_lookup[i * oid_size], idx->oid_type)) < 0)
return error;
if ((error = cb(&oid, data)) != 0)
@@ -476,7 +484,7 @@ int git_midx_close(git_midx_file *idx)
if (idx->index_map.data)
git_futils_mmap_free(&idx->index_map);
- git_vector_free(&idx->packfile_names);
+ git_vector_dispose(&idx->packfile_names);
return 0;
}
@@ -500,10 +508,30 @@ static int packfile__cmp(const void *a_, const void *b_)
}
int git_midx_writer_new(
- git_midx_writer **out,
- const char *pack_dir)
+ git_midx_writer **out,
+ const char *pack_dir
+#ifdef GIT_EXPERIMENTAL_SHA256
+ , git_midx_writer_options *opts
+#endif
+ )
{
- git_midx_writer *w = git__calloc(1, sizeof(git_midx_writer));
+ git_midx_writer *w;
+ git_oid_t oid_type;
+
+ GIT_ASSERT_ARG(out && pack_dir);
+
+#ifdef GIT_EXPERIMENTAL_SHA256
+ GIT_ERROR_CHECK_VERSION(opts,
+ GIT_MIDX_WRITER_OPTIONS_VERSION,
+ "git_midx_writer_options");
+
+ oid_type = opts && opts->oid_type ? opts->oid_type : GIT_OID_DEFAULT;
+ GIT_ASSERT_ARG(git_oid_type_is_valid(oid_type));
+#else
+ oid_type = GIT_OID_SHA1;
+#endif
+
+ w = git__calloc(1, sizeof(git_midx_writer));
GIT_ERROR_CHECK_ALLOC(w);
if (git_str_sets(&w->pack_dir, pack_dir) < 0) {
@@ -518,6 +546,8 @@ int git_midx_writer_new(
return -1;
}
+ w->oid_type = oid_type;
+
*out = w;
return 0;
}
@@ -532,7 +562,7 @@ void git_midx_writer_free(git_midx_writer *w)
git_vector_foreach (&w->packs, i, p)
git_mwindow_put_pack(p);
- git_vector_free(&w->packs);
+ git_vector_dispose(&w->packs);
git_str_dispose(&w->pack_dir);
git__free(w);
}
@@ -638,9 +668,11 @@ static int midx_write_hash(const char *buf, size_t size, void *data)
struct midx_write_hash_context *ctx = (struct midx_write_hash_context *)data;
int error;
- error = git_hash_update(ctx->ctx, buf, size);
- if (error < 0)
- return error;
+ if (ctx->ctx) {
+ error = git_hash_update(ctx->ctx, buf, size);
+ if (error < 0)
+ return error;
+ }
return ctx->write_cb(buf, size, ctx->cb_data);
}
@@ -662,12 +694,13 @@ static int midx_write(
oid_lookup = GIT_STR_INIT,
object_offsets = GIT_STR_INIT,
object_large_offsets = GIT_STR_INIT;
- unsigned char checksum[GIT_HASH_SHA1_SIZE];
- size_t checksum_size;
+ unsigned char checksum[GIT_HASH_MAX_SIZE];
+ size_t checksum_size, oid_size;
git_midx_entry *entry;
object_entry_array_t object_entries_array = GIT_ARRAY_INIT;
git_vector object_entries = GIT_VECTOR_INIT;
git_hash_ctx ctx;
+ git_hash_algorithm_t checksum_type;
struct midx_write_hash_context hash_cb_data = {0};
hdr.signature = htonl(MIDX_SIGNATURE);
@@ -679,10 +712,14 @@ static int midx_write(
hash_cb_data.cb_data = cb_data;
hash_cb_data.ctx = &ctx;
- checksum_size = GIT_HASH_SHA1_SIZE;
- error = git_hash_ctx_init(&ctx, GIT_HASH_ALGORITHM_SHA1);
- if (error < 0)
+ oid_size = git_oid_size(w->oid_type);
+ checksum_type = git_oid_algorithm(w->oid_type);
+ checksum_size = git_hash_size(checksum_type);
+ GIT_ASSERT(oid_size && checksum_type && checksum_size);
+
+ if ((error = git_hash_ctx_init(&ctx, checksum_type)) < 0)
return error;
+
cb_data = &hash_cb_data;
write_cb = midx_write_hash;
@@ -749,7 +786,9 @@ static int midx_write(
/* Fill the OID Lookup table. */
git_vector_foreach (&object_entries, i, entry) {
- error = git_str_put(&oid_lookup, (char *)&entry->sha1.id, GIT_OID_SHA1_SIZE);
+ error = git_str_put(&oid_lookup,
+ (char *)&entry->sha1.id, oid_size);
+
if (error < 0)
goto cleanup;
}
@@ -834,13 +873,16 @@ static int midx_write(
error = git_hash_final(checksum, &ctx);
if (error < 0)
goto cleanup;
+
+ hash_cb_data.ctx = NULL;
+
error = write_cb((char *)checksum, checksum_size, cb_data);
if (error < 0)
goto cleanup;
cleanup:
git_array_clear(object_entries_array);
- git_vector_free(&object_entries);
+ git_vector_dispose(&object_entries);
git_str_dispose(&packfile_names);
git_str_dispose(&oid_lookup);
git_str_dispose(&object_offsets);
diff --git a/src/libgit2/midx.h b/src/libgit2/midx.h
index bcb0d9a0abd..5107f69cba3 100644
--- a/src/libgit2/midx.h
+++ b/src/libgit2/midx.h
@@ -51,8 +51,14 @@ typedef struct git_midx_file {
/* The number of entries in the Object Large Offsets table. Each entry has an 8-byte with an offset */
size_t num_object_large_offsets;
- /* The trailer of the file. Contains the SHA1-checksum of the whole file. */
- unsigned char checksum[GIT_HASH_SHA1_SIZE];
+ /*
+ * The trailer of the file. Contains the checksum of the whole
+ * file, in the repository's object format hash.
+ */
+ unsigned char checksum[GIT_HASH_MAX_SIZE];
+
+ /* The type of object IDs in the midx. */
+ git_oid_t oid_type;
/* something like ".git/objects/pack/multi-pack-index". */
git_str filename;
@@ -82,11 +88,15 @@ struct git_midx_writer {
/* The list of `git_pack_file`s. */
git_vector packs;
+
+ /* The object ID type of the writer. */
+ git_oid_t oid_type;
};
int git_midx_open(
git_midx_file **idx_out,
- const char *path);
+ const char *path,
+ git_oid_t oid_type);
bool git_midx_needs_refresh(
const git_midx_file *idx,
const char *path);
diff --git a/src/libgit2/mwindow.c b/src/libgit2/mwindow.c
index b8295d9d119..7e4054df664 100644
--- a/src/libgit2/mwindow.c
+++ b/src/libgit2/mwindow.c
@@ -11,7 +11,6 @@
#include "futils.h"
#include "map.h"
#include "runtime.h"
-#include "strmap.h"
#include "pack.h"
#define DEFAULT_WINDOW_SIZE \
@@ -29,33 +28,27 @@ size_t git_mwindow__window_size = DEFAULT_WINDOW_SIZE;
size_t git_mwindow__mapped_limit = DEFAULT_MAPPED_LIMIT;
size_t git_mwindow__file_limit = DEFAULT_FILE_LIMIT;
-/* Mutex to control access to `git_mwindow__mem_ctl` and `git__pack_cache`. */
-git_mutex git__mwindow_mutex;
+/* Mutex to control access to `git_mwindow__mem_ctl` and `git_mwindow__pack_cache`. */
+git_mutex git_mwindow__mutex;
-/* Whenever you want to read or modify this, grab `git__mwindow_mutex` */
+/* Whenever you want to read or modify this, grab `git_mwindow__mutex` */
git_mwindow_ctl git_mwindow__mem_ctl;
/* Global list of mwindow files, to open packs once across repos */
-git_strmap *git__pack_cache = NULL;
+GIT_HASHMAP_STR_FUNCTIONS(git_mwindow_packmap, , struct git_pack_file *);
+git_mwindow_packmap git_mwindow__pack_cache;
static void git_mwindow_global_shutdown(void)
{
- git_strmap *tmp = git__pack_cache;
-
- git_mutex_free(&git__mwindow_mutex);
-
- git__pack_cache = NULL;
- git_strmap_free(tmp);
+ git_mutex_free(&git_mwindow__mutex);
+ git_mwindow_packmap_dispose(&git_mwindow__pack_cache);
}
int git_mwindow_global_init(void)
{
int error;
- GIT_ASSERT(!git__pack_cache);
-
- if ((error = git_mutex_init(&git__mwindow_mutex)) < 0 ||
- (error = git_strmap_new(&git__pack_cache)) < 0)
+ if ((error = git_mutex_init(&git_mwindow__mutex)) < 0)
return error;
return git_runtime_shutdown_register(git_mwindow_global_shutdown);
@@ -73,31 +66,34 @@ int git_mwindow_get_pack(
if ((error = git_packfile__name(&packname, path)) < 0)
return error;
- if (git_mutex_lock(&git__mwindow_mutex) < 0) {
+ if (git_mutex_lock(&git_mwindow__mutex) < 0) {
git_error_set(GIT_ERROR_OS, "failed to lock mwindow mutex");
return -1;
}
- pack = git_strmap_get(git__pack_cache, packname);
+ error = git_mwindow_packmap_get(&pack, &git_mwindow__pack_cache, packname);
git__free(packname);
- if (pack != NULL) {
+ if (error == 0) {
git_atomic32_inc(&pack->refcount);
- git_mutex_unlock(&git__mwindow_mutex);
+ git_mutex_unlock(&git_mwindow__mutex);
*out = pack;
return 0;
+ } else if (error != GIT_ENOTFOUND) {
+ return error;
}
/* If we didn't find it, we need to create it */
if ((error = git_packfile_alloc(&pack, path, oid_type)) < 0) {
- git_mutex_unlock(&git__mwindow_mutex);
+ git_mutex_unlock(&git_mwindow__mutex);
return error;
}
git_atomic32_inc(&pack->refcount);
- error = git_strmap_set(git__pack_cache, pack->pack_name, pack);
- git_mutex_unlock(&git__mwindow_mutex);
+ error = git_mwindow_packmap_put(&git_mwindow__pack_cache, pack->pack_name, pack);
+ git_mutex_unlock(&git_mwindow__mutex);
+
if (error < 0) {
git_packfile_free(pack, false);
return error;
@@ -112,21 +108,18 @@ int git_mwindow_put_pack(struct git_pack_file *pack)
int count, error;
struct git_pack_file *pack_to_delete = NULL;
- if ((error = git_mutex_lock(&git__mwindow_mutex)) < 0)
+ if ((error = git_mutex_lock(&git_mwindow__mutex)) < 0)
return error;
- /* put before get would be a corrupted state */
- GIT_ASSERT(git__pack_cache);
-
/* if we cannot find it, the state is corrupted */
- GIT_ASSERT(git_strmap_exists(git__pack_cache, pack->pack_name));
+ GIT_ASSERT(git_mwindow_packmap_contains(&git_mwindow__pack_cache, pack->pack_name));
count = git_atomic32_dec(&pack->refcount);
if (count == 0) {
- git_strmap_delete(git__pack_cache, pack->pack_name);
+ git_mwindow_packmap_remove(&git_mwindow__pack_cache, pack->pack_name);
pack_to_delete = pack;
}
- git_mutex_unlock(&git__mwindow_mutex);
+ git_mutex_unlock(&git_mwindow__mutex);
git_packfile_free(pack_to_delete, false);
return 0;
@@ -134,7 +127,7 @@ int git_mwindow_put_pack(struct git_pack_file *pack)
/*
* Free all the windows in a sequence, typically because we're done
- * with the file. Needs to hold the git__mwindow_mutex.
+ * with the file. Needs to hold the git_mwindow__mutex.
*/
static int git_mwindow_free_all_locked(git_mwindow_file *mwf)
{
@@ -152,7 +145,7 @@ static int git_mwindow_free_all_locked(git_mwindow_file *mwf)
}
if (ctl->windowfiles.length == 0) {
- git_vector_free(&ctl->windowfiles);
+ git_vector_dispose(&ctl->windowfiles);
ctl->windowfiles.contents = NULL;
}
@@ -176,14 +169,14 @@ int git_mwindow_free_all(git_mwindow_file *mwf)
{
int error;
- if (git_mutex_lock(&git__mwindow_mutex)) {
+ if (git_mutex_lock(&git_mwindow__mutex)) {
git_error_set(GIT_ERROR_THREAD, "unable to lock mwindow mutex");
return -1;
}
error = git_mwindow_free_all_locked(mwf);
- git_mutex_unlock(&git__mwindow_mutex);
+ git_mutex_unlock(&git_mwindow__mutex);
return error;
}
@@ -405,7 +398,7 @@ unsigned char *git_mwindow_open(
git_mwindow_ctl *ctl = &git_mwindow__mem_ctl;
git_mwindow *w = *cursor;
- if (git_mutex_lock(&git__mwindow_mutex)) {
+ if (git_mutex_lock(&git_mwindow__mutex)) {
git_error_set(GIT_ERROR_THREAD, "unable to lock mwindow mutex");
return NULL;
}
@@ -427,7 +420,7 @@ unsigned char *git_mwindow_open(
if (!w) {
w = new_window_locked(mwf->fd, mwf->size, offset);
if (w == NULL) {
- git_mutex_unlock(&git__mwindow_mutex);
+ git_mutex_unlock(&git_mwindow__mutex);
return NULL;
}
w->next = mwf->windows;
@@ -447,7 +440,7 @@ unsigned char *git_mwindow_open(
if (left)
*left = (unsigned int)(w->window_map.len - offset);
- git_mutex_unlock(&git__mwindow_mutex);
+ git_mutex_unlock(&git_mwindow__mutex);
return (unsigned char *) w->window_map.data + offset;
}
@@ -459,14 +452,14 @@ int git_mwindow_file_register(git_mwindow_file *mwf)
size_t i;
git_mwindow_file *closed_file = NULL;
- if (git_mutex_lock(&git__mwindow_mutex)) {
+ if (git_mutex_lock(&git_mwindow__mutex)) {
git_error_set(GIT_ERROR_THREAD, "unable to lock mwindow mutex");
return -1;
}
if (ctl->windowfiles.length == 0 &&
(error = git_vector_init(&ctl->windowfiles, 8, NULL)) < 0) {
- git_mutex_unlock(&git__mwindow_mutex);
+ git_mutex_unlock(&git_mwindow__mutex);
goto cleanup;
}
@@ -486,7 +479,7 @@ int git_mwindow_file_register(git_mwindow_file *mwf)
}
error = git_vector_insert(&ctl->windowfiles, mwf);
- git_mutex_unlock(&git__mwindow_mutex);
+ git_mutex_unlock(&git_mwindow__mutex);
if (error < 0)
goto cleanup;
@@ -505,7 +498,7 @@ int git_mwindow_file_register(git_mwindow_file *mwf)
}
cleanup:
- git_vector_free(&closed_files);
+ git_vector_dispose(&closed_files);
return error;
}
@@ -515,30 +508,30 @@ void git_mwindow_file_deregister(git_mwindow_file *mwf)
git_mwindow_file *cur;
size_t i;
- if (git_mutex_lock(&git__mwindow_mutex))
+ if (git_mutex_lock(&git_mwindow__mutex))
return;
git_vector_foreach(&ctl->windowfiles, i, cur) {
if (cur == mwf) {
git_vector_remove(&ctl->windowfiles, i);
- git_mutex_unlock(&git__mwindow_mutex);
+ git_mutex_unlock(&git_mwindow__mutex);
return;
}
}
- git_mutex_unlock(&git__mwindow_mutex);
+ git_mutex_unlock(&git_mwindow__mutex);
}
void git_mwindow_close(git_mwindow **window)
{
git_mwindow *w = *window;
if (w) {
- if (git_mutex_lock(&git__mwindow_mutex)) {
+ if (git_mutex_lock(&git_mwindow__mutex)) {
git_error_set(GIT_ERROR_THREAD, "unable to lock mwindow mutex");
return;
}
w->inuse_cnt--;
- git_mutex_unlock(&git__mwindow_mutex);
+ git_mutex_unlock(&git_mwindow__mutex);
*window = NULL;
}
}
diff --git a/src/libgit2/mwindow.h b/src/libgit2/mwindow.h
index 8e6df2613b7..43352c4196b 100644
--- a/src/libgit2/mwindow.h
+++ b/src/libgit2/mwindow.h
@@ -12,6 +12,10 @@
#include "map.h"
#include "vector.h"
+#include "hashmap_str.h"
+
+GIT_HASHMAP_STR_STRUCT(git_mwindow_packmap, struct git_pack_file *);
+GIT_HASHMAP_STR_PROTOTYPES(git_mwindow_packmap, struct git_pack_file *);
typedef struct git_mwindow {
struct git_mwindow *next;
diff --git a/src/libgit2/netops.c b/src/libgit2/netops.c
deleted file mode 100644
index 00640c600ee..00000000000
--- a/src/libgit2/netops.c
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
- * Copyright (C) the libgit2 contributors. All rights reserved.
- *
- * This file is part of libgit2, distributed under the GNU GPL v2 with
- * a Linking Exception. For full terms see the included COPYING file.
- */
-
-#include "netops.h"
-
-#include
-#include "git2/errors.h"
-
-#include "posix.h"
-#include "str.h"
-#include "runtime.h"
-
-int gitno_recv(gitno_buffer *buf)
-{
- return buf->recv(buf);
-}
-
-void gitno_buffer_setup_callback(
- gitno_buffer *buf,
- char *data,
- size_t len,
- int (*recv)(gitno_buffer *buf), void *cb_data)
-{
- memset(data, 0x0, len);
- buf->data = data;
- buf->len = len;
- buf->offset = 0;
- buf->recv = recv;
- buf->cb_data = cb_data;
-}
-
-static int recv_stream(gitno_buffer *buf)
-{
- git_stream *io = (git_stream *) buf->cb_data;
- size_t readlen = buf->len - buf->offset;
- ssize_t ret;
-
- readlen = min(readlen, INT_MAX);
-
- ret = git_stream_read(io, buf->data + buf->offset, (int)readlen);
- if (ret < 0)
- return -1;
-
- buf->offset += ret;
- return (int)ret;
-}
-
-void gitno_buffer_setup_fromstream(git_stream *st, gitno_buffer *buf, char *data, size_t len)
-{
- memset(data, 0x0, len);
- buf->data = data;
- buf->len = len;
- buf->offset = 0;
- buf->recv = recv_stream;
- buf->cb_data = st;
-}
-
-/* Consume up to ptr and move the rest of the buffer to the beginning */
-int gitno_consume(gitno_buffer *buf, const char *ptr)
-{
- size_t consumed;
-
- GIT_ASSERT(ptr - buf->data >= 0);
- GIT_ASSERT(ptr - buf->data <= (int) buf->len);
-
- consumed = ptr - buf->data;
-
- memmove(buf->data, ptr, buf->offset - consumed);
- memset(buf->data + buf->offset, 0x0, buf->len - buf->offset);
- buf->offset -= consumed;
-
- return 0;
-}
-
-/* Consume const bytes and move the rest of the buffer to the beginning */
-void gitno_consume_n(gitno_buffer *buf, size_t cons)
-{
- memmove(buf->data, buf->data + cons, buf->len - buf->offset);
- memset(buf->data + cons, 0x0, buf->len - buf->offset);
- buf->offset -= cons;
-}
-
-/* Match host names according to RFC 2818 rules */
-int gitno__match_host(const char *pattern, const char *host)
-{
- for (;;) {
- char c = git__tolower(*pattern++);
-
- if (c == '\0')
- return *host ? -1 : 0;
-
- if (c == '*') {
- c = *pattern;
- /* '*' at the end matches everything left */
- if (c == '\0')
- return 0;
-
- /*
- * We've found a pattern, so move towards the next matching
- * char. The '.' is handled specially because wildcards aren't
- * allowed to cross subdomains.
- */
-
- while(*host) {
- char h = git__tolower(*host);
- if (c == h)
- return gitno__match_host(pattern, host++);
- if (h == '.')
- return gitno__match_host(pattern, host);
- host++;
- }
- return -1;
- }
-
- if (c != git__tolower(*host++))
- return -1;
- }
-
- return -1;
-}
diff --git a/src/libgit2/netops.h b/src/libgit2/netops.h
deleted file mode 100644
index 56f96853459..00000000000
--- a/src/libgit2/netops.h
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * Copyright (C) the libgit2 contributors. All rights reserved.
- *
- * This file is part of libgit2, distributed under the GNU GPL v2 with
- * a Linking Exception. For full terms see the included COPYING file.
- */
-#ifndef INCLUDE_netops_h__
-#define INCLUDE_netops_h__
-
-#include "common.h"
-
-#include "posix.h"
-#include "stream.h"
-#include "net.h"
-
-#ifdef GIT_OPENSSL
-# include "streams/openssl.h"
-#endif
-
-typedef struct gitno_ssl {
-#ifdef GIT_OPENSSL
- SSL *ssl;
-#else
- size_t dummy;
-#endif
-} gitno_ssl;
-
-/* Represents a socket that may or may not be using SSL */
-typedef struct gitno_socket {
- GIT_SOCKET socket;
- gitno_ssl ssl;
-} gitno_socket;
-
-typedef struct gitno_buffer {
- char *data;
- size_t len;
- size_t offset;
- int (*recv)(struct gitno_buffer *buffer);
- void *cb_data;
-} gitno_buffer;
-
-/* Flags to gitno_connect */
-enum {
- /* Attempt to create an SSL connection. */
- GITNO_CONNECT_SSL = 1
-};
-
-/**
- * Check if the name in a cert matches the wanted hostname
- *
- * Check if a pattern from a certificate matches the hostname we
- * wanted to connect to according to RFC2818 rules (which specifies
- * HTTP over TLS). Mainly, an asterisk matches anything, but is
- * limited to a single url component.
- *
- * Note that this does not set an error message. It expects the user
- * to provide the message for the user.
- */
-int gitno__match_host(const char *pattern, const char *host);
-
-void gitno_buffer_setup_fromstream(git_stream *st, gitno_buffer *buf, char *data, size_t len);
-void gitno_buffer_setup_callback(gitno_buffer *buf, char *data, size_t len, int (*recv)(gitno_buffer *buf), void *cb_data);
-int gitno_recv(gitno_buffer *buf);
-
-int gitno_consume(gitno_buffer *buf, const char *ptr);
-void gitno_consume_n(gitno_buffer *buf, size_t cons);
-
-#endif
diff --git a/src/libgit2/notes.c b/src/libgit2/notes.c
index 1b1935330e9..393c1363a39 100644
--- a/src/libgit2/notes.c
+++ b/src/libgit2/notes.c
@@ -460,7 +460,7 @@ int git_note_commit_read(
{
int error;
git_tree *tree = NULL;
- char target[GIT_OID_SHA1_HEXSIZE + 1];
+ char target[GIT_OID_MAX_HEXSIZE + 1];
git_oid_tostr(target, sizeof(target), oid);
@@ -507,7 +507,7 @@ int git_note_commit_create(
{
int error;
git_tree *tree = NULL;
- char target[GIT_OID_SHA1_HEXSIZE + 1];
+ char target[GIT_OID_MAX_HEXSIZE + 1];
git_oid_tostr(target, sizeof(target), oid);
@@ -578,7 +578,7 @@ int git_note_commit_remove(
{
int error;
git_tree *tree = NULL;
- char target[GIT_OID_SHA1_HEXSIZE + 1];
+ char target[GIT_OID_MAX_HEXSIZE + 1];
git_oid_tostr(target, sizeof(target), oid);
@@ -665,8 +665,9 @@ void git_note_free(git_note *note)
}
static int process_entry_path(
- const char *entry_path,
- git_oid *annotated_object_id)
+ git_oid *annotated_object_id,
+ git_note_iterator *it,
+ const char *entry_path)
{
int error = 0;
size_t i = 0, j = 0, len;
@@ -698,12 +699,12 @@ static int process_entry_path(
buf.ptr[j] = '\0';
buf.size = j;
- if (j != GIT_OID_SHA1_HEXSIZE) {
+ if (j != git_oid_hexsize(it->repo->oid_type)) {
/* This is not a note entry */
goto cleanup;
}
- error = git_oid__fromstr(annotated_object_id, buf.ptr, GIT_OID_SHA1);
+ error = git_oid_from_string(annotated_object_id, buf.ptr, it->repo->oid_type);
cleanup:
git_str_dispose(&buf);
@@ -799,7 +800,7 @@ int git_note_next(
git_oid_cpy(note_id, &item->id);
- if ((error = process_entry_path(item->path, annotated_id)) < 0)
+ if ((error = process_entry_path(annotated_id, it, item->path)) < 0)
return error;
if ((error = git_iterator_advance(NULL, it)) < 0 && error != GIT_ITEROVER)
diff --git a/src/libgit2/object.c b/src/libgit2/object.c
index d87d40cf16d..f20dbb6cf36 100644
--- a/src/libgit2/object.c
+++ b/src/libgit2/object.c
@@ -33,7 +33,7 @@ typedef struct {
} git_object_def;
static git_object_def git_objects_table[] = {
- /* 0 = GIT_OBJECT__EXT1 */
+ /* 0 = unused */
{ "", 0, NULL, NULL, NULL },
/* 1 = GIT_OBJECT_COMMIT */
@@ -46,14 +46,7 @@ static git_object_def git_objects_table[] = {
{ "blob", sizeof(git_blob), git_blob__parse, git_blob__parse_raw, git_blob__free },
/* 4 = GIT_OBJECT_TAG */
- { "tag", sizeof(git_tag), git_tag__parse, git_tag__parse_raw, git_tag__free },
-
- /* 5 = GIT_OBJECT__EXT2 */
- { "", 0, NULL, NULL, NULL },
- /* 6 = GIT_OBJECT_OFS_DELTA */
- { "OFS_DELTA", 0, NULL, NULL, NULL },
- /* 7 = GIT_OBJECT_REF_DELTA */
- { "REF_DELTA", 0, NULL, NULL, NULL },
+ { "tag", sizeof(git_tag), git_tag__parse, git_tag__parse_raw, git_tag__free }
};
int git_object__from_raw(
@@ -108,15 +101,13 @@ int git_object__from_raw(
return 0;
}
-int git_object__from_odb_object(
+int git_object__init_from_odb_object(
git_object **object_out,
git_repository *repo,
git_odb_object *odb_obj,
git_object_t type)
{
- int error;
size_t object_size;
- git_object_def *def;
git_object *object = NULL;
GIT_ASSERT_ARG(object_out);
@@ -143,6 +134,23 @@ int git_object__from_odb_object(
object->cached.size = odb_obj->cached.size;
object->repo = repo;
+ *object_out = object;
+ return 0;
+}
+
+int git_object__from_odb_object(
+ git_object **object_out,
+ git_repository *repo,
+ git_odb_object *odb_obj,
+ git_object_t type)
+{
+ int error;
+ git_object_def *def;
+ git_object *object = NULL;
+
+ if ((error = git_object__init_from_odb_object(&object, repo, odb_obj, type)) < 0)
+ return error;
+
/* Parse raw object data */
def = &git_objects_table[odb_obj->cached.type];
GIT_ASSERT(def->free && def->parse);
@@ -181,6 +189,7 @@ int git_object_lookup_prefix(
git_object *object = NULL;
git_odb *odb = NULL;
git_odb_object *odb_obj = NULL;
+ size_t oid_hexsize;
int error = 0;
GIT_ASSERT_ARG(repo);
@@ -196,10 +205,12 @@ int git_object_lookup_prefix(
if (error < 0)
return error;
- if (len > GIT_OID_SHA1_HEXSIZE)
- len = GIT_OID_SHA1_HEXSIZE;
+ oid_hexsize = git_oid_hexsize(repo->oid_type);
- if (len == GIT_OID_SHA1_HEXSIZE) {
+ if (len > oid_hexsize)
+ len = oid_hexsize;
+
+ if (len == oid_hexsize) {
git_cached_obj *cached = NULL;
/* We want to match the full id : we can first look up in the cache,
@@ -233,8 +244,9 @@ int git_object_lookup_prefix(
error = git_odb_read(&odb_obj, odb, id);
}
} else {
- git_oid short_oid = GIT_OID_SHA1_ZERO;
+ git_oid short_oid;
+ git_oid_clear(&short_oid, repo->oid_type);
git_oid__cpy_prefix(&short_oid, id, len);
/* If len < GIT_OID_SHA1_HEXSIZE (a strict short oid was given), we have
@@ -262,7 +274,8 @@ int git_object_lookup_prefix(
}
int git_object_lookup(git_object **object_out, git_repository *repo, const git_oid *id, git_object_t type) {
- return git_object_lookup_prefix(object_out, repo, id, GIT_OID_SHA1_HEXSIZE, type);
+ return git_object_lookup_prefix(object_out,
+ repo, id, git_oid_hexsize(repo->oid_type), type);
}
void git_object_free(git_object *object)
@@ -322,7 +335,7 @@ git_object_t git_object_stringn2type(const char *str, size_t len)
return GIT_OBJECT_INVALID;
}
-int git_object_typeisloose(git_object_t type)
+int git_object_type_is_valid(git_object_t type)
{
if (type < 0 || ((size_t) type) >= ARRAY_SIZE(git_objects_table))
return 0;
@@ -330,6 +343,13 @@ int git_object_typeisloose(git_object_t type)
return (git_objects_table[type].size > 0) ? 1 : 0;
}
+#ifndef GIT_DEPRECATE_HARD
+int git_object_typeisloose(git_object_t type)
+{
+ return git_object_type_is_valid(type);
+}
+#endif
+
size_t git_object__size(git_object_t type)
{
if (type < 0 || ((size_t) type) >= ARRAY_SIZE(git_objects_table))
@@ -503,31 +523,37 @@ int git_object_lookup_bypath(
static int git_object__short_id(git_str *out, const git_object *obj)
{
git_repository *repo;
- int len = GIT_ABBREV_DEFAULT, error;
- git_oid id = GIT_OID_SHA1_ZERO;
+ git_oid id;
git_odb *odb;
+ size_t oid_hexsize;
+ int len, error;
GIT_ASSERT_ARG(out);
GIT_ASSERT_ARG(obj);
repo = git_object_owner(obj);
- if ((error = git_repository__configmap_lookup(&len, repo, GIT_CONFIGMAP_ABBREV)) < 0)
+ git_oid_clear(&id, repo->oid_type);
+ oid_hexsize = git_oid_hexsize(repo->oid_type);
+
+ if ((error = git_repository__abbrev_length(&len, repo)) < 0)
return error;
+ if ((size_t)len == oid_hexsize) {
+ if ((error = git_oid_cpy(&id, &obj->cached.oid)) < 0) {
+ return error;
+ }
+ }
+
if ((error = git_repository_odb(&odb, repo)) < 0)
return error;
- while (len < GIT_OID_SHA1_HEXSIZE) {
+ while ((size_t)len < oid_hexsize) {
/* set up short oid */
memcpy(&id.id, &obj->cached.oid.id, (len + 1) / 2);
if (len & 1)
id.id[len / 2] &= 0xf0;
-#ifdef GIT_EXPERIMENTAL_SHA256
- id.type = GIT_OID_SHA1;
-#endif
-
error = git_odb_exists_prefix(NULL, odb, &id, len);
if (error != GIT_EAMBIGUOUS)
break;
@@ -636,7 +662,7 @@ int git_object__parse_oid_header(
if (buffer[header_len + sha_len] != '\n')
return -1;
- if (git_oid__fromstr(oid, buffer + header_len, oid_type) < 0)
+ if (git_oid_from_prefix(oid, buffer + header_len, sha_len, oid_type) < 0)
return -1;
*buffer_out = buffer + (header_len + sha_len + 1);
diff --git a/src/libgit2/object.h b/src/libgit2/object.h
index a29fdfbf3dd..b6c604c8178 100644
--- a/src/libgit2/object.h
+++ b/src/libgit2/object.h
@@ -36,6 +36,12 @@ int git_object__from_raw(
git_object_t object_type,
git_oid_t oid_type);
+int git_object__init_from_odb_object(
+ git_object **object_out,
+ git_repository *repo,
+ git_odb_object *odb_obj,
+ git_object_t type);
+
int git_object__from_odb_object(
git_object **object_out,
git_repository *repo,
diff --git a/src/libgit2/odb.c b/src/libgit2/odb.c
index 1a02cbad974..e58f3c9426b 100644
--- a/src/libgit2/odb.c
+++ b/src/libgit2/odb.c
@@ -116,7 +116,7 @@ int git_odb__hashobj(git_oid *id, git_rawobj *obj, git_oid_t oid_type)
GIT_ASSERT_ARG(id);
GIT_ASSERT_ARG(obj);
- if (!git_object_typeisloose(obj->type)) {
+ if (!git_object_type_is_valid(obj->type)) {
git_error_set(GIT_ERROR_INVALID, "invalid object type");
return -1;
}
@@ -219,7 +219,7 @@ int git_odb__hashfd(
ssize_t read_len = 0;
int error = 0;
- if (!git_object_typeisloose(object_type)) {
+ if (!git_object_type_is_valid(object_type)) {
git_error_set(GIT_ERROR_INVALID, "invalid object type for hash");
return -1;
}
@@ -536,9 +536,14 @@ static void normalize_options(
opts->oid_type = GIT_OID_DEFAULT;
}
-int git_odb__new(git_odb **out, const git_odb_options *opts)
+int git_odb_new_ext(git_odb **out, const git_odb_options *opts)
{
- git_odb *db = git__calloc(1, sizeof(*db));
+ git_odb *db;
+
+ GIT_ASSERT_ARG(out);
+ GIT_ERROR_CHECK_VERSION(opts, GIT_ODB_OPTIONS_VERSION, "git_odb_options");
+
+ db = git__calloc(1, sizeof(*db));
GIT_ERROR_CHECK_ALLOC(db);
normalize_options(&db->options, opts);
@@ -564,17 +569,10 @@ int git_odb__new(git_odb **out, const git_odb_options *opts)
return 0;
}
-#ifdef GIT_EXPERIMENTAL_SHA256
-int git_odb_new(git_odb **out, const git_odb_options *opts)
-{
- return git_odb__new(out, opts);
-}
-#else
int git_odb_new(git_odb **out)
{
- return git_odb__new(out, NULL);
+ return git_odb_new_ext(out, NULL);
}
-#endif
static int add_backend_internal(
git_odb *odb, git_odb_backend *backend,
@@ -748,7 +746,8 @@ int git_odb__add_default_backends(
git_error_set(GIT_ERROR_ODB, "failed to acquire the odb lock");
return -1;
}
- if (!db->cgraph && git_commit_graph_new(&db->cgraph, objects_dir, false) < 0) {
+ if (!db->cgraph &&
+ git_commit_graph_new(&db->cgraph, objects_dir, false, db->options.oid_type) < 0) {
git_mutex_unlock(&db->lock);
return -1;
}
@@ -789,12 +788,8 @@ static int load_alternates(git_odb *odb, const char *objects_dir, int alternate_
if (*alternate == '\0' || *alternate == '#')
continue;
- /*
- * Relative path: build based on the current `objects`
- * folder. However, relative paths are only allowed in
- * the current repository.
- */
- if (*alternate == '.' && !alternate_depth) {
+ /* Relative path: build based on the current `objects` folder. */
+ if (*alternate == '.') {
if ((result = git_str_joinpath(&alternates_path, objects_dir, alternate)) < 0)
break;
alternate = git_str_cstr(&alternates_path);
@@ -832,7 +827,7 @@ int git_odb_set_commit_graph(git_odb *odb, git_commit_graph *cgraph)
return error;
}
-int git_odb__open(
+int git_odb_open_ext(
git_odb **out,
const char *objects_dir,
const git_odb_options *opts)
@@ -841,10 +836,11 @@ int git_odb__open(
GIT_ASSERT_ARG(out);
GIT_ASSERT_ARG(objects_dir);
+ GIT_ERROR_CHECK_VERSION(opts, GIT_ODB_OPTIONS_VERSION, "git_odb_options");
*out = NULL;
- if (git_odb__new(&db, opts) < 0)
+ if (git_odb_new_ext(&db, opts) < 0)
return -1;
if (git_odb__add_default_backends(db, objects_dir, 0, 0) < 0) {
@@ -856,6 +852,11 @@ int git_odb__open(
return 0;
}
+int git_odb_open(git_odb **out, const char *objects_dir)
+{
+ return git_odb_open_ext(out, objects_dir, NULL);
+}
+
int git_odb__set_caps(git_odb *odb, int caps)
{
if (caps == GIT_ODB_CAP_FROM_OWNER) {
@@ -895,7 +896,7 @@ static void odb_free(git_odb *db)
git_mutex_unlock(&db->lock);
git_commit_graph_free(db->cgraph);
- git_vector_free(&db->backends);
+ git_vector_dispose(&db->backends);
git_cache_dispose(&db->own_cache);
git_mutex_free(&db->lock);
@@ -1474,11 +1475,16 @@ static int read_prefix_1(git_odb_object **out, git_odb *db,
if (found && git_oid__cmp(&full_oid, &found_full_oid)) {
git_str buf = GIT_STR_INIT;
+ const char *idstr;
+
+ if ((idstr = git_oid_tostr_s(&full_oid)) == NULL) {
+ git_str_puts(&buf, "failed to parse object id");
+ } else {
+ git_str_printf(&buf, "multiple matches for prefix: %s", idstr);
- git_str_printf(&buf, "multiple matches for prefix: %s",
- git_oid_tostr_s(&full_oid));
- git_str_printf(&buf, " %s",
- git_oid_tostr_s(&found_full_oid));
+ if ((idstr = git_oid_tostr_s(&found_full_oid)) != NULL)
+ git_str_printf(&buf, " %s", idstr);
+ }
error = git_odb__error_ambiguous(buf.ptr);
git_str_dispose(&buf);
@@ -1584,7 +1590,7 @@ int git_odb_foreach(git_odb *db, git_odb_foreach_cb cb, void *payload)
}
cleanup:
- git_vector_free(&backends);
+ git_vector_dispose(&backends);
return error;
}
@@ -1771,7 +1777,8 @@ void git_odb_stream_free(git_odb_stream *stream)
if (stream == NULL)
return;
- git_hash_ctx_cleanup(stream->hash_ctx);
+ if (stream->hash_ctx)
+ git_hash_ctx_cleanup(stream->hash_ctx);
git__free(stream->hash_ctx);
stream->free(stream);
}
@@ -1897,7 +1904,7 @@ void git_odb_backend_data_free(git_odb_backend *backend, void *data)
git__free(data);
}
-int git_odb_refresh(struct git_odb *db)
+int git_odb_refresh(git_odb *db)
{
size_t i;
int error;
diff --git a/src/libgit2/odb.h b/src/libgit2/odb.h
index 7a712e20262..fa50b984971 100644
--- a/src/libgit2/odb.h
+++ b/src/libgit2/odb.h
@@ -160,13 +160,6 @@ void git_odb_object__free(void *object);
/* SHA256 support */
-int git_odb__new(git_odb **out, const git_odb_options *opts);
-
-int git_odb__open(
- git_odb **out,
- const char *objects_dir,
- const git_odb_options *opts);
-
int git_odb__hash(
git_oid *out,
const void *data,
@@ -180,9 +173,22 @@ int git_odb__hashfile(
git_object_t object_type,
git_oid_t oid_type);
-GIT_EXTERN(int) git_odb__backend_loose(
+int git_odb__backend_loose(
git_odb_backend **out,
const char *objects_dir,
git_odb_backend_loose_options *opts);
+#ifndef GIT_EXPERIMENTAL_SHA256
+
+int git_odb_open_ext(
+ git_odb **odb_out,
+ const char *objects_dir,
+ const git_odb_options *opts);
+
+int git_odb_new_ext(
+ git_odb **odb,
+ const git_odb_options *opts);
+
+#endif
+
#endif
diff --git a/src/libgit2/odb_loose.c b/src/libgit2/odb_loose.c
index 51195d35778..a91e296ae67 100644
--- a/src/libgit2/odb_loose.c
+++ b/src/libgit2/odb_loose.c
@@ -243,7 +243,7 @@ static int read_loose_packlike(git_rawobj *out, git_str *obj)
if ((error = parse_header_packlike(&hdr, &head_len, obj_data, obj_len)) < 0)
goto done;
- if (!git_object_typeisloose(hdr.type) || head_len > obj_len) {
+ if (!git_object_type_is_valid(hdr.type) || head_len > obj_len) {
git_error_set(GIT_ERROR_ODB, "failed to inflate loose object");
error = -1;
goto done;
@@ -296,7 +296,7 @@ static int read_loose_standard(git_rawobj *out, git_str *obj)
(error = parse_header(&hdr, &head_len, head, decompressed)) < 0)
goto done;
- if (!git_object_typeisloose(hdr.type)) {
+ if (!git_object_type_is_valid(hdr.type)) {
git_error_set(GIT_ERROR_ODB, "failed to inflate disk object");
error = -1;
goto done;
@@ -436,7 +436,7 @@ static int read_header_loose(git_rawobj *out, git_str *loc)
else
error = read_header_loose_standard(out, obj, (size_t)obj_len);
- if (!error && !git_object_typeisloose(out->type)) {
+ if (!error && !git_object_type_is_valid(out->type)) {
git_error_set(GIT_ERROR_ZLIB, "failed to read loose object header");
error = -1;
goto done;
@@ -552,7 +552,10 @@ static int locate_object_short_oid(
return git_odb__error_ambiguous("multiple matches in loose objects");
/* Convert obtained hex formatted oid to raw */
- error = git_oid__fromstr(res_oid, (char *)state.res_oid, backend->options.oid_type);
+ error = git_oid_from_prefix(res_oid, (char *)state.res_oid,
+ git_oid_hexsize(backend->options.oid_type),
+ backend->options.oid_type);
+
if (error)
return error;
@@ -951,7 +954,7 @@ static int loose_backend__readstream_packlike(
if ((error = parse_header_packlike(hdr, &head_len, data, data_len)) < 0)
return error;
- if (!git_object_typeisloose(hdr->type)) {
+ if (!git_object_type_is_valid(hdr->type)) {
git_error_set(GIT_ERROR_ODB, "failed to inflate loose object");
return -1;
}
@@ -983,7 +986,7 @@ static int loose_backend__readstream_standard(
(error = parse_header(hdr, &head_len, head, init)) < 0)
return error;
- if (!git_object_typeisloose(hdr->type)) {
+ if (!git_object_type_is_valid(hdr->type)) {
git_error_set(GIT_ERROR_ODB, "failed to inflate disk object");
return -1;
}
diff --git a/src/libgit2/odb_mempack.c b/src/libgit2/odb_mempack.c
index 6f27f45f870..2f3fba9ad98 100644
--- a/src/libgit2/odb_mempack.c
+++ b/src/libgit2/odb_mempack.c
@@ -12,7 +12,6 @@
#include "hash.h"
#include "odb.h"
#include "array.h"
-#include "oidmap.h"
#include "pack-objects.h"
#include "git2/odb_backend.h"
@@ -29,9 +28,11 @@ struct memobject {
char data[GIT_FLEX_ARRAY];
};
+GIT_HASHMAP_OID_SETUP(git_odb_mempack_oidmap, struct memobject *);
+
struct memory_packer_db {
git_odb_backend parent;
- git_oidmap *objects;
+ git_odb_mempack_oidmap objects;
git_array_t(struct memobject *) commits;
};
@@ -41,7 +42,7 @@ static int impl__write(git_odb_backend *_backend, const git_oid *oid, const void
struct memobject *obj = NULL;
size_t alloc_len;
- if (git_oidmap_exists(db->objects, oid))
+ if (git_odb_mempack_oidmap_contains(&db->objects, oid))
return 0;
GIT_ERROR_CHECK_ALLOC_ADD(&alloc_len, sizeof(struct memobject), len);
@@ -53,7 +54,7 @@ static int impl__write(git_odb_backend *_backend, const git_oid *oid, const void
obj->len = len;
obj->type = type;
- if (git_oidmap_set(db->objects, &obj->oid, obj) < 0)
+ if (git_odb_mempack_oidmap_put(&db->objects, &obj->oid, obj) < 0)
return -1;
if (type == GIT_OBJECT_COMMIT) {
@@ -69,16 +70,17 @@ static int impl__exists(git_odb_backend *backend, const git_oid *oid)
{
struct memory_packer_db *db = (struct memory_packer_db *)backend;
- return git_oidmap_exists(db->objects, oid);
+ return git_odb_mempack_oidmap_contains(&db->objects, oid);
}
static int impl__read(void **buffer_p, size_t *len_p, git_object_t *type_p, git_odb_backend *backend, const git_oid *oid)
{
struct memory_packer_db *db = (struct memory_packer_db *)backend;
struct memobject *obj;
+ int error;
- if ((obj = git_oidmap_get(db->objects, oid)) == NULL)
- return GIT_ENOTFOUND;
+ if ((error = git_odb_mempack_oidmap_get(&obj, &db->objects, oid)) != 0)
+ return error;
*len_p = obj->len;
*type_p = obj->type;
@@ -93,9 +95,10 @@ static int impl__read_header(size_t *len_p, git_object_t *type_p, git_odb_backen
{
struct memory_packer_db *db = (struct memory_packer_db *)backend;
struct memobject *obj;
+ int error;
- if ((obj = git_oidmap_get(db->objects, oid)) == NULL)
- return GIT_ENOTFOUND;
+ if ((error = git_odb_mempack_oidmap_get(&obj, &db->objects, oid)) != 0)
+ return error;
*len_p = obj->len;
*type_p = obj->type;
@@ -132,6 +135,29 @@ static int git_mempack__dump(
return err;
}
+int git_mempack_write_thin_pack(git_odb_backend *backend, git_packbuilder *pb)
+{
+ struct memory_packer_db *db = (struct memory_packer_db *)backend;
+ const git_oid *oid;
+ git_hashmap_iter_t iter = GIT_HASHMAP_INIT;
+ int err;
+
+ while (true) {
+ err = git_odb_mempack_oidmap_iterate(&iter, &oid, NULL, &db->objects);
+
+ if (err == GIT_ITEROVER)
+ break;
+ else if (err != 0)
+ return err;
+
+ err = git_packbuilder_insert(pb, oid, NULL);
+ if (err != 0)
+ return err;
+ }
+
+ return 0;
+}
+
int git_mempack_dump(
git_buf *pack,
git_repository *repo,
@@ -144,14 +170,13 @@ int git_mempack_reset(git_odb_backend *_backend)
{
struct memory_packer_db *db = (struct memory_packer_db *)_backend;
struct memobject *object = NULL;
+ git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
- git_oidmap_foreach_value(db->objects, object, {
+ while (git_odb_mempack_oidmap_iterate(&iter, NULL, &object, &db->objects) == 0)
git__free(object);
- });
git_array_clear(db->commits);
-
- git_oidmap_clear(db->objects);
+ git_odb_mempack_oidmap_clear(&db->objects);
return 0;
}
@@ -161,7 +186,7 @@ static void impl__free(git_odb_backend *_backend)
struct memory_packer_db *db = (struct memory_packer_db *)_backend;
git_mempack_reset(_backend);
- git_oidmap_free(db->objects);
+ git_odb_mempack_oidmap_dispose(&db->objects);
git__free(db);
}
@@ -174,9 +199,6 @@ int git_mempack_new(git_odb_backend **out)
db = git__calloc(1, sizeof(struct memory_packer_db));
GIT_ERROR_CHECK_ALLOC(db);
- if (git_oidmap_new(&db->objects) < 0)
- return -1;
-
db->parent.version = GIT_ODB_BACKEND_VERSION;
db->parent.read = &impl__read;
db->parent.write = &impl__write;
@@ -187,3 +209,13 @@ int git_mempack_new(git_odb_backend **out)
*out = (git_odb_backend *)db;
return 0;
}
+
+int git_mempack_object_count(size_t *out, git_odb_backend *_backend)
+{
+ struct memory_packer_db *db = (struct memory_packer_db *)_backend;
+
+ GIT_ASSERT_ARG(_backend);
+
+ *out = (size_t)git_odb_mempack_oidmap_size(&db->objects);
+ return 0;
+}
diff --git a/src/libgit2/odb_pack.c b/src/libgit2/odb_pack.c
index 1b1d122b06c..ef8d35309fe 100644
--- a/src/libgit2/odb_pack.c
+++ b/src/libgit2/odb_pack.c
@@ -309,11 +309,17 @@ static int pack_entry_find_prefix(
{
int error;
size_t i;
- git_oid found_full_oid = GIT_OID_SHA1_ZERO;
+ git_oid found_full_oid;
bool found = false;
struct git_pack_file *last_found = backend->last_found, *p;
git_midx_entry midx_entry;
+#ifdef GIT_EXPERIMENTAL_SHA256
+ git_oid_clear(&found_full_oid, short_oid->type);
+#else
+ git_oid_clear(&found_full_oid, GIT_OID_SHA1);
+#endif
+
if (backend->midx) {
error = git_midx_entry_find(&midx_entry, backend->midx, short_oid, len);
if (error == GIT_EAMBIGUOUS)
@@ -473,7 +479,9 @@ static int refresh_multi_pack_index(struct pack_backend *backend)
}
}
- error = git_midx_open(&backend->midx, git_str_cstr(&midx_path));
+ error = git_midx_open(&backend->midx, git_str_cstr(&midx_path),
+ backend->opts.oid_type);
+
git_str_dispose(&midx_path);
if (error < 0)
return error;
@@ -735,10 +743,10 @@ static int pack_backend__writepack(struct git_odb_writepack **out,
#ifdef GIT_EXPERIMENTAL_SHA256
opts.odb = odb;
+ opts.oid_type = backend->opts.oid_type;
error = git_indexer_new(&writepack->indexer,
backend->pack_folder,
- backend->opts.oid_type,
&opts);
#else
error = git_indexer_new(&writepack->indexer,
@@ -788,11 +796,24 @@ static int pack_backend__writemidx(git_odb_backend *_backend)
size_t i;
int error = 0;
+#ifdef GIT_EXPERIMENTAL_SHA256
+ git_midx_writer_options midx_opts = GIT_MIDX_WRITER_OPTIONS_INIT;
+#endif
+
GIT_ASSERT_ARG(_backend);
backend = (struct pack_backend *)_backend;
- error = git_midx_writer_new(&w, backend->pack_folder);
+#ifdef GIT_EXPERIMENTAL_SHA256
+ midx_opts.oid_type = backend->opts.oid_type;
+#endif
+
+ error = git_midx_writer_new(&w, backend->pack_folder
+#ifdef GIT_EXPERIMENTAL_SHA256
+ , &midx_opts
+#endif
+ );
+
if (error < 0)
return error;
@@ -850,8 +871,8 @@ static void pack_backend__free(git_odb_backend *_backend)
git_mwindow_put_pack(p);
git_midx_free(backend->midx);
- git_vector_free(&backend->midx_packs);
- git_vector_free(&backend->packs);
+ git_vector_dispose(&backend->midx_packs);
+ git_vector_dispose(&backend->packs);
git__free(backend->pack_folder);
git__free(backend);
}
@@ -870,7 +891,7 @@ static int pack_backend__alloc(
}
if (git_vector_init(&backend->packs, initial_size, packfile_sort__cb) < 0) {
- git_vector_free(&backend->midx_packs);
+ git_vector_dispose(&backend->midx_packs);
git__free(backend);
return -1;
}
diff --git a/src/libgit2/offmap.c b/src/libgit2/offmap.c
deleted file mode 100644
index be9eb66d8c0..00000000000
--- a/src/libgit2/offmap.c
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
- * Copyright (C) the libgit2 contributors. All rights reserved.
- *
- * This file is part of libgit2, distributed under the GNU GPL v2 with
- * a Linking Exception. For full terms see the included COPYING file.
- */
-
-#include "offmap.h"
-
-#define kmalloc git__malloc
-#define kcalloc git__calloc
-#define krealloc git__realloc
-#define kreallocarray git__reallocarray
-#define kfree git__free
-#include "khash.h"
-
-__KHASH_TYPE(off, off64_t, void *)
-
-__KHASH_IMPL(off, static kh_inline, off64_t, void *, 1, kh_int64_hash_func, kh_int64_hash_equal)
-
-
-int git_offmap_new(git_offmap **out)
-{
- *out = kh_init(off);
- GIT_ERROR_CHECK_ALLOC(*out);
-
- return 0;
-}
-
-void git_offmap_free(git_offmap *map)
-{
- kh_destroy(off, map);
-}
-
-void git_offmap_clear(git_offmap *map)
-{
- kh_clear(off, map);
-}
-
-size_t git_offmap_size(git_offmap *map)
-{
- return kh_size(map);
-}
-
-void *git_offmap_get(git_offmap *map, const off64_t key)
-{
- size_t idx = kh_get(off, map, key);
- if (idx == kh_end(map) || !kh_exist(map, idx))
- return NULL;
- return kh_val(map, idx);
-}
-
-int git_offmap_set(git_offmap *map, const off64_t key, void *value)
-{
- size_t idx;
- int rval;
-
- idx = kh_put(off, map, key, &rval);
- if (rval < 0)
- return -1;
-
- if (rval == 0)
- kh_key(map, idx) = key;
-
- kh_val(map, idx) = value;
-
- return 0;
-}
-
-int git_offmap_delete(git_offmap *map, const off64_t key)
-{
- khiter_t idx = kh_get(off, map, key);
- if (idx == kh_end(map))
- return GIT_ENOTFOUND;
- kh_del(off, map, idx);
- return 0;
-}
-
-int git_offmap_exists(git_offmap *map, const off64_t key)
-{
- return kh_get(off, map, key) != kh_end(map);
-}
-
-int git_offmap_iterate(void **value, git_offmap *map, size_t *iter, off64_t *key)
-{
- size_t i = *iter;
-
- while (i < map->n_buckets && !kh_exist(map, i))
- i++;
-
- if (i >= map->n_buckets)
- return GIT_ITEROVER;
-
- if (key)
- *key = kh_key(map, i);
- if (value)
- *value = kh_value(map, i);
- *iter = ++i;
-
- return 0;
-}
diff --git a/src/libgit2/offmap.h b/src/libgit2/offmap.h
deleted file mode 100644
index 81c459b0145..00000000000
--- a/src/libgit2/offmap.h
+++ /dev/null
@@ -1,133 +0,0 @@
-/*
- * Copyright (C) 2012 the libgit2 contributors
- *
- * This file is part of libgit2, distributed under the GNU GPL v2 with
- * a Linking Exception. For full terms see the included COPYING file.
- */
-#ifndef INCLUDE_offmap_h__
-#define INCLUDE_offmap_h__
-
-#include "common.h"
-
-#include "git2/types.h"
-
-/** A map with `off64_t`s as key. */
-typedef struct kh_off_s git_offmap;
-
-/**
- * Allocate a new `off64_t` map.
- *
- * @param out Pointer to the map that shall be allocated.
- * @return 0 on success, an error code if allocation has failed.
- */
-int git_offmap_new(git_offmap **out);
-
-/**
- * Free memory associated with the map.
- *
- * Note that this function will _not_ free values added to this
- * map.
- *
- * @param map Pointer to the map that is to be free'd. May be
- * `NULL`.
- */
-void git_offmap_free(git_offmap *map);
-
-/**
- * Clear all entries from the map.
- *
- * This function will remove all entries from the associated map.
- * Memory associated with it will not be released, though.
- *
- * @param map Pointer to the map that shall be cleared. May be
- * `NULL`.
- */
-void git_offmap_clear(git_offmap *map);
-
-/**
- * Return the number of elements in the map.
- *
- * @parameter map map containing the elements
- * @return number of elements in the map
- */
-size_t git_offmap_size(git_offmap *map);
-
-/**
- * Return value associated with the given key.
- *
- * @param map map to search key in
- * @param key key to search for
- * @return value associated with the given key or NULL if the key was not found
- */
-void *git_offmap_get(git_offmap *map, const off64_t key);
-
-/**
- * Set the entry for key to value.
- *
- * If the map has no corresponding entry for the given key, a new
- * entry will be created with the given value. If an entry exists
- * already, its value will be updated to match the given value.
- *
- * @param map map to create new entry in
- * @param key key to set
- * @param value value to associate the key with; may be NULL
- * @return zero if the key was successfully set, a negative error
- * code otherwise
- */
-int git_offmap_set(git_offmap *map, const off64_t key, void *value);
-
-/**
- * Delete an entry from the map.
- *
- * Delete the given key and its value from the map. If no such
- * key exists, this will do nothing.
- *
- * @param map map to delete key in
- * @param key key to delete
- * @return `0` if the key has been deleted, GIT_ENOTFOUND if no
- * such key was found, a negative code in case of an
- * error
- */
-int git_offmap_delete(git_offmap *map, const off64_t key);
-
-/**
- * Check whether a key exists in the given map.
- *
- * @param map map to query for the key
- * @param key key to search for
- * @return 0 if the key has not been found, 1 otherwise
- */
-int git_offmap_exists(git_offmap *map, const off64_t key);
-
-/**
- * Iterate over entries of the map.
- *
- * This functions allows to iterate over all key-value entries of
- * the map. The current position is stored in the `iter` variable
- * and should be initialized to `0` before the first call to this
- * function.
- *
- * @param map map to iterate over
- * @param value pointer to the variable where to store the current
- * value. May be NULL.
- * @param iter iterator storing the current position. Initialize
- * with zero previous to the first call.
- * @param key pointer to the variable where to store the current
- * key. May be NULL.
- * @return `0` if the next entry was correctly retrieved.
- * GIT_ITEROVER if no entries are left. A negative error
- * code otherwise.
- */
-int git_offmap_iterate(void **value, git_offmap *map, size_t *iter, off64_t *key);
-
-#define git_offmap_foreach(h, kvar, vvar, code) { size_t __i = 0; \
- while (git_offmap_iterate((void **) &(vvar), h, &__i, &(kvar)) == 0) { \
- code; \
- } }
-
-#define git_offmap_foreach_value(h, vvar, code) { size_t __i = 0; \
- while (git_offmap_iterate((void **) &(vvar), h, &__i, NULL) == 0) { \
- code; \
- } }
-
-#endif
diff --git a/src/libgit2/oid.c b/src/libgit2/oid.c
index 6cc21641d70..a550c4f693a 100644
--- a/src/libgit2/oid.c
+++ b/src/libgit2/oid.c
@@ -9,7 +9,7 @@
#include "git2/oid.h"
#include "repository.h"
-#include "threadstate.h"
+#include "runtime.h"
#include
#include
@@ -28,11 +28,7 @@ static int oid_error_invalid(const char *msg)
return -1;
}
-int git_oid__fromstrn(
- git_oid *out,
- const char *str,
- size_t length,
- git_oid_t type)
+int git_oid_from_prefix(git_oid *out, const char *str, size_t len, git_oid_t type)
{
size_t size, p;
int v;
@@ -43,10 +39,10 @@ int git_oid__fromstrn(
if (!(size = git_oid_size(type)))
return oid_error_invalid("unknown type");
- if (!length)
+ if (!len)
return oid_error_invalid("too short");
- if (length > git_oid_hexsize(type))
+ if (len > git_oid_hexsize(type))
return oid_error_invalid("too long");
#ifdef GIT_EXPERIMENTAL_SHA256
@@ -54,7 +50,7 @@ int git_oid__fromstrn(
#endif
memset(out->id, 0, size);
- for (p = 0; p < length; p++) {
+ for (p = 0; p < len; p++) {
v = git__fromhex(str[p]);
if (v < 0)
return oid_error_invalid("contains invalid characters");
@@ -65,54 +61,53 @@ int git_oid__fromstrn(
return 0;
}
-int git_oid__fromstrp(git_oid *out, const char *str, git_oid_t type)
+int git_oid_from_string(git_oid *out, const char *str, git_oid_t type)
{
- return git_oid__fromstrn(out, str, strlen(str), type);
-}
+ size_t hexsize;
-int git_oid__fromstr(git_oid *out, const char *str, git_oid_t type)
-{
- return git_oid__fromstrn(out, str, git_oid_hexsize(type), type);
-}
+ if (!(hexsize = git_oid_hexsize(type)))
+ return oid_error_invalid("unknown type");
-#ifdef GIT_EXPERIMENTAL_SHA256
-int git_oid_fromstrn(
- git_oid *out,
- const char *str,
- size_t length,
- git_oid_t type)
-{
- return git_oid__fromstrn(out, str, length, type);
-}
+ if (git_oid_from_prefix(out, str, hexsize, type) < 0)
+ return -1;
-int git_oid_fromstrp(git_oid *out, const char *str, git_oid_t type)
-{
- return git_oid_fromstrn(out, str, strlen(str), type);
+ if (str[hexsize] != '\0')
+ return oid_error_invalid("too long");
+
+ return 0;
}
-int git_oid_fromstr(git_oid *out, const char *str, git_oid_t type)
+int git_oid_from_raw(git_oid *out, const unsigned char *raw, git_oid_t type)
{
- return git_oid_fromstrn(out, str, git_oid_hexsize(type), type);
+ size_t size;
+
+ if (!(size = git_oid_size(type)))
+ return oid_error_invalid("unknown type");
+
+#ifdef GIT_EXPERIMENTAL_SHA256
+ out->type = type;
+#endif
+ memcpy(out->id, raw, size);
+ return 0;
}
-#else
+
int git_oid_fromstrn(
git_oid *out,
const char *str,
size_t length)
{
- return git_oid__fromstrn(out, str, length, GIT_OID_SHA1);
+ return git_oid_from_prefix(out, str, length, GIT_OID_SHA1);
}
int git_oid_fromstrp(git_oid *out, const char *str)
{
- return git_oid__fromstrn(out, str, strlen(str), GIT_OID_SHA1);
+ return git_oid_from_prefix(out, str, strlen(str), GIT_OID_SHA1);
}
int git_oid_fromstr(git_oid *out, const char *str)
{
- return git_oid__fromstrn(out, str, GIT_OID_SHA1_HEXSIZE, GIT_OID_SHA1);
+ return git_oid_from_prefix(out, str, GIT_OID_SHA1_HEXSIZE, GIT_OID_SHA1);
}
-#endif
int git_oid_nfmt(char *str, size_t n, const git_oid *oid)
{
@@ -153,9 +148,42 @@ int git_oid_pathfmt(char *str, const git_oid *oid)
return 0;
}
+static git_tlsdata_key thread_str_key;
+
+static void GIT_SYSTEM_CALL thread_str_free(void *s)
+{
+ char *str = (char *)s;
+ git__free(str);
+}
+
+static void thread_str_global_shutdown(void)
+{
+ char *str = git_tlsdata_get(thread_str_key);
+ git_tlsdata_set(thread_str_key, NULL);
+
+ git__free(str);
+ git_tlsdata_dispose(thread_str_key);
+}
+
+int git_oid_global_init(void)
+{
+ if (git_tlsdata_init(&thread_str_key, thread_str_free) != 0)
+ return -1;
+
+ return git_runtime_shutdown_register(thread_str_global_shutdown);
+}
+
char *git_oid_tostr_s(const git_oid *oid)
{
- char *str = GIT_THREADSTATE->oid_fmt;
+ char *str;
+
+ if ((str = git_tlsdata_get(thread_str_key)) == NULL) {
+ if ((str = git__malloc(GIT_OID_MAX_HEXSIZE + 1)) == NULL)
+ return NULL;
+
+ git_tlsdata_set(thread_str_key, str);
+ }
+
git_oid_nfmt(str, git_oid_hexsize(git_oid_type(oid)) + 1, oid);
return str;
}
@@ -194,31 +222,10 @@ char *git_oid_tostr(char *out, size_t n, const git_oid *oid)
return out;
}
-int git_oid__fromraw(git_oid *out, const unsigned char *raw, git_oid_t type)
-{
- size_t size;
-
- if (!(size = git_oid_size(type)))
- return oid_error_invalid("unknown type");
-
-#ifdef GIT_EXPERIMENTAL_SHA256
- out->type = type;
-#endif
- memcpy(out->id, raw, size);
- return 0;
-}
-
-#ifdef GIT_EXPERIMENTAL_SHA256
-int git_oid_fromraw(git_oid *out, const unsigned char *raw, git_oid_t type)
-{
- return git_oid__fromraw(out, raw, type);
-}
-#else
int git_oid_fromraw(git_oid *out, const unsigned char *raw)
{
- return git_oid__fromraw(out, raw, GIT_OID_SHA1);
+ return git_oid_from_raw(out, raw, GIT_OID_SHA1);
}
-#endif
int git_oid_cpy(git_oid *out, const git_oid *src)
{
diff --git a/src/libgit2/oid.h b/src/libgit2/oid.h
index 7b6b09d8bb6..cfcabce7111 100644
--- a/src/libgit2/oid.h
+++ b/src/libgit2/oid.h
@@ -66,6 +66,15 @@ GIT_INLINE(size_t) git_oid_hexsize(git_oid_t type)
return 0;
}
+GIT_INLINE(bool) git_oid_type_is_valid(git_oid_t type)
+{
+ return (type == GIT_OID_SHA1
+#ifdef GIT_EXPERIMENTAL_SHA256
+ || type == GIT_OID_SHA256
+#endif
+ );
+}
+
GIT_INLINE(const char *) git_oid_type_name(git_oid_t type)
{
switch (type) {
@@ -258,16 +267,12 @@ GIT_INLINE(void) git_oid_clear(git_oid *out, git_oid_t type)
/* SHA256 support */
-int git_oid__fromstr(git_oid *out, const char *str, git_oid_t type);
-
-int git_oid__fromstrp(git_oid *out, const char *str, git_oid_t type);
-
-int git_oid__fromstrn(
- git_oid *out,
- const char *str,
- size_t length,
- git_oid_t type);
+#ifndef GIT_EXPERIMENTAL_SHA256
+int git_oid_from_string(git_oid *out, const char *str, git_oid_t type);
+int git_oid_from_prefix(git_oid *out, const char *str, size_t len, git_oid_t type);
+int git_oid_from_raw(git_oid *out, const unsigned char *data, git_oid_t type);
+#endif
-int git_oid__fromraw(git_oid *out, const unsigned char *raw, git_oid_t type);
+int git_oid_global_init(void);
#endif
diff --git a/src/libgit2/oidarray.c b/src/libgit2/oidarray.c
index 583017c4ee2..37f67756aa5 100644
--- a/src/libgit2/oidarray.c
+++ b/src/libgit2/oidarray.c
@@ -15,10 +15,17 @@ void git_oidarray_dispose(git_oidarray *arr)
git__free(arr->ids);
}
-void git_oidarray__from_array(git_oidarray *arr, git_array_oid_t *array)
+void git_oidarray__from_array(git_oidarray *out, const git_array_oid_t *array)
{
- arr->count = array->size;
- arr->ids = array->ptr;
+ out->count = array->size;
+ out->ids = array->ptr;
+}
+
+void git_oidarray__to_array(git_array_oid_t *out, const git_oidarray *array)
+{
+ out->ptr = array->ids;
+ out->size = array->count;
+ out->asize = array->count;
}
void git_oidarray__reverse(git_oidarray *arr)
@@ -33,6 +40,45 @@ void git_oidarray__reverse(git_oidarray *arr)
}
}
+int git_oidarray__add(git_array_oid_t *arr, git_oid *id)
+{
+ git_oid *add, *iter;
+ size_t i;
+
+ git_array_foreach(*arr, i, iter) {
+ if (git_oid_cmp(iter, id) == 0)
+ return 0;
+ }
+
+ if ((add = git_array_alloc(*arr)) == NULL)
+ return -1;
+
+ git_oid_cpy(add, id);
+ return 0;
+}
+
+bool git_oidarray__remove(git_array_oid_t *arr, git_oid *id)
+{
+ bool found = false;
+ size_t remain, i;
+ git_oid *iter;
+
+ git_array_foreach(*arr, i, iter) {
+ if (git_oid_cmp(iter, id) == 0) {
+ arr->size--;
+ remain = arr->size - i;
+
+ if (remain > 0)
+ memmove(&arr->ptr[i], &arr->ptr[i+1], remain * sizeof(git_oid));
+
+ found = true;
+ break;
+ }
+ }
+
+ return found;
+}
+
#ifndef GIT_DEPRECATE_HARD
void git_oidarray_free(git_oidarray *arr)
diff --git a/src/libgit2/oidarray.h b/src/libgit2/oidarray.h
index eed3a109120..8f1543a32e0 100644
--- a/src/libgit2/oidarray.h
+++ b/src/libgit2/oidarray.h
@@ -15,6 +15,10 @@
typedef git_array_t(git_oid) git_array_oid_t;
extern void git_oidarray__reverse(git_oidarray *arr);
-extern void git_oidarray__from_array(git_oidarray *arr, git_array_oid_t *array);
+extern void git_oidarray__from_array(git_oidarray *out, const git_array_oid_t *array);
+extern void git_oidarray__to_array(git_array_oid_t *out, const git_oidarray *array);
+
+int git_oidarray__add(git_array_oid_t *arr, git_oid *id);
+bool git_oidarray__remove(git_array_oid_t *arr, git_oid *id);
#endif
diff --git a/src/libgit2/oidmap.c b/src/libgit2/oidmap.c
deleted file mode 100644
index eaf9fa051be..00000000000
--- a/src/libgit2/oidmap.c
+++ /dev/null
@@ -1,107 +0,0 @@
-/*
- * Copyright (C) the libgit2 contributors. All rights reserved.
- *
- * This file is part of libgit2, distributed under the GNU GPL v2 with
- * a Linking Exception. For full terms see the included COPYING file.
- */
-
-#include "oidmap.h"
-
-#define kmalloc git__malloc
-#define kcalloc git__calloc
-#define krealloc git__realloc
-#define kreallocarray git__reallocarray
-#define kfree git__free
-#include "khash.h"
-
-__KHASH_TYPE(oid, const git_oid *, void *)
-
-GIT_INLINE(khint_t) git_oidmap_hash(const git_oid *oid)
-{
- khint_t h;
- memcpy(&h, oid->id, sizeof(khint_t));
- return h;
-}
-
-__KHASH_IMPL(oid, static kh_inline, const git_oid *, void *, 1, git_oidmap_hash, git_oid_equal)
-
-int git_oidmap_new(git_oidmap **out)
-{
- *out = kh_init(oid);
- GIT_ERROR_CHECK_ALLOC(*out);
-
- return 0;
-}
-
-void git_oidmap_free(git_oidmap *map)
-{
- kh_destroy(oid, map);
-}
-
-void git_oidmap_clear(git_oidmap *map)
-{
- kh_clear(oid, map);
-}
-
-size_t git_oidmap_size(git_oidmap *map)
-{
- return kh_size(map);
-}
-
-void *git_oidmap_get(git_oidmap *map, const git_oid *key)
-{
- size_t idx = kh_get(oid, map, key);
- if (idx == kh_end(map) || !kh_exist(map, idx))
- return NULL;
- return kh_val(map, idx);
-}
-
-int git_oidmap_set(git_oidmap *map, const git_oid *key, void *value)
-{
- size_t idx;
- int rval;
-
- idx = kh_put(oid, map, key, &rval);
- if (rval < 0)
- return -1;
-
- if (rval == 0)
- kh_key(map, idx) = key;
-
- kh_val(map, idx) = value;
-
- return 0;
-}
-
-int git_oidmap_delete(git_oidmap *map, const git_oid *key)
-{
- khiter_t idx = kh_get(oid, map, key);
- if (idx == kh_end(map))
- return GIT_ENOTFOUND;
- kh_del(oid, map, idx);
- return 0;
-}
-
-int git_oidmap_exists(git_oidmap *map, const git_oid *key)
-{
- return kh_get(oid, map, key) != kh_end(map);
-}
-
-int git_oidmap_iterate(void **value, git_oidmap *map, size_t *iter, const git_oid **key)
-{
- size_t i = *iter;
-
- while (i < map->n_buckets && !kh_exist(map, i))
- i++;
-
- if (i >= map->n_buckets)
- return GIT_ITEROVER;
-
- if (key)
- *key = kh_key(map, i);
- if (value)
- *value = kh_value(map, i);
- *iter = ++i;
-
- return 0;
-}
diff --git a/src/libgit2/oidmap.h b/src/libgit2/oidmap.h
deleted file mode 100644
index b748f727c5e..00000000000
--- a/src/libgit2/oidmap.h
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- * Copyright (C) the libgit2 contributors. All rights reserved.
- *
- * This file is part of libgit2, distributed under the GNU GPL v2 with
- * a Linking Exception. For full terms see the included COPYING file.
- */
-#ifndef INCLUDE_oidmap_h__
-#define INCLUDE_oidmap_h__
-
-#include "common.h"
-
-#include "git2/oid.h"
-
-/** A map with `git_oid`s as key. */
-typedef struct kh_oid_s git_oidmap;
-
-/**
- * Allocate a new OID map.
- *
- * @param out Pointer to the map that shall be allocated.
- * @return 0 on success, an error code if allocation has failed.
- */
-int git_oidmap_new(git_oidmap **out);
-
-/**
- * Free memory associated with the map.
- *
- * Note that this function will _not_ free values added to this
- * map.
- *
- * @param map Pointer to the map that is to be free'd. May be
- * `NULL`.
- */
-void git_oidmap_free(git_oidmap *map);
-
-/**
- * Clear all entries from the map.
- *
- * This function will remove all entries from the associated map.
- * Memory associated with it will not be released, though.
- *
- * @param map Pointer to the map that shall be cleared. May be
- * `NULL`.
- */
-void git_oidmap_clear(git_oidmap *map);
-
-/**
- * Return the number of elements in the map.
- *
- * @parameter map map containing the elements
- * @return number of elements in the map
- */
-size_t git_oidmap_size(git_oidmap *map);
-
-/**
- * Return value associated with the given key.
- *
- * @param map map to search key in
- * @param key key to search for
- * @return value associated with the given key or NULL if the key was not found
- */
-void *git_oidmap_get(git_oidmap *map, const git_oid *key);
-
-/**
- * Set the entry for key to value.
- *
- * If the map has no corresponding entry for the given key, a new
- * entry will be created with the given value. If an entry exists
- * already, its value will be updated to match the given value.
- *
- * @param map map to create new entry in
- * @param key key to set
- * @param value value to associate the key with; may be NULL
- * @return zero if the key was successfully set, a negative error
- * code otherwise
- */
-int git_oidmap_set(git_oidmap *map, const git_oid *key, void *value);
-
-/**
- * Delete an entry from the map.
- *
- * Delete the given key and its value from the map. If no such
- * key exists, this will do nothing.
- *
- * @param map map to delete key in
- * @param key key to delete
- * @return `0` if the key has been deleted, GIT_ENOTFOUND if no
- * such key was found, a negative code in case of an
- * error
- */
-int git_oidmap_delete(git_oidmap *map, const git_oid *key);
-
-/**
- * Check whether a key exists in the given map.
- *
- * @param map map to query for the key
- * @param key key to search for
- * @return 0 if the key has not been found, 1 otherwise
- */
-int git_oidmap_exists(git_oidmap *map, const git_oid *key);
-
-/**
- * Iterate over entries of the map.
- *
- * This functions allows to iterate over all key-value entries of
- * the map. The current position is stored in the `iter` variable
- * and should be initialized to `0` before the first call to this
- * function.
- *
- * @param map map to iterate over
- * @param value pointer to the variable where to store the current
- * value. May be NULL.
- * @param iter iterator storing the current position. Initialize
- * with zero previous to the first call.
- * @param key pointer to the variable where to store the current
- * key. May be NULL.
- * @return `0` if the next entry was correctly retrieved.
- * GIT_ITEROVER if no entries are left. A negative error
- * code otherwise.
- */
-int git_oidmap_iterate(void **value, git_oidmap *map, size_t *iter, const git_oid **key);
-
-#define git_oidmap_foreach_value(h, vvar, code) { size_t __i = 0; \
- while (git_oidmap_iterate((void **) &(vvar), h, &__i, NULL) == 0) { \
- code; \
- } }
-
-#endif
diff --git a/src/libgit2/pack-objects.c b/src/libgit2/pack-objects.c
index 20a5dfcbdd5..efdd68aea0c 100644
--- a/src/libgit2/pack-objects.c
+++ b/src/libgit2/pack-objects.c
@@ -11,7 +11,6 @@
#include "zstream.h"
#include "delta.h"
#include "iterator.h"
-#include "netops.h"
#include "pack.h"
#include "thread.h"
#include "tree.h"
@@ -65,6 +64,9 @@ struct walk_object {
/* Size of the buffer to feed to zlib */
#define COMPRESS_BUFLEN (1024 * 1024)
+GIT_HASHMAP_OID_FUNCTIONS(git_packbuilder_pobjectmap, GIT_HASHMAP_INLINE, git_pobject *);
+GIT_HASHMAP_OID_FUNCTIONS(git_packbuilder_walk_objectmap, GIT_HASHMAP_INLINE, struct walk_object *);
+
static unsigned name_hash(const char *name)
{
unsigned c, hash = 0;
@@ -127,6 +129,7 @@ static int packbuilder_config(git_packbuilder *pb)
int git_packbuilder_new(git_packbuilder **out, git_repository *repo)
{
+ git_hash_algorithm_t hash_algorithm;
git_packbuilder *pb;
*out = NULL;
@@ -134,15 +137,18 @@ int git_packbuilder_new(git_packbuilder **out, git_repository *repo)
pb = git__calloc(1, sizeof(*pb));
GIT_ERROR_CHECK_ALLOC(pb);
- if (git_oidmap_new(&pb->object_ix) < 0 ||
- git_oidmap_new(&pb->walk_objects) < 0 ||
- git_pool_init(&pb->object_pool, sizeof(struct walk_object)) < 0)
+ pb->oid_type = repo->oid_type;
+
+ hash_algorithm = git_oid_algorithm(pb->oid_type);
+ GIT_ASSERT(hash_algorithm);
+
+ if (git_pool_init(&pb->object_pool, sizeof(struct walk_object)) < 0)
goto on_error;
pb->repo = repo;
pb->nr_threads = 1; /* do not spawn any thread by default */
- if (git_hash_ctx_init(&pb->ctx, GIT_HASH_ALGORITHM_SHA1) < 0 ||
+ if (git_hash_ctx_init(&pb->ctx, hash_algorithm) < 0 ||
git_zstream_init(&pb->zstream, GIT_ZSTREAM_DEFLATE) < 0 ||
git_repository_odb(&pb->odb, repo) < 0 ||
packbuilder_config(pb) < 0)
@@ -187,10 +193,10 @@ static int rehash(git_packbuilder *pb)
git_pobject *po;
size_t i;
- git_oidmap_clear(pb->object_ix);
+ git_packbuilder_pobjectmap_clear(&pb->object_ix);
for (i = 0, po = pb->object_list; i < pb->nr_objects; i++, po++) {
- if (git_oidmap_set(pb->object_ix, &po->id, po) < 0)
+ if (git_packbuilder_pobjectmap_put(&pb->object_ix, &po->id, po) < 0)
return -1;
}
@@ -209,7 +215,7 @@ int git_packbuilder_insert(git_packbuilder *pb, const git_oid *oid,
/* If the object already exists in the hash table, then we don't
* have any work to do */
- if (git_oidmap_exists(pb->object_ix, oid))
+ if (git_packbuilder_pobjectmap_contains(&pb->object_ix, oid))
return 0;
if (pb->nr_objects >= pb->nr_alloc) {
@@ -241,7 +247,7 @@ int git_packbuilder_insert(git_packbuilder *pb, const git_oid *oid,
git_oid_cpy(&po->id, oid);
po->hash = name_hash(name);
- if (git_oidmap_set(pb->object_ix, &po->id, po) < 0) {
+ if (git_packbuilder_pobjectmap_put(&pb->object_ix, &po->id, po) < 0) {
git_error_set_oom();
return -1;
}
@@ -249,10 +255,10 @@ int git_packbuilder_insert(git_packbuilder *pb, const git_oid *oid,
pb->done = false;
if (pb->progress_cb) {
- double current_time = git__timer();
- double elapsed = current_time - pb->last_progress_report_time;
+ uint64_t current_time = git_time_monotonic();
+ uint64_t elapsed = current_time - pb->last_progress_report_time;
- if (elapsed < 0 || elapsed >= MIN_PROGRESS_UPDATE_INTERVAL) {
+ if (elapsed >= MIN_PROGRESS_UPDATE_INTERVAL) {
pb->last_progress_report_time = current_time;
ret = pb->progress_cb(
@@ -315,9 +321,11 @@ static int write_object(
git_object_t type;
unsigned char hdr[10], *zbuf = NULL;
void *data = NULL;
- size_t hdr_len, zbuf_len = COMPRESS_BUFLEN, data_len;
+ size_t hdr_len, zbuf_len = COMPRESS_BUFLEN, data_len, oid_size;
int error;
+ oid_size = git_oid_size(pb->oid_type);
+
/*
* If we have a delta base, let's use the delta to save space.
* Otherwise load the whole object. 'data' ends up pointing to
@@ -330,7 +338,7 @@ static int write_object(
goto done;
data_len = po->delta_size;
- type = GIT_OBJECT_REF_DELTA;
+ type = GIT_PACKFILE_REF_DELTA;
} else {
if ((error = git_odb_read(&obj, pb->odb, &po->id)) < 0)
goto done;
@@ -346,9 +354,9 @@ static int write_object(
(error = git_hash_update(&pb->ctx, hdr, hdr_len)) < 0)
goto done;
- if (type == GIT_OBJECT_REF_DELTA) {
- if ((error = write_cb(po->delta->id.id, GIT_OID_SHA1_SIZE, cb_data)) < 0 ||
- (error = git_hash_update(&pb->ctx, po->delta->id.id, GIT_OID_SHA1_SIZE)) < 0)
+ if (type == GIT_PACKFILE_REF_DELTA) {
+ if ((error = write_cb(po->delta->id.id, oid_size, cb_data)) < 0 ||
+ (error = git_hash_update(&pb->ctx, po->delta->id.id, oid_size)) < 0)
goto done;
}
@@ -508,7 +516,7 @@ static int cb_tag_foreach(const char *name, git_oid *oid, void *data)
GIT_UNUSED(name);
- if ((po = git_oidmap_get(pb->object_ix, oid)) == NULL)
+ if (git_packbuilder_pobjectmap_get(&po, &pb->object_ix, oid) != 0)
return 0;
po->tagged = 1;
@@ -668,7 +676,7 @@ static int write_pack(git_packbuilder *pb,
if ((error = git_hash_final(entry_oid.id, &pb->ctx)) < 0)
goto done;
- error = write_cb(entry_oid.id, GIT_OID_SHA1_SIZE, cb_data);
+ error = write_cb(entry_oid.id, git_oid_size(pb->oid_type), cb_data);
done:
/* if callback cancelled writing, we must still free delta_data */
@@ -925,19 +933,24 @@ static int report_delta_progress(
{
int ret;
+ if (pb->failure)
+ return pb->failure;
+
if (pb->progress_cb) {
- double current_time = git__timer();
- double elapsed = current_time - pb->last_progress_report_time;
+ uint64_t current_time = git_time_monotonic();
+ uint64_t elapsed = current_time - pb->last_progress_report_time;
- if (force || elapsed < 0 || elapsed >= MIN_PROGRESS_UPDATE_INTERVAL) {
+ if (force || elapsed >= MIN_PROGRESS_UPDATE_INTERVAL) {
pb->last_progress_report_time = current_time;
ret = pb->progress_cb(
GIT_PACKBUILDER_DELTAFICATION,
count, pb->nr_objects, pb->progress_cb_payload);
- if (ret)
+ if (ret) {
+ pb->failure = ret;
return git_error_set_after_callback(ret);
+ }
}
}
@@ -969,7 +982,10 @@ static int find_deltas(git_packbuilder *pb, git_pobject **list,
}
pb->nr_deltified += 1;
- report_delta_progress(pb, pb->nr_deltified, false);
+ if ((error = report_delta_progress(pb, pb->nr_deltified, false)) < 0) {
+ GIT_ASSERT(git_packbuilder__progress_unlock(pb) == 0);
+ goto on_error;
+ }
po = *list++;
(*list_size)--;
@@ -1117,6 +1133,10 @@ struct thread_params {
size_t depth;
size_t working;
size_t data_ready;
+
+ /* A pb->progress_cb can stop the packing process by returning an error.
+ When that happens, all threads observe the error and stop voluntarily. */
+ bool stopped;
};
static void *threaded_find_deltas(void *arg)
@@ -1126,7 +1146,12 @@ static void *threaded_find_deltas(void *arg)
while (me->remaining) {
if (find_deltas(me->pb, me->list, &me->remaining,
me->window, me->depth) < 0) {
- ; /* TODO */
+ me->stopped = true;
+ GIT_ASSERT_WITH_RETVAL(git_packbuilder__progress_lock(me->pb) == 0, NULL);
+ me->working = false;
+ git_cond_signal(&me->pb->progress_cond);
+ GIT_ASSERT_WITH_RETVAL(git_packbuilder__progress_unlock(me->pb) == 0, NULL);
+ return NULL;
}
GIT_ASSERT_WITH_RETVAL(git_packbuilder__progress_lock(me->pb) == 0, NULL);
@@ -1168,8 +1193,7 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
pb->nr_threads = git__online_cpus();
if (pb->nr_threads <= 1) {
- find_deltas(pb, list, &list_size, window, depth);
- return 0;
+ return find_deltas(pb, list, &list_size, window, depth);
}
p = git__mallocarray(pb->nr_threads, sizeof(*p));
@@ -1188,6 +1212,7 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
p[i].depth = depth;
p[i].working = 1;
p[i].data_ready = 0;
+ p[i].stopped = 0;
/* try to split chunks on "path" boundaries */
while (sub_size && sub_size < list_size &&
@@ -1255,7 +1280,7 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
(!victim || victim->remaining < p[i].remaining))
victim = &p[i];
- if (victim) {
+ if (victim && !target->stopped) {
sub_size = victim->remaining / 2;
list = victim->list + victim->list_size - sub_size;
while (sub_size && list[0]->hash &&
@@ -1279,7 +1304,7 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
}
target->list_size = sub_size;
target->remaining = sub_size;
- target->working = 1;
+ target->working = 1; /* even when target->stopped, so that we don't process this thread again */
GIT_ASSERT(git_packbuilder__progress_unlock(pb) == 0);
if (git_mutex_lock(&target->mutex)) {
@@ -1292,7 +1317,7 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
git_cond_signal(&target->cond);
git_mutex_unlock(&target->mutex);
- if (!sub_size) {
+ if (target->stopped || !sub_size) {
git_thread_join(&target->thread, NULL);
git_cond_free(&target->cond);
git_mutex_free(&target->mutex);
@@ -1301,7 +1326,7 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
}
git__free(p);
- return 0;
+ return pb->failure;
}
#else
@@ -1312,6 +1337,7 @@ int git_packbuilder__prepare(git_packbuilder *pb)
{
git_pobject **delta_list;
size_t i, n = 0;
+ int error;
if (pb->nr_objects == 0 || pb->done)
return 0; /* nothing to do */
@@ -1320,8 +1346,10 @@ int git_packbuilder__prepare(git_packbuilder *pb)
* Although we do not report progress during deltafication, we
* at least report that we are in the deltafication stage
*/
- if (pb->progress_cb)
- pb->progress_cb(GIT_PACKBUILDER_DELTAFICATION, 0, pb->nr_objects, pb->progress_cb_payload);
+ if (pb->progress_cb) {
+ if ((error = pb->progress_cb(GIT_PACKBUILDER_DELTAFICATION, 0, pb->nr_objects, pb->progress_cb_payload)) < 0)
+ return git_error_set_after_callback(error);
+ }
delta_list = git__mallocarray(pb->nr_objects, sizeof(*delta_list));
GIT_ERROR_CHECK_ALLOC(delta_list);
@@ -1338,31 +1366,33 @@ int git_packbuilder__prepare(git_packbuilder *pb)
if (n > 1) {
git__tsort((void **)delta_list, n, type_size_sort);
- if (ll_find_deltas(pb, delta_list, n,
+ if ((error = ll_find_deltas(pb, delta_list, n,
GIT_PACK_WINDOW + 1,
- GIT_PACK_DEPTH) < 0) {
+ GIT_PACK_DEPTH)) < 0) {
git__free(delta_list);
- return -1;
+ return error;
}
}
- report_delta_progress(pb, pb->nr_objects, true);
+ error = report_delta_progress(pb, pb->nr_objects, true);
pb->done = true;
git__free(delta_list);
- return 0;
+ return error;
}
-#define PREPARE_PACK if (git_packbuilder__prepare(pb) < 0) { return -1; }
+#define PREPARE_PACK error = git_packbuilder__prepare(pb); if (error < 0) { return error; }
int git_packbuilder_foreach(git_packbuilder *pb, int (*cb)(void *buf, size_t size, void *payload), void *payload)
{
+ int error;
PREPARE_PACK;
return write_pack(pb, cb, payload);
}
int git_packbuilder__write_buf(git_str *buf, git_packbuilder *pb)
{
+ int error;
PREPARE_PACK;
return write_pack(pb, &write_pack_buf, buf);
@@ -1412,8 +1442,9 @@ int git_packbuilder_write(
#ifdef GIT_EXPERIMENTAL_SHA256
opts.mode = mode;
opts.odb = pb->odb;
+ opts.oid_type = GIT_OID_SHA1;
- error = git_indexer_new(&indexer, path, GIT_OID_SHA1, &opts);
+ error = git_indexer_new(&indexer, path, &opts);
#else
error = git_indexer_new(&indexer, path, mode, pb->odb, &opts);
#endif
@@ -1577,12 +1608,16 @@ static int retrieve_object(struct walk_object **out, git_packbuilder *pb, const
struct walk_object *obj;
int error;
- if ((obj = git_oidmap_get(pb->walk_objects, id)) == NULL) {
+ error = git_packbuilder_walk_objectmap_get(&obj, &pb->walk_objects, id);
+
+ if (error == GIT_ENOTFOUND) {
if ((error = lookup_walk_object(&obj, pb, id)) < 0)
return error;
- if ((error = git_oidmap_set(pb->walk_objects, &obj->id, obj)) < 0)
+ if ((error = git_packbuilder_walk_objectmap_put(&pb->walk_objects, &obj->id, obj)) < 0)
return error;
+ } else if (error != 0) {
+ return error;
}
*out = obj;
@@ -1814,13 +1849,12 @@ void git_packbuilder_free(git_packbuilder *pb)
if (pb->odb)
git_odb_free(pb->odb);
- if (pb->object_ix)
- git_oidmap_free(pb->object_ix);
+ git_packbuilder_pobjectmap_dispose(&pb->object_ix);
if (pb->object_list)
git__free(pb->object_list);
- git_oidmap_free(pb->walk_objects);
+ git_packbuilder_walk_objectmap_dispose(&pb->walk_objects);
git_pool_clear(&pb->object_pool);
git_hash_ctx_cleanup(&pb->ctx);
diff --git a/src/libgit2/pack-objects.h b/src/libgit2/pack-objects.h
index 2faa3ec7f51..ad04fb0abc6 100644
--- a/src/libgit2/pack-objects.h
+++ b/src/libgit2/pack-objects.h
@@ -12,11 +12,10 @@
#include "str.h"
#include "hash.h"
-#include "oidmap.h"
-#include "netops.h"
#include "zstream.h"
#include "pool.h"
#include "indexer.h"
+#include "hashmap_oid.h"
#include "git2/oid.h"
#include "git2/pack.h"
@@ -52,10 +51,17 @@ typedef struct git_pobject {
filled:1;
} git_pobject;
+typedef struct walk_object walk_object;
+
+GIT_HASHMAP_OID_STRUCT(git_packbuilder_pobjectmap, git_pobject *);
+GIT_HASHMAP_OID_STRUCT(git_packbuilder_walk_objectmap, walk_object *);
+
struct git_packbuilder {
git_repository *repo; /* associated repository */
git_odb *odb; /* associated object database */
+ git_oid_t oid_type;
+
git_hash_ctx ctx;
git_zstream zstream;
@@ -68,9 +74,8 @@ struct git_packbuilder {
git_pobject *object_list;
- git_oidmap *object_ix;
-
- git_oidmap *walk_objects;
+ git_packbuilder_pobjectmap object_ix;
+ git_packbuilder_walk_objectmap walk_objects;
git_pool object_pool;
#ifndef GIT_DEPRECATE_HARD
@@ -94,9 +99,15 @@ struct git_packbuilder {
git_packbuilder_progress progress_cb;
void *progress_cb_payload;
- double last_progress_report_time; /* the time progress was last reported */
+
+ /* the time progress was last reported, in millisecond ticks */
+ uint64_t last_progress_report_time;
bool done;
+
+ /* A non-zero error code in failure causes all threads to shut themselves
+ down. Some functions will return this error code. */
+ volatile int failure;
};
int git_packbuilder__write_buf(git_str *buf, git_packbuilder *pb);
diff --git a/src/libgit2/pack.c b/src/libgit2/pack.c
index c3080184449..a70975a75bf 100644
--- a/src/libgit2/pack.c
+++ b/src/libgit2/pack.c
@@ -13,6 +13,7 @@
#include "odb.h"
#include "oid.h"
#include "oidarray.h"
+#include "hashmap_oid.h"
/* Option to bypass checking existence of '.keep' files */
bool git_disable_pack_keep_file_checks = false;
@@ -41,6 +42,12 @@ static int pack_entry_find_offset(
const git_oid *short_oid,
size_t len);
+#define off64_hash(key) (uint32_t)((key)>>33^(key)^(key)<<11)
+#define off64_equal(a, b) ((a) == (b))
+
+GIT_HASHMAP_FUNCTIONS(git_pack_offsetmap, GIT_HASHMAP_INLINE, off64_t, git_pack_cache_entry *, off64_hash, off64_equal);
+GIT_HASHMAP_OID_FUNCTIONS(git_pack_oidmap, , struct git_pack_entry *);
+
static int packfile_error(const char *message)
{
git_error_set(GIT_ERROR_ODB, "invalid pack file - %s", message);
@@ -75,31 +82,21 @@ static void free_cache_object(void *o)
static void cache_free(git_pack_cache *cache)
{
+ git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
git_pack_cache_entry *entry;
- if (cache->entries) {
- git_offmap_foreach_value(cache->entries, entry, {
- free_cache_object(entry);
- });
+ while (git_pack_offsetmap_iterate(&iter, NULL, &entry, &cache->entries) == 0)
+ free_cache_object(entry);
- git_offmap_free(cache->entries);
- cache->entries = NULL;
- }
+ git_pack_offsetmap_dispose(&cache->entries);
}
static int cache_init(git_pack_cache *cache)
{
- if (git_offmap_new(&cache->entries) < 0)
- return -1;
-
cache->memory_limit = GIT_PACK_CACHE_MEMORY_LIMIT;
if (git_mutex_init(&cache->lock)) {
git_error_set(GIT_ERROR_OS, "failed to initialize pack cache mutex");
-
- git__free(cache->entries);
- cache->entries = NULL;
-
return -1;
}
@@ -108,15 +105,16 @@ static int cache_init(git_pack_cache *cache)
static git_pack_cache_entry *cache_get(git_pack_cache *cache, off64_t offset)
{
- git_pack_cache_entry *entry;
+ git_pack_cache_entry *entry = NULL;
if (git_mutex_lock(&cache->lock) < 0)
return NULL;
- if ((entry = git_offmap_get(cache->entries, offset)) != NULL) {
+ if (git_pack_offsetmap_get(&entry, &cache->entries, offset) == 0) {
git_atomic32_inc(&entry->refcount);
entry->last_usage = cache->use_ctr++;
}
+
git_mutex_unlock(&cache->lock);
return entry;
@@ -125,16 +123,17 @@ static git_pack_cache_entry *cache_get(git_pack_cache *cache, off64_t offset)
/* Run with the cache lock held */
static void free_lowest_entry(git_pack_cache *cache)
{
- off64_t offset;
+ git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
git_pack_cache_entry *entry;
+ off64_t offset;
- git_offmap_foreach(cache->entries, offset, entry, {
+ while (git_pack_offsetmap_iterate(&iter, &offset, &entry, &cache->entries) == 0) {
if (entry && git_atomic32_get(&entry->refcount) == 0) {
cache->memory_used -= entry->raw.len;
- git_offmap_delete(cache->entries, offset);
+ git_pack_offsetmap_remove(&cache->entries, offset);
free_cache_object(entry);
}
- });
+ }
}
static int cache_add(
@@ -157,12 +156,12 @@ static int cache_add(
return -1;
}
/* Add it to the cache if nobody else has */
- exists = git_offmap_exists(cache->entries, offset);
+ exists = git_pack_offsetmap_contains(&cache->entries, offset);
if (!exists) {
while (cache->memory_used + base->len > cache->memory_limit)
free_lowest_entry(cache);
- git_offmap_set(cache->entries, offset, entry);
+ git_pack_offsetmap_put(&cache->entries, offset, entry);
cache->memory_used += entry->raw.len;
*cached_out = entry;
@@ -200,7 +199,7 @@ static void pack_index_free(struct git_pack_file *p)
static int pack_index_check_locked(const char *path, struct git_pack_file *p)
{
struct git_pack_idx_header *hdr;
- uint32_t version, nr, i, *index;
+ uint32_t version, nr = 0, i, *index;
void *idx_map;
size_t idx_size;
struct stat st;
@@ -246,7 +245,6 @@ static int pack_index_check_locked(const char *path, struct git_pack_file *p)
version = 1;
}
- nr = 0;
index = idx_map;
if (version > 1)
@@ -269,7 +267,7 @@ static int pack_index_check_locked(const char *path, struct git_pack_file *p)
* - 20/32-byte SHA of the packfile
* - 20/32-byte SHA file checksum
*/
- if (idx_size != (4 * 256 + (nr * (p->oid_size + 4)) + (p->oid_size * 2))) {
+ if (idx_size != (4 * 256 + ((uint64_t) nr * (p->oid_size + 4)) + (p->oid_size * 2))) {
git_futils_mmap_free(&p->index_map);
return packfile_error("index is corrupted");
}
@@ -287,8 +285,8 @@ static int pack_index_check_locked(const char *path, struct git_pack_file *p)
* variable sized table containing 8-byte entries
* for offsets larger than 2^31.
*/
- unsigned long min_size = 8 + (4 * 256) + (nr * (p->oid_size + 4 + 4)) + (p->oid_size * 2);
- unsigned long max_size = min_size;
+ uint64_t min_size = 8 + (4 * 256) + ((uint64_t)nr * (p->oid_size + 4 + 4)) + (p->oid_size * 2);
+ uint64_t max_size = min_size;
if (nr)
max_size += (nr - 1)*8;
@@ -392,7 +390,7 @@ int git_packfile__object_header(size_t *out, unsigned char *hdr, size_t size, gi
unsigned char *hdr_base;
unsigned char c;
- GIT_ASSERT_ARG(type >= GIT_OBJECT_COMMIT && type <= GIT_OBJECT_REF_DELTA);
+ GIT_ASSERT_ARG(type >= GIT_OBJECT_COMMIT && type <= GIT_PACKFILE_REF_DELTA);
/* TODO: add support for chunked objects; see git.git 6c0d19b1 */
@@ -534,7 +532,7 @@ int git_packfile_resolve_header(
if (error < 0)
return error;
- if (type == GIT_OBJECT_OFS_DELTA || type == GIT_OBJECT_REF_DELTA) {
+ if (type == GIT_PACKFILE_OFS_DELTA || type == GIT_PACKFILE_REF_DELTA) {
size_t base_size;
git_packfile_stream stream;
@@ -555,12 +553,12 @@ int git_packfile_resolve_header(
base_offset = 0;
}
- while (type == GIT_OBJECT_OFS_DELTA || type == GIT_OBJECT_REF_DELTA) {
+ while (type == GIT_PACKFILE_OFS_DELTA || type == GIT_PACKFILE_REF_DELTA) {
curpos = base_offset;
error = git_packfile_unpack_header(&size, &type, p, &w_curs, &curpos);
if (error < 0)
return error;
- if (type != GIT_OBJECT_OFS_DELTA && type != GIT_OBJECT_REF_DELTA)
+ if (type != GIT_PACKFILE_OFS_DELTA && type != GIT_PACKFILE_REF_DELTA)
break;
error = get_delta_base(&base_offset, p, &w_curs, &curpos, type, base_offset);
@@ -637,7 +635,7 @@ static int pack_dependency_chain(git_dependency_chain *chain_out,
elem->type = type;
elem->base_key = obj_offset;
- if (type != GIT_OBJECT_OFS_DELTA && type != GIT_OBJECT_REF_DELTA)
+ if (type != GIT_PACKFILE_OFS_DELTA && type != GIT_PACKFILE_REF_DELTA)
break;
error = get_delta_base(&base_offset, p, &w_curs, &curpos, type, obj_offset);
@@ -677,7 +675,7 @@ int git_packfile_unpack(
git_pack_cache_entry *cached = NULL;
struct pack_chain_elem small_stack[SMALL_STACK_SIZE];
size_t stack_size = 0, elem_pos, alloclen;
- git_object_t base_type;
+ int base_type;
error = git_mutex_lock(&p->lock);
if (error < 0) {
@@ -737,8 +735,8 @@ int git_packfile_unpack(
if (error < 0)
goto cleanup;
break;
- case GIT_OBJECT_OFS_DELTA:
- case GIT_OBJECT_REF_DELTA:
+ case GIT_PACKFILE_OFS_DELTA:
+ case GIT_PACKFILE_REF_DELTA:
error = packfile_error("dependency chain ends in a delta");
goto cleanup;
default:
@@ -985,7 +983,7 @@ int get_delta_base(
* than the hash size is stupid, as then a REF_DELTA would be
* smaller to store.
*/
- if (type == GIT_OBJECT_OFS_DELTA) {
+ if (type == GIT_PACKFILE_OFS_DELTA) {
unsigned used = 0;
unsigned char c = base_info[used++];
size_t unsigned_base_offset = c & 127;
@@ -1002,15 +1000,15 @@ int get_delta_base(
return packfile_error("out of bounds");
base_offset = delta_obj_offset - unsigned_base_offset;
*curpos += used;
- } else if (type == GIT_OBJECT_REF_DELTA) {
+ } else if (type == GIT_PACKFILE_REF_DELTA) {
git_oid base_oid;
- git_oid__fromraw(&base_oid, base_info, p->oid_type);
+ git_oid_from_raw(&base_oid, base_info, p->oid_type);
/* If we have the cooperative cache, search in it first */
if (p->has_cache) {
struct git_pack_entry *entry;
- if ((entry = git_oidmap_get(p->idx_cache, &base_oid)) != NULL) {
+ if (git_pack_oidmap_get(&entry, &p->idx_cache, &base_oid) == 0) {
if (entry->offset == 0)
return packfile_error("delta offset is zero");
@@ -1269,13 +1267,13 @@ static off64_t nth_packed_object_offset_locked(struct git_pack_file *p, uint32_t
end = index + p->index_map.len;
index += 4 * 256;
if (p->index_version == 1)
- return ntohl(*((uint32_t *)(index + (p->oid_size + 4) * n)));
+ return ntohl(*((uint32_t *)(index + (p->oid_size + 4) * (size_t) n)));
- index += 8 + p->num_objects * (p->oid_size + 4);
+ index += 8 + (size_t) p->num_objects * (p->oid_size + 4);
off32 = ntohl(*((uint32_t *)(index + 4 * n)));
if (!(off32 & 0x80000000))
return off32;
- index += p->num_objects * 4 + (off32 & 0x7fffffff) * 8;
+ index += (size_t) p->num_objects * 4 + (off32 & 0x7fffffff) * 8;
/* Make sure we're not being sent out of bounds */
if (index >= end - 8)
@@ -1352,7 +1350,7 @@ int git_pack_foreach_entry(
git_vector_insert(&oids, (void*)¤t[4]);
}
- git_vector_free(&offsets);
+ git_vector_dispose(&offsets);
p->ids = (unsigned char **)git_vector_detach(NULL, NULL, &oids);
}
@@ -1374,7 +1372,7 @@ int git_pack_foreach_entry(
git_array_clear(oids);
GIT_ERROR_CHECK_ALLOC(oid);
}
- git_oid__fromraw(oid, p->ids[i], p->oid_type);
+ git_oid_from_raw(oid, p->ids[i], p->oid_type);
}
git_mutex_unlock(&p->lock);
@@ -1443,7 +1441,7 @@ int git_pack_foreach_entry_offset(
ntohl(*((uint32_t *)(large_offset_ptr + 4)));
}
- git_oid__fromraw(¤t_oid, (index + p->oid_size * i), p->oid_type);
+ git_oid_from_raw(¤t_oid, (index + p->oid_size * i), p->oid_type);
if ((error = cb(¤t_oid, current_offset, data)) != 0) {
error = git_error_set_after_callback(error);
goto cleanup;
@@ -1452,7 +1450,7 @@ int git_pack_foreach_entry_offset(
} else {
for (i = 0; i < p->num_objects; i++) {
current_offset = ntohl(*(const uint32_t *)(index + (p->oid_size + 4) * i));
- git_oid__fromraw(¤t_oid, (index + (p->oid_size + 4) * i + 4), p->oid_type);
+ git_oid_from_raw(¤t_oid, (index + (p->oid_size + 4) * i + 4), p->oid_type);
if ((error = cb(¤t_oid, current_offset, data)) != 0) {
error = git_error_set_after_callback(error);
goto cleanup;
@@ -1500,6 +1498,7 @@ static int pack_entry_find_offset(
size_t len)
{
const uint32_t *level1_ofs;
+ size_t ofs_delta = 0;
const unsigned char *index;
unsigned hi, lo, stride;
int pos, found = 0;
@@ -1525,9 +1524,15 @@ static int pack_entry_find_offset(
if (p->index_version > 1) {
level1_ofs += 2;
+ ofs_delta = 2;
index += 8;
}
+ if ((size_t)short_oid->id[0] + ofs_delta >= p->index_map.len) {
+ git_error_set(GIT_ERROR_INTERNAL, "internal error: p->short_oid->[0] out of bounds");
+ goto cleanup;
+ }
+
index += 4 * 256;
hi = ntohl(level1_ofs[(int)short_oid->id[0]]);
lo = ((short_oid->id[0] == 0x0) ? 0 : ntohl(level1_ofs[(int)short_oid->id[0] - 1]));
@@ -1590,7 +1595,7 @@ static int pack_entry_find_offset(
}
*offset_out = offset;
- git_oid__fromraw(found_oid, current, p->oid_type);
+ git_oid_from_raw(found_oid, current, p->oid_type);
#ifdef INDEX_DEBUG_LOOKUP
{
diff --git a/src/libgit2/pack.h b/src/libgit2/pack.h
index 1a9eb14b295..e802d60747c 100644
--- a/src/libgit2/pack.h
+++ b/src/libgit2/pack.h
@@ -16,10 +16,9 @@
#include "map.h"
#include "mwindow.h"
#include "odb.h"
-#include "offmap.h"
-#include "oidmap.h"
#include "zstream.h"
#include "oid.h"
+#include "hashmap_oid.h"
/**
* Function type for callbacks from git_pack_foreach_entry_offset.
@@ -34,6 +33,10 @@ typedef int git_pack_foreach_entry_offset_cb(
#define PACK_SIGNATURE 0x5041434b /* "PACK" */
#define PACK_VERSION 2
#define pack_version_ok(v) ((v) == htonl(2))
+
+#define GIT_PACKFILE_OFS_DELTA 6
+#define GIT_PACKFILE_REF_DELTA 7
+
struct git_pack_header {
uint32_t hdr_signature;
uint32_t hdr_version;
@@ -83,12 +86,23 @@ typedef git_array_t(struct pack_chain_elem) git_dependency_chain;
#define GIT_PACK_CACHE_MEMORY_LIMIT 16 * 1024 * 1024
#define GIT_PACK_CACHE_SIZE_LIMIT 1024 * 1024 /* don't bother caching anything over 1MB */
+struct git_pack_entry {
+ off64_t offset;
+ git_oid id;
+ struct git_pack_file *p;
+};
+
+GIT_HASHMAP_STRUCT(git_pack_offsetmap, off64_t, git_pack_cache_entry *);
+
+GIT_HASHMAP_OID_STRUCT(git_pack_oidmap, struct git_pack_entry *);
+GIT_HASHMAP_OID_PROTOTYPES(git_pack_oidmap, struct git_pack_entry *);
+
typedef struct {
size_t memory_used;
size_t memory_limit;
size_t use_ctr;
git_mutex lock;
- git_offmap *entries;
+ git_pack_offsetmap entries;
} git_pack_cache;
struct git_pack_file {
@@ -110,7 +124,8 @@ struct git_pack_file {
int index_version;
git_time_t mtime;
- git_oidmap *idx_cache;
+
+ git_pack_oidmap idx_cache;
unsigned char **ids;
git_pack_cache bases; /* delta base cache */
@@ -139,12 +154,6 @@ int git_pack__lookup_id(
const unsigned char *id_prefix,
const git_oid_t oid_type);
-struct git_pack_entry {
- off64_t offset;
- git_oid id;
- struct git_pack_file *p;
-};
-
typedef struct git_packfile_stream {
off64_t curpos;
int done;
diff --git a/src/libgit2/parse.c b/src/libgit2/parse.c
index 55d3cb10ec9..ea693462144 100644
--- a/src/libgit2/parse.c
+++ b/src/libgit2/parse.c
@@ -102,13 +102,16 @@ int git_parse_advance_digit(int64_t *out, git_parse_ctx *ctx, int base)
return 0;
}
-int git_parse_advance_oid(git_oid *out, git_parse_ctx *ctx)
+int git_parse_advance_oid(git_oid *out, git_parse_ctx *ctx, git_oid_t oid_type)
{
- if (ctx->line_len < GIT_OID_SHA1_HEXSIZE)
+ size_t oid_hexsize = git_oid_hexsize(oid_type);
+ GIT_ASSERT(oid_hexsize);
+
+ if (ctx->line_len < oid_hexsize)
return -1;
- if ((git_oid__fromstrn(out, ctx->line, GIT_OID_SHA1_HEXSIZE, GIT_OID_SHA1)) < 0)
+ if ((git_oid_from_prefix(out, ctx->line, oid_hexsize, oid_type)) < 0)
return -1;
- git_parse_advance_chars(ctx, GIT_OID_SHA1_HEXSIZE);
+ git_parse_advance_chars(ctx, oid_hexsize);
return 0;
}
diff --git a/src/libgit2/parse.h b/src/libgit2/parse.h
index 0ecb7c103b9..beef1de12fb 100644
--- a/src/libgit2/parse.h
+++ b/src/libgit2/parse.h
@@ -50,7 +50,7 @@ int git_parse_advance_expected(
int git_parse_advance_ws(git_parse_ctx *ctx);
int git_parse_advance_nl(git_parse_ctx *ctx);
int git_parse_advance_digit(int64_t *out, git_parse_ctx *ctx, int base);
-int git_parse_advance_oid(git_oid *out, git_parse_ctx *ctx);
+int git_parse_advance_oid(git_oid *out, git_parse_ctx *ctx, git_oid_t oid_type);
enum GIT_PARSE_PEEK_FLAGS {
GIT_PARSE_PEEK_SKIP_WHITESPACE = (1 << 0)
diff --git a/src/libgit2/patch.h b/src/libgit2/patch.h
index 1e1471ed613..86328e886e7 100644
--- a/src/libgit2/patch.h
+++ b/src/libgit2/patch.h
@@ -59,9 +59,15 @@ typedef struct {
* This prefix will be removed when looking for files. The default is 1.
*/
uint32_t prefix_len;
+
+ /**
+ * The type of object IDs in the patch file. The default is
+ * `GIT_OID_DEFAULT`.
+ */
+ git_oid_t oid_type;
} git_patch_options;
-#define GIT_PATCH_OPTIONS_INIT { 1 }
+#define GIT_PATCH_OPTIONS_INIT { 1, GIT_OID_DEFAULT }
extern int git_patch__to_buf(git_str *out, git_patch *patch);
extern void git_patch_free(git_patch *patch);
diff --git a/src/libgit2/patch_generate.c b/src/libgit2/patch_generate.c
index bc598fea870..079bc53ae9b 100644
--- a/src/libgit2/patch_generate.c
+++ b/src/libgit2/patch_generate.c
@@ -81,7 +81,8 @@ static void patch_generated_init_common(git_patch_generated *patch)
static int patch_generated_normalize_options(
git_diff_options *out,
- const git_diff_options *opts)
+ const git_diff_options *opts,
+ git_repository *repo)
{
if (opts) {
GIT_ERROR_CHECK_VERSION(opts, GIT_DIFF_OPTIONS_VERSION, "git_diff_options");
@@ -91,6 +92,23 @@ static int patch_generated_normalize_options(
memcpy(out, &default_opts, sizeof(git_diff_options));
}
+ if (repo && opts && opts->oid_type && repo->oid_type != opts->oid_type) {
+ /*
+ * This limitation feels unnecessary - we should consider
+ * allowing users to generate diffs with a different object
+ * ID format than the repository.
+ */
+ git_error_set(GIT_ERROR_INVALID,
+ "specified object ID type does not match repository object ID type");
+ return -1;
+ } else if (repo) {
+ out->oid_type = repo->oid_type;
+ } else if (opts && opts->oid_type) {
+ out->oid_type = opts->oid_type;
+ } else {
+ out->oid_type = GIT_OID_DEFAULT;
+ }
+
out->old_prefix = opts && opts->old_prefix ?
git__strdup(opts->old_prefix) :
git__strdup(DIFF_OLD_PREFIX_DEFAULT);
@@ -118,7 +136,7 @@ static int patch_generated_init(
patch->delta_index = delta_index;
if ((error = patch_generated_normalize_options(
- &patch->base.diff_opts, &diff->opts)) < 0 ||
+ &patch->base.diff_opts, &diff->opts, diff->repo)) < 0 ||
(error = git_diff_file_content__init_from_diff(
&patch->ofile, diff, patch->base.delta, true)) < 0 ||
(error = git_diff_file_content__init_from_diff(
@@ -449,7 +467,7 @@ static int patch_generated_from_sources(
git_xdiff_output *xo,
git_diff_file_content_src *oldsrc,
git_diff_file_content_src *newsrc,
- const git_diff_options *opts)
+ const git_diff_options *given_opts)
{
int error = 0;
git_repository *repo =
@@ -457,11 +475,12 @@ static int patch_generated_from_sources(
newsrc->blob ? git_blob_owner(newsrc->blob) : NULL;
git_diff_file *lfile = &pd->delta.old_file, *rfile = &pd->delta.new_file;
git_diff_file_content *ldata = &pd->patch.ofile, *rdata = &pd->patch.nfile;
+ git_diff_options *opts = &pd->patch.base.diff_opts;
- if ((error = patch_generated_normalize_options(&pd->patch.base.diff_opts, opts)) < 0)
+ if ((error = patch_generated_normalize_options(opts, given_opts, repo)) < 0)
return error;
- if (opts && (opts->flags & GIT_DIFF_REVERSE) != 0) {
+ if ((opts->flags & GIT_DIFF_REVERSE) != 0) {
void *tmp = lfile; lfile = rfile; rfile = tmp;
tmp = ldata; ldata = rdata; rdata = tmp;
}
diff --git a/src/libgit2/patch_parse.c b/src/libgit2/patch_parse.c
index ffdb99231a2..0a157178074 100644
--- a/src/libgit2/patch_parse.c
+++ b/src/libgit2/patch_parse.c
@@ -166,15 +166,19 @@ static int parse_header_oid(
uint16_t *oid_len,
git_patch_parse_ctx *ctx)
{
- size_t len;
+ size_t hexsize, len;
+
+ hexsize = git_oid_hexsize(ctx->opts.oid_type);
- for (len = 0; len < ctx->parse_ctx.line_len && len < GIT_OID_SHA1_HEXSIZE; len++) {
+ for (len = 0;
+ len < ctx->parse_ctx.line_len && len < hexsize;
+ len++) {
if (!git__isxdigit(ctx->parse_ctx.line[len]))
break;
}
- if (len < GIT_OID_MINPREFIXLEN || len > GIT_OID_SHA1_HEXSIZE ||
- git_oid__fromstrn(oid, ctx->parse_ctx.line, len, GIT_OID_SHA1) < 0)
+ if (len < GIT_OID_MINPREFIXLEN || len > hexsize ||
+ git_oid_from_prefix(oid, ctx->parse_ctx.line, len, ctx->opts.oid_type) < 0)
return git_parse_err("invalid hex formatted object id at line %"PRIuZ,
ctx->parse_ctx.line_num);
@@ -558,9 +562,9 @@ static int parse_hunk_header(
static int eof_for_origin(int origin) {
if (origin == GIT_DIFF_LINE_ADDITION)
- return GIT_DIFF_LINE_ADD_EOFNL;
- if (origin == GIT_DIFF_LINE_DELETION)
return GIT_DIFF_LINE_DEL_EOFNL;
+ if (origin == GIT_DIFF_LINE_DELETION)
+ return GIT_DIFF_LINE_ADD_EOFNL;
return GIT_DIFF_LINE_CONTEXT_EOFNL;
}
@@ -1065,12 +1069,14 @@ static int check_patch(git_patch_parsed *patch)
return git_parse_err("patch with no hunks");
if (delta->status == GIT_DELTA_ADDED) {
- git_oid_clear(&delta->old_file.id, GIT_OID_SHA1);
+ git_oid_clear(&delta->old_file.id,
+ patch->base.diff_opts.oid_type);
delta->old_file.id_abbrev = 0;
}
if (delta->status == GIT_DELTA_DELETED) {
- git_oid_clear(&delta->new_file.id, GIT_OID_SHA1);
+ git_oid_clear(&delta->new_file.id,
+ patch->base.diff_opts.oid_type);
delta->new_file.id_abbrev = 0;
}
@@ -1187,11 +1193,13 @@ int git_patch_parse(
patch->base.delta->status = GIT_DELTA_MODIFIED;
patch->base.delta->nfiles = 2;
+ patch->base.diff_opts.oid_type = ctx->opts.oid_type;
+
start = ctx->parse_ctx.remain_len;
if ((error = parse_patch_header(patch, ctx)) < 0 ||
- (error = parse_patch_body(patch, ctx)) < 0 ||
- (error = check_patch(patch)) < 0)
+ (error = parse_patch_body(patch, ctx)) < 0 ||
+ (error = check_patch(patch)) < 0)
goto done;
used = start - ctx->parse_ctx.remain_len;
diff --git a/src/libgit2/path.c b/src/libgit2/path.c
index a19340efe6f..4b584fb8056 100644
--- a/src/libgit2/path.c
+++ b/src/libgit2/path.c
@@ -202,7 +202,7 @@ GIT_INLINE(size_t) common_prefix_icase(const char *str, size_t len, const char *
{
size_t count = 0;
- while (len > 0 && tolower(*str) == tolower(*prefix)) {
+ while (len > 0 && git__tolower(*str) == git__tolower(*prefix)) {
count++;
str++;
prefix++;
diff --git a/src/libgit2/pathspec.c b/src/libgit2/pathspec.c
index 3e44643c675..26684c08104 100644
--- a/src/libgit2/pathspec.c
+++ b/src/libgit2/pathspec.c
@@ -105,7 +105,7 @@ int git_pathspec__vinit(
/* free data from the pathspec vector */
void git_pathspec__vfree(git_vector *vspec)
{
- git_vector_free_deep(vspec);
+ git_vector_dispose_deep(vspec);
}
struct pathspec_match_context {
diff --git a/src/libgit2/push.c b/src/libgit2/push.c
index e256818707a..b0e84173c74 100644
--- a/src/libgit2/push.c
+++ b/src/libgit2/push.c
@@ -56,14 +56,22 @@ int git_push_new(git_push **out, git_remote *remote, const git_push_options *opt
}
if (git_vector_init(&p->status, 0, push_status_ref_cmp) < 0) {
- git_vector_free(&p->specs);
+ git_vector_dispose(&p->specs);
git__free(p);
return -1;
}
if (git_vector_init(&p->updates, 0, NULL) < 0) {
- git_vector_free(&p->status);
- git_vector_free(&p->specs);
+ git_vector_dispose(&p->status);
+ git_vector_dispose(&p->specs);
+ git__free(p);
+ return -1;
+ }
+
+ if (git_vector_init(&p->remote_push_options, 0, git__strcmp_cb) < 0) {
+ git_vector_dispose(&p->status);
+ git_vector_dispose(&p->specs);
+ git_vector_dispose(&p->updates);
git__free(p);
return -1;
}
@@ -118,8 +126,8 @@ static int parse_refspec(git_push *push, push_spec **spec, const char *str)
s = git__calloc(1, sizeof(*s));
GIT_ERROR_CHECK_ALLOC(s);
- git_oid_clear(&s->loid, GIT_OID_SHA1);
- git_oid_clear(&s->roid, GIT_OID_SHA1);
+ git_oid_clear(&s->loid, push->repo->oid_type);
+ git_oid_clear(&s->roid, push->repo->oid_type);
if (git_refspec__parse(&s->refspec, str, false) < 0) {
git_error_set(GIT_ERROR_INVALID, "invalid refspec %s", str);
@@ -213,12 +221,25 @@ int git_push_update_tips(git_push *push, const git_remote_callbacks *callbacks)
fire_callback = 0;
}
- if (fire_callback && callbacks && callbacks->update_tips) {
- error = callbacks->update_tips(git_str_cstr(&remote_ref_name),
- &push_spec->roid, &push_spec->loid, callbacks->payload);
+ if (!fire_callback || !callbacks)
+ continue;
- if (error < 0)
- goto on_error;
+ if (callbacks->update_refs)
+ error = callbacks->update_refs(
+ git_str_cstr(&remote_ref_name),
+ &push_spec->roid, &push_spec->loid,
+ &push_spec->refspec, callbacks->payload);
+#ifndef GIT_DEPRECATE_HARD
+ else if (callbacks->update_tips)
+ error = callbacks->update_tips(
+ git_str_cstr(&remote_ref_name),
+ &push_spec->roid, &push_spec->loid,
+ callbacks->payload);
+#endif
+
+ if (error < 0) {
+ git_error_set_after_callback_function(error, "git_remote_push");
+ goto on_error;
}
}
@@ -275,6 +296,7 @@ static int queue_objects(git_push *push)
git_vector_foreach(&push->specs, i, spec) {
git_object_t type;
+ git_oid id;
size_t size;
if (git_oid_is_zero(&spec->loid))
@@ -296,20 +318,20 @@ static int queue_objects(git_push *push)
if ((error = enqueue_tag(&target, push, &spec->loid)) < 0)
goto on_error;
- if (git_object_type(target) == GIT_OBJECT_COMMIT) {
- if ((error = git_revwalk_push(rw, git_object_id(target))) < 0) {
- git_object_free(target);
- goto on_error;
- }
- } else {
- if ((error = git_packbuilder_insert(
- push->pb, git_object_id(target), NULL)) < 0) {
- git_object_free(target);
- goto on_error;
- }
- }
+ type = git_object_type(target);
+ git_oid_cpy(&id, git_object_id(target));
+
git_object_free(target);
- } else if ((error = git_revwalk_push(rw, &spec->loid)) < 0)
+ } else {
+ git_oid_cpy(&id, &spec->loid);
+ }
+
+ if (type == GIT_OBJECT_COMMIT)
+ error = git_revwalk_push(rw, &id);
+ else
+ error = git_packbuilder_insert(push->pb, &id, NULL);
+
+ if (error < 0)
goto on_error;
if (!spec->refspec.force) {
@@ -444,10 +466,21 @@ static int do_push(git_push *push)
if ((error = calculate_work(push)) < 0)
goto on_error;
- if (callbacks && callbacks->push_negotiation &&
- (error = callbacks->push_negotiation((const git_push_update **) push->updates.contents,
- push->updates.length, callbacks->payload)) < 0)
- goto on_error;
+ if (callbacks && callbacks->push_negotiation) {
+ git_error_clear();
+
+ error = callbacks->push_negotiation(
+ (const git_push_update **) push->updates.contents,
+ push->updates.length, callbacks->payload);
+
+ if (error < 0) {
+ git_error_set_after_callback_function(error,
+ "push_negotiation");
+ goto on_error;
+ }
+
+ error = 0;
+ }
if ((error = queue_objects(push)) < 0 ||
(error = transport->push(transport, push)) < 0)
@@ -479,12 +512,24 @@ static int filter_refs(git_remote *remote)
int git_push_finish(git_push *push)
{
int error;
+ unsigned int remote_caps;
if (!git_remote_connected(push->remote)) {
git_error_set(GIT_ERROR_NET, "remote is disconnected");
return -1;
}
+ if ((error = git_remote_capabilities(&remote_caps, push->remote)) < 0) {
+ git_error_set(GIT_ERROR_INVALID, "remote capabilities not available");
+ return -1;
+ }
+
+ if (git_vector_length(&push->remote_push_options) > 0 &&
+ !(remote_caps & GIT_REMOTE_CAPABILITY_PUSH_OPTIONS)) {
+ git_error_set(GIT_ERROR_INVALID, "push-options not supported by remote");
+ return -1;
+ }
+
if ((error = filter_refs(push->remote)) < 0 ||
(error = do_push(push)) < 0)
return error;
@@ -528,6 +573,7 @@ void git_push_free(git_push *push)
push_spec *spec;
push_status *status;
git_push_update *update;
+ char *option;
unsigned int i;
if (push == NULL)
@@ -536,19 +582,24 @@ void git_push_free(git_push *push)
git_vector_foreach(&push->specs, i, spec) {
free_refspec(spec);
}
- git_vector_free(&push->specs);
+ git_vector_dispose(&push->specs);
git_vector_foreach(&push->status, i, status) {
git_push_status_free(status);
}
- git_vector_free(&push->status);
+ git_vector_dispose(&push->status);
git_vector_foreach(&push->updates, i, update) {
git__free(update->src_refname);
git__free(update->dst_refname);
git__free(update);
}
- git_vector_free(&push->updates);
+ git_vector_dispose(&push->updates);
+
+ git_vector_foreach(&push->remote_push_options, i, option) {
+ git__free(option);
+ }
+ git_vector_dispose(&push->remote_push_options);
git__free(push);
}
diff --git a/src/libgit2/push.h b/src/libgit2/push.h
index fc72e845eee..40a1823e45b 100644
--- a/src/libgit2/push.h
+++ b/src/libgit2/push.h
@@ -34,6 +34,7 @@ struct git_push {
git_vector specs;
git_vector updates;
bool report_status;
+ git_vector remote_push_options;
/* report-status */
bool unpack_ok;
diff --git a/src/libgit2/reader.c b/src/libgit2/reader.c
index be29bb41c11..df2b2807f55 100644
--- a/src/libgit2/reader.c
+++ b/src/libgit2/reader.c
@@ -125,7 +125,7 @@ static int workdir_reader_read(
goto done;
if (out_id || reader->index) {
- if ((error = git_odb__hash(&id, out->ptr, out->size, GIT_OBJECT_BLOB, GIT_OID_SHA1)) < 0)
+ if ((error = git_odb__hash(&id, out->ptr, out->size, GIT_OBJECT_BLOB, reader->repo->oid_type)) < 0)
goto done;
}
diff --git a/src/libgit2/rebase.c b/src/libgit2/rebase.c
index 1970d5ddc60..eb8a728357c 100644
--- a/src/libgit2/rebase.c
+++ b/src/libgit2/rebase.c
@@ -65,6 +65,9 @@ struct git_rebase {
git_rebase_t type;
char *state_path;
+ /* Temporary buffer for paths within the state path. */
+ git_str state_filename;
+
unsigned int head_detached:1,
inmemory:1,
quiet:1,
@@ -134,33 +137,42 @@ static int rebase_state_type(
GIT_INLINE(int) rebase_readfile(
git_str *out,
- git_str *state_path,
+ git_rebase *rebase,
const char *filename)
{
- size_t state_path_len = state_path->size;
+ /*
+ * `rebase->state_filename` is a temporary buffer to avoid
+ * unnecessary allocations and copies of `rebase->state_path`.
+ * At the start and end of this function it always contains the
+ * contents of `rebase->state_path` itself.
+ */
+ size_t state_path_len = rebase->state_filename.size;
int error;
git_str_clear(out);
- if ((error = git_str_joinpath(state_path, state_path->ptr, filename)) < 0 ||
- (error = git_futils_readbuffer(out, state_path->ptr)) < 0)
+ if ((error = git_str_joinpath(&rebase->state_filename, rebase->state_filename.ptr, filename)) < 0 ||
+ (error = git_futils_readbuffer(out, rebase->state_filename.ptr)) < 0)
goto done;
git_str_rtrim(out);
done:
- git_str_truncate(state_path, state_path_len);
+ git_str_truncate(&rebase->state_filename, state_path_len);
return error;
}
GIT_INLINE(int) rebase_readint(
- size_t *out, git_str *asc_out, git_str *state_path, const char *filename)
+ size_t *out,
+ git_str *asc_out,
+ git_rebase *rebase,
+ const char *filename)
{
int32_t num;
const char *eol;
int error = 0;
- if ((error = rebase_readfile(asc_out, state_path, filename)) < 0)
+ if ((error = rebase_readfile(asc_out, rebase, filename)) < 0)
return error;
if (git__strntol32(&num, asc_out->ptr, asc_out->size, &eol, 10) < 0 || num < 0 || *eol) {
@@ -174,15 +186,18 @@ GIT_INLINE(int) rebase_readint(
}
GIT_INLINE(int) rebase_readoid(
- git_oid *out, git_str *str_out, git_str *state_path, const char *filename)
+ git_oid *out,
+ git_str *str_out,
+ git_rebase *rebase,
+ const char *filename)
{
int error;
- if ((error = rebase_readfile(str_out, state_path, filename)) < 0)
+ if ((error = rebase_readfile(str_out, rebase, filename)) < 0)
return error;
- if (str_out->size != GIT_OID_SHA1_HEXSIZE ||
- git_oid__fromstr(out, str_out->ptr, GIT_OID_SHA1) < 0) {
+ if (str_out->size != git_oid_hexsize(rebase->repo->oid_type) ||
+ git_oid_from_string(out, str_out->ptr, rebase->repo->oid_type) < 0) {
git_error_set(GIT_ERROR_REBASE, "the file '%s' contains an invalid object ID", filename);
return -1;
}
@@ -213,17 +228,14 @@ static git_rebase_operation *rebase_operation_alloc(
static int rebase_open_merge(git_rebase *rebase)
{
- git_str state_path = GIT_STR_INIT, buf = GIT_STR_INIT, cmt = GIT_STR_INIT;
+ git_str buf = GIT_STR_INIT, cmt = GIT_STR_INIT;
git_oid id;
git_rebase_operation *operation;
size_t i, msgnum = 0, end;
int error;
- if ((error = git_str_puts(&state_path, rebase->state_path)) < 0)
- goto done;
-
/* Read 'msgnum' if it exists (otherwise, let msgnum = 0) */
- if ((error = rebase_readint(&msgnum, &buf, &state_path, MSGNUM_FILE)) < 0 &&
+ if ((error = rebase_readint(&msgnum, &buf, rebase, MSGNUM_FILE)) < 0 &&
error != GIT_ENOTFOUND)
goto done;
@@ -233,11 +245,11 @@ static int rebase_open_merge(git_rebase *rebase)
}
/* Read 'end' */
- if ((error = rebase_readint(&end, &buf, &state_path, END_FILE)) < 0)
+ if ((error = rebase_readint(&end, &buf, rebase, END_FILE)) < 0)
goto done;
/* Read 'current' if it exists */
- if ((error = rebase_readoid(&id, &buf, &state_path, CURRENT_FILE)) < 0 &&
+ if ((error = rebase_readoid(&id, &buf, rebase, CURRENT_FILE)) < 0 &&
error != GIT_ENOTFOUND)
goto done;
@@ -249,7 +261,7 @@ static int rebase_open_merge(git_rebase *rebase)
git_str_clear(&cmt);
if ((error = git_str_printf(&cmt, "cmt.%" PRIuZ, (i+1))) < 0 ||
- (error = rebase_readoid(&id, &buf, &state_path, cmt.ptr)) < 0)
+ (error = rebase_readoid(&id, &buf, rebase, cmt.ptr)) < 0)
goto done;
operation = rebase_operation_alloc(rebase, GIT_REBASE_OPERATION_PICK, &id, NULL);
@@ -257,14 +269,13 @@ static int rebase_open_merge(git_rebase *rebase)
}
/* Read 'onto_name' */
- if ((error = rebase_readfile(&buf, &state_path, ONTO_NAME_FILE)) < 0)
+ if ((error = rebase_readfile(&buf, rebase, ONTO_NAME_FILE)) < 0)
goto done;
rebase->onto_name = git_str_detach(&buf);
done:
git_str_dispose(&cmt);
- git_str_dispose(&state_path);
git_str_dispose(&buf);
return error;
@@ -308,9 +319,9 @@ int git_rebase_open(
const git_rebase_options *given_opts)
{
git_rebase *rebase;
- git_str path = GIT_STR_INIT, orig_head_name = GIT_STR_INIT,
- orig_head_id = GIT_STR_INIT, onto_id = GIT_STR_INIT;
- size_t state_path_len;
+ git_str orig_head_name = GIT_STR_INIT,
+ orig_head_id = GIT_STR_INIT,
+ onto_id = GIT_STR_INIT;
int error;
GIT_ASSERT_ARG(repo);
@@ -332,13 +343,10 @@ int git_rebase_open(
goto done;
}
- if ((error = git_str_puts(&path, rebase->state_path)) < 0)
+ if ((error = git_str_puts(&rebase->state_filename, rebase->state_path)) < 0)
goto done;
- state_path_len = git_str_len(&path);
-
- if ((error = git_str_joinpath(&path, path.ptr, HEAD_NAME_FILE)) < 0 ||
- (error = git_futils_readbuffer(&orig_head_name, path.ptr)) < 0)
+ if ((error = rebase_readfile(&orig_head_name, rebase, HEAD_NAME_FILE)) < 0)
goto done;
git_str_rtrim(&orig_head_name);
@@ -346,36 +354,16 @@ int git_rebase_open(
if (strcmp(ORIG_DETACHED_HEAD, orig_head_name.ptr) == 0)
rebase->head_detached = 1;
- git_str_truncate(&path, state_path_len);
-
- if ((error = git_str_joinpath(&path, path.ptr, ORIG_HEAD_FILE)) < 0)
- goto done;
-
- if (!git_fs_path_isfile(path.ptr)) {
+ if ((error = rebase_readoid(&rebase->orig_head_id, &orig_head_id, rebase, ORIG_HEAD_FILE)) < 0) {
/* Previous versions of git.git used 'head' here; support that. */
- git_str_truncate(&path, state_path_len);
+ if (error == GIT_ENOTFOUND)
+ error = rebase_readoid(&rebase->orig_head_id, &orig_head_id, rebase, HEAD_FILE);
- if ((error = git_str_joinpath(&path, path.ptr, HEAD_FILE)) < 0)
+ if (error < 0)
goto done;
}
- if ((error = git_futils_readbuffer(&orig_head_id, path.ptr)) < 0)
- goto done;
-
- git_str_rtrim(&orig_head_id);
-
- if ((error = git_oid__fromstr(&rebase->orig_head_id, orig_head_id.ptr, GIT_OID_SHA1)) < 0)
- goto done;
-
- git_str_truncate(&path, state_path_len);
-
- if ((error = git_str_joinpath(&path, path.ptr, ONTO_FILE)) < 0 ||
- (error = git_futils_readbuffer(&onto_id, path.ptr)) < 0)
- goto done;
-
- git_str_rtrim(&onto_id);
-
- if ((error = git_oid__fromstr(&rebase->onto_id, onto_id.ptr, GIT_OID_SHA1)) < 0)
+ if ((error = rebase_readoid(&rebase->onto_id, &onto_id, rebase, ONTO_FILE)) < 0)
goto done;
if (!rebase->head_detached)
@@ -403,7 +391,6 @@ int git_rebase_open(
else
git_rebase_free(rebase);
- git_str_dispose(&path);
git_str_dispose(&orig_head_name);
git_str_dispose(&orig_head_id);
git_str_dispose(&onto_id);
@@ -453,13 +440,13 @@ static const char *rebase_onto_name(const git_annotated_commit *onto)
static int rebase_setupfiles_merge(git_rebase *rebase)
{
git_str commit_filename = GIT_STR_INIT;
- char id_str[GIT_OID_SHA1_HEXSIZE];
+ char id_str[GIT_OID_MAX_HEXSIZE + 1];
git_rebase_operation *operation;
size_t i;
int error = 0;
if ((error = rebase_setupfile(rebase, END_FILE, 0, "%" PRIuZ "\n", git_array_size(rebase->operations))) < 0 ||
- (error = rebase_setupfile(rebase, ONTO_NAME_FILE, 0, "%s\n", rebase->onto_name)) < 0)
+ (error = rebase_setupfile(rebase, ONTO_NAME_FILE, 0, "%s\n", rebase->onto_name)) < 0)
goto done;
for (i = 0; i < git_array_size(rebase->operations); i++) {
@@ -468,10 +455,9 @@ static int rebase_setupfiles_merge(git_rebase *rebase)
git_str_clear(&commit_filename);
git_str_printf(&commit_filename, CMT_FILE_FMT, i+1);
- git_oid_fmt(id_str, &operation->id);
+ git_oid_tostr(id_str, GIT_OID_MAX_HEXSIZE + 1, &operation->id);
- if ((error = rebase_setupfile(rebase, commit_filename.ptr, 0,
- "%.*s\n", GIT_OID_SHA1_HEXSIZE, id_str)) < 0)
+ if ((error = rebase_setupfile(rebase, commit_filename.ptr, 0, "%s\n", id_str)) < 0)
goto done;
}
@@ -482,11 +468,11 @@ static int rebase_setupfiles_merge(git_rebase *rebase)
static int rebase_setupfiles(git_rebase *rebase)
{
- char onto[GIT_OID_SHA1_HEXSIZE], orig_head[GIT_OID_SHA1_HEXSIZE];
+ char onto[GIT_OID_MAX_HEXSIZE + 1], orig_head[GIT_OID_MAX_HEXSIZE + 1];
const char *orig_head_name;
- git_oid_fmt(onto, &rebase->onto_id);
- git_oid_fmt(orig_head, &rebase->orig_head_id);
+ git_oid_tostr(onto, GIT_OID_MAX_HEXSIZE + 1, &rebase->onto_id);
+ git_oid_tostr(orig_head, GIT_OID_MAX_HEXSIZE + 1, &rebase->orig_head_id);
if (p_mkdir(rebase->state_path, REBASE_DIR_MODE) < 0) {
git_error_set(GIT_ERROR_OS, "failed to create rebase directory '%s'", rebase->state_path);
@@ -498,8 +484,8 @@ static int rebase_setupfiles(git_rebase *rebase)
if (git_repository__set_orig_head(rebase->repo, &rebase->orig_head_id) < 0 ||
rebase_setupfile(rebase, HEAD_NAME_FILE, 0, "%s\n", orig_head_name) < 0 ||
- rebase_setupfile(rebase, ONTO_FILE, 0, "%.*s\n", GIT_OID_SHA1_HEXSIZE, onto) < 0 ||
- rebase_setupfile(rebase, ORIG_HEAD_FILE, 0, "%.*s\n", GIT_OID_SHA1_HEXSIZE, orig_head) < 0 ||
+ rebase_setupfile(rebase, ONTO_FILE, 0, "%s\n", onto) < 0 ||
+ rebase_setupfile(rebase, ORIG_HEAD_FILE, 0, "%s\n", orig_head) < 0 ||
rebase_setupfile(rebase, QUIET_FILE, 0, rebase->quiet ? "t\n" : "\n") < 0)
return -1;
@@ -644,7 +630,8 @@ static int rebase_init_merge(
GIT_UNUSED(upstream);
- if ((error = git_str_joinpath(&state_path, repo->gitdir, REBASE_MERGE_DIR)) < 0)
+ if ((error = git_str_joinpath(&state_path, repo->gitdir, REBASE_MERGE_DIR)) < 0 ||
+ (error = git_str_put(&rebase->state_filename, state_path.ptr, state_path.size)) < 0)
goto done;
rebase->state_path = git_str_detach(&state_path);
@@ -814,7 +801,7 @@ static int rebase_next_merge(
git_indexwriter indexwriter = GIT_INDEXWRITER_INIT;
git_rebase_operation *operation;
git_checkout_options checkout_opts;
- char current_idstr[GIT_OID_SHA1_HEXSIZE];
+ char current_idstr[GIT_OID_MAX_HEXSIZE + 1];
unsigned int parent_count;
int error;
@@ -837,13 +824,13 @@ static int rebase_next_merge(
goto done;
}
- git_oid_fmt(current_idstr, &operation->id);
+ git_oid_tostr(current_idstr, GIT_OID_MAX_HEXSIZE + 1, &operation->id);
normalize_checkout_options_for_apply(&checkout_opts, rebase, current_commit);
if ((error = git_indexwriter_init_for_operation(&indexwriter, rebase->repo, &checkout_opts.checkout_strategy)) < 0 ||
(error = rebase_setupfile(rebase, MSGNUM_FILE, 0, "%" PRIuZ "\n", rebase->current+1)) < 0 ||
- (error = rebase_setupfile(rebase, CURRENT_FILE, 0, "%.*s\n", GIT_OID_SHA1_HEXSIZE, current_idstr)) < 0 ||
+ (error = rebase_setupfile(rebase, CURRENT_FILE, 0, "%s\n", current_idstr)) < 0 ||
(error = git_merge_trees(&index, rebase->repo, parent_tree, head_tree, current_tree, &rebase->options.merge_options)) < 0 ||
(error = git_merge__check_result(rebase->repo, index)) < 0 ||
(error = git_checkout_index(rebase->repo, index, &checkout_opts)) < 0 ||
@@ -1103,7 +1090,7 @@ static int rebase_commit_merge(
git_reference *head = NULL;
git_commit *head_commit = NULL, *commit = NULL;
git_index *index = NULL;
- char old_idstr[GIT_OID_SHA1_HEXSIZE], new_idstr[GIT_OID_SHA1_HEXSIZE];
+ char old_idstr[GIT_OID_MAX_HEXSIZE + 1], new_idstr[GIT_OID_MAX_HEXSIZE + 1];
int error;
operation = git_array_get(rebase->operations, rebase->current);
@@ -1119,11 +1106,11 @@ static int rebase_commit_merge(
rebase->repo, NULL, "HEAD", git_commit_id(commit), "rebase")) < 0)
goto done;
- git_oid_fmt(old_idstr, &operation->id);
- git_oid_fmt(new_idstr, git_commit_id(commit));
+ git_oid_tostr(old_idstr, GIT_OID_MAX_HEXSIZE + 1, &operation->id);
+ git_oid_tostr(new_idstr, GIT_OID_MAX_HEXSIZE + 1, git_commit_id(commit));
if ((error = rebase_setupfile(rebase, REWRITTEN_FILE, O_CREAT|O_WRONLY|O_APPEND,
- "%.*s %.*s\n", GIT_OID_SHA1_HEXSIZE, old_idstr, GIT_OID_SHA1_HEXSIZE, new_idstr)) < 0)
+ "%s %s\n", old_idstr, new_idstr)) < 0)
goto done;
git_oid_cpy(commit_id, git_commit_id(commit));
@@ -1306,7 +1293,9 @@ static int rebase_copy_notes(
git_rebase *rebase,
const git_signature *committer)
{
- git_str path = GIT_STR_INIT, rewritten = GIT_STR_INIT, notes_ref = GIT_STR_INIT;
+ git_str path = GIT_STR_INIT,
+ rewritten = GIT_STR_INIT,
+ notes_ref = GIT_STR_INIT;
char *pair_list, *fromstr, *tostr, *end;
git_oid from, to;
unsigned int linenum = 1;
@@ -1342,10 +1331,10 @@ static int rebase_copy_notes(
tostr = end+1;
*end = '\0';
- if (strlen(fromstr) != GIT_OID_SHA1_HEXSIZE ||
- strlen(tostr) != GIT_OID_SHA1_HEXSIZE ||
- git_oid__fromstr(&from, fromstr, GIT_OID_SHA1) < 0 ||
- git_oid__fromstr(&to, tostr, GIT_OID_SHA1) < 0)
+ if (strlen(fromstr) != git_oid_hexsize(rebase->repo->oid_type) ||
+ strlen(tostr) != git_oid_hexsize(rebase->repo->oid_type) ||
+ git_oid_from_string(&from, fromstr, rebase->repo->oid_type) < 0 ||
+ git_oid_from_string(&to, tostr, rebase->repo->oid_type) < 0)
goto on_error;
if ((error = rebase_copy_note(rebase, notes_ref.ptr, &from, &to, committer)) < 0)
@@ -1373,17 +1362,15 @@ static int return_to_orig_head(git_rebase *rebase)
git_reference *terminal_ref = NULL, *branch_ref = NULL, *head_ref = NULL;
git_commit *terminal_commit = NULL;
git_str branch_msg = GIT_STR_INIT, head_msg = GIT_STR_INIT;
- char onto[GIT_OID_SHA1_HEXSIZE];
+ char onto[GIT_OID_MAX_HEXSIZE + 1];
int error = 0;
- git_oid_fmt(onto, &rebase->onto_id);
+ git_oid_tostr(onto, GIT_OID_MAX_HEXSIZE + 1, &rebase->onto_id);
if ((error = git_str_printf(&branch_msg,
- "rebase finished: %s onto %.*s",
- rebase->orig_head_name, GIT_OID_SHA1_HEXSIZE, onto)) == 0 &&
+ "rebase finished: %s onto %s", rebase->orig_head_name, onto)) == 0 &&
(error = git_str_printf(&head_msg,
- "rebase finished: returning to %s",
- rebase->orig_head_name)) == 0 &&
+ "rebase finished: returning to %s", rebase->orig_head_name)) == 0 &&
(error = git_repository_head(&terminal_ref, rebase->repo)) == 0 &&
(error = git_reference_peel((git_object **)&terminal_commit,
terminal_ref, GIT_OBJECT_COMMIT)) == 0 &&
@@ -1475,6 +1462,7 @@ void git_rebase_free(git_rebase *rebase)
git__free(rebase->onto_name);
git__free(rebase->orig_head_name);
git__free(rebase->state_path);
+ git_str_dispose(&rebase->state_filename);
git_array_clear(rebase->operations);
git__free((char *)rebase->options.rewrite_notes_ref);
git__free(rebase);
diff --git a/src/libgit2/refdb_fs.c b/src/libgit2/refdb_fs.c
index 9ce1a960833..1138ebe74d3 100644
--- a/src/libgit2/refdb_fs.c
+++ b/src/libgit2/refdb_fs.c
@@ -26,7 +26,6 @@
#include
#include
#include
-#include
#define DEFAULT_NESTING_LEVEL 5
#define MAX_NESTING_LEVEL 10
@@ -62,8 +61,8 @@ typedef struct refdb_fs_backend {
git_oid_t oid_type;
- int fsync : 1,
- sorted : 1;
+ unsigned int fsync : 1,
+ sorted : 1;
int peeling_mode;
git_iterator_flag_t iterator_flags;
uint32_t direach_flags;
@@ -161,7 +160,7 @@ static int packed_reload(refdb_fs_backend *backend)
/* parse " \n" */
- if (git_oid__fromstr(&oid, scan, backend->oid_type) < 0)
+ if (git_oid_from_prefix(&oid, scan, oid_hexsize, backend->oid_type) < 0)
goto parse_failed;
scan += oid_hexsize;
@@ -182,7 +181,7 @@ static int packed_reload(refdb_fs_backend *backend)
/* look for optional "^\n" */
if (*scan == '^') {
- if (git_oid__fromstr(&oid, scan + 1, backend->oid_type) < 0)
+ if (git_oid_from_prefix(&oid, scan + 1, oid_hexsize, backend->oid_type) < 0)
goto parse_failed;
scan += oid_hexsize + 1;
@@ -229,7 +228,7 @@ static int loose_parse_oid(
goto corrupted;
/* we need to get 40 OID characters from the file */
- if (git_oid__fromstr(oid, str, oid_type) < 0)
+ if (git_oid_from_prefix(oid, str, oid_hexsize, oid_type) < 0)
goto corrupted;
/* If the file is longer than 40 chars, the 41st must be a space */
@@ -410,7 +409,9 @@ static const char *loose_parse_symbolic(git_str *file_content)
static bool is_per_worktree_ref(const char *ref_name)
{
return git__prefixcmp(ref_name, "refs/") != 0 ||
- git__prefixcmp(ref_name, "refs/bisect/") == 0;
+ git__prefixcmp(ref_name, "refs/bisect/") == 0 ||
+ git__prefixcmp(ref_name, "refs/worktree/") == 0 ||
+ git__prefixcmp(ref_name, "refs/rewritten/") == 0;
}
static int loose_lookup(
@@ -722,7 +723,7 @@ static int packed_lookup(
git_oid oid, peel, *peel_ptr = NULL;
if (data_end - rec < (long)oid_hexsize ||
- git_oid__fromstr(&oid, rec, backend->oid_type) < 0) {
+ git_oid_from_prefix(&oid, rec, oid_hexsize, backend->oid_type) < 0) {
goto parse_failed;
}
rec += oid_hexsize + 1;
@@ -738,7 +739,7 @@ static int packed_lookup(
if (*rec == '^') {
rec++;
if (data_end - rec < (long)oid_hexsize ||
- git_oid__fromstr(&peel, rec, backend->oid_type) < 0) {
+ git_oid_from_prefix(&peel, rec, oid_hexsize, backend->oid_type) < 0) {
goto parse_failed;
}
peel_ptr = &peel;
@@ -799,86 +800,155 @@ static void refdb_fs_backend__iterator_free(git_reference_iterator *_iter)
{
refdb_fs_iter *iter = GIT_CONTAINER_OF(_iter, refdb_fs_iter, parent);
- git_vector_free(&iter->loose);
+ git_vector_dispose(&iter->loose);
git_pool_clear(&iter->pool);
git_sortedcache_free(iter->cache);
git__free(iter);
}
-static int iter_load_loose_paths(refdb_fs_backend *backend, refdb_fs_iter *iter)
+struct iter_load_context {
+ refdb_fs_backend *backend;
+ refdb_fs_iter *iter;
+
+ /*
+ * If we have a glob with a prefix (eg `refs/heads/ *`) then we can
+ * optimize our prefix to avoid walking refs that we know won't
+ * match. This is that prefix.
+ */
+ const char *ref_prefix;
+ size_t ref_prefix_len;
+
+ /* Temporary variables to avoid unnecessary allocations */
+ git_str ref_name;
+ git_str path;
+};
+
+static void iter_load_optimize_prefix(struct iter_load_context *ctx)
{
- int error = 0;
- git_str path = GIT_STR_INIT;
- git_iterator *fsit = NULL;
- git_iterator_options fsit_opts = GIT_ITERATOR_OPTIONS_INIT;
- const git_index_entry *entry = NULL;
- const char *ref_prefix = GIT_REFS_DIR;
- size_t ref_prefix_len = strlen(ref_prefix);
+ const char *pos, *last_sep = NULL;
- if (!backend->commonpath) /* do nothing if no commonpath for loose refs */
- return 0;
+ if (!ctx->iter->glob)
+ return;
- fsit_opts.flags = backend->iterator_flags;
-
- if (iter->glob) {
- const char *last_sep = NULL;
- const char *pos;
- for (pos = iter->glob; *pos; ++pos) {
- switch (*pos) {
- case '?':
- case '*':
- case '[':
- case '\\':
- break;
- case '/':
- last_sep = pos;
- /* FALLTHROUGH */
- default:
- continue;
- }
+ for (pos = ctx->iter->glob; *pos; pos++) {
+ switch (*pos) {
+ case '?':
+ case '*':
+ case '[':
+ case '\\':
break;
+ case '/':
+ last_sep = pos;
+ /* FALLTHROUGH */
+ default:
+ continue;
}
- if (last_sep) {
- ref_prefix = iter->glob;
- ref_prefix_len = (last_sep - ref_prefix) + 1;
- }
+ break;
}
- if ((error = git_str_puts(&path, backend->commonpath)) < 0 ||
- (error = git_str_put(&path, ref_prefix, ref_prefix_len)) < 0) {
- git_str_dispose(&path);
- return error;
+ if (last_sep) {
+ ctx->ref_prefix = ctx->iter->glob;
+ ctx->ref_prefix_len = (last_sep - ctx->ref_prefix) + 1;
}
+}
+
+static int iter_load_paths(
+ struct iter_load_context *ctx,
+ const char *root_path,
+ bool worktree)
+{
+ git_iterator *fsit = NULL;
+ git_iterator_options fsit_opts = GIT_ITERATOR_OPTIONS_INIT;
+ const git_index_entry *entry;
+ int error = 0;
+
+ fsit_opts.flags = ctx->backend->iterator_flags;
+
+ git_str_clear(&ctx->path);
+ git_str_puts(&ctx->path, root_path);
+ git_str_put(&ctx->path, ctx->ref_prefix, ctx->ref_prefix_len);
- if ((error = git_iterator_for_filesystem(&fsit, path.ptr, &fsit_opts)) < 0) {
- git_str_dispose(&path);
- return (iter->glob && error == GIT_ENOTFOUND)? 0 : error;
+ fsit_opts.flags = ctx->backend->iterator_flags;
+ fsit_opts.oid_type = ctx->backend->oid_type;
+
+ if ((error = git_iterator_for_filesystem(&fsit, ctx->path.ptr, &fsit_opts)) < 0) {
+ /*
+ * Subdirectories - either glob provided or per-worktree refs - need
+ * not exist.
+ */
+ if ((worktree || ctx->iter->glob) && error == GIT_ENOTFOUND)
+ error = 0;
+
+ goto done;
}
- error = git_str_sets(&path, ref_prefix);
+ git_str_clear(&ctx->ref_name);
+ git_str_put(&ctx->ref_name, ctx->ref_prefix, ctx->ref_prefix_len);
- while (!error && !git_iterator_advance(&entry, fsit)) {
- const char *ref_name;
+ while (git_iterator_advance(&entry, fsit) == 0) {
char *ref_dup;
- git_str_truncate(&path, ref_prefix_len);
- git_str_puts(&path, entry->path);
- ref_name = git_str_cstr(&path);
+ git_str_truncate(&ctx->ref_name, ctx->ref_prefix_len);
+ git_str_puts(&ctx->ref_name, entry->path);
+
+ if (worktree) {
+ if (!is_per_worktree_ref(ctx->ref_name.ptr))
+ continue;
+ } else {
+ if (git_repository_is_worktree(ctx->backend->repo) &&
+ is_per_worktree_ref(ctx->ref_name.ptr))
+ continue;
+ }
- if (git__suffixcmp(ref_name, ".lock") == 0 ||
- (iter->glob && wildmatch(iter->glob, ref_name, 0) != 0))
+ if (git__suffixcmp(ctx->ref_name.ptr, ".lock") == 0)
continue;
- ref_dup = git_pool_strdup(&iter->pool, ref_name);
- if (!ref_dup)
- error = -1;
- else
- error = git_vector_insert(&iter->loose, ref_dup);
+ if (ctx->iter->glob && wildmatch(ctx->iter->glob, ctx->ref_name.ptr, 0))
+ continue;
+
+ ref_dup = git_pool_strdup(&ctx->iter->pool, ctx->ref_name.ptr);
+ GIT_ERROR_CHECK_ALLOC(ref_dup);
+
+ if ((error = git_vector_insert(&ctx->iter->loose, ref_dup)) < 0)
+ goto done;
}
+done:
git_iterator_free(fsit);
- git_str_dispose(&path);
+ return error;
+}
+
+#define iter_load_context_init(b, i) { b, i, GIT_REFS_DIR, CONST_STRLEN(GIT_REFS_DIR) }
+#define iter_load_context_dispose(ctx) do { \
+ git_str_dispose(&((ctx)->path)); \
+ git_str_dispose(&((ctx)->ref_name)); \
+} while(0)
+static int iter_load_loose_paths(
+ refdb_fs_backend *backend,
+ refdb_fs_iter *iter)
+{
+ struct iter_load_context ctx = iter_load_context_init(backend, iter);
+
+ int error = 0;
+
+ if (!backend->commonpath)
+ return 0;
+
+ iter_load_optimize_prefix(&ctx);
+
+ if ((error = iter_load_paths(&ctx,
+ backend->commonpath, false)) < 0)
+ goto done;
+
+ if (git_repository_is_worktree(backend->repo)) {
+ if ((error = iter_load_paths(&ctx,
+ backend->gitpath, true)) < 0)
+ goto done;
+ }
+
+done:
+ iter_load_context_dispose(&ctx);
return error;
}
@@ -1782,7 +1852,7 @@ static int refdb_fs_backend__rename(
(error = refdb_fs_backend__lookup(&old, _backend, old_name)) < 0)
return error;
- if ((error = refdb_fs_backend__delete(_backend, old_name, NULL, NULL)) < 0) {
+ if ((error = loose_lock(&file, backend, old->name)) < 0) {
git_reference_free(old);
return error;
}
@@ -1790,32 +1860,33 @@ static int refdb_fs_backend__rename(
new = git_reference__realloc(&old, new_name);
if (!new) {
git_reference_free(old);
+ git_filebuf_cleanup(&file);
return -1;
}
- if ((error = loose_lock(&file, backend, new->name)) < 0) {
+ if ((error = refdb_fs_backend__delete_tail(_backend, &file, old_name, NULL, NULL)) < 0) {
git_reference_free(new);
+ git_filebuf_cleanup(&file);
return error;
}
- /* Try to rename the refog; it's ok if the old doesn't exist */
- error = refdb_reflog_fs__rename(_backend, old_name, new_name);
- if (((error == 0) || (error == GIT_ENOTFOUND)) &&
- ((error = reflog_append(backend, new, git_reference_target(new), NULL, who, message)) < 0)) {
+ if ((error = loose_lock(&file, backend, new_name)) < 0) {
git_reference_free(new);
- git_filebuf_cleanup(&file);
return error;
}
- if (error < 0) {
+ /* Try to rename the refog; it's ok if the old doesn't exist */
+ error = refdb_reflog_fs__rename(_backend, old_name, new_name);
+ if (((error == 0) || (error == GIT_ENOTFOUND)) &&
+ ((error = reflog_append(backend, new, git_reference_target(new), NULL, who, message)) < 0)) {
git_reference_free(new);
git_filebuf_cleanup(&file);
return error;
}
-
if ((error = loose_commit(&file, new)) < 0 || out == NULL) {
git_reference_free(new);
+ git_filebuf_cleanup(&file);
return error;
}
@@ -1949,9 +2020,9 @@ static int reflog_parse(git_reflog *log, const char *buf, size_t buf_size)
entry->committer = git__calloc(1, sizeof(*entry->committer));
GIT_ERROR_CHECK_ALLOC(entry->committer);
- if (git_parse_advance_oid(&entry->oid_old, &parser) < 0 ||
+ if (git_parse_advance_oid(&entry->oid_old, &parser, log->oid_type) < 0 ||
git_parse_advance_expected(&parser, " ", 1) < 0 ||
- git_parse_advance_oid(&entry->oid_cur, &parser) < 0)
+ git_parse_advance_oid(&entry->oid_cur, &parser, log->oid_type) < 0)
goto next;
sig = parser.line;
@@ -2398,7 +2469,12 @@ static int refdb_reflog_fs__delete(git_refdb_backend *_backend, const char *name
if ((error = reflog_path(&path, backend->repo, name)) < 0)
goto out;
- if (!git_fs_path_exists(path.ptr))
+ /*
+ * If a reference was moved downwards, eg refs/heads/br2 -> refs/heads/br2/new-name,
+ * refs/heads/br2 does exist but it's a directory. That's a valid situation.
+ * Proceed only if it's a file.
+ */
+ if (!git_fs_path_isfile(path.ptr))
goto out;
if ((error = p_unlink(path.ptr)) < 0)
diff --git a/src/libgit2/reflog.c b/src/libgit2/reflog.c
index 86d4355e336..b998172916e 100644
--- a/src/libgit2/reflog.c
+++ b/src/libgit2/reflog.c
@@ -13,7 +13,6 @@
#include "refdb.h"
#include "git2/sys/refdb_backend.h"
-#include "git2/sys/reflog.h"
void git_reflog_entry__free(git_reflog_entry *entry)
{
@@ -40,7 +39,7 @@ void git_reflog_free(git_reflog *reflog)
git_reflog_entry__free(entry);
}
- git_vector_free(&reflog->entries);
+ git_vector_dispose(&reflog->entries);
git__free(reflog->ref_name);
git__free(reflog);
}
diff --git a/src/libgit2/reflog.h b/src/libgit2/reflog.h
index bc98785981a..ab3afdf10fc 100644
--- a/src/libgit2/reflog.h
+++ b/src/libgit2/reflog.h
@@ -37,4 +37,6 @@ GIT_INLINE(size_t) reflog_inverse_index(size_t idx, size_t total)
return (total - 1) - idx;
}
+void git_reflog_entry__free(git_reflog_entry *entry);
+
#endif
diff --git a/src/libgit2/refs.c b/src/libgit2/refs.c
index 8e4abaccc1f..e01278521dc 100644
--- a/src/libgit2/refs.c
+++ b/src/libgit2/refs.c
@@ -72,6 +72,7 @@ git_reference *git_reference__alloc(
const git_oid *oid,
const git_oid *peel)
{
+ git_oid_t oid_type;
git_reference *ref;
GIT_ASSERT_ARG_WITH_RETVAL(name, NULL);
@@ -84,10 +85,16 @@ git_reference *git_reference__alloc(
ref->type = GIT_REFERENCE_DIRECT;
git_oid_cpy(&ref->target.oid, oid);
+#ifdef GIT_EXPERIMENTAL_SHA256
+ oid_type = oid->type;
+#else
+ oid_type = GIT_OID_SHA1;
+#endif
+
if (peel != NULL)
git_oid_cpy(&ref->peel, peel);
else
- git_oid_clear(&ref->peel, GIT_OID_SHA1);
+ git_oid_clear(&ref->peel, oid_type);
return ref;
}
@@ -801,7 +808,7 @@ int git_reference_list(
if (git_reference_foreach_name(
repo, &cb__reflist_add, (void *)&ref_list) < 0) {
- git_vector_free(&ref_list);
+ git_vector_dispose(&ref_list);
return -1;
}
@@ -828,17 +835,20 @@ static int is_valid_ref_char(char ch)
}
}
-static int ensure_segment_validity(const char *name, char may_contain_glob)
+static int ensure_segment_validity(const char *name, char may_contain_glob, bool allow_caret_prefix)
{
const char *current = name;
+ const char *start = current;
char prev = '\0';
const int lock_len = (int)strlen(GIT_FILELOCK_EXTENSION);
int segment_len;
if (*current == '.')
return -1; /* Refname starts with "." */
+ if (allow_caret_prefix && *current == '^')
+ start++;
- for (current = name; ; current++) {
+ for (current = start; ; current++) {
if (*current == '\0' || *current == '/')
break;
@@ -870,7 +880,7 @@ static int ensure_segment_validity(const char *name, char may_contain_glob)
return segment_len;
}
-static bool is_all_caps_and_underscore(const char *name, size_t len)
+static bool is_valid_normalized_name(const char *name, size_t len)
{
size_t i;
char c;
@@ -881,6 +891,9 @@ static bool is_all_caps_and_underscore(const char *name, size_t len)
for (i = 0; i < len; i++)
{
c = name[i];
+ if (i == 0 && c == '^')
+ continue; /* The first character is allowed to be "^" for negative refspecs */
+
if ((c < 'A' || c > 'Z') && c != '_')
return false;
}
@@ -901,9 +914,10 @@ int git_reference__normalize_name(
int segment_len, segments_count = 0, error = GIT_EINVALIDSPEC;
unsigned int process_flags;
bool normalize = (buf != NULL);
+ bool allow_caret_prefix = true;
bool validate = (flags & GIT_REFERENCE_FORMAT__VALIDATION_DISABLE) == 0;
-#ifdef GIT_USE_ICONV
+#ifdef GIT_I18N_ICONV
git_fs_path_iconv_t ic = GIT_PATH_ICONV_INIT;
#endif
@@ -918,7 +932,7 @@ int git_reference__normalize_name(
if (normalize)
git_str_clear(buf);
-#ifdef GIT_USE_ICONV
+#ifdef GIT_I18N_ICONV
if ((flags & GIT_REFERENCE_FORMAT__PRECOMPOSE_UNICODE) != 0) {
size_t namelen = strlen(current);
if ((error = git_fs_path_iconv_init_precompose(&ic)) < 0 ||
@@ -938,7 +952,7 @@ int git_reference__normalize_name(
while (true) {
char may_contain_glob = process_flags & GIT_REFERENCE_FORMAT_REFSPEC_PATTERN;
- segment_len = ensure_segment_validity(current, may_contain_glob);
+ segment_len = ensure_segment_validity(current, may_contain_glob, allow_caret_prefix);
if (segment_len < 0)
goto cleanup;
@@ -974,6 +988,12 @@ int git_reference__normalize_name(
break;
current += segment_len + 1;
+
+ /*
+ * A caret prefix is only allowed in the first segment to signify a
+ * negative refspec.
+ */
+ allow_caret_prefix = false;
}
/* A refname can not be empty */
@@ -993,12 +1013,12 @@ int git_reference__normalize_name(
if ((segments_count == 1 ) &&
!(flags & GIT_REFERENCE_FORMAT_REFSPEC_SHORTHAND) &&
- !(is_all_caps_and_underscore(name, (size_t)segment_len) ||
+ !(is_valid_normalized_name(name, (size_t)segment_len) ||
((flags & GIT_REFERENCE_FORMAT_REFSPEC_PATTERN) && !strcmp("*", name))))
goto cleanup;
if ((segments_count > 1)
- && (is_all_caps_and_underscore(name, strchr(name, '/') - name)))
+ && (is_valid_normalized_name(name, strchr(name, '/') - name)))
goto cleanup;
error = 0;
@@ -1012,7 +1032,7 @@ int git_reference__normalize_name(
if (error && normalize)
git_str_dispose(buf);
-#ifdef GIT_USE_ICONV
+#ifdef GIT_I18N_ICONV
git_fs_path_iconv_clear(&ic);
#endif
@@ -1056,10 +1076,14 @@ int git_reference_cmp(
const git_reference *ref2)
{
git_reference_t type1, type2;
+ int ret;
GIT_ASSERT_ARG(ref1);
GIT_ASSERT_ARG(ref2);
+ if ((ret = strcmp(ref1->name, ref2->name)) != 0)
+ return ret;
+
type1 = git_reference_type(ref1);
type2 = git_reference_type(ref2);
@@ -1073,6 +1097,12 @@ int git_reference_cmp(
return git_oid__cmp(&ref1->target.oid, &ref2->target.oid);
}
+int git_reference__cmp_cb(const void *a, const void *b)
+{
+ return git_reference_cmp(
+ (const git_reference *)a, (const git_reference *)b);
+}
+
/*
* Starting with the reference given by `ref_name`, follows symbolic
* references until a direct reference is found and updated the OID
diff --git a/src/libgit2/refs.h b/src/libgit2/refs.h
index cb888bf8f49..a06965b60d8 100644
--- a/src/libgit2/refs.h
+++ b/src/libgit2/refs.h
@@ -12,7 +12,6 @@
#include "git2/oid.h"
#include "git2/refs.h"
#include "git2/refdb.h"
-#include "strmap.h"
#include "str.h"
#include "oid.h"
@@ -92,6 +91,12 @@ int git_reference__is_tag(const char *ref_name);
int git_reference__is_note(const char *ref_name);
const char *git_reference__shorthand(const char *name);
+/*
+ * A `git_reference_cmp` wrapper suitable for passing to generic
+ * comparators, like `vector_cmp` / `tsort` / etc.
+ */
+int git_reference__cmp_cb(const void *a, const void *b);
+
/**
* Lookup a reference by name and try to resolve to an OID.
*
diff --git a/src/libgit2/refspec.c b/src/libgit2/refspec.c
index f0a0c2bfb3e..7ce8ef4ba71 100644
--- a/src/libgit2/refspec.c
+++ b/src/libgit2/refspec.c
@@ -22,6 +22,7 @@ int git_refspec__parse(git_refspec *refspec, const char *input, bool is_fetch)
const char *lhs, *rhs;
int valid = 0;
unsigned int flags;
+ bool is_neg_refspec = false;
GIT_ASSERT_ARG(refspec);
GIT_ASSERT_ARG(input);
@@ -34,6 +35,9 @@ int git_refspec__parse(git_refspec *refspec, const char *input, bool is_fetch)
refspec->force = 1;
lhs++;
}
+ if (*lhs == '^') {
+ is_neg_refspec = true;
+ }
rhs = strrchr(lhs, ':');
@@ -62,7 +66,14 @@ int git_refspec__parse(git_refspec *refspec, const char *input, bool is_fetch)
llen = (rhs ? (size_t)(rhs - lhs - 1) : strlen(lhs));
if (1 <= llen && memchr(lhs, '*', llen)) {
- if ((rhs && !is_glob) || (!rhs && is_fetch))
+ /*
+ * If the lefthand side contains a glob, then one of the following must be
+ * true, otherwise the spec is invalid
+ * 1) the rhs exists and also contains a glob
+ * 2) it is a negative refspec (i.e. no rhs)
+ * 3) the rhs doesn't exist and we're fetching
+ */
+ if ((rhs && !is_glob) || (rhs && is_neg_refspec) || (!rhs && is_fetch && !is_neg_refspec))
goto invalid;
is_glob = 1;
} else if (rhs && is_glob)
@@ -225,6 +236,14 @@ int git_refspec_force(const git_refspec *refspec)
return refspec->force;
}
+int git_refspec_src_matches_negative(const git_refspec *refspec, const char *refname)
+{
+ if (refspec == NULL || refspec->src == NULL || !git_refspec_is_negative(refspec))
+ return false;
+
+ return (wildmatch(refspec->src + 1, refname, 0) == 0);
+}
+
int git_refspec_src_matches(const git_refspec *refspec, const char *refname)
{
if (refspec == NULL || refspec->src == NULL)
@@ -340,6 +359,14 @@ int git_refspec_is_wildcard(const git_refspec *spec)
return (spec->src[strlen(spec->src) - 1] == '*');
}
+int git_refspec_is_negative(const git_refspec *spec)
+{
+ GIT_ASSERT_ARG(spec);
+ GIT_ASSERT_ARG(spec->src);
+
+ return (spec->src[0] == '^' && spec->dst == NULL);
+}
+
git_direction git_refspec_direction(const git_refspec *spec)
{
GIT_ASSERT_ARG(spec);
diff --git a/src/libgit2/refspec.h b/src/libgit2/refspec.h
index bf4f7fcfbbc..37612216c04 100644
--- a/src/libgit2/refspec.h
+++ b/src/libgit2/refspec.h
@@ -45,6 +45,14 @@ int git_refspec__serialize(git_str *out, const git_refspec *refspec);
*/
int git_refspec_is_wildcard(const git_refspec *spec);
+/**
+ * Determines if a refspec is a negative refspec.
+ *
+ * @param spec the refspec
+ * @return 1 if the refspec is a negative, 0 otherwise
+ */
+int git_refspec_is_negative(const git_refspec *spec);
+
/**
* DWIM `spec` with `refs` existing on the remote, append the dwim'ed
* result in `out`.
diff --git a/src/libgit2/remote.c b/src/libgit2/remote.c
index c3e2a324d23..0b674c5ef2c 100644
--- a/src/libgit2/remote.c
+++ b/src/libgit2/remote.c
@@ -23,6 +23,7 @@
#include "git2/types.h"
#include "git2/oid.h"
#include "git2/net.h"
+#include "transports/smart.h"
#define CONFIG_URL_FMT "remote.%s.url"
#define CONFIG_PUSHURL_FMT "remote.%s.pushurl"
@@ -1292,9 +1293,9 @@ static int git_remote__download(
free_refspecs(&remote->active_refspecs);
error = dwim_refspecs(&remote->active_refspecs, to_active, &refs);
- git_vector_free(&refs);
+ git_vector_dispose(&refs);
free_refspecs(&specs);
- git_vector_free(&specs);
+ git_vector_dispose(&specs);
if (error < 0)
goto on_error;
@@ -1310,9 +1311,9 @@ static int git_remote__download(
error = git_fetch_download_pack(remote);
on_error:
- git_vector_free(&refs);
+ git_vector_dispose(&refs);
free_refspecs(&specs);
- git_vector_free(&specs);
+ git_vector_dispose(&specs);
return error;
}
@@ -1338,7 +1339,11 @@ int git_remote_download(
if ((error = connect_or_reset_options(remote, GIT_DIRECTION_FETCH, &connect_opts)) < 0)
return error;
- return git_remote__download(remote, refspecs, opts);
+ error = git_remote__download(remote, refspecs, opts);
+
+ git_remote_connect_options_dispose(&connect_opts);
+
+ return error;
}
int git_remote_fetch(
@@ -1347,13 +1352,14 @@ int git_remote_fetch(
const git_fetch_options *opts,
const char *reflog_message)
{
- int error, update_fetchhead = 1;
git_remote_autotag_option_t tagopt = remote->download_tags;
bool prune = false;
git_str reflog_msg_buf = GIT_STR_INIT;
git_remote_connect_options connect_opts = GIT_REMOTE_CONNECT_OPTIONS_INIT;
unsigned int capabilities;
git_oid_t oid_type;
+ unsigned int update_flags = GIT_REMOTE_UPDATE_FETCHHEAD;
+ int error;
GIT_ASSERT_ARG(remote);
@@ -1370,7 +1376,7 @@ int git_remote_fetch(
return error;
if (opts) {
- update_fetchhead = opts->update_fetchhead;
+ update_flags = opts->update_fetchhead;
tagopt = opts->download_tags;
}
@@ -1397,8 +1403,14 @@ int git_remote_fetch(
}
/* Create "remote/foo" branches for all remote branches */
- error = git_remote_update_tips(remote, &connect_opts.callbacks, update_fetchhead, tagopt, git_str_cstr(&reflog_msg_buf));
+ error = git_remote_update_tips(remote,
+ &connect_opts.callbacks,
+ update_flags,
+ tagopt,
+ git_str_cstr(&reflog_msg_buf));
+
git_str_dispose(&reflog_msg_buf);
+
if (error < 0)
goto done;
@@ -1577,7 +1589,7 @@ static int git_remote_write_fetchhead(git_remote *remote, git_refspec *spec, git
for (i = 0; i < fetchhead_refs.length; ++i)
git_fetchhead_ref_free(fetchhead_refs.contents[i]);
- git_vector_free(&fetchhead_refs);
+ git_vector_dispose(&fetchhead_refs);
git_reference_free(head_ref);
return error;
@@ -1631,7 +1643,10 @@ int git_remote_prune(git_remote *remote, const git_remote_callbacks *callbacks)
const git_refspec *spec;
const char *refname;
int error;
- git_oid zero_id = GIT_OID_SHA1_ZERO;
+ git_oid zero_id;
+
+ GIT_ASSERT(remote && remote->repo);
+ git_oid_clear(&zero_id, remote->repo->oid_type);
if (callbacks)
GIT_ERROR_CHECK_VERSION(callbacks, GIT_REMOTE_CALLBACKS_VERSION, "git_remote_callbacks");
@@ -1709,19 +1724,28 @@ int git_remote_prune(git_remote *remote, const git_remote_callbacks *callbacks)
git_oid_cpy(&id, git_reference_target(ref));
error = git_reference_delete(ref);
git_reference_free(ref);
+
if (error < 0)
goto cleanup;
- if (callbacks && callbacks->update_tips)
- error = callbacks->update_tips(refname, &id, &zero_id, callbacks->payload);
+ if (callbacks && callbacks->update_refs)
+ error = callbacks->update_refs(refname, &id,
+ &zero_id, NULL, callbacks->payload);
+#ifndef GIT_DEPRECATE_HARD
+ else if (callbacks && callbacks->update_tips)
+ error = callbacks->update_tips(refname, &id,
+ &zero_id, callbacks->payload);
+#endif
- if (error < 0)
+ if (error < 0) {
+ git_error_set_after_callback_function(error, "git_remote_fetch");
goto cleanup;
+ }
}
cleanup:
- git_vector_free(&remote_refs);
- git_vector_free_deep(&candidates);
+ git_vector_dispose(&remote_refs);
+ git_vector_dispose_deep(&candidates);
return error;
}
@@ -1729,13 +1753,17 @@ static int update_ref(
const git_remote *remote,
const char *ref_name,
git_oid *id,
+ git_refspec *spec,
const char *msg,
const git_remote_callbacks *callbacks)
{
git_reference *ref;
- git_oid old_id = GIT_OID_SHA1_ZERO;
+ git_oid old_id;
int error;
+ GIT_ASSERT(remote && remote->repo);
+ git_oid_clear(&old_id, remote->repo->oid_type);
+
error = git_reference_name_to_id(&old_id, remote->repo, ref_name);
if (error < 0 && error != GIT_ENOTFOUND)
@@ -1754,9 +1782,19 @@ static int update_ref(
if (error < 0)
return error;
- if (callbacks && callbacks->update_tips &&
- (error = callbacks->update_tips(ref_name, &old_id, id, callbacks->payload)) < 0)
+ if (callbacks && callbacks->update_refs)
+ error = callbacks->update_refs(ref_name, &old_id,
+ id, spec, callbacks->payload);
+#ifndef GIT_DEPRECATE_HARD
+ else if (callbacks && callbacks->update_tips)
+ error = callbacks->update_tips(ref_name, &old_id,
+ id, callbacks->payload);
+#endif
+
+ if (error < 0) {
+ git_error_set_after_callback_function(error, "git_remote_fetch");
return error;
+ }
return 0;
}
@@ -1767,6 +1805,7 @@ static int update_one_tip(
git_refspec *spec,
git_remote_head *head,
git_refspec *tagspec,
+ unsigned int update_flags,
git_remote_autotag_option_t tagopt,
const char *log_message,
const git_remote_callbacks *callbacks)
@@ -1774,11 +1813,13 @@ static int update_one_tip(
git_odb *odb;
git_str refname = GIT_STR_INIT;
git_reference *ref = NULL;
- bool autotag = false;
+ bool autotag = false, updated = false;
git_oid old;
int valid;
int error;
+ GIT_ASSERT(remote && remote->repo);
+
if ((error = git_repository_odb__weakptr(&odb, remote->repo)) < 0)
goto done;
@@ -1839,29 +1880,40 @@ static int update_one_tip(
}
if (error == GIT_ENOTFOUND) {
- git_oid_clear(&old, GIT_OID_SHA1);
+ git_oid_clear(&old, remote->repo->oid_type);
error = 0;
if (autotag && (error = git_vector_insert(update_heads, head)) < 0)
goto done;
}
- if (!git_oid__cmp(&old, &head->oid))
- goto done;
+ if ((updated = !git_oid_equal(&old, &head->oid))) {
+ /* In autotag mode, don't overwrite any locally-existing tags */
+ error = git_reference_create(&ref, remote->repo, refname.ptr, &head->oid, !autotag,
+ log_message);
- /* In autotag mode, don't overwrite any locally-existing tags */
- error = git_reference_create(&ref, remote->repo, refname.ptr, &head->oid, !autotag,
- log_message);
+ if (error < 0) {
+ if (error == GIT_EEXISTS)
+ error = 0;
- if (error < 0) {
- if (error == GIT_EEXISTS)
- error = 0;
+ goto done;
+ }
+ }
+ if (!callbacks ||
+ (!updated && (update_flags & GIT_REMOTE_UPDATE_REPORT_UNCHANGED) == 0))
goto done;
- }
- if (callbacks && callbacks->update_tips != NULL &&
- (error = callbacks->update_tips(refname.ptr, &old, &head->oid, callbacks->payload)) < 0)
+ if (callbacks && callbacks->update_refs)
+ error = callbacks->update_refs(refname.ptr, &old,
+ &head->oid, spec, callbacks->payload);
+#ifndef GIT_DEPRECATE_HARD
+ else if (callbacks && callbacks->update_tips)
+ error = callbacks->update_tips(refname.ptr, &old,
+ &head->oid, callbacks->payload);
+#endif
+
+ if (error < 0)
git_error_set_after_callback_function(error, "git_remote_fetch");
done:
@@ -1873,7 +1925,7 @@ static int update_one_tip(
static int update_tips_for_spec(
git_remote *remote,
const git_remote_callbacks *callbacks,
- int update_fetchhead,
+ unsigned int update_flags,
git_remote_autotag_option_t tagopt,
git_refspec *spec,
git_vector *refs,
@@ -1885,7 +1937,7 @@ static int update_tips_for_spec(
int error = 0;
size_t i;
- GIT_ASSERT_ARG(remote);
+ GIT_ASSERT_ARG(remote && remote->repo);
if (git_refspec__parse(&tagspec, GIT_REFSPEC_TAGS, true) < 0)
return -1;
@@ -1896,19 +1948,22 @@ static int update_tips_for_spec(
/* Update tips based on the remote heads */
git_vector_foreach(refs, i, head) {
- if (update_one_tip(&update_heads, remote, spec, head, &tagspec, tagopt, log_message, callbacks) < 0)
+ if (update_one_tip(&update_heads,
+ remote, spec, head, &tagspec,
+ update_flags, tagopt, log_message,
+ callbacks) < 0)
goto on_error;
}
/* Handle specified oid sources */
- if (git_oid__is_hexstr(spec->src, GIT_OID_SHA1)) {
+ if (git_oid__is_hexstr(spec->src, remote->repo->oid_type)) {
git_oid id;
- if ((error = git_oid__fromstr(&id, spec->src, GIT_OID_SHA1)) < 0)
+ if ((error = git_oid_from_string(&id, spec->src, remote->repo->oid_type)) < 0)
goto on_error;
if (spec->dst &&
- (error = update_ref(remote, spec->dst, &id, log_message, callbacks)) < 0)
+ (error = update_ref(remote, spec->dst, &id, spec, log_message, callbacks)) < 0)
goto on_error;
git_oid_cpy(&oid_head.oid, &id);
@@ -1918,17 +1973,17 @@ static int update_tips_for_spec(
goto on_error;
}
- if (update_fetchhead &&
+ if ((update_flags & GIT_REMOTE_UPDATE_FETCHHEAD) &&
(error = git_remote_write_fetchhead(remote, spec, &update_heads)) < 0)
goto on_error;
git_refspec__dispose(&tagspec);
- git_vector_free(&update_heads);
+ git_vector_dispose(&update_heads);
return 0;
on_error:
git_refspec__dispose(&tagspec);
- git_vector_free(&update_heads);
+ git_vector_dispose(&update_heads);
return -1;
}
@@ -2020,7 +2075,7 @@ static int opportunistic_updates(
git_str_clear(&refname);
if ((error = git_refspec__transform(&refname, spec, head->name)) < 0 ||
- (error = update_ref(remote, refname.ptr, &head->oid, msg, callbacks)) < 0)
+ (error = update_ref(remote, refname.ptr, &head->oid, spec, msg, callbacks)) < 0)
goto cleanup;
}
@@ -2049,11 +2104,11 @@ static int truncate_fetch_head(const char *gitdir)
}
int git_remote_update_tips(
- git_remote *remote,
- const git_remote_callbacks *callbacks,
- int update_fetchhead,
- git_remote_autotag_option_t download_tags,
- const char *reflog_message)
+ git_remote *remote,
+ const git_remote_callbacks *callbacks,
+ unsigned int update_flags,
+ git_remote_autotag_option_t download_tags,
+ const char *reflog_message)
{
git_refspec *spec, tagspec;
git_vector refs = GIT_VECTOR_INIT;
@@ -2082,7 +2137,7 @@ int git_remote_update_tips(
goto out;
if (tagopt == GIT_REMOTE_DOWNLOAD_TAGS_ALL) {
- if ((error = update_tips_for_spec(remote, callbacks, update_fetchhead, tagopt, &tagspec, &refs, reflog_message)) < 0)
+ if ((error = update_tips_for_spec(remote, callbacks, update_flags, tagopt, &tagspec, &refs, reflog_message)) < 0)
goto out;
}
@@ -2090,7 +2145,7 @@ int git_remote_update_tips(
if (spec->push)
continue;
- if ((error = update_tips_for_spec(remote, callbacks, update_fetchhead, tagopt, spec, &refs, reflog_message)) < 0)
+ if ((error = update_tips_for_spec(remote, callbacks, update_flags, tagopt, spec, &refs, reflog_message)) < 0)
goto out;
}
@@ -2099,7 +2154,7 @@ int git_remote_update_tips(
error = opportunistic_updates(remote, callbacks, &refs, reflog_message);
out:
- git_vector_free(&refs);
+ git_vector_dispose(&refs);
git_refspec__dispose(&tagspec);
return error;
}
@@ -2158,19 +2213,19 @@ void git_remote_free(git_remote *remote)
remote->transport = NULL;
}
- git_vector_free(&remote->refs);
+ git_vector_dispose(&remote->refs);
free_refspecs(&remote->refspecs);
- git_vector_free(&remote->refspecs);
+ git_vector_dispose(&remote->refspecs);
free_refspecs(&remote->active_refspecs);
- git_vector_free(&remote->active_refspecs);
+ git_vector_dispose(&remote->active_refspecs);
free_refspecs(&remote->passive_refspecs);
- git_vector_free(&remote->passive_refspecs);
+ git_vector_dispose(&remote->passive_refspecs);
free_heads(&remote->local_heads);
- git_vector_free(&remote->local_heads);
+ git_vector_dispose(&remote->local_heads);
git_push_free(remote->push);
git__free(remote->url);
@@ -2213,7 +2268,7 @@ int git_remote_list(git_strarray *remotes_list, git_repository *repo)
cfg, "^remote\\..*\\.(push)?url$", remote_list_cb, &list);
if (error < 0) {
- git_vector_free_deep(&list);
+ git_vector_dispose_deep(&list);
return error;
}
@@ -2494,7 +2549,7 @@ static int rename_fetch_refspecs(git_vector *problems, git_remote *remote, const
git_vector_foreach(problems, i, str)
git__free(str);
- git_vector_free(problems);
+ git_vector_dispose(problems);
}
return error;
@@ -2534,7 +2589,7 @@ int git_remote_rename(git_strarray *out, git_repository *repo, const char *name,
cleanup:
if (error < 0)
- git_vector_free(&problem_refspecs);
+ git_vector_dispose(&problem_refspecs);
git_remote_free(remote);
return error;
@@ -2573,17 +2628,21 @@ int git_remote_name_is_valid(int *valid, const char *remote_name)
git_refspec *git_remote__matching_refspec(git_remote *remote, const char *refname)
{
git_refspec *spec;
+ git_refspec *match = NULL;
size_t i;
git_vector_foreach(&remote->active_refspecs, i, spec) {
if (spec->push)
continue;
- if (git_refspec_src_matches(spec, refname))
- return spec;
+ if (git_refspec_src_matches_negative(spec, refname))
+ return NULL;
+
+ if (git_refspec_src_matches(spec, refname) && match == NULL)
+ match = spec;
}
- return NULL;
+ return match;
}
git_refspec *git_remote__matching_dst_refspec(git_remote *remote, const char *refname)
@@ -2641,7 +2700,7 @@ static int copy_refspecs(git_strarray *array, const git_remote *remote, unsigned
return 0;
on_error:
- git_vector_free_deep(&refspecs);
+ git_vector_dispose_deep(&refspecs);
return -1;
}
@@ -2789,7 +2848,7 @@ static int remove_refs(git_repository *repo, const git_refspec *spec)
git_vector_foreach(&refs, i, dup) {
git__free(dup);
}
- git_vector_free(&refs);
+ git_vector_dispose(&refs);
return error;
}
@@ -2958,12 +3017,22 @@ int git_remote_upload(
}
}
- if ((error = git_push_finish(push)) < 0)
- goto cleanup;
+ if (opts && opts->remote_push_options.count > 0)
+ for (i = 0; i < opts->remote_push_options.count; ++i) {
+ char *optstr = git__strdup(opts->remote_push_options.strings[i]);
+ GIT_ERROR_CHECK_ALLOC(optstr);
- if (connect_opts.callbacks.push_update_reference &&
- (error = git_push_status_foreach(push, connect_opts.callbacks.push_update_reference, connect_opts.callbacks.payload)) < 0)
- goto cleanup;
+ if ((error = git_vector_insert(&push->remote_push_options, optstr)) < 0)
+ goto cleanup;
+ }
+
+ error = git_push_finish(push);
+
+ if (connect_opts.callbacks.push_update_reference) {
+ const int cb_error = git_push_status_foreach(push, connect_opts.callbacks.push_update_reference, connect_opts.callbacks.payload);
+ if (!error)
+ error = cb_error;
+ }
cleanup:
git_remote_connect_options_dispose(&connect_opts);
diff --git a/src/libgit2/remote.h b/src/libgit2/remote.h
index 676b3c2ab65..9e089be38c5 100644
--- a/src/libgit2/remote.h
+++ b/src/libgit2/remote.h
@@ -38,6 +38,7 @@ struct git_remote {
git_remote_autotag_option_t download_tags;
int prune_refs;
int passed_refspecs;
+ git_fetch_negotiation nego;
};
int git_remote__urlfordirection(git_str *url_out, struct git_remote *remote, int direction, const git_remote_callbacks *callbacks);
diff --git a/src/libgit2/repository.c b/src/libgit2/repository.c
index 8c41167a1c0..a88217e6556 100644
--- a/src/libgit2/repository.c
+++ b/src/libgit2/repository.c
@@ -15,6 +15,7 @@
#include "buf.h"
#include "common.h"
#include "commit.h"
+#include "grafts.h"
#include "tag.h"
#include "blob.h"
#include "futils.h"
@@ -33,7 +34,6 @@
#include "submodule.h"
#include "worktree.h"
#include "path.h"
-#include "strmap.h"
#ifdef GIT_WIN32
# include "win32/w32_util.h"
@@ -61,12 +61,13 @@ static const struct {
{ GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "hooks", true },
{ GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "logs", true },
{ GIT_REPOSITORY_ITEM_GITDIR, GIT_REPOSITORY_ITEM__LAST, "modules", true },
- { GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "worktrees", true }
+ { GIT_REPOSITORY_ITEM_COMMONDIR, GIT_REPOSITORY_ITEM_GITDIR, "worktrees", true },
+ { GIT_REPOSITORY_ITEM_GITDIR, GIT_REPOSITORY_ITEM_GITDIR, "config.worktree", false }
};
static int check_repositoryformatversion(int *version, git_config *config);
static int check_extensions(git_config *config, int version);
-static int load_global_config(git_config **config);
+static int load_global_config(git_config **config, bool use_env);
static int load_objectformat(git_repository *repo, git_config *config);
#define GIT_COMMONDIR_FILE "commondir"
@@ -151,6 +152,10 @@ int git_repository__cleanup(git_repository *repo)
git_repository_submodule_cache_clear(repo);
git_cache_clear(&repo->objects);
git_attr_cache_flush(repo);
+ git_grafts_free(repo->grafts);
+ repo->grafts = NULL;
+ git_grafts_free(repo->shallow_grafts);
+ repo->shallow_grafts = NULL;
set_config(repo, NULL);
set_index(repo, NULL);
@@ -191,11 +196,23 @@ void git_repository_free(git_repository *repo)
}
/* Check if we have a separate commondir (e.g. we have a worktree) */
-static int lookup_commondir(bool *separate, git_str *commondir, git_str *repository_path)
+static int lookup_commondir(
+ bool *separate,
+ git_str *commondir,
+ git_str *repository_path,
+ uint32_t flags)
{
- git_str common_link = GIT_STR_INIT;
+ git_str common_link = GIT_STR_INIT;
int error;
+ /* Environment variable overrides configuration */
+ if ((flags & GIT_REPOSITORY_OPEN_FROM_ENV)) {
+ error = git__getenv(commondir, "GIT_COMMON_DIR");
+
+ if (!error || error != GIT_ENOTFOUND)
+ goto done;
+ }
+
/*
* If there's no commondir file, the repository path is the
* common path, but it needs a trailing slash.
@@ -222,12 +239,11 @@ static int lookup_commondir(bool *separate, git_str *commondir, git_str *reposit
git_str_swap(commondir, &common_link);
}
- git_str_dispose(&common_link);
-
/* Make sure the commondir path always has a trailing slash */
error = git_fs_path_prettify_dir(commondir, commondir->ptr, NULL);
done:
+ git_str_dispose(&common_link);
return error;
}
@@ -252,14 +268,19 @@ GIT_INLINE(int) validate_repo_path(git_str *path)
*
* Open a repository object from its path
*/
-static int is_valid_repository_path(bool *out, git_str *repository_path, git_str *common_path)
+static int is_valid_repository_path(
+ bool *out,
+ git_str *repository_path,
+ git_str *common_path,
+ uint32_t flags)
{
bool separate_commondir = false;
int error;
*out = false;
- if ((error = lookup_commondir(&separate_commondir, common_path, repository_path)) < 0)
+ if ((error = lookup_commondir(&separate_commondir,
+ common_path, repository_path, flags)) < 0)
return error;
/* Ensure HEAD file exists */
@@ -307,19 +328,36 @@ static git_repository *repository_alloc(void)
return NULL;
}
-int git_repository_new(git_repository **out)
+int git_repository_new_ext(
+ git_repository **out,
+ git_repository_new_options *opts)
{
git_repository *repo;
+ GIT_ASSERT_ARG(out);
+ GIT_ERROR_CHECK_VERSION(opts,
+ GIT_REPOSITORY_NEW_OPTIONS_VERSION,
+ "git_repository_new_options");
+
+ if (opts && opts->oid_type)
+ GIT_ASSERT_ARG(git_oid_type_is_valid(opts->oid_type));
+
*out = repo = repository_alloc();
GIT_ERROR_CHECK_ALLOC(repo);
repo->is_bare = 1;
repo->is_worktree = 0;
+ repo->oid_type = opts && opts->oid_type ? opts->oid_type :
+ GIT_OID_DEFAULT;
return 0;
}
+int git_repository_new(git_repository **out)
+{
+ return git_repository_new_ext(out, NULL);
+}
+
static int load_config_data(git_repository *repo, const git_config *config)
{
int is_bare;
@@ -337,19 +375,42 @@ static int load_config_data(git_repository *repo, const git_config *config)
return 0;
}
-static int load_workdir(git_repository *repo, git_config *config, git_str *parent_path)
+static int load_workdir(
+ git_repository *repo,
+ git_config *config,
+ git_str *parent_path)
{
- int error;
- git_config_entry *ce;
+ git_config_entry *ce = NULL;
git_str worktree = GIT_STR_INIT;
git_str path = GIT_STR_INIT;
+ git_str workdir_env = GIT_STR_INIT;
+ const char *value = NULL;
+ int error;
if (repo->is_bare)
return 0;
- if ((error = git_config__lookup_entry(
- &ce, config, "core.worktree", false)) < 0)
- return error;
+ /* Environment variables are preferred */
+ if (repo->use_env) {
+ error = git__getenv(&workdir_env, "GIT_WORK_TREE");
+
+ if (error == 0)
+ value = workdir_env.ptr;
+ else if (error == GIT_ENOTFOUND)
+ error = 0;
+ else
+ goto cleanup;
+ }
+
+ /* Examine configuration values if necessary */
+ if (!value) {
+ if ((error = git_config__lookup_entry(&ce, config,
+ "core.worktree", false)) < 0)
+ return error;
+
+ if (ce && ce->value)
+ value = ce->value;
+ }
if (repo->is_worktree) {
char *gitlink = git_worktree__read_link(repo->gitdir, GIT_GITDIR_FILE);
@@ -367,17 +428,21 @@ static int load_workdir(git_repository *repo, git_config *config, git_str *paren
}
repo->workdir = git_str_detach(&worktree);
- }
- else if (ce && ce->value) {
- if ((error = git_fs_path_prettify_dir(
- &worktree, ce->value, repo->gitdir)) < 0)
+ } else if (value) {
+ if (!*value) {
+ git_error_set(GIT_ERROR_NET, "working directory cannot be set to empty path");
+ error = -1;
+ goto cleanup;
+ }
+
+ if ((error = git_fs_path_prettify_dir(&worktree,
+ value, repo->gitdir)) < 0)
goto cleanup;
repo->workdir = git_str_detach(&worktree);
- }
- else if (parent_path && git_fs_path_isdir(parent_path->ptr))
+ } else if (parent_path && git_fs_path_isdir(parent_path->ptr)) {
repo->workdir = git_str_detach(parent_path);
- else {
+ } else {
if (git_fs_path_dirname_r(&worktree, repo->gitdir) < 0 ||
git_fs_path_to_dir(&worktree) < 0) {
error = -1;
@@ -388,8 +453,10 @@ static int load_workdir(git_repository *repo, git_config *config, git_str *paren
}
GIT_ERROR_CHECK_ALLOC(repo->workdir);
+
cleanup:
git_str_dispose(&path);
+ git_str_dispose(&workdir_env);
git_config_entry_free(ce);
return error;
}
@@ -495,25 +562,39 @@ typedef struct {
static int validate_ownership_cb(const git_config_entry *entry, void *payload)
{
validate_ownership_data *data = payload;
+ const char *test_path;
if (strcmp(entry->value, "") == 0) {
*data->is_safe = false;
} else if (strcmp(entry->value, "*") == 0) {
*data->is_safe = true;
} else {
- const char *test_path = entry->value;
+ if (git_str_sets(&data->tmp, entry->value) < 0)
+ return -1;
+
+ if (!git_fs_path_is_root(data->tmp.ptr)) {
+ /* Input must not have trailing backslash. */
+ if (!data->tmp.size ||
+ data->tmp.ptr[data->tmp.size - 1] == '/')
+ return 0;
+
+ if (git_fs_path_to_dir(&data->tmp) < 0)
+ return -1;
+ }
+
+ test_path = data->tmp.ptr;
-#ifdef GIT_WIN32
/*
- * Git for Windows does some truly bizarre things with
- * paths that start with a forward slash; and expects you
- * to escape that with `%(prefix)`. This syntax generally
- * means to add the prefix that Git was installed to -- eg
- * `/usr/local` -- unless it's an absolute path, in which
- * case the leading `%(prefix)/` is just removed. And Git
- * for Windows expects you to use this syntax for absolute
- * Unix-style paths (in "Git Bash" or Windows Subsystem for
- * Linux).
+ * Git - and especially, Git for Windows - does some
+ * truly bizarre things with paths that start with a
+ * forward slash; and expects you to escape that with
+ * `%(prefix)`. This syntax generally means to add the
+ * prefix that Git was installed to (eg `/usr/local`)
+ * unless it's an absolute path, in which case the
+ * leading `%(prefix)/` is just removed. And Git for
+ * Windows expects you to use this syntax for absolute
+ * Unix-style paths (in "Git Bash" or Windows Subsystem
+ * for Linux).
*
* Worse, the behavior used to be that a leading `/` was
* not absolute. It would indicate that Git for Windows
@@ -528,20 +609,18 @@ static int validate_ownership_cb(const git_config_entry *entry, void *payload)
*/
if (strncmp(test_path, "%(prefix)//", strlen("%(prefix)//")) == 0)
test_path += strlen("%(prefix)/");
- else if (strncmp(test_path, "//", 2) == 0 &&
- strncmp(test_path, "//wsl.localhost/", strlen("//wsl.localhost/")) != 0)
- test_path++;
-#endif
- if (git_fs_path_prettify_dir(&data->tmp, test_path, NULL) == 0 &&
- strcmp(data->tmp.ptr, data->repo_path) == 0)
+ if (strcmp(test_path, data->repo_path) == 0)
*data->is_safe = true;
}
return 0;
}
-static int validate_ownership_config(bool *is_safe, const char *path)
+static int validate_ownership_config(
+ bool *is_safe,
+ const char *path,
+ bool use_env)
{
validate_ownership_data ownership_data = {
path, GIT_STR_INIT, is_safe
@@ -549,7 +628,7 @@ static int validate_ownership_config(bool *is_safe, const char *path)
git_config *config;
int error;
- if (load_global_config(&config) != 0)
+ if (load_global_config(&config, use_env) != 0)
return 0;
error = git_config_get_multivar_foreach(config,
@@ -623,13 +702,17 @@ static int validate_ownership(git_repository *repo)
}
if (is_safe ||
- (error = validate_ownership_config(&is_safe, validation_paths[0])) < 0)
+ (error = validate_ownership_config(
+ &is_safe, validation_paths[0], repo->use_env)) < 0)
goto done;
if (!is_safe) {
+ size_t path_len = git_fs_path_is_root(path) ?
+ strlen(path) : git_fs_path_dirlen(path);
+
git_error_set(GIT_ERROR_CONFIG,
- "repository path '%s' is not owned by current user",
- path);
+ "repository path '%.*s' is not owned by current user",
+ (int)min(path_len, INT_MAX), path);
error = GIT_EOWNER;
}
@@ -637,14 +720,28 @@ static int validate_ownership(git_repository *repo)
return error;
}
-static int find_repo(
- git_str *gitdir_path,
- git_str *workdir_path,
- git_str *gitlink_path,
- git_str *commondir_path,
+struct repo_paths {
+ git_str gitdir;
+ git_str workdir;
+ git_str gitlink;
+ git_str commondir;
+};
+
+#define REPO_PATHS_INIT { GIT_STR_INIT }
+
+GIT_INLINE(void) repo_paths_dispose(struct repo_paths *paths)
+{
+ git_str_dispose(&paths->gitdir);
+ git_str_dispose(&paths->workdir);
+ git_str_dispose(&paths->gitlink);
+ git_str_dispose(&paths->commondir);
+}
+
+static int find_repo_traverse(
+ struct repo_paths *out,
const char *start_path,
- uint32_t flags,
- const char *ceiling_dirs)
+ const char *ceiling_dirs,
+ uint32_t flags)
{
git_str path = GIT_STR_INIT;
git_str repo_link = GIT_STR_INIT;
@@ -656,19 +753,23 @@ static int find_repo(
size_t ceiling_offset = 0;
int error;
- git_str_clear(gitdir_path);
+ git_str_clear(&out->gitdir);
- error = git_fs_path_prettify(&path, start_path, NULL);
- if (error < 0)
+ if ((error = git_fs_path_prettify(&path, start_path, NULL)) < 0)
return error;
- /* in_dot_git toggles each loop:
+ /*
+ * In each loop we look first for a `.git` dir within the
+ * directory, then to see if the directory itself is a repo.
+ *
+ * In other words: if we start in /a/b/c, then we look at:
* /a/b/c/.git, /a/b/c, /a/b/.git, /a/b, /a/.git, /a
- * With GIT_REPOSITORY_OPEN_BARE or GIT_REPOSITORY_OPEN_NO_DOTGIT, we
- * assume we started with /a/b/c.git and don't append .git the first
- * time through.
- * min_iterations indicates the number of iterations left before going
- * further counts as a search. */
+ *
+ * With GIT_REPOSITORY_OPEN_BARE or GIT_REPOSITORY_OPEN_NO_DOTGIT,
+ * we assume we started with /a/b/c.git and don't append .git the
+ * first time through. min_iterations indicates the number of
+ * iterations left before going further counts as a search.
+ */
if (flags & (GIT_REPOSITORY_OPEN_BARE | GIT_REPOSITORY_OPEN_NO_DOTGIT)) {
in_dot_git = true;
min_iterations = 1;
@@ -695,48 +796,51 @@ static int find_repo(
break;
if (S_ISDIR(st.st_mode)) {
- if ((error = is_valid_repository_path(&is_valid, &path, &common_link)) < 0)
+ if ((error = is_valid_repository_path(&is_valid, &path, &common_link, flags)) < 0)
goto out;
if (is_valid) {
if ((error = git_fs_path_to_dir(&path)) < 0 ||
- (error = git_str_set(gitdir_path, path.ptr, path.size)) < 0)
+ (error = git_str_set(&out->gitdir, path.ptr, path.size)) < 0)
goto out;
- if (gitlink_path)
- if ((error = git_str_attach(gitlink_path, git_worktree__read_link(path.ptr, GIT_GITDIR_FILE), 0)) < 0)
- goto out;
- if (commondir_path)
- git_str_swap(&common_link, commondir_path);
+ if ((error = git_str_attach(&out->gitlink, git_worktree__read_link(path.ptr, GIT_GITDIR_FILE), 0)) < 0)
+ goto out;
+
+ git_str_swap(&common_link, &out->commondir);
break;
}
} else if (S_ISREG(st.st_mode) && git__suffixcmp(path.ptr, "/" DOT_GIT) == 0) {
if ((error = read_gitfile(&repo_link, path.ptr)) < 0 ||
- (error = is_valid_repository_path(&is_valid, &repo_link, &common_link)) < 0)
+ (error = is_valid_repository_path(&is_valid, &repo_link, &common_link, flags)) < 0)
goto out;
if (is_valid) {
- git_str_swap(gitdir_path, &repo_link);
+ git_str_swap(&out->gitdir, &repo_link);
+
+ if ((error = git_str_put(&out->gitlink, path.ptr, path.size)) < 0)
+ goto out;
- if (gitlink_path)
- if ((error = git_str_put(gitlink_path, path.ptr, path.size)) < 0)
- goto out;
- if (commondir_path)
- git_str_swap(&common_link, commondir_path);
+ git_str_swap(&common_link, &out->commondir);
}
break;
}
}
- /* Move up one directory. If we're in_dot_git, we'll search the
- * parent itself next. If we're !in_dot_git, we'll search .git
- * in the parent directory next (added at the top of the loop). */
+ /*
+ * Move up one directory. If we're in_dot_git, we'll
+ * search the parent itself next. If we're !in_dot_git,
+ * we'll search .git in the parent directory next (added
+ * at the top of the loop).
+ */
if ((error = git_fs_path_dirname_r(&path, path.ptr)) < 0)
goto out;
- /* Once we've checked the directory (and .git if applicable),
- * find the ceiling for a search. */
+ /*
+ * Once we've checked the directory (and .git if
+ * applicable), find the ceiling for a search.
+ */
if (min_iterations && (--min_iterations == 0))
ceiling_offset = find_ceiling_dir_offset(path.ptr, ceiling_dirs);
@@ -746,29 +850,139 @@ static int find_repo(
break;
}
- if (workdir_path && !(flags & GIT_REPOSITORY_OPEN_BARE)) {
- if (!git_str_len(gitdir_path))
- git_str_clear(workdir_path);
- else if ((error = git_fs_path_dirname_r(workdir_path, path.ptr)) < 0 ||
- (error = git_fs_path_to_dir(workdir_path)) < 0)
+ if (!(flags & GIT_REPOSITORY_OPEN_BARE)) {
+ if (!git_str_len(&out->gitdir))
+ git_str_clear(&out->workdir);
+ else if ((error = git_fs_path_dirname_r(&out->workdir, path.ptr)) < 0 ||
+ (error = git_fs_path_to_dir(&out->workdir)) < 0)
goto out;
}
- /* If we didn't find the repository, and we don't have any other error
- * to report, report that. */
- if (!git_str_len(gitdir_path)) {
- git_error_set(GIT_ERROR_REPOSITORY, "could not find repository from '%s'", start_path);
+ /* If we didn't find the repository, and we don't have any other
+ * error to report, report that. */
+ if (!git_str_len(&out->gitdir)) {
+ git_error_set(GIT_ERROR_REPOSITORY, "could not find repository at '%s'", start_path);
error = GIT_ENOTFOUND;
goto out;
}
out:
+ if (error)
+ repo_paths_dispose(out);
+
git_str_dispose(&path);
git_str_dispose(&repo_link);
git_str_dispose(&common_link);
return error;
}
+static int load_grafts(git_repository *repo)
+{
+ git_str path = GIT_STR_INIT;
+ int error;
+
+ /* refresh if they've both been opened previously */
+ if (repo->grafts && repo->shallow_grafts) {
+ if ((error = git_grafts_refresh(repo->grafts)) < 0 ||
+ (error = git_grafts_refresh(repo->shallow_grafts)) < 0)
+ return error;
+ }
+
+ /* resolve info path, which may not be found for inmemory repository */
+ if ((error = git_repository__item_path(&path, repo, GIT_REPOSITORY_ITEM_INFO)) < 0) {
+ if (error != GIT_ENOTFOUND)
+ return error;
+
+ /* create empty/inmemory grafts for inmemory repository */
+ if (!repo->grafts && (error = git_grafts_new(&repo->grafts, repo->oid_type)) < 0)
+ return error;
+
+ if (!repo->shallow_grafts && (error = git_grafts_new(&repo->shallow_grafts, repo->oid_type)) < 0)
+ return error;
+
+ return 0;
+ }
+
+ /* load grafts from disk */
+ if ((error = git_str_joinpath(&path, path.ptr, "grafts")) < 0 ||
+ (error = git_grafts_open_or_refresh(&repo->grafts, path.ptr, repo->oid_type)) < 0)
+ goto error;
+
+ git_str_clear(&path);
+
+ if ((error = git_str_joinpath(&path, repo->gitdir, "shallow")) < 0 ||
+ (error = git_grafts_open_or_refresh(&repo->shallow_grafts, path.ptr, repo->oid_type)) < 0)
+ goto error;
+
+error:
+ git_str_dispose(&path);
+ return error;
+}
+
+static int find_repo(
+ struct repo_paths *out,
+ const char *start_path,
+ const char *ceiling_dirs,
+ uint32_t flags)
+{
+ bool use_env = !!(flags & GIT_REPOSITORY_OPEN_FROM_ENV);
+ git_str gitdir_buf = GIT_STR_INIT,
+ ceiling_dirs_buf = GIT_STR_INIT,
+ across_fs_buf = GIT_STR_INIT;
+ int error;
+
+ if (use_env && !start_path) {
+ error = git__getenv(&gitdir_buf, "GIT_DIR");
+
+ if (!error) {
+ start_path = gitdir_buf.ptr;
+ flags |= GIT_REPOSITORY_OPEN_NO_SEARCH;
+ flags |= GIT_REPOSITORY_OPEN_NO_DOTGIT;
+ } else if (error == GIT_ENOTFOUND) {
+ start_path = ".";
+ } else {
+ goto done;
+ }
+ }
+
+ if (use_env && !ceiling_dirs) {
+ error = git__getenv(&ceiling_dirs_buf,
+ "GIT_CEILING_DIRECTORIES");
+
+ if (!error)
+ ceiling_dirs = ceiling_dirs_buf.ptr;
+ else if (error != GIT_ENOTFOUND)
+ goto done;
+ }
+
+ if (use_env) {
+ error = git__getenv(&across_fs_buf,
+ "GIT_DISCOVERY_ACROSS_FILESYSTEM");
+
+ if (!error) {
+ int across_fs = 0;
+
+ if ((error = git_config_parse_bool(&across_fs,
+ git_str_cstr(&across_fs_buf))) < 0)
+ goto done;
+
+ if (across_fs)
+ flags |= GIT_REPOSITORY_OPEN_CROSS_FS;
+ } else if (error != GIT_ENOTFOUND) {
+ goto done;
+ }
+ }
+
+ error = find_repo_traverse(out, start_path, ceiling_dirs, flags);
+
+done:
+ git_str_dispose(&gitdir_buf);
+ git_str_dispose(&ceiling_dirs_buf);
+ git_str_dispose(&across_fs_buf);
+
+ return error;
+}
+
static int obtain_config_and_set_oid_type(
git_config **config_ptr,
git_repository *repo)
@@ -787,7 +1001,7 @@ static int obtain_config_and_set_oid_type(
goto out;
if (config &&
- (error = check_repositoryformatversion(&version, config)) < 0)
+ (error = check_repositoryformatversion(&version, config)) < 0)
goto out;
if ((error = check_extensions(config, version)) < 0)
@@ -797,7 +1011,7 @@ static int obtain_config_and_set_oid_type(
if ((error = load_objectformat(repo, config)) < 0)
goto out;
} else {
- repo->oid_type = GIT_OID_SHA1;
+ repo->oid_type = GIT_OID_DEFAULT;
}
out:
@@ -817,7 +1031,7 @@ int git_repository_open_bare(
git_config *config;
if ((error = git_fs_path_prettify_dir(&path, bare_path, NULL)) < 0 ||
- (error = is_valid_repository_path(&is_valid, &path, &common_path)) < 0)
+ (error = is_valid_repository_path(&is_valid, &path, &common_path, 0)) < 0)
return error;
if (!is_valid) {
@@ -851,173 +1065,22 @@ int git_repository_open_bare(
return error;
}
-static int _git_repository_open_ext_from_env(
- git_repository **out,
- const char *start_path)
+static int repo_load_namespace(git_repository *repo)
{
- git_repository *repo = NULL;
- git_index *index = NULL;
- git_odb *odb = NULL;
- git_str dir_buf = GIT_STR_INIT;
- git_str ceiling_dirs_buf = GIT_STR_INIT;
- git_str across_fs_buf = GIT_STR_INIT;
- git_str index_file_buf = GIT_STR_INIT;
git_str namespace_buf = GIT_STR_INIT;
- git_str object_dir_buf = GIT_STR_INIT;
- git_str alts_buf = GIT_STR_INIT;
- git_str work_tree_buf = GIT_STR_INIT;
- git_str common_dir_buf = GIT_STR_INIT;
- const char *ceiling_dirs = NULL;
- unsigned flags = 0;
int error;
- if (!start_path) {
- error = git__getenv(&dir_buf, "GIT_DIR");
- if (error == GIT_ENOTFOUND) {
- git_error_clear();
- start_path = ".";
- } else if (error < 0)
- goto error;
- else {
- start_path = git_str_cstr(&dir_buf);
- flags |= GIT_REPOSITORY_OPEN_NO_SEARCH;
- flags |= GIT_REPOSITORY_OPEN_NO_DOTGIT;
- }
- }
-
- error = git__getenv(&ceiling_dirs_buf, "GIT_CEILING_DIRECTORIES");
- if (error == GIT_ENOTFOUND)
- git_error_clear();
- else if (error < 0)
- goto error;
- else
- ceiling_dirs = git_str_cstr(&ceiling_dirs_buf);
-
- error = git__getenv(&across_fs_buf, "GIT_DISCOVERY_ACROSS_FILESYSTEM");
- if (error == GIT_ENOTFOUND)
- git_error_clear();
- else if (error < 0)
- goto error;
- else {
- int across_fs = 0;
- error = git_config_parse_bool(&across_fs, git_str_cstr(&across_fs_buf));
- if (error < 0)
- goto error;
- if (across_fs)
- flags |= GIT_REPOSITORY_OPEN_CROSS_FS;
- }
-
- error = git__getenv(&index_file_buf, "GIT_INDEX_FILE");
- if (error == GIT_ENOTFOUND)
- git_error_clear();
- else if (error < 0)
- goto error;
- else {
- error = git_index_open(&index, git_str_cstr(&index_file_buf));
- if (error < 0)
- goto error;
- }
+ if (!repo->use_env)
+ return 0;
error = git__getenv(&namespace_buf, "GIT_NAMESPACE");
- if (error == GIT_ENOTFOUND)
- git_error_clear();
- else if (error < 0)
- goto error;
-
- error = git__getenv(&object_dir_buf, "GIT_OBJECT_DIRECTORY");
- if (error == GIT_ENOTFOUND)
- git_error_clear();
- else if (error < 0)
- goto error;
- else {
- error = git_odb__open(&odb, git_str_cstr(&object_dir_buf), NULL);
- if (error < 0)
- goto error;
- }
- error = git__getenv(&work_tree_buf, "GIT_WORK_TREE");
- if (error == GIT_ENOTFOUND)
- git_error_clear();
- else if (error < 0)
- goto error;
- else {
- git_error_set(GIT_ERROR_INVALID, "GIT_WORK_TREE unimplemented");
- error = GIT_ERROR;
- goto error;
- }
-
- error = git__getenv(&work_tree_buf, "GIT_COMMON_DIR");
- if (error == GIT_ENOTFOUND)
- git_error_clear();
- else if (error < 0)
- goto error;
- else {
- git_error_set(GIT_ERROR_INVALID, "GIT_COMMON_DIR unimplemented");
- error = GIT_ERROR;
- goto error;
- }
-
- error = git_repository_open_ext(&repo, start_path, flags, ceiling_dirs);
- if (error < 0)
- goto error;
-
- if (odb)
- git_repository_set_odb(repo, odb);
-
- error = git__getenv(&alts_buf, "GIT_ALTERNATE_OBJECT_DIRECTORIES");
- if (error == GIT_ENOTFOUND) {
- git_error_clear();
- error = 0;
- } else if (error < 0)
- goto error;
- else {
- const char *end;
- char *alt, *sep;
- if (!odb) {
- error = git_repository_odb(&odb, repo);
- if (error < 0)
- goto error;
- }
-
- end = git_str_cstr(&alts_buf) + git_str_len(&alts_buf);
- for (sep = alt = alts_buf.ptr; sep != end; alt = sep+1) {
- for (sep = alt; *sep && *sep != GIT_PATH_LIST_SEPARATOR; sep++)
- ;
- if (*sep)
- *sep = '\0';
- error = git_odb_add_disk_alternate(odb, alt);
- if (error < 0)
- goto error;
- }
- }
-
- if (git_str_len(&namespace_buf)) {
- error = git_repository_set_namespace(repo, git_str_cstr(&namespace_buf));
- if (error < 0)
- goto error;
- }
-
- git_repository_set_index(repo, index);
+ if (error == 0)
+ repo->namespace = git_str_detach(&namespace_buf);
+ else if (error != GIT_ENOTFOUND)
+ return error;
- if (out) {
- *out = repo;
- goto success;
- }
-error:
- git_repository_free(repo);
-success:
- git_odb_free(odb);
- git_index_free(index);
- git_str_dispose(&common_dir_buf);
- git_str_dispose(&work_tree_buf);
- git_str_dispose(&alts_buf);
- git_str_dispose(&object_dir_buf);
- git_str_dispose(&namespace_buf);
- git_str_dispose(&index_file_buf);
- git_str_dispose(&across_fs_buf);
- git_str_dispose(&ceiling_dirs_buf);
- git_str_dispose(&dir_buf);
- return error;
+ return 0;
}
static int repo_is_worktree(unsigned *out, const git_repository *repo)
@@ -1049,21 +1112,16 @@ int git_repository_open_ext(
unsigned int flags,
const char *ceiling_dirs)
{
- int error;
- unsigned is_worktree;
- git_str gitdir = GIT_STR_INIT, workdir = GIT_STR_INIT,
- gitlink = GIT_STR_INIT, commondir = GIT_STR_INIT;
+ struct repo_paths paths = { GIT_STR_INIT };
git_repository *repo = NULL;
git_config *config = NULL;
-
- if (flags & GIT_REPOSITORY_OPEN_FROM_ENV)
- return _git_repository_open_ext_from_env(repo_ptr, start_path);
+ unsigned is_worktree;
+ int error;
if (repo_ptr)
*repo_ptr = NULL;
- error = find_repo(
- &gitdir, &workdir, &gitlink, &commondir, start_path, flags, ceiling_dirs);
+ error = find_repo(&paths, start_path, ceiling_dirs, flags);
if (error < 0 || !repo_ptr)
goto cleanup;
@@ -1071,35 +1129,44 @@ int git_repository_open_ext(
repo = repository_alloc();
GIT_ERROR_CHECK_ALLOC(repo);
- repo->gitdir = git_str_detach(&gitdir);
+ repo->use_env = !!(flags & GIT_REPOSITORY_OPEN_FROM_ENV);
+
+ repo->gitdir = git_str_detach(&paths.gitdir);
GIT_ERROR_CHECK_ALLOC(repo->gitdir);
- if (gitlink.size) {
- repo->gitlink = git_str_detach(&gitlink);
+ if (paths.gitlink.size) {
+ repo->gitlink = git_str_detach(&paths.gitlink);
GIT_ERROR_CHECK_ALLOC(repo->gitlink);
}
- if (commondir.size) {
- repo->commondir = git_str_detach(&commondir);
+ if (paths.commondir.size) {
+ repo->commondir = git_str_detach(&paths.commondir);
GIT_ERROR_CHECK_ALLOC(repo->commondir);
}
if ((error = repo_is_worktree(&is_worktree, repo)) < 0)
goto cleanup;
+
repo->is_worktree = is_worktree;
error = obtain_config_and_set_oid_type(&config, repo);
if (error < 0)
goto cleanup;
+ if ((error = load_grafts(repo)) < 0)
+ goto cleanup;
+
if ((flags & GIT_REPOSITORY_OPEN_BARE) != 0) {
repo->is_bare = 1;
} else {
if (config &&
((error = load_config_data(repo, config)) < 0 ||
- (error = load_workdir(repo, config, &workdir)) < 0))
+ (error = load_workdir(repo, config, &paths.workdir)) < 0))
goto cleanup;
}
+ if ((error = repo_load_namespace(repo)) < 0)
+ goto cleanup;
+
/*
* Ensure that the git directory and worktree are
* owned by the current user.
@@ -1109,10 +1176,7 @@ int git_repository_open_ext(
goto cleanup;
cleanup:
- git_str_dispose(&gitdir);
- git_str_dispose(&workdir);
- git_str_dispose(&gitlink);
- git_str_dispose(&commondir);
+ repo_paths_dispose(&paths);
git_config_free(config);
if (error < 0)
@@ -1161,15 +1225,18 @@ int git_repository_open_from_worktree(git_repository **repo_out, git_worktree *w
return err;
}
-int git_repository_wrap_odb(git_repository **repo_out, git_odb *odb)
+int git_repository_wrap_odb(git_repository **out, git_odb *odb)
{
git_repository *repo;
repo = repository_alloc();
GIT_ERROR_CHECK_ALLOC(repo);
+ GIT_ASSERT(git_oid_type_is_valid(odb->options.oid_type));
+ repo->oid_type = odb->options.oid_type;
+
git_repository_set_odb(repo, odb);
- *repo_out = repo;
+ *out = repo;
return 0;
}
@@ -1180,11 +1247,35 @@ int git_repository_discover(
int across_fs,
const char *ceiling_dirs)
{
+ struct repo_paths paths = { GIT_STR_INIT };
uint32_t flags = across_fs ? GIT_REPOSITORY_OPEN_CROSS_FS : 0;
+ int error;
GIT_ASSERT_ARG(start_path);
- GIT_BUF_WRAP_PRIVATE(out, find_repo, NULL, NULL, NULL, start_path, flags, ceiling_dirs);
+ if ((error = find_repo(&paths, start_path, ceiling_dirs, flags)) == 0)
+ error = git_buf_fromstr(out, &paths.gitdir);
+
+ repo_paths_dispose(&paths);
+ return error;
+}
+
+static int has_config_worktree(bool *out, git_config *cfg)
+{
+ int worktreeconfig = 0, error;
+
+ *out = false;
+
+ error = git_config_get_bool(&worktreeconfig, cfg, "extensions.worktreeconfig");
+
+ if (error == 0)
+ *out = worktreeconfig;
+ else if (error == GIT_ENOTFOUND)
+ *out = false;
+ else
+ return error;
+
+ return 0;
}
static int load_config(
@@ -1195,9 +1286,11 @@ static int load_config(
const char *system_config_path,
const char *programdata_path)
{
- int error;
git_str config_path = GIT_STR_INIT;
git_config *cfg = NULL;
+ git_config_level_t write_order;
+ bool has_worktree;
+ int error;
GIT_ASSERT_ARG(out);
@@ -1211,6 +1304,14 @@ static int load_config(
if (error && error != GIT_ENOTFOUND)
goto on_error;
+ if ((error = has_config_worktree(&has_worktree, cfg)) == 0 &&
+ has_worktree &&
+ (error = git_repository__item_path(&config_path, repo, GIT_REPOSITORY_ITEM_WORKTREE_CONFIG)) == 0)
+ error = git_config_add_file_ondisk(cfg, config_path.ptr, GIT_CONFIG_LEVEL_WORKTREE, repo, 0);
+
+ if (error && error != GIT_ENOTFOUND)
+ goto on_error;
+
git_str_dispose(&config_path);
}
@@ -1240,6 +1341,11 @@ static int load_config(
git_error_clear(); /* clear any lingering ENOTFOUND errors */
+ write_order = GIT_CONFIG_LEVEL_LOCAL;
+
+ if ((error = git_config_set_writeorder(cfg, &write_order, 1)) < 0)
+ goto on_error;
+
*out = cfg;
return 0;
@@ -1255,32 +1361,81 @@ static const char *path_unless_empty(git_str *buf)
return git_str_len(buf) > 0 ? git_str_cstr(buf) : NULL;
}
+GIT_INLINE(int) config_path_system(git_str *out, bool use_env)
+{
+ if (use_env) {
+ git_str no_system_buf = GIT_STR_INIT;
+ int no_system = 0;
+ int error;
+
+ error = git__getenv(&no_system_buf, "GIT_CONFIG_NOSYSTEM");
+
+ if (error && error != GIT_ENOTFOUND)
+ return error;
+
+ error = git_config_parse_bool(&no_system, no_system_buf.ptr);
+ git_str_dispose(&no_system_buf);
+
+ if (no_system)
+ return 0;
+
+ error = git__getenv(out, "GIT_CONFIG_SYSTEM");
+
+ if (error == 0 || error != GIT_ENOTFOUND)
+ return 0;
+ }
+
+ git_config__find_system(out);
+ return 0;
+}
+
+GIT_INLINE(int) config_path_global(git_str *out, bool use_env)
+{
+ if (use_env) {
+ int error = git__getenv(out, "GIT_CONFIG_GLOBAL");
+
+ if (error == 0 || error != GIT_ENOTFOUND)
+ return 0;
+ }
+
+ git_config__find_global(out);
+ return 0;
+}
+
int git_repository_config__weakptr(git_config **out, git_repository *repo)
{
int error = 0;
if (repo->_config == NULL) {
+ git_str system_buf = GIT_STR_INIT;
git_str global_buf = GIT_STR_INIT;
git_str xdg_buf = GIT_STR_INIT;
- git_str system_buf = GIT_STR_INIT;
git_str programdata_buf = GIT_STR_INIT;
+ bool use_env = repo->use_env;
git_config *config;
- git_config__find_global(&global_buf);
- git_config__find_xdg(&xdg_buf);
- git_config__find_system(&system_buf);
- git_config__find_programdata(&programdata_buf);
+ if (!(error = config_path_system(&system_buf, use_env)) &&
+ !(error = config_path_global(&global_buf, use_env))) {
+ git_config__find_xdg(&xdg_buf);
+ git_config__find_programdata(&programdata_buf);
+ }
- /* If there is no global file, open a backend for it anyway */
- if (git_str_len(&global_buf) == 0)
- git_config__global_location(&global_buf);
+ if (!error) {
+ /*
+ * If there is no global file, open a backend
+ * for it anyway.
+ */
+ if (git_str_len(&global_buf) == 0)
+ git_config__global_location(&global_buf);
+
+ error = load_config(
+ &config, repo,
+ path_unless_empty(&global_buf),
+ path_unless_empty(&xdg_buf),
+ path_unless_empty(&system_buf),
+ path_unless_empty(&programdata_buf));
+ }
- error = load_config(
- &config, repo,
- path_unless_empty(&global_buf),
- path_unless_empty(&xdg_buf),
- path_unless_empty(&system_buf),
- path_unless_empty(&programdata_buf));
if (!error) {
GIT_REFCOUNT_OWN(config, repo);
@@ -1329,6 +1484,56 @@ int git_repository_set_config(git_repository *repo, git_config *config)
return 0;
}
+static int repository_odb_path(git_str *out, git_repository *repo)
+{
+ int error = GIT_ENOTFOUND;
+
+ if (repo->use_env)
+ error = git__getenv(out, "GIT_OBJECT_DIRECTORY");
+
+ if (error == GIT_ENOTFOUND)
+ error = git_repository__item_path(out, repo,
+ GIT_REPOSITORY_ITEM_OBJECTS);
+
+ return error;
+}
+
+static int repository_odb_alternates(
+ git_odb *odb,
+ git_repository *repo)
+{
+ git_str alternates = GIT_STR_INIT;
+ char *sep, *alt;
+ int error;
+
+ if (!repo->use_env)
+ return 0;
+
+ error = git__getenv(&alternates, "GIT_ALTERNATE_OBJECT_DIRECTORIES");
+
+ if (error != 0)
+ return (error == GIT_ENOTFOUND) ? 0 : error;
+
+ alt = alternates.ptr;
+
+ while (*alt) {
+ sep = strchr(alt, GIT_PATH_LIST_SEPARATOR);
+
+ if (sep)
+ *sep = '\0';
+
+ error = git_odb_add_disk_alternate(odb, alt);
+
+ if (sep)
+ alt = sep + 1;
+ else
+ break;
+ }
+
+ git_str_dispose(&alternates);
+ return 0;
+}
+
int git_repository_odb__weakptr(git_odb **out, git_repository *repo)
{
int error = 0;
@@ -1344,9 +1549,9 @@ int git_repository_odb__weakptr(git_odb **out, git_repository *repo)
odb_opts.oid_type = repo->oid_type;
- if ((error = git_repository__item_path(&odb_path, repo,
- GIT_REPOSITORY_ITEM_OBJECTS)) < 0 ||
- (error = git_odb__new(&odb, &odb_opts)) < 0)
+ if ((error = repository_odb_path(&odb_path, repo)) < 0 ||
+ (error = git_odb_new_ext(&odb, &odb_opts)) < 0 ||
+ (error = repository_odb_alternates(odb, repo)) < 0)
return error;
GIT_REFCOUNT_OWN(odb, repo);
@@ -1430,6 +1635,20 @@ int git_repository_set_refdb(git_repository *repo, git_refdb *refdb)
return 0;
}
+static int repository_index_path(git_str *out, git_repository *repo)
+{
+ int error = GIT_ENOTFOUND;
+
+ if (repo->use_env)
+ error = git__getenv(out, "GIT_INDEX_FILE");
+
+ if (error == GIT_ENOTFOUND)
+ error = git_repository__item_path(out, repo,
+ GIT_REPOSITORY_ITEM_INDEX);
+
+ return error;
+}
+
int git_repository_index__weakptr(git_index **out, git_repository *repo)
{
int error = 0;
@@ -1440,11 +1659,14 @@ int git_repository_index__weakptr(git_index **out, git_repository *repo)
if (repo->_index == NULL) {
git_str index_path = GIT_STR_INIT;
git_index *index;
+ git_index_options index_opts = GIT_INDEX_OPTIONS_INIT;
- if ((error = git_str_joinpath(&index_path, repo->gitdir, GIT_INDEX_FILE)) < 0)
+ if ((error = repository_index_path(&index_path, repo)) < 0)
return error;
- error = git_index_open(&index, index_path.ptr);
+ index_opts.oid_type = repo->oid_type;
+ error = git_index_open_ext(&index, index_path.ptr, &index_opts);
+
if (!error) {
GIT_REFCOUNT_OWN(index, repo);
@@ -1480,6 +1702,22 @@ int git_repository_set_index(git_repository *repo, git_index *index)
return 0;
}
+int git_repository_grafts__weakptr(git_grafts **out, git_repository *repo)
+{
+ GIT_ASSERT_ARG(out && repo);
+ GIT_ASSERT(repo->grafts);
+ *out = repo->grafts;
+ return 0;
+}
+
+int git_repository_shallow_grafts__weakptr(git_grafts **out, git_repository *repo)
+{
+ GIT_ASSERT_ARG(out && repo);
+ GIT_ASSERT(repo->shallow_grafts);
+ *out = repo->shallow_grafts;
+ return 0;
+}
+
int git_repository_set_namespace(git_repository *repo, const char *namespace)
{
git__free(repo->namespace);
@@ -1629,10 +1867,12 @@ static int check_repositoryformatversion(int *version, git_config *config)
static const char *builtin_extensions[] = {
"noop",
- "objectformat"
+ "objectformat",
+ "worktreeconfig",
+ "preciousobjects"
};
-static git_vector user_extensions = GIT_VECTOR_INIT;
+static git_vector user_extensions = { 0, git__strcmp_cb };
static int check_valid_extension(const git_config_entry *entry, void *payload)
{
@@ -1700,7 +1940,7 @@ static int load_objectformat(git_repository *repo, git_config *config)
if ((error = git_config_get_entry(&entry, config, "extensions.objectformat")) < 0) {
if (error == GIT_ENOTFOUND) {
- repo->oid_type = GIT_OID_SHA1;
+ repo->oid_type = GIT_OID_DEFAULT;
git_error_clear();
error = 0;
}
@@ -1773,7 +2013,7 @@ int git_repository__extensions(char ***out, size_t *out_len)
char *extension;
size_t i, j;
- if (git_vector_init(&extensions, 8, NULL) < 0)
+ if (git_vector_init(&extensions, 8, git__strcmp_cb) < 0)
return -1;
for (i = 0; i < ARRAY_SIZE(builtin_extensions); i++) {
@@ -1805,21 +2045,49 @@ int git_repository__extensions(char ***out, size_t *out_len)
return -1;
}
+ git_vector_sort(&extensions);
+
*out = (char **)git_vector_detach(out_len, NULL, &extensions);
return 0;
}
+static int dup_ext_err(void **old, void *extension)
+{
+ GIT_UNUSED(old);
+ GIT_UNUSED(extension);
+ return GIT_EEXISTS;
+}
+
int git_repository__set_extensions(const char **extensions, size_t len)
{
char *extension;
- size_t i;
+ size_t i, j;
+ int error;
git_repository__free_extensions();
for (i = 0; i < len; i++) {
- if ((extension = git__strdup(extensions[i])) == NULL ||
- git_vector_insert(&user_extensions, extension) < 0)
+ bool is_builtin = false;
+
+ for (j = 0; j < ARRAY_SIZE(builtin_extensions); j++) {
+ if (strcmp(builtin_extensions[j], extensions[i]) == 0) {
+ is_builtin = true;
+ break;
+ }
+ }
+
+ if (is_builtin)
+ continue;
+
+ if ((extension = git__strdup(extensions[i])) == NULL)
return -1;
+
+ if ((error = git_vector_insert_sorted(&user_extensions, extension, dup_ext_err)) < 0) {
+ git__free(extension);
+
+ if (error != GIT_EEXISTS)
+ return -1;
+ }
}
return 0;
@@ -1827,7 +2095,7 @@ int git_repository__set_extensions(const char **extensions, size_t len)
void git_repository__free_extensions(void)
{
- git_vector_free_deep(&user_extensions);
+ git_vector_dispose_deep(&user_extensions);
}
int git_repository_create_head(const char *git_dir, const char *ref_name)
@@ -1888,7 +2156,7 @@ static bool is_filesystem_case_insensitive(const char *gitdir_path)
* Return a configuration object with only the global and system
* configurations; no repository-level configuration.
*/
-static int load_global_config(git_config **config)
+static int load_global_config(git_config **config, bool use_env)
{
git_str global_buf = GIT_STR_INIT;
git_str xdg_buf = GIT_STR_INIT;
@@ -1896,16 +2164,17 @@ static int load_global_config(git_config **config)
git_str programdata_buf = GIT_STR_INIT;
int error;
- git_config__find_global(&global_buf);
- git_config__find_xdg(&xdg_buf);
- git_config__find_system(&system_buf);
- git_config__find_programdata(&programdata_buf);
+ if (!(error = config_path_system(&system_buf, use_env)) &&
+ !(error = config_path_global(&global_buf, use_env))) {
+ git_config__find_xdg(&xdg_buf);
+ git_config__find_programdata(&programdata_buf);
- error = load_config(config, NULL,
- path_unless_empty(&global_buf),
- path_unless_empty(&xdg_buf),
- path_unless_empty(&system_buf),
- path_unless_empty(&programdata_buf));
+ error = load_config(config, NULL,
+ path_unless_empty(&global_buf),
+ path_unless_empty(&xdg_buf),
+ path_unless_empty(&system_buf),
+ path_unless_empty(&programdata_buf));
+ }
git_str_dispose(&global_buf);
git_str_dispose(&xdg_buf);
@@ -1915,7 +2184,7 @@ static int load_global_config(git_config **config)
return error;
}
-static bool are_symlinks_supported(const char *wd_path)
+static bool are_symlinks_supported(const char *wd_path, bool use_env)
{
git_config *config = NULL;
int symlinks = 0;
@@ -1928,10 +2197,12 @@ static bool are_symlinks_supported(const char *wd_path)
* _not_ set, then we do not test or enable symlink support.
*/
#ifdef GIT_WIN32
- if (load_global_config(&config) < 0 ||
+ if (load_global_config(&config, use_env) < 0 ||
git_config_get_bool(&symlinks, config, "core.symlinks") < 0 ||
!symlinks)
goto done;
+#else
+ GIT_UNUSED(use_env);
#endif
if (!(symlinks = git_fs_path_supports_symlinks(wd_path)))
@@ -2004,7 +2275,8 @@ static int repo_init_fs_configs(
const char *cfg_path,
const char *repo_dir,
const char *work_dir,
- bool update_ignorecase)
+ bool update_ignorecase,
+ bool use_env)
{
int error = 0;
@@ -2015,7 +2287,7 @@ static int repo_init_fs_configs(
cfg, "core.filemode", is_chmod_supported(cfg_path))) < 0)
return error;
- if (!are_symlinks_supported(work_dir)) {
+ if (!are_symlinks_supported(work_dir, use_env)) {
if ((error = git_config_set_bool(cfg, "core.symlinks", false)) < 0)
return error;
} else if (git_config_delete_entry(cfg, "core.symlinks") < 0)
@@ -2029,7 +2301,7 @@ static int repo_init_fs_configs(
git_error_clear();
}
-#ifdef GIT_USE_ICONV
+#ifdef GIT_I18N_ICONV
if ((error = git_config_set_bool(
cfg, "core.precomposeunicode",
git_fs_path_does_decompose_unicode(work_dir))) < 0)
@@ -2052,6 +2324,7 @@ static int repo_init_config(
git_config *config = NULL;
bool is_bare = ((flags & GIT_REPOSITORY_INIT_BARE) != 0);
bool is_reinit = ((flags & GIT_REPOSITORY_INIT__IS_REINIT) != 0);
+ bool use_env = ((flags & GIT_REPOSITORY_OPEN_FROM_ENV) != 0);
int version = GIT_REPO_VERSION_DEFAULT;
if ((error = repo_local_config(&config, &cfg_path, NULL, repo_dir)) < 0)
@@ -2072,7 +2345,8 @@ static int repo_init_config(
SET_REPO_CONFIG(int32, "core.repositoryformatversion", version);
if ((error = repo_init_fs_configs(
- config, cfg_path.ptr, repo_dir, work_dir, !is_reinit)) < 0)
+ config, cfg_path.ptr, repo_dir, work_dir,
+ !is_reinit, use_env)) < 0)
goto cleanup;
if (!is_bare) {
@@ -2102,7 +2376,7 @@ static int repo_init_config(
SET_REPO_CONFIG(bool, "receive.denyNonFastforwards", true);
}
- if (oid_type != GIT_OID_SHA1) {
+ if (oid_type != GIT_OID_DEFAULT) {
SET_REPO_CONFIG(int32, "core.repositoryformatversion", 1);
SET_REPO_CONFIG(string, "extensions.objectformat", git_oid_type_name(oid_type));
}
@@ -2136,8 +2410,8 @@ int git_repository_reinit_filesystem(git_repository *repo, int recurse)
const char *repo_dir = git_repository_path(repo);
if (!(error = repo_local_config(&config, &path, repo, repo_dir)))
- error = repo_init_fs_configs(
- config, path.ptr, repo_dir, git_repository_workdir(repo), true);
+ error = repo_init_fs_configs(config, path.ptr, repo_dir,
+ git_repository_workdir(repo), true, repo->use_env);
git_config_free(config);
git_str_dispose(&path);
@@ -2236,7 +2510,7 @@ static int repo_write_gitlink(
error = git_fs_path_make_relative(&path_to_repo, in_dir);
if (!error)
- error = git_str_join(&buf, ' ', GIT_FILE_CONTENT_PREFIX, path_to_repo.ptr);
+ error = git_str_printf(&buf, "%s %s\n", GIT_FILE_CONTENT_PREFIX, path_to_repo.ptr);
if (!error)
error = repo_write_template(in_dir, true, DOT_GIT, 0666, true, buf.ptr);
@@ -2268,7 +2542,8 @@ static int repo_init_structure(
int error = 0;
repo_template_item *tpl;
bool external_tpl =
- ((opts->flags & GIT_REPOSITORY_INIT_EXTERNAL_TEMPLATE) != 0);
+ opts->template_path != NULL ||
+ (opts->flags & GIT_REPOSITORY_INIT_EXTERNAL_TEMPLATE) != 0;
mode_t dmode = pick_dir_mode(opts);
bool chmod = opts->mode != GIT_REPOSITORY_INIT_SHARED_UMASK;
@@ -2419,14 +2694,15 @@ static int repo_init_directories(
is_bare = ((opts->flags & GIT_REPOSITORY_INIT_BARE) != 0);
add_dotgit =
- (opts->flags & GIT_REPOSITORY_INIT_NO_DOTGIT_DIR) == 0 &&
- !is_bare &&
+ !is_bare && !opts->workdir_path &&
git__suffixcmp(given_repo, "/" DOT_GIT) != 0 &&
git__suffixcmp(given_repo, "/" GIT_DIR) != 0;
if (git_str_joinpath(repo_path, given_repo, add_dotgit ? GIT_DIR : "") < 0)
return -1;
+ git_fs_path_mkposix(repo_path->ptr);
+
has_dotgit = (git__suffixcmp(repo_path->ptr, "/" GIT_DIR) == 0);
if (has_dotgit)
opts->flags |= GIT_REPOSITORY_INIT__HAS_DOTGIT;
@@ -2606,7 +2882,7 @@ int git_repository_init_ext(
wd = (opts->flags & GIT_REPOSITORY_INIT_BARE) ? NULL : git_str_cstr(&wd_path);
- if ((error = is_valid_repository_path(&is_valid, &repo_path, &common_path)) < 0)
+ if ((error = is_valid_repository_path(&is_valid, &repo_path, &common_path, opts->flags)) < 0)
goto out;
if (is_valid) {
@@ -2994,14 +3270,18 @@ int git_repository_set_workdir(
if (git_fs_path_prettify_dir(&path, workdir, NULL) < 0)
return -1;
- if (repo->workdir && strcmp(repo->workdir, path.ptr) == 0)
+ if (repo->workdir && strcmp(repo->workdir, path.ptr) == 0) {
+ git_str_dispose(&path);
return 0;
+ }
if (update_gitlink) {
git_config *config;
- if (git_repository_config__weakptr(&config, repo) < 0)
+ if (git_repository_config__weakptr(&config, repo) < 0) {
+ git_str_dispose(&path);
return -1;
+ }
error = repo_write_gitlink(path.ptr, git_repository_path(repo), false);
@@ -3023,6 +3303,7 @@ int git_repository_set_workdir(
git__free(old_workdir);
}
+ git_str_dispose(&path);
return error;
}
@@ -3065,6 +3346,25 @@ int git_repository_set_bare(git_repository *repo)
return 0;
}
+int git_repository_head_commit(git_commit **commit, git_repository *repo)
+{
+ git_reference *head;
+ git_object *obj;
+ int error;
+
+ if ((error = git_repository_head(&head, repo)) < 0)
+ return error;
+
+ if ((error = git_reference_peel(&obj, head, GIT_OBJECT_COMMIT)) < 0)
+ goto cleanup;
+
+ *commit = (git_commit *)obj;
+
+cleanup:
+ git_reference_free(head);
+ return error;
+}
+
int git_repository_head_tree(git_tree **tree, git_repository *repo)
{
git_reference *head;
@@ -3221,12 +3521,18 @@ int git_repository_hashfile(
static int checkout_message(git_str *out, git_reference *old, const char *new)
{
+ const char *idstr;
+
git_str_puts(out, "checkout: moving from ");
- if (git_reference_type(old) == GIT_REFERENCE_SYMBOLIC)
+ if (git_reference_type(old) == GIT_REFERENCE_SYMBOLIC) {
git_str_puts(out, git_reference__shorthand(git_reference_symbolic_target(old)));
- else
- git_str_puts(out, git_oid_tostr_s(git_reference_target(old)));
+ } else {
+ if ((idstr = git_oid_tostr_s(git_reference_target(old))) == NULL)
+ return -1;
+
+ git_str_puts(out, idstr);
+ }
git_str_puts(out, " to ");
@@ -3262,8 +3568,11 @@ static int detach(git_repository *repo, const git_oid *id, const char *new)
if ((error = git_object_peel(&peeled, object, GIT_OBJECT_COMMIT)) < 0)
goto cleanup;
- if (new == NULL)
- new = git_oid_tostr_s(git_object_id(peeled));
+ if (new == NULL &&
+ (new = git_oid_tostr_s(git_object_id(peeled))) == NULL) {
+ error = -1;
+ goto cleanup;
+ }
if ((error = checkout_message(&log_message, current, new)) < 0)
goto cleanup;
@@ -3351,6 +3660,7 @@ int git_repository_detach_head(git_repository *repo)
git_reference *old_head = NULL, *new_head = NULL, *current = NULL;
git_object *object = NULL;
git_str log_message = GIT_STR_INIT;
+ const char *idstr;
int error;
GIT_ASSERT_ARG(repo);
@@ -3364,7 +3674,12 @@ int git_repository_detach_head(git_repository *repo)
if ((error = git_object_lookup(&object, repo, git_reference_target(old_head), GIT_OBJECT_COMMIT)) < 0)
goto cleanup;
- if ((error = checkout_message(&log_message, current, git_oid_tostr_s(git_object_id(object)))) < 0)
+ if ((idstr = git_oid_tostr_s(git_object_id(object))) == NULL) {
+ error = -1;
+ goto cleanup;
+ }
+
+ if ((error = checkout_message(&log_message, current, idstr)) < 0)
goto cleanup;
error = git_reference_create(&new_head, repo, GIT_HEAD_FILE, git_reference_target(old_head),
@@ -3470,6 +3785,66 @@ int git_repository_state_cleanup(git_repository *repo)
return git_repository__cleanup_files(repo, state_files, ARRAY_SIZE(state_files));
}
+int git_repository__shallow_roots(
+ git_oid **out,
+ size_t *out_len,
+ git_repository *repo)
+{
+ int error = 0;
+
+ if (!repo->shallow_grafts && (error = load_grafts(repo)) < 0)
+ return error;
+
+ if ((error = git_grafts_refresh(repo->shallow_grafts)) < 0)
+ return error;
+
+ if ((error = git_grafts_oids(out, out_len, repo->shallow_grafts)) < 0)
+ return error;
+
+ return 0;
+}
+
+int git_repository__shallow_roots_write(git_repository *repo, git_oidarray *roots)
+{
+ git_filebuf file = GIT_FILEBUF_INIT;
+ git_str path = GIT_STR_INIT;
+ char oid_str[GIT_OID_MAX_HEXSIZE + 1];
+ size_t i;
+ int filebuf_hash, error = 0;
+
+ GIT_ASSERT_ARG(repo);
+
+ filebuf_hash = git_filebuf_hash_flags(git_oid_algorithm(repo->oid_type));
+ GIT_ASSERT(filebuf_hash);
+
+ if ((error = git_str_joinpath(&path, repo->gitdir, "shallow")) < 0)
+ goto on_error;
+
+ if ((error = git_filebuf_open(&file, git_str_cstr(&path), filebuf_hash, 0666)) < 0)
+ goto on_error;
+
+ for (i = 0; i < roots->count; i++) {
+ git_oid_tostr(oid_str, sizeof(oid_str), &roots->ids[i]);
+ git_filebuf_write(&file, oid_str, git_oid_hexsize(repo->oid_type));
+ git_filebuf_write(&file, "\n", 1);
+ }
+
+ git_filebuf_commit(&file);
+
+ if ((error = load_grafts(repo)) < 0) {
+ error = -1;
+ goto on_error;
+ }
+
+ if (!roots->count)
+ remove(path.ptr);
+
+on_error:
+ git_str_dispose(&path);
+
+ return error;
+}
+
int git_repository_is_shallow(git_repository *repo)
{
git_str path = GIT_STR_INIT;
@@ -3489,6 +3864,7 @@ int git_repository_is_shallow(git_repository *repo)
if (error < 0)
return error;
+
return st.st_size == 0 ? 0 : 1;
}
@@ -3560,3 +3936,89 @@ git_oid_t git_repository_oid_type(git_repository *repo)
{
return repo ? repo->oid_type : 0;
}
+
+struct mergehead_data {
+ git_repository *repo;
+ git_vector *parents;
+};
+
+static int insert_mergehead(const git_oid *oid, void *payload)
+{
+ git_commit *commit;
+ struct mergehead_data *data = (struct mergehead_data *)payload;
+
+ if (git_commit_lookup(&commit, data->repo, oid) < 0)
+ return -1;
+
+ return git_vector_insert(data->parents, commit);
+}
+
+int git_repository_commit_parents(git_commitarray *out, git_repository *repo)
+{
+ git_commit *first_parent = NULL, *commit;
+ git_reference *head_ref = NULL;
+ git_vector parents = GIT_VECTOR_INIT;
+ struct mergehead_data data;
+ size_t i;
+ int error;
+
+ GIT_ASSERT_ARG(out && repo);
+
+ out->count = 0;
+ out->commits = NULL;
+
+ error = git_revparse_ext((git_object **)&first_parent, &head_ref, repo, "HEAD");
+
+ if (error != 0) {
+ if (error == GIT_ENOTFOUND)
+ error = 0;
+
+ goto done;
+ }
+
+ if ((error = git_vector_insert(&parents, first_parent)) < 0)
+ goto done;
+
+ data.repo = repo;
+ data.parents = &parents;
+
+ error = git_repository_mergehead_foreach(repo, insert_mergehead, &data);
+
+ if (error == GIT_ENOTFOUND)
+ error = 0;
+ else if (error != 0)
+ goto done;
+
+ out->commits = (git_commit **)git_vector_detach(&out->count, NULL, &parents);
+
+done:
+ git_vector_foreach(&parents, i, commit)
+ git__free(commit);
+
+ git_reference_free(head_ref);
+ return error;
+}
+
+int git_repository__abbrev_length(int *out, git_repository *repo)
+{
+ size_t oid_hexsize;
+ int len;
+ int error;
+
+ oid_hexsize = git_oid_hexsize(repo->oid_type);
+
+ if ((error = git_repository__configmap_lookup(&len, repo, GIT_CONFIGMAP_ABBREV)) < 0)
+ return error;
+
+ if (len < GIT_ABBREV_MINIMUM) {
+ git_error_set(GIT_ERROR_CONFIG, "invalid oid abbreviation setting: '%d'", len);
+ return -1;
+ }
+
+ if (len == GIT_ABBREV_FALSE || (size_t)len > oid_hexsize)
+ len = (int)oid_hexsize;
+
+ *out = len;
+
+ return error;
+}
diff --git a/src/libgit2/repository.h b/src/libgit2/repository.h
index 75380ae5347..7da2d165577 100644
--- a/src/libgit2/repository.h
+++ b/src/libgit2/repository.h
@@ -15,6 +15,7 @@
#include "git2/repository.h"
#include "git2/object.h"
#include "git2/config.h"
+#include "git2/sys/repository.h"
#include "array.h"
#include "cache.h"
@@ -24,6 +25,7 @@
#include "attrcache.h"
#include "submodule.h"
#include "diff_driver.h"
+#include "grafts.h"
#define DOT_GIT ".git"
#define GIT_DIR DOT_GIT "/"
@@ -101,6 +103,8 @@ typedef enum {
/* core.trustctime */
GIT_TRUSTCTIME_DEFAULT = GIT_CONFIGMAP_TRUE,
/* core.abbrev */
+ GIT_ABBREV_FALSE = GIT_OID_MAX_HEXSIZE,
+ GIT_ABBREV_MINIMUM = 4,
GIT_ABBREV_DEFAULT = 7,
/* core.precomposeunicode */
GIT_PRECOMPOSE_DEFAULT = GIT_CONFIGMAP_FALSE,
@@ -151,16 +155,20 @@ struct git_repository {
git_array_t(git_str) reserved_names;
- unsigned is_bare:1;
- unsigned is_worktree:1;
+ unsigned use_env:1,
+ is_bare:1,
+ is_worktree:1;
git_oid_t oid_type;
unsigned int lru_counter;
+ git_grafts *grafts;
+ git_grafts *shallow_grafts;
+
git_atomic32 attr_session_key;
intptr_t configmap_cache[GIT_CONFIGMAP_CACHE_MAX];
- git_strmap *submodule_cache;
+ git_submodule_cache *submodule_cache;
};
GIT_INLINE(git_attr_cache *) git_repository_attr_cache(git_repository *repo)
@@ -168,6 +176,7 @@ GIT_INLINE(git_attr_cache *) git_repository_attr_cache(git_repository *repo)
return repo->attrcache;
}
+int git_repository_head_commit(git_commit **commit, git_repository *repo);
int git_repository_head_tree(git_tree **tree, git_repository *repo);
int git_repository_create_head(const char *git_dir, const char *ref_name);
@@ -188,6 +197,8 @@ int git_repository_config__weakptr(git_config **out, git_repository *repo);
int git_repository_odb__weakptr(git_odb **out, git_repository *repo);
int git_repository_refdb__weakptr(git_refdb **out, git_repository *repo);
int git_repository_index__weakptr(git_index **out, git_repository *repo);
+int git_repository_grafts__weakptr(git_grafts **out, git_repository *repo);
+int git_repository_shallow_grafts__weakptr(git_grafts **out, git_repository *repo);
/*
* Configuration map cache
@@ -198,6 +209,9 @@ int git_repository_index__weakptr(git_index **out, git_repository *repo);
int git_repository__configmap_lookup(int *out, git_repository *repo, git_configmap_item item);
void git_repository__configmap_lookup_cache_clear(git_repository *repo);
+/** Return the length that object names will be abbreviated to. */
+int git_repository__abbrev_length(int *out, git_repository *repo);
+
int git_repository__item_path(git_str *out, const git_repository *repo, git_repository_item_t item);
GIT_INLINE(int) git_repository__ensure_not_bare(
@@ -239,6 +253,9 @@ extern size_t git_repository__reserved_names_posix_len;
bool git_repository__reserved_names(
git_str **out, size_t *outlen, git_repository *repo, bool include_ntfs);
+int git_repository__shallow_roots(git_oid **out, size_t *out_len, git_repository *repo);
+int git_repository__shallow_roots_write(git_repository *repo, git_oidarray *roots);
+
/*
* The default branch for the repository; the `init.defaultBranch`
* configuration option, if set, or `master` if it is not.
@@ -265,4 +282,14 @@ int git_repository__set_objectformat(
git_repository *repo,
git_oid_t oid_type);
+/* SHA256 support */
+
+#ifndef GIT_EXPERIMENTAL_SHA256
+
+GIT_EXTERN(int) git_repository_new_ext(
+ git_repository **out,
+ git_repository_new_options *opts);
+
+#endif
+
#endif
diff --git a/src/libgit2/reset.c b/src/libgit2/reset.c
index 9574819cb16..605c4afd5e2 100644
--- a/src/libgit2/reset.c
+++ b/src/libgit2/reset.c
@@ -188,9 +188,9 @@ int git_reset(
git_reset_t reset_type,
const git_checkout_options *checkout_opts)
{
- char to[GIT_OID_SHA1_HEXSIZE + 1];
+ char to[GIT_OID_MAX_HEXSIZE + 1];
- git_oid_tostr(to, GIT_OID_SHA1_HEXSIZE + 1, git_object_id(target));
+ git_oid_tostr(to, GIT_OID_MAX_HEXSIZE + 1, git_object_id(target));
return reset(repo, target, to, reset_type, checkout_opts);
}
diff --git a/src/libgit2/revert.c b/src/libgit2/revert.c
index 1106dfe2f2c..2fb53f8f541 100644
--- a/src/libgit2/revert.c
+++ b/src/libgit2/revert.c
@@ -74,8 +74,7 @@ static int revert_normalize_opts(
const char *their_label)
{
int error = 0;
- unsigned int default_checkout_strategy = GIT_CHECKOUT_SAFE |
- GIT_CHECKOUT_ALLOW_CONFLICTS;
+ unsigned int default_checkout_strategy = GIT_CHECKOUT_ALLOW_CONFLICTS;
GIT_UNUSED(repo);
@@ -107,12 +106,10 @@ static int revert_state_cleanup(git_repository *repo)
static int revert_seterr(git_commit *commit, const char *fmt)
{
- char commit_oidstr[GIT_OID_SHA1_HEXSIZE + 1];
+ char commit_id[GIT_OID_MAX_HEXSIZE + 1];
- git_oid_fmt(commit_oidstr, git_commit_id(commit));
- commit_oidstr[GIT_OID_SHA1_HEXSIZE] = '\0';
-
- git_error_set(GIT_ERROR_REVERT, fmt, commit_oidstr);
+ git_oid_tostr(commit_id, GIT_OID_MAX_HEXSIZE + 1, git_commit_id(commit));
+ git_error_set(GIT_ERROR_REVERT, fmt, commit_id);
return -1;
}
@@ -176,7 +173,7 @@ int git_revert(
git_revert_options opts;
git_reference *our_ref = NULL;
git_commit *our_commit = NULL;
- char commit_oidstr[GIT_OID_SHA1_HEXSIZE + 1];
+ char commit_id[GIT_OID_MAX_HEXSIZE + 1];
const char *commit_msg;
git_str their_label = GIT_STR_INIT;
git_index *index = NULL;
@@ -191,19 +188,18 @@ int git_revert(
if ((error = git_repository__ensure_not_bare(repo, "revert")) < 0)
return error;
- git_oid_fmt(commit_oidstr, git_commit_id(commit));
- commit_oidstr[GIT_OID_SHA1_HEXSIZE] = '\0';
+ git_oid_tostr(commit_id, GIT_OID_MAX_HEXSIZE + 1, git_commit_id(commit));
if ((commit_msg = git_commit_summary(commit)) == NULL) {
error = -1;
goto on_error;
}
- if ((error = git_str_printf(&their_label, "parent of %.7s... %s", commit_oidstr, commit_msg)) < 0 ||
+ if ((error = git_str_printf(&their_label, "parent of %.7s... %s", commit_id, commit_msg)) < 0 ||
(error = revert_normalize_opts(repo, &opts, given_opts, git_str_cstr(&their_label))) < 0 ||
(error = git_indexwriter_init_for_operation(&indexwriter, repo, &opts.checkout_opts.checkout_strategy)) < 0 ||
- (error = write_revert_head(repo, commit_oidstr)) < 0 ||
- (error = write_merge_msg(repo, commit_oidstr, commit_msg)) < 0 ||
+ (error = write_revert_head(repo, commit_id)) < 0 ||
+ (error = write_merge_msg(repo, commit_id, commit_msg)) < 0 ||
(error = git_repository_head(&our_ref, repo)) < 0 ||
(error = git_reference_peel((git_object **)&our_commit, our_ref, GIT_OBJECT_COMMIT)) < 0 ||
(error = git_revert_commit(&index, repo, commit, our_commit, opts.mainline, &opts.merge_opts)) < 0 ||
diff --git a/src/libgit2/revparse.c b/src/libgit2/revparse.c
index 964afe378da..2238ba5269c 100644
--- a/src/libgit2/revparse.c
+++ b/src/libgit2/revparse.c
@@ -23,7 +23,7 @@ static int maybe_sha_or_abbrev(
{
git_oid oid;
- if (git_oid__fromstrn(&oid, spec, speclen, repo->oid_type) < 0)
+ if (git_oid_from_prefix(&oid, spec, speclen, repo->oid_type) < 0)
return GIT_ENOTFOUND;
return git_object_lookup_prefix(out, repo, &oid, speclen, GIT_OBJECT_ANY);
@@ -701,6 +701,7 @@ static int revparse(
git_object *base_rev = NULL;
bool should_return_reference = true;
+ bool parsed = false;
GIT_ASSERT_ARG(object_out);
GIT_ASSERT_ARG(reference_out);
@@ -710,7 +711,7 @@ static int revparse(
*object_out = NULL;
*reference_out = NULL;
- while (spec[pos]) {
+ while (!parsed && spec[pos]) {
switch (spec[pos]) {
case '^':
should_return_reference = false;
@@ -815,8 +816,10 @@ static int revparse(
if (temp_object != NULL)
base_rev = temp_object;
break;
- } else if (spec[pos+1] == '\0') {
+ } else if (spec[pos + 1] == '\0' && !pos) {
spec = "HEAD";
+ identifier_len = 4;
+ parsed = true;
break;
}
/* fall through */
@@ -932,7 +935,7 @@ int git_revparse(
* allowed.
*/
if (!git__strcmp(spec, "..")) {
- git_error_set(GIT_ERROR_INVALID, "Invalid pattern '..'");
+ git_error_set(GIT_ERROR_INVALID, "invalid pattern '..'");
return GIT_EINVALIDSPEC;
}
diff --git a/src/libgit2/revwalk.c b/src/libgit2/revwalk.c
index 3269d9279b6..a793a8e179c 100644
--- a/src/libgit2/revwalk.c
+++ b/src/libgit2/revwalk.c
@@ -14,6 +14,9 @@
#include "git2/revparse.h"
#include "merge.h"
#include "vector.h"
+#include "hashmap_oid.h"
+
+GIT_HASHMAP_OID_FUNCTIONS(git_revwalk_oidmap, GIT_HASHMAP_INLINE, git_commit_list_node *);
static int get_revision(git_commit_list_node **out, git_revwalk *walk, git_commit_list **list);
@@ -23,7 +26,7 @@ git_commit_list_node *git_revwalk__commit_lookup(
git_commit_list_node *commit;
/* lookup and reserve space if not already present */
- if ((commit = git_oidmap_get(walk->commits, oid)) != NULL)
+ if (git_revwalk_oidmap_get(&commit, &walk->commits, oid) == 0)
return commit;
commit = git_commit_list_alloc_node(walk);
@@ -32,7 +35,7 @@ git_commit_list_node *git_revwalk__commit_lookup(
git_oid_cpy(&commit->oid, oid);
- if ((git_oidmap_set(walk->commits, &commit->oid, commit)) < 0)
+ if (git_revwalk_oidmap_put(&walk->commits, &commit->oid, commit) < 0)
return NULL;
return commit;
@@ -83,8 +86,13 @@ int git_revwalk__push_commit(git_revwalk *walk, const git_oid *oid, const git_re
commit->uninteresting = opts->uninteresting;
list = walk->user_input;
- if ((opts->insert_by_date &&
- git_commit_list_insert_by_date(commit, &list) == NULL) ||
+
+ /* To insert by date, we need to parse so we know the date. */
+ if (opts->insert_by_date && ((error = git_commit_list_parse(walk, commit)) < 0))
+ return error;
+
+ if ((opts->insert_by_date == 0 ||
+ git_commit_list_insert_by_date(commit, &list) == NULL) &&
git_commit_list_insert(commit, &list) == NULL) {
git_error_set_oom();
return -1;
@@ -609,7 +617,7 @@ static int sort_in_topological_order(git_commit_list **out, git_revwalk *walk, g
static int prepare_walk(git_revwalk *walk)
{
int error = 0;
- git_commit_list *list, *commits = NULL;
+ git_commit_list *list, *commits = NULL, *commits_last = NULL;
git_commit_list_node *next;
/* If there were no pushes, we know that the walk is already over */
@@ -618,6 +626,12 @@ static int prepare_walk(git_revwalk *walk)
return GIT_ITEROVER;
}
+ /*
+ * This is a bit convoluted, but necessary to maintain the order of
+ * the commits. This is especially important in situations where
+ * git_revwalk__push_glob is called with a git_revwalk__push_options
+ * setting insert_by_date = 1, which is critical for fetch negotiation.
+ */
for (list = walk->user_input; list; list = list->next) {
git_commit_list_node *commit = list->item;
if ((error = git_commit_list_parse(walk, commit)) < 0)
@@ -627,8 +641,19 @@ static int prepare_walk(git_revwalk *walk)
mark_parents_uninteresting(commit);
if (!commit->seen) {
+ git_commit_list *new_list = NULL;
+ if ((new_list = git_commit_list_create(commit, NULL)) == NULL) {
+ git_error_set_oom();
+ return -1;
+ }
+
commit->seen = 1;
- git_commit_list_insert(commit, &commits);
+ if (commits_last == NULL)
+ commits = new_list;
+ else
+ commits_last->next = new_list;
+
+ commits_last = new_list;
}
}
@@ -678,8 +703,7 @@ int git_revwalk_new(git_revwalk **revwalk_out, git_repository *repo)
git_revwalk *walk = git__calloc(1, sizeof(git_revwalk));
GIT_ERROR_CHECK_ALLOC(walk);
- if (git_oidmap_new(&walk->commits) < 0 ||
- git_pqueue_init(&walk->iterator_time, 0, 8, git_commit_list_time_cmp) < 0 ||
+ if (git_pqueue_init(&walk->iterator_time, 0, 8, git_commit_list_time_cmp) < 0 ||
git_pool_init(&walk->commit_pool, COMMIT_ALLOC) < 0)
return -1;
@@ -705,7 +729,7 @@ void git_revwalk_free(git_revwalk *walk)
git_revwalk_reset(walk);
git_odb_free(walk->odb);
- git_oidmap_free(walk->commits);
+ git_revwalk_oidmap_dispose(&walk->commits);
git_pool_clear(&walk->commit_pool);
git_pqueue_free(&walk->iterator_time);
git__free(walk);
@@ -777,17 +801,18 @@ int git_revwalk_next(git_oid *oid, git_revwalk *walk)
int git_revwalk_reset(git_revwalk *walk)
{
git_commit_list_node *commit;
+ git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
GIT_ASSERT_ARG(walk);
- git_oidmap_foreach_value(walk->commits, commit, {
+ while (git_revwalk_oidmap_iterate(&iter, NULL, &commit, &walk->commits) == 0) {
commit->seen = 0;
commit->in_degree = 0;
commit->topo_delay = 0;
commit->uninteresting = 0;
commit->added = 0;
commit->flags = 0;
- });
+ }
git_pqueue_clear(&walk->iterator_time);
git_commit_list_free(&walk->iterator_topo);
diff --git a/src/libgit2/revwalk.h b/src/libgit2/revwalk.h
index 94b8a6fb1fd..632b2807cd8 100644
--- a/src/libgit2/revwalk.h
+++ b/src/libgit2/revwalk.h
@@ -10,19 +10,19 @@
#include "common.h"
#include "git2/revwalk.h"
-#include "oidmap.h"
#include "commit_list.h"
#include "pqueue.h"
#include "pool.h"
#include "vector.h"
+#include "hashmap_oid.h"
-#include "oidmap.h"
+GIT_HASHMAP_OID_STRUCT(git_revwalk_oidmap, git_commit_list_node *);
struct git_revwalk {
git_repository *repo;
git_odb *odb;
- git_oidmap *commits;
+ git_revwalk_oidmap commits;
git_pool commit_pool;
git_commit_list *iterator_topo;
diff --git a/src/libgit2/settings.c b/src/libgit2/settings.c
new file mode 100644
index 00000000000..2e000f3c69f
--- /dev/null
+++ b/src/libgit2/settings.c
@@ -0,0 +1,493 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include "settings.h"
+
+#include
+#include "alloc.h"
+#include "buf.h"
+#include "cache.h"
+#include "common.h"
+#include "filter.h"
+#include "grafts.h"
+#include "hash.h"
+#include "index.h"
+#include "merge_driver.h"
+#include "pool.h"
+#include "mwindow.h"
+#include "object.h"
+#include "odb.h"
+#include "rand.h"
+#include "refs.h"
+#include "runtime.h"
+#include "sysdir.h"
+#include "thread.h"
+#include "git2/global.h"
+#include "streams/registry.h"
+#include "streams/mbedtls.h"
+#include "streams/openssl.h"
+#include "streams/socket.h"
+#include "transports/smart.h"
+#include "transports/http.h"
+#include "transports/ssh_libssh2.h"
+
+#ifdef GIT_WIN32
+# include "win32/w32_leakcheck.h"
+#endif
+
+/* Declarations for tuneable settings */
+extern size_t git_mwindow__window_size;
+extern size_t git_mwindow__mapped_limit;
+extern size_t git_mwindow__file_limit;
+extern size_t git_indexer__max_objects;
+extern bool git_disable_pack_keep_file_checks;
+extern int git_odb__packed_priority;
+extern int git_odb__loose_priority;
+extern int git_socket_stream__connect_timeout;
+extern int git_socket_stream__timeout;
+
+char *git__user_agent;
+char *git__user_agent_product;
+char *git__ssl_ciphers;
+
+static void settings_global_shutdown(void)
+{
+ git__free(git__user_agent);
+ git__free(git__user_agent_product);
+
+ git__free(git__ssl_ciphers);
+ git_repository__free_extensions();
+}
+
+int git_settings_global_init(void)
+{
+ return git_runtime_shutdown_register(settings_global_shutdown);
+}
+
+static int config_level_to_sysdir(int *out, int config_level)
+{
+ switch (config_level) {
+ case GIT_CONFIG_LEVEL_SYSTEM:
+ *out = GIT_SYSDIR_SYSTEM;
+ return 0;
+ case GIT_CONFIG_LEVEL_XDG:
+ *out = GIT_SYSDIR_XDG;
+ return 0;
+ case GIT_CONFIG_LEVEL_GLOBAL:
+ *out = GIT_SYSDIR_GLOBAL;
+ return 0;
+ case GIT_CONFIG_LEVEL_PROGRAMDATA:
+ *out = GIT_SYSDIR_PROGRAMDATA;
+ return 0;
+ default:
+ break;
+ }
+
+ git_error_set(
+ GIT_ERROR_INVALID, "invalid config path selector %d", config_level);
+ return -1;
+}
+
+const char *git_settings__user_agent_product(void)
+{
+ return git__user_agent_product ? git__user_agent_product :
+ "git/2.0";
+}
+
+const char *git_settings__user_agent(void)
+{
+ return git__user_agent ? git__user_agent :
+ "libgit2 " LIBGIT2_VERSION;
+}
+
+int git_libgit2_opts(int key, ...)
+{
+ int error = 0;
+ va_list ap;
+
+ va_start(ap, key);
+
+ switch (key) {
+ case GIT_OPT_SET_MWINDOW_SIZE:
+ git_mwindow__window_size = va_arg(ap, size_t);
+ break;
+
+ case GIT_OPT_GET_MWINDOW_SIZE:
+ *(va_arg(ap, size_t *)) = git_mwindow__window_size;
+ break;
+
+ case GIT_OPT_SET_MWINDOW_MAPPED_LIMIT:
+ git_mwindow__mapped_limit = va_arg(ap, size_t);
+ break;
+
+ case GIT_OPT_GET_MWINDOW_MAPPED_LIMIT:
+ *(va_arg(ap, size_t *)) = git_mwindow__mapped_limit;
+ break;
+
+ case GIT_OPT_SET_MWINDOW_FILE_LIMIT:
+ git_mwindow__file_limit = va_arg(ap, size_t);
+ break;
+
+ case GIT_OPT_GET_MWINDOW_FILE_LIMIT:
+ *(va_arg(ap, size_t *)) = git_mwindow__file_limit;
+ break;
+
+ case GIT_OPT_GET_SEARCH_PATH:
+ {
+ int sysdir = va_arg(ap, int);
+ git_buf *out = va_arg(ap, git_buf *);
+ git_str str = GIT_STR_INIT;
+ const git_str *tmp;
+ int level;
+
+ if ((error = git_buf_tostr(&str, out)) < 0 ||
+ (error = config_level_to_sysdir(&level, sysdir)) < 0 ||
+ (error = git_sysdir_get(&tmp, level)) < 0 ||
+ (error = git_str_put(&str, tmp->ptr, tmp->size)) < 0)
+ break;
+
+ error = git_buf_fromstr(out, &str);
+ }
+ break;
+
+ case GIT_OPT_SET_SEARCH_PATH:
+ {
+ int level;
+
+ if ((error = config_level_to_sysdir(&level, va_arg(ap, int))) >= 0)
+ error = git_sysdir_set(level, va_arg(ap, const char *));
+ }
+ break;
+
+ case GIT_OPT_SET_CACHE_OBJECT_LIMIT:
+ {
+ git_object_t type = (git_object_t)va_arg(ap, int);
+ size_t size = va_arg(ap, size_t);
+ error = git_cache_set_max_object_size(type, size);
+ break;
+ }
+
+ case GIT_OPT_SET_CACHE_MAX_SIZE:
+ git_cache__max_storage = va_arg(ap, ssize_t);
+ break;
+
+ case GIT_OPT_ENABLE_CACHING:
+ git_cache__enabled = (va_arg(ap, int) != 0);
+ break;
+
+ case GIT_OPT_GET_CACHED_MEMORY:
+ *(va_arg(ap, ssize_t *)) = git_cache__current_storage.val;
+ *(va_arg(ap, ssize_t *)) = git_cache__max_storage;
+ break;
+
+ case GIT_OPT_GET_TEMPLATE_PATH:
+ {
+ git_buf *out = va_arg(ap, git_buf *);
+ git_str str = GIT_STR_INIT;
+ const git_str *tmp;
+
+ if ((error = git_buf_tostr(&str, out)) < 0 ||
+ (error = git_sysdir_get(&tmp, GIT_SYSDIR_TEMPLATE)) < 0 ||
+ (error = git_str_put(&str, tmp->ptr, tmp->size)) < 0)
+ break;
+
+ error = git_buf_fromstr(out, &str);
+ }
+ break;
+
+ case GIT_OPT_SET_TEMPLATE_PATH:
+ error = git_sysdir_set(GIT_SYSDIR_TEMPLATE, va_arg(ap, const char *));
+ break;
+
+ case GIT_OPT_SET_SSL_CERT_LOCATIONS:
+#if defined(GIT_HTTPS_OPENSSL) || defined(GIT_HTTPS_OPENSSL_DYNAMIC)
+ {
+ const char *file = va_arg(ap, const char *);
+ const char *path = va_arg(ap, const char *);
+ error = git_openssl__set_cert_location(file, path);
+ }
+#elif defined(GIT_HTTPS_MBEDTLS)
+ {
+ const char *file = va_arg(ap, const char *);
+ const char *path = va_arg(ap, const char *);
+ error = git_mbedtls__set_cert_location(file, path);
+ }
+#else
+ git_error_set(GIT_ERROR_SSL, "TLS backend doesn't support certificate locations");
+ error = -1;
+#endif
+ break;
+
+ case GIT_OPT_ADD_SSL_X509_CERT:
+#if defined(GIT_HTTPS_OPENSSL) || defined(GIT_HTTPS_OPENSSL_DYNAMIC)
+ {
+ X509 *cert = va_arg(ap, X509 *);
+ error = git_openssl__add_x509_cert(cert);
+ }
+#else
+ git_error_set(GIT_ERROR_SSL, "TLS backend doesn't support adding of the raw certs");
+ error = -1;
+#endif
+ break;
+
+ case GIT_OPT_SET_USER_AGENT:
+ {
+ const char *new_agent = va_arg(ap, const char *);
+
+ git__free(git__user_agent);
+
+ if (new_agent) {
+ git__user_agent= git__strdup(new_agent);
+
+ if (!git__user_agent)
+ error = -1;
+ } else {
+ git__user_agent = NULL;
+ }
+ }
+ break;
+
+ case GIT_OPT_GET_USER_AGENT:
+ {
+ git_buf *out = va_arg(ap, git_buf *);
+ git_str str = GIT_STR_INIT;
+
+ if ((error = git_buf_tostr(&str, out)) < 0 ||
+ (error = git_str_puts(&str, git_settings__user_agent())) < 0)
+ break;
+
+ error = git_buf_fromstr(out, &str);
+ }
+ break;
+
+ case GIT_OPT_SET_USER_AGENT_PRODUCT:
+ {
+ const char *new_agent = va_arg(ap, const char *);
+
+ git__free(git__user_agent_product);
+
+ if (new_agent) {
+ git__user_agent_product = git__strdup(new_agent);
+
+ if (!git__user_agent_product)
+ error = -1;
+ } else {
+ git__user_agent_product = NULL;
+ }
+ }
+ break;
+
+ case GIT_OPT_GET_USER_AGENT_PRODUCT:
+ {
+ git_buf *out = va_arg(ap, git_buf *);
+ git_str str = GIT_STR_INIT;
+
+ if ((error = git_buf_tostr(&str, out)) < 0 ||
+ (error = git_str_puts(&str, git_settings__user_agent_product())) < 0)
+ break;
+
+ error = git_buf_fromstr(out, &str);
+ }
+ break;
+
+ case GIT_OPT_ENABLE_STRICT_OBJECT_CREATION:
+ git_object__strict_input_validation = (va_arg(ap, int) != 0);
+ break;
+
+ case GIT_OPT_ENABLE_STRICT_SYMBOLIC_REF_CREATION:
+ git_reference__enable_symbolic_ref_target_validation = (va_arg(ap, int) != 0);
+ break;
+
+ case GIT_OPT_SET_SSL_CIPHERS:
+#if defined(GIT_HTTPS_OPENSSL) || \
+ defined(GIT_HTTPS_OPENSSL_DYNAMIC) || \
+ defined(GIT_HTTPS_MBEDTLS)
+ {
+ git__free(git__ssl_ciphers);
+ git__ssl_ciphers = git__strdup(va_arg(ap, const char *));
+ if (!git__ssl_ciphers) {
+ git_error_set_oom();
+ error = -1;
+ }
+ }
+#else
+ git_error_set(GIT_ERROR_SSL, "TLS backend doesn't support custom ciphers");
+ error = -1;
+#endif
+ break;
+
+ case GIT_OPT_ENABLE_OFS_DELTA:
+ git_smart__ofs_delta_enabled = (va_arg(ap, int) != 0);
+ break;
+
+ case GIT_OPT_ENABLE_FSYNC_GITDIR:
+ git_repository__fsync_gitdir = (va_arg(ap, int) != 0);
+ break;
+
+ case GIT_OPT_GET_WINDOWS_SHAREMODE:
+#ifdef GIT_WIN32
+ *(va_arg(ap, unsigned long *)) = git_win32__createfile_sharemode;
+#endif
+ break;
+
+ case GIT_OPT_SET_WINDOWS_SHAREMODE:
+#ifdef GIT_WIN32
+ git_win32__createfile_sharemode = va_arg(ap, unsigned long);
+#endif
+ break;
+
+ case GIT_OPT_ENABLE_STRICT_HASH_VERIFICATION:
+ git_odb__strict_hash_verification = (va_arg(ap, int) != 0);
+ break;
+
+ case GIT_OPT_SET_ALLOCATOR:
+ error = git_allocator_setup(va_arg(ap, git_allocator *));
+ break;
+
+ case GIT_OPT_ENABLE_UNSAVED_INDEX_SAFETY:
+ git_index__enforce_unsaved_safety = (va_arg(ap, int) != 0);
+ break;
+
+ case GIT_OPT_SET_PACK_MAX_OBJECTS:
+ git_indexer__max_objects = va_arg(ap, size_t);
+ break;
+
+ case GIT_OPT_GET_PACK_MAX_OBJECTS:
+ *(va_arg(ap, size_t *)) = git_indexer__max_objects;
+ break;
+
+ case GIT_OPT_DISABLE_PACK_KEEP_FILE_CHECKS:
+ git_disable_pack_keep_file_checks = (va_arg(ap, int) != 0);
+ break;
+
+ case GIT_OPT_ENABLE_HTTP_EXPECT_CONTINUE:
+ git_http__expect_continue = (va_arg(ap, int) != 0);
+ break;
+
+ case GIT_OPT_SET_ODB_PACKED_PRIORITY:
+ git_odb__packed_priority = va_arg(ap, int);
+ break;
+
+ case GIT_OPT_SET_ODB_LOOSE_PRIORITY:
+ git_odb__loose_priority = va_arg(ap, int);
+ break;
+
+ case GIT_OPT_SET_EXTENSIONS:
+ {
+ const char **extensions = va_arg(ap, const char **);
+ size_t len = va_arg(ap, size_t);
+ error = git_repository__set_extensions(extensions, len);
+ }
+ break;
+
+ case GIT_OPT_GET_EXTENSIONS:
+ {
+ git_strarray *out = va_arg(ap, git_strarray *);
+ char **extensions;
+ size_t len;
+
+ if ((error = git_repository__extensions(&extensions, &len)) < 0)
+ break;
+
+ out->strings = extensions;
+ out->count = len;
+ }
+ break;
+
+ case GIT_OPT_GET_OWNER_VALIDATION:
+ *(va_arg(ap, int *)) = git_repository__validate_ownership;
+ break;
+
+ case GIT_OPT_SET_OWNER_VALIDATION:
+ git_repository__validate_ownership = (va_arg(ap, int) != 0);
+ break;
+
+ case GIT_OPT_GET_HOMEDIR:
+ {
+ git_buf *out = va_arg(ap, git_buf *);
+ git_str str = GIT_STR_INIT;
+ const git_str *tmp;
+
+ if ((error = git_buf_tostr(&str, out)) < 0 ||
+ (error = git_sysdir_get(&tmp, GIT_SYSDIR_HOME)) < 0 ||
+ (error = git_str_put(&str, tmp->ptr, tmp->size)) < 0)
+ break;
+
+ error = git_buf_fromstr(out, &str);
+ }
+ break;
+
+ case GIT_OPT_SET_HOMEDIR:
+ error = git_sysdir_set(GIT_SYSDIR_HOME, va_arg(ap, const char *));
+ break;
+
+ case GIT_OPT_GET_SERVER_CONNECT_TIMEOUT:
+ *(va_arg(ap, int *)) = git_socket_stream__connect_timeout;
+ break;
+
+ case GIT_OPT_SET_SERVER_CONNECT_TIMEOUT:
+ {
+ int timeout = va_arg(ap, int);
+
+ if (timeout < 0) {
+ git_error_set(GIT_ERROR_INVALID, "invalid connect timeout");
+ error = -1;
+ } else {
+ git_socket_stream__connect_timeout = timeout;
+ }
+ }
+ break;
+
+ case GIT_OPT_GET_SERVER_TIMEOUT:
+ *(va_arg(ap, int *)) = git_socket_stream__timeout;
+ break;
+
+ case GIT_OPT_SET_SERVER_TIMEOUT:
+ {
+ int timeout = va_arg(ap, int);
+
+ if (timeout < 0) {
+ git_error_set(GIT_ERROR_INVALID, "invalid timeout");
+ error = -1;
+ } else {
+ git_socket_stream__timeout = timeout;
+ }
+ }
+ break;
+
+ default:
+ git_error_set(GIT_ERROR_INVALID, "invalid option key");
+ error = -1;
+ }
+
+ va_end(ap);
+
+ return error;
+}
+
+const char *git_libgit2_buildinfo(git_buildinfo_t key)
+{
+ switch (key) {
+
+#ifdef GIT_BUILD_CPU
+ case GIT_BUILDINFO_CPU:
+ return GIT_BUILD_CPU;
+ break;
+#endif
+
+#ifdef GIT_BUILD_COMMIT
+ case GIT_BUILDINFO_COMMIT:
+ return GIT_BUILD_COMMIT;
+ break;
+#endif
+
+ default:
+ break;
+ }
+
+ return NULL;
+}
diff --git a/src/libgit2/settings.h b/src/libgit2/settings.h
index dc42ce93952..292936676aa 100644
--- a/src/libgit2/settings.h
+++ b/src/libgit2/settings.h
@@ -4,8 +4,12 @@
* This file is part of libgit2, distributed under the GNU GPL v2 with
* a Linking Exception. For full terms see the included COPYING file.
*/
+#ifndef INCLUDE_settings_h__
+#define INCLUDE_settings_h__
extern int git_settings_global_init(void);
-extern const char *git_libgit2__user_agent(void);
-extern const char *git_libgit2__ssl_ciphers(void);
+extern const char *git_settings__user_agent(void);
+extern const char *git_settings__user_agent_product(void);
+
+#endif
diff --git a/src/libgit2/signature.c b/src/libgit2/signature.c
index 5d6ab572cbf..71da4162371 100644
--- a/src/libgit2/signature.c
+++ b/src/libgit2/signature.c
@@ -10,6 +10,7 @@
#include "repository.h"
#include "git2/common.h"
#include "posix.h"
+#include "date.h"
void git_signature_free(git_signature *sig)
{
@@ -43,7 +44,6 @@ static bool contains_angle_brackets(const char *input)
static bool is_crud(unsigned char c)
{
return c <= 32 ||
- c == '.' ||
c == ',' ||
c == ':' ||
c == ';' ||
@@ -153,15 +153,10 @@ int git_signature__pdup(git_signature **dest, const git_signature *source, git_p
return 0;
}
-int git_signature_now(git_signature **sig_out, const char *name, const char *email)
+static void current_time(time_t *now_out, int *offset_out)
{
- time_t now;
time_t offset;
- struct tm *utc_tm;
- git_signature *sig;
- struct tm _utc;
-
- *sig_out = NULL;
+ struct tm _utc, *utc_tm;
/*
* Get the current time as seconds since the epoch and
@@ -171,18 +166,26 @@ int git_signature_now(git_signature **sig_out, const char *name, const char *ema
* us that time as seconds since the epoch. The difference
* between its return value and 'now' is our offset to UTC.
*/
- time(&now);
- utc_tm = p_gmtime_r(&now, &_utc);
+ time(now_out);
+ utc_tm = p_gmtime_r(now_out, &_utc);
utc_tm->tm_isdst = -1;
- offset = (time_t)difftime(now, mktime(utc_tm));
+ offset = (time_t)difftime(*now_out, mktime(utc_tm));
offset /= 60;
- if (git_signature_new(&sig, name, email, now, (int)offset) < 0)
- return -1;
+ *offset_out = (int)offset;
+}
+
+int git_signature_now(
+ git_signature **sig_out,
+ const char *name,
+ const char *email)
+{
+ time_t now;
+ int offset;
- *sig_out = sig;
+ current_time(&now, &offset);
- return 0;
+ return git_signature_new(sig_out, name, email, now, offset);
}
int git_signature_default(git_signature **out, git_repository *repo)
@@ -202,6 +205,120 @@ int git_signature_default(git_signature **out, git_repository *repo)
return error;
}
+static int user_from_env(
+ git_signature **out,
+ git_repository *repo,
+ const char *name_env_var,
+ const char *email_env_var,
+ const char *date_env_var,
+ time_t default_time,
+ int default_offset)
+{
+ int error;
+ git_config *cfg;
+ const char *name, *email, *date;
+ git_time_t timestamp;
+ int offset;
+ git_str name_env = GIT_STR_INIT;
+ git_str email_env = GIT_STR_INIT;
+ git_str date_env = GIT_STR_INIT;
+
+ if ((error = git_repository_config_snapshot(&cfg, repo)) < 0)
+ return error;
+
+ /* Check if the environment variable for the name is set */
+ if (!(git__getenv(&name_env, name_env_var))) {
+ name = git_str_cstr(&name_env);
+ } else {
+ /* or else read the configuration value. */
+ if ((error = git_config_get_string(&name, cfg, "user.name")) < 0)
+ goto done;
+ }
+
+ /* Check if the environment variable for the email is set. */
+ if (!(git__getenv(&email_env, email_env_var))) {
+ email = git_str_cstr(&email_env);
+ } else {
+ if ((error = git_config_get_string(&email, cfg, "user.email")) == GIT_ENOTFOUND) {
+ git_error *last_error;
+
+ git_error_save(&last_error);
+
+ if ((error = git__getenv(&email_env, "EMAIL")) < 0) {
+ git_error_restore(last_error);
+ error = GIT_ENOTFOUND;
+ goto done;
+ }
+
+ email = git_str_cstr(&email_env);
+ git_error_free(last_error);
+ } else if (error < 0) {
+ goto done;
+ }
+ }
+
+ /* Check if the environment variable for the timestamp is set */
+ if (!(git__getenv(&date_env, date_env_var))) {
+ date = git_str_cstr(&date_env);
+
+ if ((error = git_date_offset_parse(×tamp, &offset, date)) < 0)
+ goto done;
+ } else {
+ timestamp = default_time;
+ offset = default_offset;
+ }
+
+ error = git_signature_new(out, name, email, timestamp, offset);
+
+done:
+ git_config_free(cfg);
+ git_str_dispose(&name_env);
+ git_str_dispose(&email_env);
+ git_str_dispose(&date_env);
+ return error;
+}
+
+int git_signature_default_from_env(
+ git_signature **author_out,
+ git_signature **committer_out,
+ git_repository *repo)
+{
+ git_signature *author = NULL, *committer = NULL;
+ time_t now;
+ int offset;
+ int error;
+
+ GIT_ASSERT_ARG(author_out || committer_out);
+ GIT_ASSERT_ARG(repo);
+
+ current_time(&now, &offset);
+
+ if (author_out &&
+ (error = user_from_env(&author, repo, "GIT_AUTHOR_NAME",
+ "GIT_AUTHOR_EMAIL", "GIT_AUTHOR_DATE",
+ now, offset)) < 0)
+ goto on_error;
+
+ if (committer_out &&
+ (error = user_from_env(&committer, repo, "GIT_COMMITTER_NAME",
+ "GIT_COMMITTER_EMAIL", "GIT_COMMITTER_DATE",
+ now, offset)) < 0)
+ goto on_error;
+
+ if (author_out)
+ *author_out = author;
+
+ if (committer_out)
+ *committer_out = committer;
+
+ return 0;
+
+on_error:
+ git__free(author);
+ git__free(committer);
+ return error;
+}
+
int git_signature__parse(git_signature *sig, const char **buffer_out,
const char *buffer_end, const char *header, char ender)
{
diff --git a/src/libgit2/signature.h b/src/libgit2/signature.h
index 5c8270954e7..a5645e9bba5 100644
--- a/src/libgit2/signature.h
+++ b/src/libgit2/signature.h
@@ -17,7 +17,6 @@
int git_signature__parse(git_signature *sig, const char **buffer_out, const char *buffer_end, const char *header, char ender);
void git_signature__writebuf(git_str *buf, const char *header, const git_signature *sig);
bool git_signature__equal(const git_signature *one, const git_signature *two);
-
int git_signature__pdup(git_signature **dest, const git_signature *source, git_pool *pool);
#endif
diff --git a/src/libgit2/stash.c b/src/libgit2/stash.c
index 319ae3a3f0c..23c82b408fd 100644
--- a/src/libgit2/stash.c
+++ b/src/libgit2/stash.c
@@ -281,10 +281,11 @@ static int build_untracked_tree(
git_tree *i_tree = NULL;
git_diff *diff = NULL;
git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
+ git_index_options index_opts = GIT_INDEX_OPTIONS_FOR_REPO(repo);
struct stash_update_rules data = {0};
int error;
- if ((error = git_index_new(&i_index)) < 0)
+ if ((error = git_index_new_ext(&i_index, &index_opts)) < 0)
goto cleanup;
if (flags & GIT_STASH_INCLUDE_UNTRACKED) {
@@ -484,10 +485,11 @@ static int commit_worktree(
{
git_index *i_index = NULL, *r_index = NULL;
git_tree *w_tree = NULL;
+ git_index_options index_opts = GIT_INDEX_OPTIONS_FOR_REPO(repo);
int error = 0, ignorecase;
if ((error = git_repository_index(&r_index, repo) < 0) ||
- (error = git_index_new(&i_index)) < 0 ||
+ (error = git_index_new_ext(&i_index, &index_opts)) < 0 ||
(error = git_index__fill(i_index, &r_index->entries) < 0) ||
(error = git_repository__configmap_lookup(&ignorecase, repo, GIT_CONFIGMAP_IGNORECASE)) < 0)
goto cleanup;
@@ -688,6 +690,7 @@ int git_stash_save_with_opts(
git_str msg = GIT_STR_INIT;
git_tree *tree = NULL;
git_reference *head = NULL;
+ git_index_options index_opts = GIT_INDEX_OPTIONS_FOR_REPO(repo);
bool has_paths = false;
int error;
@@ -732,7 +735,7 @@ int git_stash_save_with_opts(
i_commit, b_commit, u_commit)) < 0)
goto cleanup;
} else {
- if ((error = git_index_new(&paths_index)) < 0 ||
+ if ((error = git_index_new_ext(&paths_index, &index_opts)) < 0 ||
(error = retrieve_head(&head, repo)) < 0 ||
(error = git_reference_peel((git_object**)&tree, head, GIT_OBJECT_TREE)) < 0 ||
(error = git_index_read_tree(paths_index, tree)) < 0 ||
@@ -1003,15 +1006,17 @@ static int stage_new_file(const git_index_entry **entries, void *data)
static int stage_new_files(
git_index **out,
+ git_repository *repo,
git_tree *parent_tree,
git_tree *tree)
{
git_iterator *iterators[2] = { NULL, NULL };
git_iterator_options iterator_options = GIT_ITERATOR_OPTIONS_INIT;
git_index *index = NULL;
+ git_index_options index_opts = GIT_INDEX_OPTIONS_FOR_REPO(repo);
int error;
- if ((error = git_index_new(&index)) < 0 ||
+ if ((error = git_index_new_ext(&index, &index_opts)) < 0 ||
(error = git_iterator_for_tree(
&iterators[0], parent_tree, &iterator_options)) < 0 ||
(error = git_iterator_for_tree(
@@ -1095,10 +1100,10 @@ int git_stash_apply(
* previously unstaged contents are staged, not the previously staged.)
*/
} else if ((opts.flags & GIT_STASH_APPLY_REINSTATE_INDEX) == 0) {
- if ((error = stage_new_files(
- &stash_adds, stash_parent_tree, stash_tree)) < 0 ||
- (error = merge_indexes(
- &unstashed_index, repo, stash_parent_tree, repo_index, stash_adds)) < 0)
+ if ((error = stage_new_files(&stash_adds, repo,
+ stash_parent_tree, stash_tree)) < 0 ||
+ (error = merge_indexes(&unstashed_index, repo,
+ stash_parent_tree, repo_index, stash_adds)) < 0)
goto cleanup;
}
diff --git a/src/libgit2/status.c b/src/libgit2/status.c
index df0f7450731..06356ad8b8b 100644
--- a/src/libgit2/status.c
+++ b/src/libgit2/status.c
@@ -414,7 +414,7 @@ void git_status_list_free(git_status_list *status)
git_diff_free(status->head2idx);
git_diff_free(status->idx2wd);
- git_vector_free_deep(&status->paired);
+ git_vector_dispose_deep(&status->paired);
git__memzero(status, sizeof(*status));
git__free(status);
diff --git a/src/libgit2/streams/mbedtls.c b/src/libgit2/streams/mbedtls.c
index 0cf5c8af1fb..ccf0f110303 100644
--- a/src/libgit2/streams/mbedtls.c
+++ b/src/libgit2/streams/mbedtls.c
@@ -7,14 +7,13 @@
#include "streams/mbedtls.h"
-#ifdef GIT_MBEDTLS
+#ifdef GIT_HTTPS_MBEDTLS
#include
#include "runtime.h"
#include "stream.h"
#include "streams/socket.h"
-#include "netops.h"
#include "git2/transport.h"
#include "util.h"
@@ -33,7 +32,6 @@
# endif
#endif
-#include
#include
#include
#include
@@ -41,12 +39,18 @@
#undef inline
-#define GIT_SSL_DEFAULT_CIPHERS "TLS-ECDHE-ECDSA-WITH-AES-128-GCM-SHA256:TLS-ECDHE-RSA-WITH-AES-128-GCM-SHA256:TLS-ECDHE-ECDSA-WITH-AES-256-GCM-SHA384:TLS-ECDHE-RSA-WITH-AES-256-GCM-SHA384:TLS-DHE-RSA-WITH-AES-128-GCM-SHA256:TLS-DHE-DSS-WITH-AES-128-GCM-SHA256:TLS-DHE-RSA-WITH-AES-256-GCM-SHA384:TLS-DHE-DSS-WITH-AES-256-GCM-SHA384:TLS-ECDHE-ECDSA-WITH-AES-128-CBC-SHA256:TLS-ECDHE-RSA-WITH-AES-128-CBC-SHA256:TLS-ECDHE-ECDSA-WITH-AES-128-CBC-SHA:TLS-ECDHE-RSA-WITH-AES-128-CBC-SHA:TLS-ECDHE-ECDSA-WITH-AES-256-CBC-SHA384:TLS-ECDHE-RSA-WITH-AES-256-CBC-SHA384:TLS-ECDHE-ECDSA-WITH-AES-256-CBC-SHA:TLS-ECDHE-RSA-WITH-AES-256-CBC-SHA:TLS-DHE-RSA-WITH-AES-128-CBC-SHA256:TLS-DHE-RSA-WITH-AES-256-CBC-SHA256:TLS-DHE-RSA-WITH-AES-128-CBC-SHA:TLS-DHE-RSA-WITH-AES-256-CBC-SHA:TLS-DHE-DSS-WITH-AES-128-CBC-SHA256:TLS-DHE-DSS-WITH-AES-256-CBC-SHA256:TLS-DHE-DSS-WITH-AES-128-CBC-SHA:TLS-DHE-DSS-WITH-AES-256-CBC-SHA:TLS-RSA-WITH-AES-128-GCM-SHA256:TLS-RSA-WITH-AES-256-GCM-SHA384:TLS-RSA-WITH-AES-128-CBC-SHA256:TLS-RSA-WITH-AES-256-CBC-SHA256:TLS-RSA-WITH-AES-128-CBC-SHA:TLS-RSA-WITH-AES-256-CBC-SHA"
-#define GIT_SSL_DEFAULT_CIPHERS_COUNT 30
+#define GIT_SSL_DEFAULT_CIPHERS "TLS1-3-AES-128-GCM-SHA256:TLS1-3-AES-256-GCM-SHA384:TLS1-3-CHACHA20-POLY1305-SHA256:TLS-ECDHE-ECDSA-WITH-AES-128-GCM-SHA256:TLS-ECDHE-RSA-WITH-AES-128-GCM-SHA256:TLS-ECDHE-ECDSA-WITH-AES-256-GCM-SHA384:TLS-ECDHE-RSA-WITH-AES-256-GCM-SHA384:TLS-ECDHE-ECDSA-WITH-CHACHA20-POLY1305-SHA256:TLS-ECDHE-RSA-WITH-CHACHA20-POLY1305-SHA256:TLS-DHE-RSA-WITH-AES-128-GCM-SHA256:TLS-DHE-RSA-WITH-AES-256-GCM-SHA384:TLS-DHE-RSA-WITH-CHACHA20-POLY1305-SHA256"
+#define GIT_SSL_DEFAULT_CIPHERS_COUNT 12
-static mbedtls_ssl_config *git__ssl_conf;
static int ciphers_list[GIT_SSL_DEFAULT_CIPHERS_COUNT];
-static mbedtls_entropy_context *mbedtls_entropy;
+
+static bool initialized = false;
+static mbedtls_ssl_config mbedtls_config;
+static mbedtls_ctr_drbg_context mbedtls_rng;
+static mbedtls_entropy_context mbedtls_entropy;
+
+static bool has_ca_chain = false;
+static mbedtls_x509_crt mbedtls_ca_chain;
/**
* This function aims to clean-up the SSL context which
@@ -54,19 +58,16 @@ static mbedtls_entropy_context *mbedtls_entropy;
*/
static void shutdown_ssl(void)
{
- if (git__ssl_conf) {
- mbedtls_x509_crt_free(git__ssl_conf->ca_chain);
- git__free(git__ssl_conf->ca_chain);
- mbedtls_ctr_drbg_free(git__ssl_conf->p_rng);
- git__free(git__ssl_conf->p_rng);
- mbedtls_ssl_config_free(git__ssl_conf);
- git__free(git__ssl_conf);
- git__ssl_conf = NULL;
+ if (has_ca_chain) {
+ mbedtls_x509_crt_free(&mbedtls_ca_chain);
+ has_ca_chain = false;
}
- if (mbedtls_entropy) {
- mbedtls_entropy_free(mbedtls_entropy);
- git__free(mbedtls_entropy);
- mbedtls_entropy = NULL;
+
+ if (initialized) {
+ mbedtls_ctr_drbg_free(&mbedtls_rng);
+ mbedtls_ssl_config_free(&mbedtls_config);
+ mbedtls_entropy_free(&mbedtls_entropy);
+ initialized = false;
}
}
@@ -75,32 +76,37 @@ int git_mbedtls_stream_global_init(void)
int loaded = 0;
char *crtpath = GIT_DEFAULT_CERT_LOCATION;
struct stat statbuf;
- mbedtls_ctr_drbg_context *ctr_drbg = NULL;
size_t ciphers_known = 0;
char *cipher_name = NULL;
char *cipher_string = NULL;
char *cipher_string_tmp = NULL;
- git__ssl_conf = git__malloc(sizeof(mbedtls_ssl_config));
- GIT_ERROR_CHECK_ALLOC(git__ssl_conf);
+ mbedtls_ssl_config_init(&mbedtls_config);
+ mbedtls_entropy_init(&mbedtls_entropy);
+ mbedtls_ctr_drbg_init(&mbedtls_rng);
- mbedtls_ssl_config_init(git__ssl_conf);
- if (mbedtls_ssl_config_defaults(git__ssl_conf,
- MBEDTLS_SSL_IS_CLIENT,
- MBEDTLS_SSL_TRANSPORT_STREAM,
- MBEDTLS_SSL_PRESET_DEFAULT) != 0) {
+ if (mbedtls_ssl_config_defaults(&mbedtls_config,
+ MBEDTLS_SSL_IS_CLIENT,
+ MBEDTLS_SSL_TRANSPORT_STREAM,
+ MBEDTLS_SSL_PRESET_DEFAULT) != 0) {
git_error_set(GIT_ERROR_SSL, "failed to initialize mbedTLS");
goto cleanup;
}
- /* configure TLSv1 */
- mbedtls_ssl_conf_min_version(git__ssl_conf, MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_0);
+ /*
+ * Configure TLSv1.2 or better; if the minor version constant isn't
+ * defined then this version of mbedTLS doesn't support such an old
+ * version, so we need not do anything.
+ */
+#ifdef MBEDTLS_SSL_MINOR_VERSION_3
+ mbedtls_ssl_conf_min_version(&mbedtls_config, MBEDTLS_SSL_MAJOR_VERSION_3, MBEDTLS_SSL_MINOR_VERSION_3);
+#endif
/* verify_server_cert is responsible for making the check.
* OPTIONAL because REQUIRED drops the certificate as soon as the check
* is made, so we can never see the certificate and override it. */
- mbedtls_ssl_conf_authmode(git__ssl_conf, MBEDTLS_SSL_VERIFY_OPTIONAL);
+ mbedtls_ssl_conf_authmode(&mbedtls_config, MBEDTLS_SSL_VERIFY_OPTIONAL);
/* set the list of allowed ciphersuites */
ciphers_known = 0;
@@ -124,42 +130,33 @@ int git_mbedtls_stream_global_init(void)
git_error_set(GIT_ERROR_SSL, "no cipher could be enabled");
goto cleanup;
}
- mbedtls_ssl_conf_ciphersuites(git__ssl_conf, ciphers_list);
+ mbedtls_ssl_conf_ciphersuites(&mbedtls_config, ciphers_list);
/* Seeding the random number generator */
- mbedtls_entropy = git__malloc(sizeof(mbedtls_entropy_context));
- GIT_ERROR_CHECK_ALLOC(mbedtls_entropy);
-
- mbedtls_entropy_init(mbedtls_entropy);
- ctr_drbg = git__malloc(sizeof(mbedtls_ctr_drbg_context));
- GIT_ERROR_CHECK_ALLOC(ctr_drbg);
-
- mbedtls_ctr_drbg_init(ctr_drbg);
-
- if (mbedtls_ctr_drbg_seed(ctr_drbg,
- mbedtls_entropy_func,
- mbedtls_entropy, NULL, 0) != 0) {
+ if (mbedtls_ctr_drbg_seed(&mbedtls_rng, mbedtls_entropy_func,
+ &mbedtls_entropy, NULL, 0) != 0) {
git_error_set(GIT_ERROR_SSL, "failed to initialize mbedTLS entropy pool");
goto cleanup;
}
- mbedtls_ssl_conf_rng(git__ssl_conf, mbedtls_ctr_drbg_random, ctr_drbg);
+ mbedtls_ssl_conf_rng(&mbedtls_config, mbedtls_ctr_drbg_random, &mbedtls_rng);
/* load default certificates */
if (crtpath != NULL && stat(crtpath, &statbuf) == 0 && S_ISREG(statbuf.st_mode))
loaded = (git_mbedtls__set_cert_location(crtpath, NULL) == 0);
+
if (!loaded && crtpath != NULL && stat(crtpath, &statbuf) == 0 && S_ISDIR(statbuf.st_mode))
loaded = (git_mbedtls__set_cert_location(NULL, crtpath) == 0);
+ initialized = true;
+
return git_runtime_shutdown_register(shutdown_ssl);
cleanup:
- mbedtls_ctr_drbg_free(ctr_drbg);
- git__free(ctr_drbg);
- mbedtls_ssl_config_free(git__ssl_conf);
- git__free(git__ssl_conf);
- git__ssl_conf = NULL;
+ mbedtls_ctr_drbg_free(&mbedtls_rng);
+ mbedtls_ssl_config_free(&mbedtls_config);
+ mbedtls_entropy_free(&mbedtls_entropy);
return -1;
}
@@ -193,7 +190,7 @@ static int ssl_set_error(mbedtls_ssl_context *ssl, int error)
break;
case MBEDTLS_ERR_X509_CERT_VERIFY_FAILED:
- git_error_set(GIT_ERROR_SSL, "SSL error: %#04x [%x] - %s", error, ssl->session_negotiate->verify_result, errbuf);
+ git_error_set(GIT_ERROR_SSL, "SSL error: %#04x [%x] - %s", error, mbedtls_ssl_get_verify_result(ssl), errbuf);
ret = GIT_ECERTIFICATE;
break;
@@ -375,7 +372,7 @@ static int mbedtls_stream_wrap(
st->ssl = git__malloc(sizeof(mbedtls_ssl_context));
GIT_ERROR_CHECK_ALLOC(st->ssl);
mbedtls_ssl_init(st->ssl);
- if (mbedtls_ssl_setup(st->ssl, git__ssl_conf)) {
+ if (mbedtls_ssl_setup(st->ssl, &mbedtls_config)) {
git_error_set(GIT_ERROR_SSL, "failed to create ssl object");
error = -1;
goto out_err;
@@ -442,30 +439,30 @@ int git_mbedtls__set_cert_location(const char *file, const char *path)
{
int ret = 0;
char errbuf[512];
- mbedtls_x509_crt *cacert;
GIT_ASSERT_ARG(file || path);
- cacert = git__malloc(sizeof(mbedtls_x509_crt));
- GIT_ERROR_CHECK_ALLOC(cacert);
+ if (has_ca_chain)
+ mbedtls_x509_crt_free(&mbedtls_ca_chain);
+
+ mbedtls_x509_crt_init(&mbedtls_ca_chain);
- mbedtls_x509_crt_init(cacert);
if (file)
- ret = mbedtls_x509_crt_parse_file(cacert, file);
+ ret = mbedtls_x509_crt_parse_file(&mbedtls_ca_chain, file);
+
if (ret >= 0 && path)
- ret = mbedtls_x509_crt_parse_path(cacert, path);
+ ret = mbedtls_x509_crt_parse_path(&mbedtls_ca_chain, path);
+
/* mbedtls_x509_crt_parse_path returns the number of invalid certs on success */
if (ret < 0) {
- mbedtls_x509_crt_free(cacert);
- git__free(cacert);
+ mbedtls_x509_crt_free(&mbedtls_ca_chain);
mbedtls_strerror( ret, errbuf, 512 );
git_error_set(GIT_ERROR_SSL, "failed to load CA certificates: %#04x - %s", ret, errbuf);
return -1;
}
- mbedtls_x509_crt_free(git__ssl_conf->ca_chain);
- git__free(git__ssl_conf->ca_chain);
- mbedtls_ssl_conf_ca_chain(git__ssl_conf, cacert, NULL);
+ mbedtls_ssl_conf_ca_chain(&mbedtls_config, &mbedtls_ca_chain, NULL);
+ has_ca_chain = true;
return 0;
}
diff --git a/src/libgit2/streams/mbedtls.h b/src/libgit2/streams/mbedtls.h
index bcca6dd401a..76c0627a2ca 100644
--- a/src/libgit2/streams/mbedtls.h
+++ b/src/libgit2/streams/mbedtls.h
@@ -13,7 +13,7 @@
extern int git_mbedtls_stream_global_init(void);
-#ifdef GIT_MBEDTLS
+#ifdef GIT_HTTPS_MBEDTLS
extern int git_mbedtls__set_cert_location(const char *file, const char *path);
extern int git_mbedtls_stream_new(git_stream **out, const char *host, const char *port);
diff --git a/src/libgit2/streams/openssl.c b/src/libgit2/streams/openssl.c
index 5e0e2c939db..f12b699f9b0 100644
--- a/src/libgit2/streams/openssl.c
+++ b/src/libgit2/streams/openssl.c
@@ -9,7 +9,7 @@
#include "streams/openssl_legacy.h"
#include "streams/openssl_dynamic.h"
-#ifdef GIT_OPENSSL
+#if defined(GIT_HTTPS_OPENSSL) || defined(GIT_HTTPS_OPENSSL_DYNAMIC)
#include
@@ -18,8 +18,8 @@
#include "settings.h"
#include "posix.h"
#include "stream.h"
+#include "net.h"
#include "streams/socket.h"
-#include "netops.h"
#include "git2/transport.h"
#include "git2/sys/openssl.h"
@@ -29,16 +29,18 @@
# include
#endif
-#ifndef GIT_OPENSSL_DYNAMIC
+#ifndef GIT_HTTPS_OPENSSL_DYNAMIC
# include
# include
# include
# include
#endif
+extern char *git__ssl_ciphers;
+
SSL_CTX *git__ssl_ctx;
-#define GIT_SSL_DEFAULT_CIPHERS "ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:DHE-RSA-AES128-GCM-SHA256:DHE-DSS-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:DHE-DSS-AES256-GCM-SHA384:ECDHE-ECDSA-AES128-SHA256:ECDHE-RSA-AES128-SHA256:ECDHE-ECDSA-AES128-SHA:ECDHE-RSA-AES128-SHA:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384:ECDHE-ECDSA-AES256-SHA:ECDHE-RSA-AES256-SHA:DHE-RSA-AES128-SHA256:DHE-RSA-AES256-SHA256:DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA:DHE-DSS-AES128-SHA256:DHE-DSS-AES256-SHA256:DHE-DSS-AES128-SHA:DHE-DSS-AES256-SHA:AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA256:AES256-SHA256:AES128-SHA:AES256-SHA"
+#define GIT_SSL_DEFAULT_CIPHERS "TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:DHE-RSA-CHACHA20-POLY1305"
static BIO_METHOD *git_stream_bio_method;
@@ -62,7 +64,7 @@ static void shutdown_ssl(void)
}
#ifdef VALGRIND
-# if !defined(GIT_OPENSSL_LEGACY) && !defined(GIT_OPENSSL_DYNAMIC)
+# if !defined(GIT_HTTPS_OPENSSL_LEGACY) && !defined(GIT_HTTPS_OPENSSL_DYNAMIC)
static void *git_openssl_malloc(size_t bytes, const char *file, int line)
{
@@ -70,21 +72,21 @@ static void *git_openssl_malloc(size_t bytes, const char *file, int line)
GIT_UNUSED(line);
return git__calloc(1, bytes);
}
-
+
static void *git_openssl_realloc(void *mem, size_t size, const char *file, int line)
{
GIT_UNUSED(file);
GIT_UNUSED(line);
return git__realloc(mem, size);
}
-
+
static void git_openssl_free(void *mem, const char *file, int line)
{
GIT_UNUSED(file);
GIT_UNUSED(line);
git__free(mem);
}
-# else /* !GIT_OPENSSL_LEGACY && !GIT_OPENSSL_DYNAMIC */
+# else /* !GIT_HTTPS_OPENSSL_LEGACY && !GIT_HTTPS_OPENSSL_DYNAMIC */
static void *git_openssl_malloc(size_t bytes)
{
return git__calloc(1, bytes);
@@ -99,13 +101,16 @@ static void git_openssl_free(void *mem)
{
git__free(mem);
}
-# endif /* !GIT_OPENSSL_LEGACY && !GIT_OPENSSL_DYNAMIC */
+# endif /* !GIT_HTTPS_OPENSSL_LEGACY && !GIT_HTTPS_OPENSSL_DYNAMIC */
#endif /* VALGRIND */
static int openssl_init(void)
{
- long ssl_opts = SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3;
- const char *ciphers = git_libgit2__ssl_ciphers();
+ long ssl_opts = SSL_OP_NO_SSLv2 |
+ SSL_OP_NO_SSLv3 |
+ SSL_OP_NO_TLSv1 |
+ SSL_OP_NO_TLSv1_1;
+ const char *ciphers = git__ssl_ciphers;
#ifdef VALGRIND
static bool allocators_initialized = false;
#endif
@@ -133,10 +138,10 @@ static int openssl_init(void)
OPENSSL_init_ssl(0, NULL);
/*
- * Load SSLv{2,3} and TLSv1 so that we can talk with servers
- * which use the SSL hellos, which are often used for
- * compatibility. We then disable SSL so we only allow OpenSSL
- * to speak TLSv1 to perform the encryption itself.
+ * Despite the name SSLv23_method, this is actually a version-
+ * flexible context, which honors the protocol versions
+ * specified in `ssl_opts`. So we only support TLSv1.2 and
+ * higher.
*/
if (!(git__ssl_ctx = SSL_CTX_new(SSLv23_method())))
goto error;
@@ -176,7 +181,7 @@ bool openssl_initialized;
int git_openssl_stream_global_init(void)
{
-#ifndef GIT_OPENSSL_DYNAMIC
+#ifndef GIT_HTTPS_OPENSSL_DYNAMIC
return openssl_init();
#else
if (git_mutex_init(&openssl_mutex) != 0)
@@ -188,7 +193,7 @@ int git_openssl_stream_global_init(void)
static int openssl_ensure_initialized(void)
{
-#ifdef GIT_OPENSSL_DYNAMIC
+#ifdef GIT_HTTPS_OPENSSL_DYNAMIC
int error = 0;
if (git_mutex_lock(&openssl_mutex) != 0)
@@ -209,7 +214,7 @@ static int openssl_ensure_initialized(void)
#endif
}
-#if !defined(GIT_OPENSSL_LEGACY) && !defined(GIT_OPENSSL_DYNAMIC)
+#if !defined(GIT_HTTPS_OPENSSL_LEGACY) && !defined(GIT_HTTPS_OPENSSL_DYNAMIC)
int git_openssl_set_locking(void)
{
# ifdef GIT_THREADS
@@ -357,15 +362,10 @@ static int ssl_teardown(SSL *ssl)
return ret;
}
-static int check_host_name(const char *name, const char *host)
+static bool check_host_name(const char *host, const char *name)
{
- if (!strcasecmp(name, host))
- return 0;
-
- if (gitno__match_host(name, host) < 0)
- return -1;
-
- return 0;
+ return !strcasecmp(host, name) ||
+ git_net_hostname_matches_cert(host, name);
}
static int verify_server_cert(SSL *ssl, const char *host)
@@ -425,10 +425,7 @@ static int verify_server_cert(SSL *ssl, const char *host)
if (memchr(name, '\0', namelen))
continue;
- if (check_host_name(name, host) < 0)
- matched = 0;
- else
- matched = 1;
+ matched = !!check_host_name(host, name);
} else if (type == GEN_IPADD) {
/* Here name isn't so much a name but a binary representation of the IP */
matched = addr && !!memcmp(name, addr, namelen);
@@ -481,7 +478,7 @@ static int verify_server_cert(SSL *ssl, const char *host)
goto cert_fail_name;
}
- if (check_host_name((char *)peer_cn, host) < 0)
+ if (!check_host_name(host, (char *)peer_cn))
goto cert_fail_name;
goto cleanup;
@@ -728,6 +725,30 @@ int git_openssl__set_cert_location(const char *file, const char *path)
return 0;
}
+int git_openssl__add_x509_cert(X509 *cert)
+{
+ X509_STORE *cert_store;
+
+ if (openssl_ensure_initialized() < 0)
+ return -1;
+
+ if (!(cert_store = SSL_CTX_get_cert_store(git__ssl_ctx)))
+ return -1;
+
+ if (cert && X509_STORE_add_cert(cert_store, cert) == 0) {
+ git_error_set(GIT_ERROR_SSL, "OpenSSL error: failed to add raw X509 certificate");
+ return -1;
+ }
+
+ return 0;
+}
+
+int git_openssl__reset_context(void)
+{
+ shutdown_ssl();
+ return openssl_init();
+}
+
#else
#include "stream.h"
diff --git a/src/libgit2/streams/openssl.h b/src/libgit2/streams/openssl.h
index 89fb60a82ee..2a5f04099bc 100644
--- a/src/libgit2/streams/openssl.h
+++ b/src/libgit2/streams/openssl.h
@@ -15,15 +15,17 @@
extern int git_openssl_stream_global_init(void);
-#if defined(GIT_OPENSSL) && !defined(GIT_OPENSSL_DYNAMIC)
+#if defined(GIT_HTTPS_OPENSSL)
# include
# include
# include
# include
# endif
-#ifdef GIT_OPENSSL
+#if defined(GIT_HTTPS_OPENSSL) || defined(GIT_HTTPS_OPENSSL_DYNAMIC)
extern int git_openssl__set_cert_location(const char *file, const char *path);
+extern int git_openssl__add_x509_cert(X509 *cert);
+extern int git_openssl__reset_context(void);
extern int git_openssl_stream_new(git_stream **out, const char *host, const char *port);
extern int git_openssl_stream_wrap(git_stream **out, git_stream *in, const char *host);
#endif
diff --git a/src/libgit2/streams/openssl_dynamic.c b/src/libgit2/streams/openssl_dynamic.c
index 222c1099d6b..3ab292073d9 100644
--- a/src/libgit2/streams/openssl_dynamic.c
+++ b/src/libgit2/streams/openssl_dynamic.c
@@ -8,7 +8,7 @@
#include "streams/openssl.h"
#include "streams/openssl_dynamic.h"
-#if defined(GIT_OPENSSL) && defined(GIT_OPENSSL_DYNAMIC)
+#ifdef GIT_HTTPS_OPENSSL_DYNAMIC
#include "runtime.h"
@@ -65,6 +65,7 @@ int (*SSL_write)(SSL *ssl, const void *buf, int num);
long (*SSL_CTX_ctrl)(SSL_CTX *ctx, int cmd, long larg, void *parg);
void (*SSL_CTX_free)(SSL_CTX *ctx);
SSL_CTX *(*SSL_CTX_new)(const SSL_METHOD *method);
+X509_STORE *(*SSL_CTX_get_cert_store)(const SSL_CTX *);
int (*SSL_CTX_set_cipher_list)(SSL_CTX *ctx, const char *str);
int (*SSL_CTX_set_default_verify_paths)(SSL_CTX *ctx);
long (*SSL_CTX_set_options)(SSL_CTX *ctx, long options);
@@ -80,6 +81,7 @@ int (*X509_NAME_get_index_by_NID)(X509_NAME *name, int nid, int lastpos);
void (*X509_free)(X509 *a);
void *(*X509_get_ext_d2i)(const X509 *x, int nid, int *crit, int *idx);
X509_NAME *(*X509_get_subject_name)(const X509 *x);
+int (*X509_STORE_add_cert)(X509_STORE *ctx, X509 *x);
int (*i2d_X509)(X509 *a, unsigned char **ppout);
@@ -126,7 +128,8 @@ int git_openssl_stream_dynamic_init(void)
(openssl_handle = dlopen("libssl.so.1.0.0", RTLD_NOW)) == NULL &&
(openssl_handle = dlopen("libssl.1.0.0.dylib", RTLD_NOW)) == NULL &&
(openssl_handle = dlopen("libssl.so.10", RTLD_NOW)) == NULL &&
- (openssl_handle = dlopen("libssl.so.3", RTLD_NOW)) == NULL) {
+ (openssl_handle = dlopen("libssl.so.3", RTLD_NOW)) == NULL &&
+ (openssl_handle = dlopen("libssl.3.dylib", RTLD_NOW)) == NULL) {
git_error_set(GIT_ERROR_SSL, "could not load ssl libraries");
return -1;
}
@@ -194,6 +197,7 @@ int git_openssl_stream_dynamic_init(void)
SSL_CTX_ctrl = (long (*)(SSL_CTX *, int, long, void *))openssl_sym(&err, "SSL_CTX_ctrl", true);
SSL_CTX_free = (void (*)(SSL_CTX *))openssl_sym(&err, "SSL_CTX_free", true);
SSL_CTX_new = (SSL_CTX *(*)(const SSL_METHOD *))openssl_sym(&err, "SSL_CTX_new", true);
+ SSL_CTX_get_cert_store = (X509_STORE *(*)(const SSL_CTX *))openssl_sym(&err, "SSL_CTX_get_cert_store", true);
SSL_CTX_set_cipher_list = (int (*)(SSL_CTX *, const char *))openssl_sym(&err, "SSL_CTX_set_cipher_list", true);
SSL_CTX_set_default_verify_paths = (int (*)(SSL_CTX *ctx))openssl_sym(&err, "SSL_CTX_set_default_verify_paths", true);
SSL_CTX_set_options = (long (*)(SSL_CTX *, long))openssl_sym(&err, "SSL_CTX_set_options", false);
@@ -209,6 +213,7 @@ int git_openssl_stream_dynamic_init(void)
X509_free = (void (*)(X509 *))openssl_sym(&err, "X509_free", true);
X509_get_ext_d2i = (void *(*)(const X509 *x, int nid, int *crit, int *idx))openssl_sym(&err, "X509_get_ext_d2i", true);
X509_get_subject_name = (X509_NAME *(*)(const X509 *))openssl_sym(&err, "X509_get_subject_name", true);
+ X509_STORE_add_cert = (int (*)(X509_STORE *ctx, X509 *x))openssl_sym(&err, "X509_STORE_add_cert", true);
i2d_X509 = (int (*)(X509 *a, unsigned char **ppout))openssl_sym(&err, "i2d_X509", true);
@@ -310,4 +315,4 @@ void GENERAL_NAMES_free(GENERAL_NAME *sk)
sk_free(sk);
}
-#endif /* GIT_OPENSSL && GIT_OPENSSL_DYNAMIC */
+#endif /* GIT_HTTPS_OPENSSL_DYNAMIC */
diff --git a/src/libgit2/streams/openssl_dynamic.h b/src/libgit2/streams/openssl_dynamic.h
index a9969191003..07a650b91af 100644
--- a/src/libgit2/streams/openssl_dynamic.h
+++ b/src/libgit2/streams/openssl_dynamic.h
@@ -149,7 +149,7 @@
#ifndef INCLUDE_streams_openssl_dynamic_h__
#define INCLUDE_streams_openssl_dynamic_h__
-#ifdef GIT_OPENSSL_DYNAMIC
+#ifdef GIT_HTTPS_OPENSSL_DYNAMIC
# define BIO_CTRL_FLUSH 11
@@ -182,6 +182,8 @@
# define SSL_OP_NO_COMPRESSION 0x00020000L
# define SSL_OP_NO_SSLv2 0x01000000L
# define SSL_OP_NO_SSLv3 0x02000000L
+# define SSL_OP_NO_TLSv1 0x04000000L
+# define SSL_OP_NO_TLSv1_1 0x10000000L
# define SSL_MODE_AUTO_RETRY 0x00000004L
@@ -204,6 +206,7 @@ typedef void SSL_METHOD;
typedef void X509;
typedef void X509_NAME;
typedef void X509_NAME_ENTRY;
+typedef void X509_STORE;
typedef void X509_STORE_CTX;
typedef struct {
@@ -309,6 +312,7 @@ extern int (*SSL_write)(SSL *ssl, const void *buf, int num);
extern long (*SSL_CTX_ctrl)(SSL_CTX *ctx, int cmd, long larg, void *parg);
extern void (*SSL_CTX_free)(SSL_CTX *ctx);
extern SSL_CTX *(*SSL_CTX_new)(const SSL_METHOD *method);
+extern X509_STORE *(*SSL_CTX_get_cert_store)(const SSL_CTX *ctx);
extern int (*SSL_CTX_set_cipher_list)(SSL_CTX *ctx, const char *str);
extern int (*SSL_CTX_set_default_verify_paths)(SSL_CTX *ctx);
extern long (*SSL_CTX_set_options)(SSL_CTX *ctx, long options);
@@ -326,6 +330,7 @@ extern int (*X509_NAME_get_index_by_NID)(X509_NAME *name, int nid, int lastpos);
extern void (*X509_free)(X509 *a);
extern void *(*X509_get_ext_d2i)(const X509 *x, int nid, int *crit, int *idx);
extern X509_NAME *(*X509_get_subject_name)(const X509 *x);
+extern int (*X509_STORE_add_cert)(X509_STORE *ctx, X509 *x);
extern int (*i2d_X509)(X509 *a, unsigned char **ppout);
@@ -343,6 +348,6 @@ extern void GENERAL_NAMES_free(GENERAL_NAME *sk);
extern int git_openssl_stream_dynamic_init(void);
-#endif /* GIT_OPENSSL_DYNAMIC */
+#endif /* GIT_HTTPS_OPENSSL_DYNAMIC */
#endif
diff --git a/src/libgit2/streams/openssl_legacy.c b/src/libgit2/streams/openssl_legacy.c
index e61e6efbb5e..7d361263f49 100644
--- a/src/libgit2/streams/openssl_legacy.c
+++ b/src/libgit2/streams/openssl_legacy.c
@@ -11,14 +11,14 @@
#include "runtime.h"
#include "git2/sys/openssl.h"
-#if defined(GIT_OPENSSL) && !defined(GIT_OPENSSL_DYNAMIC)
+#if defined(GIT_HTTPS_OPENSSL) && !defined(GIT_HTTPS_OPENSSL_DYNAMIC)
# include
# include
# include
# include
#endif
-#if defined(GIT_OPENSSL_LEGACY) || defined(GIT_OPENSSL_DYNAMIC)
+#if defined(GIT_HTTPS_OPENSSL_LEGACY) || defined(GIT_HTTPS_OPENSSL_DYNAMIC)
/*
* OpenSSL 1.1 made BIO opaque so we have to use functions to interact with it
@@ -173,7 +173,7 @@ int git_openssl_set_locking(void)
return -1;
#endif
-#ifdef GIT_OPENSSL_DYNAMIC
+#ifdef GIT_HTTPS_OPENSSL_DYNAMIC
/*
* This function is required on legacy versions of OpenSSL; when building
* with dynamically-loaded OpenSSL, we detect whether we loaded it or not.
@@ -200,4 +200,4 @@ int git_openssl_set_locking(void)
}
#endif /* GIT_THREADS */
-#endif /* GIT_OPENSSL_LEGACY || GIT_OPENSSL_DYNAMIC */
+#endif /* GIT_HTTPS_OPENSSL_LEGACY || GIT_HTTPS_OPENSSL_DYNAMIC */
diff --git a/src/libgit2/streams/openssl_legacy.h b/src/libgit2/streams/openssl_legacy.h
index e6dae957207..205c984adcc 100644
--- a/src/libgit2/streams/openssl_legacy.h
+++ b/src/libgit2/streams/openssl_legacy.h
@@ -9,7 +9,7 @@
#include "streams/openssl_dynamic.h"
-#if defined(GIT_OPENSSL) && !defined(GIT_OPENSSL_DYNAMIC)
+#if defined(GIT_HTTPS_OPENSSL) && !defined(GIT_HTTPS_OPENSSL_DYNAMIC)
# include
# include
# include
@@ -17,11 +17,11 @@
# if (defined(OPENSSL_VERSION_NUMBER) && OPENSSL_VERSION_NUMBER < 0x10100000L) || \
(defined(LIBRESSL_VERSION_NUMBER) && LIBRESSL_VERSION_NUMBER < 0x20700000L)
-# define GIT_OPENSSL_LEGACY
+# define GIT_HTTPS_OPENSSL_LEGACY
# endif
#endif
-#if defined(GIT_OPENSSL_LEGACY) && !defined(GIT_OPENSSL_DYNAMIC)
+#if defined(GIT_HTTPS_OPENSSL_LEGACY) && !defined(GIT_HTTPS_OPENSSL_DYNAMIC)
# define OPENSSL_init_ssl OPENSSL_init_ssl__legacy
# define BIO_meth_new BIO_meth_new__legacy
# define BIO_meth_free BIO_meth_free__legacy
@@ -39,7 +39,7 @@
# define ASN1_STRING_get0_data ASN1_STRING_get0_data__legacy
#endif
-#if defined(GIT_OPENSSL_LEGACY) || defined(GIT_OPENSSL_DYNAMIC)
+#if defined(GIT_HTTPS_OPENSSL_LEGACY) || defined(GIT_HTTPS_OPENSSL_DYNAMIC)
extern int OPENSSL_init_ssl__legacy(uint64_t opts, const void *settings);
extern BIO_METHOD *BIO_meth_new__legacy(int type, const char *name);
diff --git a/src/libgit2/streams/schannel.c b/src/libgit2/streams/schannel.c
new file mode 100644
index 00000000000..062758a2587
--- /dev/null
+++ b/src/libgit2/streams/schannel.c
@@ -0,0 +1,715 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include "streams/schannel.h"
+
+#ifdef GIT_HTTPS_SCHANNEL
+
+#define SECURITY_WIN32
+
+#include
+#include
+#include
+
+#include "stream.h"
+#include "streams/socket.h"
+
+#ifndef SP_PROT_TLS1_2_CLIENT
+# define SP_PROT_TLS1_2_CLIENT 2048
+#endif
+
+#ifndef SP_PROT_TLS1_3_CLIENT
+# define SP_PROT_TLS1_3_CLIENT 8192
+#endif
+
+#ifndef SECBUFFER_ALERT
+# define SECBUFFER_ALERT 17
+#endif
+
+#define READ_BLOCKSIZE (16 * 1024)
+
+typedef enum {
+ STATE_NONE = 0,
+ STATE_CRED = 1,
+ STATE_CONTEXT = 2,
+ STATE_CERTIFICATE = 3
+} schannel_state;
+
+typedef struct {
+ git_stream parent;
+ git_stream *io;
+ int owned;
+ bool connected;
+ wchar_t *host_w;
+
+ schannel_state state;
+
+ CredHandle cred;
+ CtxtHandle context;
+ SecPkgContext_StreamSizes stream_sizes;
+
+ CERT_CONTEXT *certificate;
+ const CERT_CHAIN_CONTEXT *cert_chain;
+ git_cert_x509 x509;
+
+ git_str plaintext_in;
+ git_str ciphertext_in;
+} schannel_stream;
+
+static int connect_context(schannel_stream *st)
+{
+ SCHANNEL_CRED cred = { 0 };
+ SECURITY_STATUS status = SEC_E_INTERNAL_ERROR;
+ DWORD context_flags;
+ static size_t MAX_RETRIES = 1024;
+ size_t retries;
+ ssize_t read_len;
+ int error = 0;
+
+ if (st->owned && (error = git_stream_connect(st->io)) < 0)
+ return error;
+
+ cred.dwVersion = SCHANNEL_CRED_VERSION;
+ cred.dwFlags = SCH_CRED_IGNORE_NO_REVOCATION_CHECK |
+ SCH_CRED_IGNORE_REVOCATION_OFFLINE |
+ SCH_CRED_MANUAL_CRED_VALIDATION |
+ SCH_CRED_NO_DEFAULT_CREDS |
+ SCH_CRED_NO_SERVERNAME_CHECK;
+ cred.grbitEnabledProtocols = SP_PROT_TLS1_2_CLIENT |
+ SP_PROT_TLS1_3_CLIENT;
+
+ if (AcquireCredentialsHandleW(NULL, SCHANNEL_NAME_W,
+ SECPKG_CRED_OUTBOUND, NULL, &cred, NULL,
+ NULL, &st->cred, NULL) != SEC_E_OK) {
+ git_error_set(GIT_ERROR_OS, "could not acquire credentials handle");
+ return -1;
+ }
+
+ st->state = STATE_CRED;
+
+ context_flags = ISC_REQ_ALLOCATE_MEMORY |
+ ISC_REQ_CONFIDENTIALITY |
+ ISC_REQ_REPLAY_DETECT |
+ ISC_REQ_SEQUENCE_DETECT |
+ ISC_REQ_STREAM;
+
+ for (retries = 0; retries < MAX_RETRIES; retries++) {
+ SecBuffer input_buf[] = {
+ { (unsigned long)st->ciphertext_in.size,
+ SECBUFFER_TOKEN,
+ st->ciphertext_in.size ? st->ciphertext_in.ptr : NULL },
+ { 0, SECBUFFER_EMPTY, NULL }
+ };
+ SecBuffer output_buf[] = { { 0, SECBUFFER_TOKEN, NULL },
+ { 0, SECBUFFER_ALERT, NULL } };
+
+ SecBufferDesc input_buf_desc = { SECBUFFER_VERSION, 2, input_buf };
+ SecBufferDesc output_buf_desc = { SECBUFFER_VERSION, 2, output_buf };
+
+ status = InitializeSecurityContextW(&st->cred,
+ retries ? &st->context : NULL, st->host_w,
+ context_flags, 0, 0, retries ? &input_buf_desc : NULL, 0,
+ retries ? NULL : &st->context, &output_buf_desc,
+ &context_flags, NULL);
+
+ if (status == SEC_E_OK || status == SEC_I_CONTINUE_NEEDED) {
+ st->state = STATE_CONTEXT;
+
+ if (output_buf[0].cbBuffer > 0) {
+ error = git_stream__write_full(st->io,
+ output_buf[0].pvBuffer,
+ output_buf[0].cbBuffer, 0);
+
+ FreeContextBuffer(output_buf[0].pvBuffer);
+ }
+
+ /* handle any leftover, unprocessed data */
+ if (input_buf[1].BufferType == SECBUFFER_EXTRA) {
+ GIT_ASSERT(st->ciphertext_in.size > input_buf[1].cbBuffer);
+
+ git_str_consume_bytes(&st->ciphertext_in,
+ st->ciphertext_in.size - input_buf[1].cbBuffer);
+ } else {
+ git_str_clear(&st->ciphertext_in);
+ }
+
+ if (error < 0 || status == SEC_E_OK)
+ break;
+ } else if (status == SEC_E_INCOMPLETE_MESSAGE) {
+ /* we need additional data from the client; */
+ if (git_str_grow_by(&st->ciphertext_in, READ_BLOCKSIZE) < 0) {
+ error = -1;
+ break;
+ }
+
+ if ((read_len = git_stream_read(st->io,
+ st->ciphertext_in.ptr + st->ciphertext_in.size,
+ (st->ciphertext_in.asize - st->ciphertext_in.size))) < 0) {
+ error = -1;
+ break;
+ }
+
+ GIT_ASSERT((size_t)read_len <=
+ st->ciphertext_in.asize - st->ciphertext_in.size);
+ st->ciphertext_in.size += read_len;
+ } else {
+ git_error_set(GIT_ERROR_OS,
+ "could not initialize security context");
+ error = -1;
+ break;
+ }
+
+ GIT_ASSERT(st->ciphertext_in.size < ULONG_MAX);
+ }
+
+ if (retries == MAX_RETRIES) {
+ git_error_set(GIT_ERROR_SSL,
+ "could not initialize security context: too many retries");
+ error = -1;
+ }
+
+ if (!error) {
+ if (QueryContextAttributesW(&st->context,
+ SECPKG_ATTR_STREAM_SIZES,
+ &st->stream_sizes) != SEC_E_OK) {
+ git_error_set(GIT_ERROR_SSL,
+ "could not query stream sizes");
+ error = -1;
+ }
+ }
+
+ return error;
+}
+
+static int set_certificate_lookup_error(DWORD status)
+{
+ switch (status) {
+ case CERT_TRUST_IS_NOT_TIME_VALID:
+ git_error_set(GIT_ERROR_SSL,
+ "certificate is expired or not yet valid");
+ break;
+ case CERT_TRUST_IS_REVOKED:
+ git_error_set(GIT_ERROR_SSL, "certificate is revoked");
+ break;
+ case CERT_TRUST_IS_NOT_SIGNATURE_VALID:
+ case CERT_TRUST_IS_NOT_VALID_FOR_USAGE:
+ case CERT_TRUST_INVALID_EXTENSION:
+ case CERT_TRUST_INVALID_POLICY_CONSTRAINTS:
+ case CERT_TRUST_INVALID_BASIC_CONSTRAINTS:
+ case CERT_TRUST_INVALID_NAME_CONSTRAINTS:
+ case CERT_TRUST_HAS_NOT_SUPPORTED_NAME_CONSTRAINT:
+ case CERT_TRUST_HAS_NOT_DEFINED_NAME_CONSTRAINT:
+ case CERT_TRUST_HAS_NOT_PERMITTED_NAME_CONSTRAINT:
+ case CERT_TRUST_HAS_EXCLUDED_NAME_CONSTRAINT:
+ case CERT_TRUST_NO_ISSUANCE_CHAIN_POLICY:
+ case CERT_TRUST_HAS_NOT_SUPPORTED_CRITICAL_EXT:
+ git_error_set(GIT_ERROR_SSL, "certificate is not valid");
+ break;
+ case CERT_TRUST_IS_UNTRUSTED_ROOT:
+ case CERT_TRUST_IS_CYCLIC:
+ case CERT_TRUST_IS_EXPLICIT_DISTRUST:
+ git_error_set(GIT_ERROR_SSL, "certificate is not trusted");
+ break;
+ case CERT_TRUST_REVOCATION_STATUS_UNKNOWN:
+ git_error_set(GIT_ERROR_SSL,
+ "certificate revocation status could not be verified");
+ break;
+ case CERT_TRUST_IS_OFFLINE_REVOCATION:
+ git_error_set(GIT_ERROR_SSL,
+ "certificate revocation is offline or stale");
+ break;
+ case CERT_TRUST_HAS_WEAK_SIGNATURE:
+ git_error_set(GIT_ERROR_SSL, "certificate has a weak signature");
+ break;
+ default:
+ git_error_set(GIT_ERROR_SSL,
+ "unknown certificate lookup failure: %d", status);
+ return -1;
+ }
+
+ return GIT_ECERTIFICATE;
+}
+
+static int set_certificate_validation_error(DWORD status)
+{
+ switch (status) {
+ case TRUST_E_CERT_SIGNATURE:
+ git_error_set(GIT_ERROR_SSL,
+ "the certificate cannot be verified");
+ break;
+ case CRYPT_E_REVOKED:
+ git_error_set(GIT_ERROR_SSL,
+ "the certificate or signature has been revoked");
+ break;
+ case CERT_E_UNTRUSTEDROOT:
+ git_error_set(GIT_ERROR_SSL,
+ "the certificate root is not trusted");
+ break;
+ case CERT_E_UNTRUSTEDTESTROOT:
+ git_error_set(GIT_ERROR_SSL,
+ "the certificate root is a test certificate");
+ break;
+ case CERT_E_CHAINING:
+ git_error_set(GIT_ERROR_SSL,
+ "the certificate chain is invalid");
+ break;
+ case CERT_E_WRONG_USAGE:
+ case CERT_E_PURPOSE:
+ git_error_set(GIT_ERROR_SSL,
+ "the certificate is not valid for this usage");
+ break;
+ case CERT_E_EXPIRED:
+ git_error_set(GIT_ERROR_SSL,
+ "certificate is expired or not yet valid");
+ break;
+ case CERT_E_INVALID_NAME:
+ case CERT_E_CN_NO_MATCH:
+ git_error_set(GIT_ERROR_SSL,
+ "certificate is not valid for this hostname");
+ break;
+ case CERT_E_INVALID_POLICY:
+ case TRUST_E_BASIC_CONSTRAINTS:
+ case CERT_E_CRITICAL:
+ case CERT_E_VALIDITYPERIODNESTING:
+ git_error_set(GIT_ERROR_SSL, "certificate is not valid");
+ break;
+ case CRYPT_E_NO_REVOCATION_CHECK:
+ git_error_set(GIT_ERROR_SSL,
+ "certificate revocation status could not be verified");
+ break;
+ case CRYPT_E_REVOCATION_OFFLINE:
+ git_error_set(GIT_ERROR_SSL,
+ "certificate revocation is offline or stale");
+ break;
+ case CERT_E_ROLE:
+ git_error_set(GIT_ERROR_SSL, "certificate authority is not valid");
+ break;
+ default:
+ git_error_set(GIT_ERROR_SSL,
+ "unknown certificate policy checking failure: %d",
+ status);
+ return -1;
+ }
+
+ return GIT_ECERTIFICATE;
+}
+
+static int check_certificate(schannel_stream* st)
+{
+ CERT_CHAIN_PARA cert_chain_parameters;
+ SSL_EXTRA_CERT_CHAIN_POLICY_PARA ssl_policy_parameters;
+ CERT_CHAIN_POLICY_PARA cert_policy_parameters =
+ { sizeof(CERT_CHAIN_POLICY_PARA), 0, &ssl_policy_parameters };
+ CERT_CHAIN_POLICY_STATUS cert_policy_status;
+
+ memset(&cert_chain_parameters, 0, sizeof(CERT_CHAIN_PARA));
+ cert_chain_parameters.cbSize = sizeof(CERT_CHAIN_PARA);
+
+ if (QueryContextAttributesW(&st->context,
+ SECPKG_ATTR_REMOTE_CERT_CONTEXT,
+ &st->certificate) != SEC_E_OK) {
+ git_error_set(GIT_ERROR_OS,
+ "could not query remote certificate context");
+ return -1;
+ }
+
+ /* TODO: do we really want to do revokcation checking ? */
+ if (!CertGetCertificateChain(NULL, st->certificate, NULL,
+ st->certificate->hCertStore, &cert_chain_parameters,
+ CERT_CHAIN_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT,
+ NULL, &st->cert_chain)) {
+ git_error_set(GIT_ERROR_OS, "could not query remote certificate chain");
+ CertFreeCertificateContext(st->certificate);
+ return -1;
+ }
+
+ st->state = STATE_CERTIFICATE;
+
+ /* Set up the x509 certificate data for future callbacks */
+
+ st->x509.parent.cert_type = GIT_CERT_X509;
+ st->x509.data = st->certificate->pbCertEncoded;
+ st->x509.len = st->certificate->cbCertEncoded;
+
+ /* Handle initial certificate validation */
+
+ if (st->cert_chain->TrustStatus.dwErrorStatus != CERT_TRUST_NO_ERROR)
+ return set_certificate_lookup_error(st->cert_chain->TrustStatus.dwErrorStatus);
+
+ ssl_policy_parameters.cbSize = sizeof(SSL_EXTRA_CERT_CHAIN_POLICY_PARA);
+ ssl_policy_parameters.dwAuthType = AUTHTYPE_SERVER;
+ ssl_policy_parameters.pwszServerName = st->host_w;
+
+ if (!CertVerifyCertificateChainPolicy(CERT_CHAIN_POLICY_SSL,
+ st->cert_chain, &cert_policy_parameters,
+ &cert_policy_status)) {
+ git_error_set(GIT_ERROR_OS, "could not verify certificate chain policy");
+ return -1;
+ }
+
+ if (cert_policy_status.dwError != SEC_E_OK)
+ return set_certificate_validation_error(cert_policy_status.dwError);
+
+ return 0;
+}
+
+static int schannel_connect(git_stream *stream)
+{
+ schannel_stream *st = (schannel_stream *)stream;
+ int error;
+
+ GIT_ASSERT(st->state == STATE_NONE);
+
+ if ((error = connect_context(st)) < 0 ||
+ (error = check_certificate(st)) < 0)
+ return error;
+
+ st->connected = 1;
+ return 0;
+}
+
+static int schannel_certificate(git_cert **out, git_stream *stream)
+{
+ schannel_stream *st = (schannel_stream *)stream;
+
+ *out = &st->x509.parent;
+ return 0;
+}
+
+static int schannel_set_proxy(
+ git_stream *stream,
+ const git_proxy_options *proxy_options)
+{
+ schannel_stream *st = (schannel_stream *)stream;
+ return git_stream_set_proxy(st->io, proxy_options);
+}
+
+static ssize_t schannel_write(
+ git_stream *stream,
+ const char *data,
+ size_t data_len,
+ int flags)
+{
+ schannel_stream *st = (schannel_stream *)stream;
+ SecBuffer encrypt_buf[3];
+ SecBufferDesc encrypt_buf_desc = { SECBUFFER_VERSION, 3, encrypt_buf };
+ git_str ciphertext_out = GIT_STR_INIT;
+ ssize_t total_len = 0;
+
+ GIT_UNUSED(flags);
+
+ if (data_len > SSIZE_MAX)
+ data_len = SSIZE_MAX;
+
+ git_str_init(&ciphertext_out,
+ st->stream_sizes.cbHeader +
+ st->stream_sizes.cbMaximumMessage +
+ st->stream_sizes.cbTrailer);
+
+ while (data_len > 0) {
+ size_t message_len = min(data_len, st->stream_sizes.cbMaximumMessage);
+ size_t ciphertext_len, ciphertext_written = 0;
+
+ encrypt_buf[0].BufferType = SECBUFFER_STREAM_HEADER;
+ encrypt_buf[0].cbBuffer = st->stream_sizes.cbHeader;
+ encrypt_buf[0].pvBuffer = ciphertext_out.ptr;
+
+ encrypt_buf[1].BufferType = SECBUFFER_DATA;
+ encrypt_buf[1].cbBuffer = (unsigned long)message_len;
+ encrypt_buf[1].pvBuffer =
+ ciphertext_out.ptr + st->stream_sizes.cbHeader;
+
+ encrypt_buf[2].BufferType = SECBUFFER_STREAM_TRAILER;
+ encrypt_buf[2].cbBuffer = st->stream_sizes.cbTrailer;
+ encrypt_buf[2].pvBuffer =
+ ciphertext_out.ptr + st->stream_sizes.cbHeader +
+ message_len;
+
+ memcpy(ciphertext_out.ptr + st->stream_sizes.cbHeader, data, message_len);
+
+ if (EncryptMessage(&st->context, 0, &encrypt_buf_desc, 0) != SEC_E_OK) {
+ git_error_set(GIT_ERROR_OS, "could not encrypt tls message");
+ total_len = -1;
+ goto done;
+ }
+
+ ciphertext_len = encrypt_buf[0].cbBuffer +
+ encrypt_buf[1].cbBuffer +
+ encrypt_buf[2].cbBuffer;
+
+ while (ciphertext_written < ciphertext_len) {
+ ssize_t chunk_len = git_stream_write(st->io,
+ ciphertext_out.ptr + ciphertext_written,
+ ciphertext_len - ciphertext_written, 0);
+
+ if (chunk_len < 0) {
+ total_len = -1;
+ goto done;
+ }
+
+ ciphertext_len -= chunk_len;
+ ciphertext_written += chunk_len;
+ }
+
+ total_len += message_len;
+
+ data += message_len;
+ data_len -= message_len;
+ }
+
+done:
+ git_str_dispose(&ciphertext_out);
+ return total_len;
+}
+
+static ssize_t schannel_read(git_stream *stream, void *_data, size_t data_len)
+{
+ schannel_stream *st = (schannel_stream *)stream;
+ char *data = (char *)_data;
+ SecBuffer decrypt_buf[4];
+ SecBufferDesc decrypt_buf_desc = { SECBUFFER_VERSION, 4, decrypt_buf };
+ SECURITY_STATUS status;
+ ssize_t chunk_len, total_len = 0;
+
+ if (data_len > SSIZE_MAX)
+ data_len = SSIZE_MAX;
+
+ /*
+ * Loop until we have some bytes to return - we may have decrypted
+ * bytes queued or ciphertext from the wire that we can decrypt and
+ * return. Return any queued bytes if they're available to avoid a
+ * network read, which may block. We may return less than the
+ * caller requested, and they can retry for an actual network
+ */
+ while ((size_t)total_len < data_len) {
+ if (st->plaintext_in.size > 0) {
+ size_t copy_len = min(st->plaintext_in.size, data_len);
+
+ memcpy(data, st->plaintext_in.ptr, copy_len);
+ git_str_consume_bytes(&st->plaintext_in, copy_len);
+
+ data += copy_len;
+ data_len -= copy_len;
+
+ total_len += copy_len;
+
+ continue;
+ }
+
+ if (st->ciphertext_in.size > 0) {
+ decrypt_buf[0].BufferType = SECBUFFER_DATA;
+ decrypt_buf[0].cbBuffer = (unsigned long)min(st->ciphertext_in.size, ULONG_MAX);
+ decrypt_buf[0].pvBuffer = st->ciphertext_in.ptr;
+
+ decrypt_buf[1].BufferType = SECBUFFER_EMPTY;
+ decrypt_buf[1].cbBuffer = 0;
+ decrypt_buf[1].pvBuffer = NULL;
+
+ decrypt_buf[2].BufferType = SECBUFFER_EMPTY;
+ decrypt_buf[2].cbBuffer = 0;
+ decrypt_buf[2].pvBuffer = NULL;
+
+ decrypt_buf[3].BufferType = SECBUFFER_EMPTY;
+ decrypt_buf[3].cbBuffer = 0;
+ decrypt_buf[3].pvBuffer = NULL;
+
+ status = DecryptMessage(&st->context, &decrypt_buf_desc, 0, NULL);
+
+ if (status == SEC_E_OK) {
+ GIT_ASSERT(decrypt_buf[0].BufferType == SECBUFFER_STREAM_HEADER);
+ GIT_ASSERT(decrypt_buf[1].BufferType == SECBUFFER_DATA);
+ GIT_ASSERT(decrypt_buf[2].BufferType == SECBUFFER_STREAM_TRAILER);
+
+ if (git_str_put(&st->plaintext_in, decrypt_buf[1].pvBuffer, decrypt_buf[1].cbBuffer) < 0) {
+ total_len = -1;
+ goto done;
+ }
+
+ if (decrypt_buf[3].BufferType == SECBUFFER_EXTRA) {
+ git_str_consume_bytes(&st->ciphertext_in, (st->ciphertext_in.size - decrypt_buf[3].cbBuffer));
+ } else {
+ git_str_clear(&st->ciphertext_in);
+ }
+
+ continue;
+ } else if (status == SEC_E_CONTEXT_EXPIRED) {
+ break;
+ } else if (status != SEC_E_INCOMPLETE_MESSAGE) {
+ git_error_set(GIT_ERROR_SSL, "could not decrypt tls message");
+ total_len = -1;
+ goto done;
+ }
+ }
+
+ if (total_len != 0)
+ break;
+
+ if (git_str_grow_by(&st->ciphertext_in, READ_BLOCKSIZE) < 0) {
+ total_len = -1;
+ goto done;
+ }
+
+ if ((chunk_len = git_stream_read(st->io, st->ciphertext_in.ptr + st->ciphertext_in.size, st->ciphertext_in.asize - st->ciphertext_in.size)) < 0) {
+ total_len = -1;
+ goto done;
+ }
+
+ st->ciphertext_in.size += chunk_len;
+ }
+
+done:
+ return total_len;
+}
+
+static int schannel_close(git_stream *stream)
+{
+ schannel_stream *st = (schannel_stream *)stream;
+ int error = 0;
+
+ if (st->connected) {
+ SecBuffer shutdown_buf;
+ SecBufferDesc shutdown_buf_desc =
+ { SECBUFFER_VERSION, 1, &shutdown_buf };
+ DWORD shutdown_message = SCHANNEL_SHUTDOWN, shutdown_flags;
+
+ shutdown_buf.BufferType = SECBUFFER_TOKEN;
+ shutdown_buf.cbBuffer = sizeof(DWORD);
+ shutdown_buf.pvBuffer = &shutdown_message;
+
+ if (ApplyControlToken(&st->context, &shutdown_buf_desc) != SEC_E_OK) {
+ git_error_set(GIT_ERROR_SSL, "could not shutdown stream");
+ error = -1;
+ }
+
+ shutdown_buf.BufferType = SECBUFFER_TOKEN;
+ shutdown_buf.cbBuffer = 0;
+ shutdown_buf.pvBuffer = NULL;
+
+ shutdown_flags = ISC_REQ_ALLOCATE_MEMORY |
+ ISC_REQ_CONFIDENTIALITY |
+ ISC_REQ_REPLAY_DETECT |
+ ISC_REQ_SEQUENCE_DETECT |
+ ISC_REQ_STREAM;
+
+ if (InitializeSecurityContext(&st->cred, &st->context,
+ NULL, shutdown_flags, 0, 0,
+ &shutdown_buf_desc, 0, NULL,
+ &shutdown_buf_desc, &shutdown_flags,
+ NULL) == SEC_E_OK) {
+ if (shutdown_buf.cbBuffer > 0) {
+ if (git_stream__write_full(st->io,
+ shutdown_buf.pvBuffer,
+ shutdown_buf.cbBuffer, 0) < 0)
+ error = -1;
+
+ FreeContextBuffer(shutdown_buf.pvBuffer);
+ }
+ }
+ }
+
+ st->connected = false;
+
+ if (st->owned && git_stream_close(st->io) < 0)
+ error = -1;
+
+ return error;
+}
+
+static void schannel_free(git_stream *stream)
+{
+ schannel_stream *st = (schannel_stream *)stream;
+
+ if (st->state >= STATE_CERTIFICATE) {
+ CertFreeCertificateContext(st->certificate);
+ CertFreeCertificateChain(st->cert_chain);
+ }
+
+ if (st->state >= STATE_CONTEXT)
+ DeleteSecurityContext(&st->context);
+
+ if (st->state >= STATE_CRED)
+ FreeCredentialsHandle(&st->cred);
+
+ st->state = STATE_NONE;
+
+ git_str_dispose(&st->ciphertext_in);
+ git_str_dispose(&st->plaintext_in);
+
+ git__free(st->host_w);
+
+ if (st->owned)
+ git_stream_free(st->io);
+
+ git__free(st);
+}
+
+static int schannel_stream_wrap(
+ git_stream **out,
+ git_stream *in,
+ const char *host,
+ int owned)
+{
+ schannel_stream *st;
+
+ st = git__calloc(1, sizeof(schannel_stream));
+ GIT_ERROR_CHECK_ALLOC(st);
+
+ st->io = in;
+ st->owned = owned;
+
+ if (git_utf8_to_16_alloc(&st->host_w, host) < 0) {
+ git__free(st);
+ return -1;
+ }
+
+ st->parent.version = GIT_STREAM_VERSION;
+ st->parent.encrypted = 1;
+ st->parent.proxy_support = git_stream_supports_proxy(st->io);
+ st->parent.connect = schannel_connect;
+ st->parent.certificate = schannel_certificate;
+ st->parent.set_proxy = schannel_set_proxy;
+ st->parent.read = schannel_read;
+ st->parent.write = schannel_write;
+ st->parent.close = schannel_close;
+ st->parent.free = schannel_free;
+
+ *out = (git_stream *)st;
+ return 0;
+}
+
+extern int git_schannel_stream_new(
+ git_stream **out,
+ const char *host,
+ const char *port)
+{
+ git_stream *stream;
+ int error;
+
+ GIT_ASSERT_ARG(out);
+ GIT_ASSERT_ARG(host);
+ GIT_ASSERT_ARG(port);
+
+ if ((error = git_socket_stream_new(&stream, host, port)) < 0)
+ return error;
+
+ if ((error = schannel_stream_wrap(out, stream, host, 1)) < 0) {
+ git_stream_close(stream);
+ git_stream_free(stream);
+ }
+
+ return error;
+}
+
+extern int git_schannel_stream_wrap(
+ git_stream **out,
+ git_stream *in,
+ const char *host)
+{
+ return schannel_stream_wrap(out, in, host, 0);
+}
+
+#endif
diff --git a/src/libgit2/streams/schannel.h b/src/libgit2/streams/schannel.h
new file mode 100644
index 00000000000..153bdbf96e7
--- /dev/null
+++ b/src/libgit2/streams/schannel.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_steams_schannel_h__
+#define INCLUDE_steams_schannel_h__
+
+#include "common.h"
+
+#include "git2/sys/stream.h"
+
+#ifdef GIT_HTTPS_SCHANNEL
+
+extern int git_schannel_stream_new(
+ git_stream **out,
+ const char *host,
+ const char *port);
+
+extern int git_schannel_stream_wrap(
+ git_stream **out,
+ git_stream *in,
+ const char *host);
+
+#endif
+
+#endif
diff --git a/src/libgit2/streams/socket.c b/src/libgit2/streams/socket.c
index 908e8c02f9b..a463312fd85 100644
--- a/src/libgit2/streams/socket.c
+++ b/src/libgit2/streams/socket.c
@@ -8,26 +8,29 @@
#include "streams/socket.h"
#include "posix.h"
-#include "netops.h"
#include "registry.h"
+#include "runtime.h"
#include "stream.h"
#ifndef _WIN32
-# include
-# include
-# include
-# include
-# include
-# include
-# include
+# include
+# include
+# include
+# include
+# include
+# include
+# include
#else
-# include
-# include
-# ifdef _MSC_VER
-# pragma comment(lib, "ws2_32")
-# endif
+# include
+# include
+# ifdef _MSC_VER
+# pragma comment(lib, "ws2_32")
+# endif
#endif
+int git_socket_stream__connect_timeout = 0;
+int git_socket_stream__timeout = 0;
+
#ifdef GIT_WIN32
static void net_set_error(const char *str)
{
@@ -54,11 +57,8 @@ static int close_socket(GIT_SOCKET s)
return 0;
#ifdef GIT_WIN32
- if (SOCKET_ERROR == closesocket(s))
- return -1;
-
- if (0 != WSACleanup()) {
- git_error_set(GIT_ERROR_OS, "winsock cleanup failed");
+ if (closesocket(s) != 0) {
+ net_set_error("could not close socket");
return -1;
}
@@ -69,38 +69,119 @@ static int close_socket(GIT_SOCKET s)
}
-static int socket_connect(git_stream *stream)
+static int set_nonblocking(GIT_SOCKET s)
{
- struct addrinfo *info = NULL, *p;
- struct addrinfo hints;
- git_socket_stream *st = (git_socket_stream *) stream;
- GIT_SOCKET s = INVALID_SOCKET;
- int ret;
-
#ifdef GIT_WIN32
- /* on win32, the WSA context needs to be initialized
- * before any socket calls can be performed */
- WSADATA wsd;
+ unsigned long nonblocking = 1;
- if (WSAStartup(MAKEWORD(2,2), &wsd) != 0) {
- git_error_set(GIT_ERROR_OS, "winsock init failed");
+ if (ioctlsocket(s, FIONBIO, &nonblocking) != 0) {
+ net_set_error("could not set socket non-blocking");
return -1;
}
+#else
+ int flags;
+
+ if ((flags = fcntl(s, F_GETFL, 0)) == -1) {
+ net_set_error("could not query socket flags");
+ return -1;
+ }
+
+ flags |= O_NONBLOCK;
- if (LOBYTE(wsd.wVersion) != 2 || HIBYTE(wsd.wVersion) != 2) {
- WSACleanup();
- git_error_set(GIT_ERROR_OS, "winsock init failed");
+ if (fcntl(s, F_SETFL, flags) != 0) {
+ net_set_error("could not set socket non-blocking");
return -1;
}
#endif
+ return 0;
+}
+
+/* Promote a sockerr to an errno for our error handling routines */
+static int handle_sockerr(GIT_SOCKET socket)
+{
+ int sockerr;
+ socklen_t errlen = sizeof(sockerr);
+
+ if (getsockopt(socket, SOL_SOCKET, SO_ERROR,
+ (void *)&sockerr, &errlen) < 0)
+ return -1;
+
+ if (sockerr == ETIMEDOUT)
+ return GIT_TIMEOUT;
+
+ errno = sockerr;
+ return -1;
+}
+
+GIT_INLINE(bool) connect_would_block(int error)
+{
+#ifdef GIT_WIN32
+ if (error == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK)
+ return true;
+#endif
+
+ if (error == -1 && errno == EINPROGRESS)
+ return true;
+
+ return false;
+}
+
+static int connect_with_timeout(
+ GIT_SOCKET socket,
+ const struct sockaddr *address,
+ socklen_t address_len,
+ int timeout)
+{
+ struct pollfd fd;
+ int error;
+
+ if (timeout && (error = set_nonblocking(socket)) < 0)
+ return error;
+
+ error = connect(socket, address, address_len);
+
+ if (error == 0 || !connect_would_block(error))
+ return error;
+
+ fd.fd = socket;
+ fd.events = POLLOUT;
+ fd.revents = 0;
+
+ error = p_poll(&fd, 1, timeout);
+
+ if (error == 0) {
+ return GIT_TIMEOUT;
+ } else if (error != 1) {
+ return -1;
+ } else if ((fd.revents & (POLLPRI | POLLHUP | POLLERR))) {
+ return handle_sockerr(socket);
+ } else if ((fd.revents & POLLOUT) != POLLOUT) {
+ git_error_set(GIT_ERROR_NET,
+ "unknown error while polling for connect: %d",
+ fd.revents);
+ return -1;
+ }
+
+ return 0;
+}
+
+static int socket_connect(git_stream *stream)
+{
+ git_socket_stream *st = (git_socket_stream *) stream;
+ GIT_SOCKET s = INVALID_SOCKET;
+ struct addrinfo *info = NULL, *p;
+ struct addrinfo hints;
+ int error;
+
memset(&hints, 0x0, sizeof(struct addrinfo));
hints.ai_socktype = SOCK_STREAM;
hints.ai_family = AF_UNSPEC;
- if ((ret = p_getaddrinfo(st->host, st->port, &hints, &info)) != 0) {
+ if ((error = p_getaddrinfo(st->host, st->port, &hints, &info)) != 0) {
git_error_set(GIT_ERROR_NET,
- "failed to resolve address for %s: %s", st->host, p_gai_strerror(ret));
+ "failed to resolve address for %s: %s",
+ st->host, p_gai_strerror(error));
return -1;
}
@@ -110,51 +191,115 @@ static int socket_connect(git_stream *stream)
if (s == INVALID_SOCKET)
continue;
- if (connect(s, p->ai_addr, (socklen_t)p->ai_addrlen) == 0)
+ error = connect_with_timeout(s, p->ai_addr,
+ (socklen_t)p->ai_addrlen,
+ st->parent.connect_timeout);
+
+ if (error == 0)
break;
/* If we can't connect, try the next one */
close_socket(s);
s = INVALID_SOCKET;
+
+ if (error == GIT_TIMEOUT)
+ break;
}
/* Oops, we couldn't connect to any address */
- if (s == INVALID_SOCKET && p == NULL) {
- git_error_set(GIT_ERROR_OS, "failed to connect to %s", st->host);
- p_freeaddrinfo(info);
- return -1;
+ if (s == INVALID_SOCKET) {
+ if (error == GIT_TIMEOUT)
+ git_error_set(GIT_ERROR_NET, "failed to connect to %s: Operation timed out", st->host);
+ else
+ git_error_set(GIT_ERROR_OS, "failed to connect to %s", st->host);
+ error = -1;
+ goto done;
}
+ if (st->parent.timeout && !st->parent.connect_timeout &&
+ (error = set_nonblocking(s)) < 0)
+ return error;
+
st->s = s;
+ error = 0;
+
+done:
p_freeaddrinfo(info);
- return 0;
+ return error;
}
-static ssize_t socket_write(git_stream *stream, const char *data, size_t len, int flags)
+static ssize_t socket_write(
+ git_stream *stream,
+ const char *data,
+ size_t len,
+ int flags)
{
git_socket_stream *st = (git_socket_stream *) stream;
- ssize_t written;
+ struct pollfd fd;
+ ssize_t ret;
GIT_ASSERT(flags == 0);
GIT_UNUSED(flags);
- errno = 0;
+ ret = p_send(st->s, data, len, 0);
- if ((written = p_send(st->s, data, len, 0)) < 0) {
- net_set_error("error sending data");
+ if (st->parent.timeout && ret < 0 &&
+ (errno == EAGAIN || errno != EWOULDBLOCK)) {
+ fd.fd = st->s;
+ fd.events = POLLOUT;
+ fd.revents = 0;
+
+ ret = p_poll(&fd, 1, st->parent.timeout);
+
+ if (ret == 1) {
+ ret = p_send(st->s, data, len, 0);
+ } else if (ret == 0) {
+ git_error_set(GIT_ERROR_NET,
+ "could not write to socket: timed out");
+ return GIT_TIMEOUT;
+ }
+ }
+
+ if (ret < 0) {
+ net_set_error("error receiving data from socket");
return -1;
}
- return written;
+ return ret;
}
-static ssize_t socket_read(git_stream *stream, void *data, size_t len)
+static ssize_t socket_read(
+ git_stream *stream,
+ void *data,
+ size_t len)
{
- ssize_t ret;
git_socket_stream *st = (git_socket_stream *) stream;
+ struct pollfd fd;
+ ssize_t ret;
- if ((ret = p_recv(st->s, data, len, 0)) < 0)
- net_set_error("error receiving socket data");
+ ret = p_recv(st->s, data, len, 0);
+
+ if (st->parent.timeout && ret < 0 &&
+ (errno == EAGAIN || errno != EWOULDBLOCK)) {
+ fd.fd = st->s;
+ fd.events = POLLIN;
+ fd.revents = 0;
+
+ ret = p_poll(&fd, 1, st->parent.timeout);
+
+ if (ret == 1) {
+ ret = p_recv(st->s, data, len, 0);
+ } else if (ret == 0) {
+ git_error_set(GIT_ERROR_NET,
+ "could not read from socket: timed out");
+ return GIT_TIMEOUT;
+ }
+ }
+
+ if (ret < 0) {
+ net_set_error("error receiving data from socket");
+ return -1;
+ }
return ret;
}
@@ -202,6 +347,8 @@ static int default_socket_stream_new(
}
st->parent.version = GIT_STREAM_VERSION;
+ st->parent.timeout = git_socket_stream__timeout;
+ st->parent.connect_timeout = git_socket_stream__connect_timeout;
st->parent.connect = socket_connect;
st->parent.write = socket_write;
st->parent.read = socket_read;
@@ -240,3 +387,42 @@ int git_socket_stream_new(
return init(out, host, port);
}
+
+#ifdef GIT_WIN32
+
+static void socket_stream_global_shutdown(void)
+{
+ WSACleanup();
+}
+
+int git_socket_stream_global_init(void)
+{
+ WORD winsock_version;
+ WSADATA wsa_data;
+
+ winsock_version = MAKEWORD(2, 2);
+
+ if (WSAStartup(winsock_version, &wsa_data) != 0) {
+ git_error_set(GIT_ERROR_OS, "could not initialize Windows Socket Library");
+ return -1;
+ }
+
+ if (LOBYTE(wsa_data.wVersion) != 2 ||
+ HIBYTE(wsa_data.wVersion) != 2) {
+ git_error_set(GIT_ERROR_SSL, "Windows Socket Library does not support Winsock 2.2");
+ return -1;
+ }
+
+ return git_runtime_shutdown_register(socket_stream_global_shutdown);
+}
+
+#else
+
+#include "stream.h"
+
+int git_socket_stream_global_init(void)
+{
+ return 0;
+}
+
+ #endif
diff --git a/src/libgit2/streams/socket.h b/src/libgit2/streams/socket.h
index 3235f31679c..73e8de099a6 100644
--- a/src/libgit2/streams/socket.h
+++ b/src/libgit2/streams/socket.h
@@ -9,7 +9,7 @@
#include "common.h"
-#include "netops.h"
+#include "stream.h"
typedef struct {
git_stream parent;
@@ -20,4 +20,6 @@ typedef struct {
extern int git_socket_stream_new(git_stream **out, const char *host, const char *port);
+extern int git_socket_stream_global_init(void);
+
#endif
diff --git a/src/libgit2/streams/stransport.c b/src/libgit2/streams/stransport.c
index 3f31d2541c7..3dbc403b7f4 100644
--- a/src/libgit2/streams/stransport.c
+++ b/src/libgit2/streams/stransport.c
@@ -7,19 +7,22 @@
#include "streams/stransport.h"
-#ifdef GIT_SECURE_TRANSPORT
+#ifdef GIT_HTTPS_SECURETRANSPORT
#include
#include
#include
+#include "common.h"
+#include "trace.h"
#include "git2/transport.h"
-
#include "streams/socket.h"
static int stransport_error(OSStatus ret)
{
- CFStringRef message;
+ CFStringRef message_ref = NULL;
+ const char *message_cstr = NULL;
+ char *message_ptr = NULL;
if (ret == noErr || ret == errSSLClosedGraceful) {
git_error_clear();
@@ -27,14 +30,39 @@ static int stransport_error(OSStatus ret)
}
#if !TARGET_OS_IPHONE
- message = SecCopyErrorMessageString(ret, NULL);
- GIT_ERROR_CHECK_ALLOC(message);
+ message_ref = SecCopyErrorMessageString(ret, NULL);
+ GIT_ERROR_CHECK_ALLOC(message_ref);
+
+ /*
+ * Attempt the cheap CFString conversion; this can return NULL
+ * when that would be expensive. In that case, call the more
+ * expensive function.
+ */
+ message_cstr = CFStringGetCStringPtr(message_ref, kCFStringEncodingUTF8);
+
+ if (!message_cstr) {
+ /* Provide buffer to convert from UTF16 to UTF8 */
+ size_t message_size = CFStringGetLength(message_ref) * 2 + 1;
+
+ message_cstr = message_ptr = git__malloc(message_size);
+ GIT_ERROR_CHECK_ALLOC(message_ptr);
+
+ if (!CFStringGetCString(message_ref, message_ptr, message_size, kCFStringEncodingUTF8)) {
+ git_error_set(GIT_ERROR_NET, "SecureTransport error: %d", (unsigned int)ret);
+ goto done;
+ }
+ }
- git_error_set(GIT_ERROR_NET, "SecureTransport error: %s", CFStringGetCStringPtr(message, kCFStringEncodingUTF8));
- CFRelease(message);
+ git_error_set(GIT_ERROR_NET, "SecureTransport error: %s", message_cstr);
+
+done:
+ git__free(message_ptr);
+ CFRelease(message_ref);
#else
git_error_set(GIT_ERROR_NET, "SecureTransport error: OSStatus %d", (unsigned int)ret);
- GIT_UNUSED(message);
+ GIT_UNUSED(message_ref);
+ GIT_UNUSED(message_cstr);
+ GIT_UNUSED(message_ptr);
#endif
return -1;
@@ -44,6 +72,7 @@ typedef struct {
git_stream parent;
git_stream *io;
int owned;
+ int error;
SSLContextRef ctx;
CFDataRef der_data;
git_cert_x509 cert_info;
@@ -61,7 +90,10 @@ static int stransport_connect(git_stream *stream)
return error;
ret = SSLHandshake(st->ctx);
- if (ret != errSSLServerAuthCompleted) {
+
+ if (ret != errSSLServerAuthCompleted && st->error != 0)
+ return -1;
+ else if (ret != errSSLServerAuthCompleted) {
git_error_set(GIT_ERROR_SSL, "unexpected return value from ssl handshake %d", (int)ret);
return -1;
}
@@ -147,10 +179,20 @@ static int stransport_set_proxy(
*/
static OSStatus write_cb(SSLConnectionRef conn, const void *data, size_t *len)
{
- git_stream *io = (git_stream *) conn;
+ stransport_stream *st = (stransport_stream *)conn;
+ git_stream *io = st->io;
+ OSStatus ret;
+
+ st->error = 0;
+
+ ret = git_stream__write_full(io, data, *len, 0);
- if (git_stream__write_full(io, data, *len, 0) < 0)
- return -36; /* "ioErr" from MacErrors.h which is not available on iOS */
+ if (ret < 0) {
+ st->error = ret;
+ return (ret == GIT_TIMEOUT) ?
+ -9853 /* errSSLNetworkTimeout */:
+ -36 /* ioErr */;
+ }
return noErr;
}
@@ -164,8 +206,12 @@ static ssize_t stransport_write(git_stream *stream, const char *data, size_t len
GIT_UNUSED(flags);
data_len = min(len, SSIZE_MAX);
- if ((ret = SSLWrite(st->ctx, data, data_len, &processed)) != noErr)
+ if ((ret = SSLWrite(st->ctx, data, data_len, &processed)) != noErr) {
+ if (st->error == GIT_TIMEOUT)
+ return GIT_TIMEOUT;
+
return stransport_error(ret);
+ }
GIT_ASSERT(processed < SSIZE_MAX);
return (ssize_t)processed;
@@ -182,18 +228,24 @@ static ssize_t stransport_write(git_stream *stream, const char *data, size_t len
*/
static OSStatus read_cb(SSLConnectionRef conn, void *data, size_t *len)
{
- git_stream *io = (git_stream *) conn;
+ stransport_stream *st = (stransport_stream *)conn;
+ git_stream *io = st->io;
OSStatus error = noErr;
size_t off = 0;
ssize_t ret;
+ st->error = 0;
+
do {
ret = git_stream_read(io, data + off, *len - off);
+
if (ret < 0) {
- error = -36; /* "ioErr" from MacErrors.h which is not available on iOS */
+ st->error = ret;
+ error = (ret == GIT_TIMEOUT) ?
+ -9853 /* errSSLNetworkTimeout */:
+ -36 /* ioErr */;
break;
- }
- if (ret == 0) {
+ } else if (ret == 0) {
error = errSSLClosedGraceful;
break;
}
@@ -207,12 +259,20 @@ static OSStatus read_cb(SSLConnectionRef conn, void *data, size_t *len)
static ssize_t stransport_read(git_stream *stream, void *data, size_t len)
{
- stransport_stream *st = (stransport_stream *) stream;
+ stransport_stream *st = (stransport_stream *)stream;
size_t processed;
OSStatus ret;
- if ((ret = SSLRead(st->ctx, data, len, &processed)) != noErr)
+ if ((ret = SSLRead(st->ctx, data, len, &processed)) != noErr) {
+ /* This specific SecureTransport error is not well described */
+ if (ret == -9806)
+ git_trace(GIT_TRACE_INFO, "SecureTraceport error during SSLRead: returned -9806 (connection closed via error)");
+
+ if (st->error == GIT_TIMEOUT)
+ return GIT_TIMEOUT;
+
return stransport_error(ret);
+ }
return processed;
}
@@ -269,10 +329,9 @@ static int stransport_wrap(
}
if ((ret = SSLSetIOFuncs(st->ctx, read_cb, write_cb)) != noErr ||
- (ret = SSLSetConnection(st->ctx, st->io)) != noErr ||
+ (ret = SSLSetConnection(st->ctx, st)) != noErr ||
(ret = SSLSetSessionOption(st->ctx, kSSLSessionOptionBreakOnServerAuth, true)) != noErr ||
- (ret = SSLSetProtocolVersionMin(st->ctx, kTLSProtocol1)) != noErr ||
- (ret = SSLSetProtocolVersionMax(st->ctx, kTLSProtocol12)) != noErr ||
+ (ret = SSLSetProtocolVersionMin(st->ctx, kTLSProtocol12)) != noErr ||
(ret = SSLSetPeerDomainName(st->ctx, host, strlen(host))) != noErr) {
CFRelease(st->ctx);
git__free(st);
diff --git a/src/libgit2/streams/stransport.h b/src/libgit2/streams/stransport.h
index 1026e204b16..e1b936b53ba 100644
--- a/src/libgit2/streams/stransport.h
+++ b/src/libgit2/streams/stransport.h
@@ -11,7 +11,7 @@
#include "git2/sys/stream.h"
-#ifdef GIT_SECURE_TRANSPORT
+#ifdef GIT_HTTPS_SECURETRANSPORT
extern int git_stransport_stream_new(git_stream **out, const char *host, const char *port);
extern int git_stransport_stream_wrap(git_stream **out, git_stream *in, const char *host);
diff --git a/src/libgit2/streams/tls.c b/src/libgit2/streams/tls.c
index e063a33f99a..47ef2689f3f 100644
--- a/src/libgit2/streams/tls.c
+++ b/src/libgit2/streams/tls.c
@@ -13,6 +13,7 @@
#include "streams/mbedtls.h"
#include "streams/openssl.h"
#include "streams/stransport.h"
+#include "streams/schannel.h"
int git_tls_stream_new(git_stream **out, const char *host, const char *port)
{
@@ -27,12 +28,15 @@ int git_tls_stream_new(git_stream **out, const char *host, const char *port)
if ((error = git_stream_registry_lookup(&custom, GIT_STREAM_TLS)) == 0) {
init = custom.init;
} else if (error == GIT_ENOTFOUND) {
-#ifdef GIT_SECURE_TRANSPORT
+#if defined(GIT_HTTPS_SECURETRANSPORT)
init = git_stransport_stream_new;
-#elif defined(GIT_OPENSSL)
+#elif defined(GIT_HTTPS_OPENSSL) || \
+ defined(GIT_HTTPS_OPENSSL_DYNAMIC)
init = git_openssl_stream_new;
-#elif defined(GIT_MBEDTLS)
+#elif defined(GIT_HTTPS_MBEDTLS)
init = git_mbedtls_stream_new;
+#elif defined(GIT_HTTPS_SCHANNEL)
+ init = git_schannel_stream_new;
#endif
} else {
return error;
@@ -57,12 +61,15 @@ int git_tls_stream_wrap(git_stream **out, git_stream *in, const char *host)
if (git_stream_registry_lookup(&custom, GIT_STREAM_TLS) == 0) {
wrap = custom.wrap;
} else {
-#ifdef GIT_SECURE_TRANSPORT
+#if defined(GIT_HTTPS_SECURETRANSPORT)
wrap = git_stransport_stream_wrap;
-#elif defined(GIT_OPENSSL)
+#elif defined(GIT_HTTPS_OPENSSL) || \
+ defined(GIT_HTTPS_OPENSSL_DYNAMIC)
wrap = git_openssl_stream_wrap;
-#elif defined(GIT_MBEDTLS)
+#elif defined(GIT_HTTPS_MBEDTLS)
wrap = git_mbedtls_stream_wrap;
+#elif defined(GIT_HTTPS_SCHANNEL)
+ wrap = git_schannel_stream_wrap;
#endif
}
diff --git a/src/libgit2/submodule.c b/src/libgit2/submodule.c
index 95ea84fc233..7444e8c678b 100644
--- a/src/libgit2/submodule.c
+++ b/src/libgit2/submodule.c
@@ -169,22 +169,27 @@ static int is_path_occupied(bool *occupied, git_repository *repo, const char *pa
return error;
}
+GIT_HASHMAP_STR_SETUP(git_submodule_namemap, char *);
+
/**
* Release the name map returned by 'load_submodule_names'.
*/
-static void free_submodule_names(git_strmap *names)
+static void free_submodule_names(git_submodule_namemap *names)
{
+ git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
const char *key;
char *value;
if (names == NULL)
return;
- git_strmap_foreach(names, key, value, {
- git__free((char *) key);
+ while (git_submodule_namemap_iterate(&iter, &key, &value, names) == 0) {
+ git__free((char *)key);
git__free(value);
- });
- git_strmap_free(names);
+ }
+
+ git_submodule_namemap_dispose(names);
+ git__free(names);
return;
}
@@ -194,19 +199,22 @@ static void free_submodule_names(git_strmap *names)
* TODO: for some use-cases, this might need case-folding on a
* case-insensitive filesystem
*/
-static int load_submodule_names(git_strmap **out, git_repository *repo, git_config *cfg)
+static int load_submodule_names(git_submodule_namemap **out, git_repository *repo, git_config *cfg)
{
- const char *key = "submodule\\..*\\.path";
+ const char *key = "^submodule\\..*\\.path$";
+ char *value;
git_config_iterator *iter = NULL;
git_config_entry *entry;
git_str buf = GIT_STR_INIT;
- git_strmap *names;
+ git_submodule_namemap *names;
int isvalid, error;
*out = NULL;
- if ((error = git_strmap_new(&names)) < 0)
+ if ((names = git__calloc(1, sizeof(git_submodule_namemap))) == NULL) {
+ error = -1;
goto out;
+ }
if ((error = git_config_iterator_glob_new(&iter, cfg, key)) < 0)
goto out;
@@ -216,7 +224,7 @@ static int load_submodule_names(git_strmap **out, git_repository *repo, git_conf
fdot = strchr(entry->name, '.');
ldot = strrchr(entry->name, '.');
- if (git_strmap_exists(names, entry->value)) {
+ if (git_submodule_namemap_contains(names, entry->value)) {
git_error_set(GIT_ERROR_SUBMODULE,
"duplicated submodule path '%s'", entry->value);
error = -1;
@@ -233,7 +241,12 @@ static int load_submodule_names(git_strmap **out, git_repository *repo, git_conf
if (!isvalid)
continue;
- if ((error = git_strmap_set(names, git__strdup(entry->value), git_str_detach(&buf))) < 0) {
+ if ((value = git__strdup(entry->value)) == NULL) {
+ error = -1;
+ goto out;
+ }
+
+ if ((error = git_submodule_namemap_put(names, value, git_str_detach(&buf))) < 0) {
git_error_set(GIT_ERROR_NOMEMORY, "error inserting submodule into hash table");
error = -1;
goto out;
@@ -252,31 +265,43 @@ static int load_submodule_names(git_strmap **out, git_repository *repo, git_conf
return error;
}
-int git_submodule_cache_init(git_strmap **out, git_repository *repo)
+GIT_HASHMAP_STR_FUNCTIONS(git_submodule_cache, GIT_HASHMAP_INLINE, git_submodule *);
+
+int git_submodule__map(git_submodule_cache *cache, git_repository *repo);
+
+int git_submodule_cache_init(git_submodule_cache **out, git_repository *repo)
{
+ git_submodule_cache *cache = NULL;
int error = 0;
- git_strmap *cache = NULL;
+
GIT_ASSERT_ARG(out);
GIT_ASSERT_ARG(repo);
- if ((error = git_strmap_new(&cache)) < 0)
- return error;
- if ((error = git_submodule__map(repo, cache)) < 0) {
+
+ if ((cache = git__calloc(1, sizeof(git_submodule_cache))) == NULL)
+ return -1;
+
+ if ((error = git_submodule__map(cache, repo)) < 0) {
git_submodule_cache_free(cache);
return error;
}
+
*out = cache;
return error;
}
-int git_submodule_cache_free(git_strmap *cache)
+int git_submodule_cache_free(git_submodule_cache *cache)
{
git_submodule *sm = NULL;
+ git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
+
if (cache == NULL)
return 0;
- git_strmap_foreach_value(cache, sm, {
+
+ while (git_submodule_cache_iterate(&iter, NULL, &sm, cache) == 0)
git_submodule_free(sm);
- });
- git_strmap_free(cache);
+
+ git_submodule_cache_dispose(cache);
+ git__free(cache);
return 0;
}
@@ -292,7 +317,7 @@ int git_submodule__lookup_with_cache(
git_submodule **out, /* NULL if user only wants to test existence */
git_repository *repo,
const char *name, /* trailing slash is allowed */
- git_strmap *cache)
+ git_submodule_cache *cache)
{
int error;
unsigned int location;
@@ -307,7 +332,7 @@ int git_submodule__lookup_with_cache(
}
if (cache != NULL) {
- if ((sm = git_strmap_get(cache, name)) != NULL) {
+ if (git_submodule_cache_get(&sm, cache, name) == 0) {
if (out) {
*out = sm;
GIT_REFCOUNT_INC(*out);
@@ -332,7 +357,7 @@ int git_submodule__lookup_with_cache(
/* If it's not configured or we're looking by path */
if (location == 0 || location == GIT_SUBMODULE_STATUS_IN_WD) {
git_config_backend *mods;
- const char *pattern = "submodule\\..*\\.path";
+ const char *pattern = "^submodule\\..*\\.path$";
git_str path = GIT_STR_INIT;
fbp_data data = { NULL, NULL };
@@ -434,19 +459,23 @@ static void submodule_free_dup(void *sm)
git_submodule_free(sm);
}
-static int submodule_get_or_create(git_submodule **out, git_repository *repo, git_strmap *map, const char *name)
+static int submodule_get_or_create(
+ git_submodule **out,
+ git_repository *repo,
+ git_submodule_cache *cache,
+ const char *name)
{
git_submodule *sm = NULL;
int error;
- if ((sm = git_strmap_get(map, name)) != NULL)
+ if (git_submodule_cache_get(&sm, cache, name) == 0)
goto done;
/* if the submodule doesn't exist yet in the map, create it */
if ((error = submodule_alloc(&sm, repo, name)) < 0)
return error;
- if ((error = git_strmap_set(map, sm->name, sm)) < 0) {
+ if ((error = git_submodule_cache_put(cache, sm->name, sm)) < 0) {
git_submodule_free(sm);
return error;
}
@@ -457,12 +486,15 @@ static int submodule_get_or_create(git_submodule **out, git_repository *repo, gi
return 0;
}
-static int submodules_from_index(git_strmap *map, git_index *idx, git_config *cfg)
+static int submodules_from_index(
+ git_submodule_cache *cache,
+ git_index *idx,
+ git_config *cfg)
{
int error;
git_iterator *i = NULL;
const git_index_entry *entry;
- git_strmap *names;
+ git_submodule_namemap *names;
if ((error = load_submodule_names(&names, git_index_owner(idx), cfg)))
goto done;
@@ -473,7 +505,7 @@ static int submodules_from_index(git_strmap *map, git_index *idx, git_config *cf
while (!(error = git_iterator_advance(&entry, i))) {
git_submodule *sm;
- if ((sm = git_strmap_get(map, entry->path)) != NULL) {
+ if (git_submodule_cache_get(&sm, cache, entry->path) == 0) {
if (S_ISGITLINK(entry->mode))
submodule_update_from_index_entry(sm, entry);
else
@@ -481,10 +513,10 @@ static int submodules_from_index(git_strmap *map, git_index *idx, git_config *cf
} else if (S_ISGITLINK(entry->mode)) {
const char *name;
- if ((name = git_strmap_get(names, entry->path)) == NULL)
+ if (git_submodule_namemap_get((char **)&name, names, entry->path) != 0)
name = entry->path;
- if (!submodule_get_or_create(&sm, git_index_owner(idx), map, name)) {
+ if (!submodule_get_or_create(&sm, git_index_owner(idx), cache, name)) {
submodule_update_from_index_entry(sm, entry);
git_submodule_free(sm);
}
@@ -501,12 +533,15 @@ static int submodules_from_index(git_strmap *map, git_index *idx, git_config *cf
return error;
}
-static int submodules_from_head(git_strmap *map, git_tree *head, git_config *cfg)
+static int submodules_from_head(
+ git_submodule_cache *cache,
+ git_tree *head,
+ git_config *cfg)
{
int error;
git_iterator *i = NULL;
const git_index_entry *entry;
- git_strmap *names;
+ git_submodule_namemap *names;
if ((error = load_submodule_names(&names, git_tree_owner(head), cfg)))
goto done;
@@ -517,7 +552,7 @@ static int submodules_from_head(git_strmap *map, git_tree *head, git_config *cfg
while (!(error = git_iterator_advance(&entry, i))) {
git_submodule *sm;
- if ((sm = git_strmap_get(map, entry->path)) != NULL) {
+ if (git_submodule_cache_get(&sm, cache, entry->path) == 0) {
if (S_ISGITLINK(entry->mode))
submodule_update_from_head_data(sm, entry->mode, &entry->id);
else
@@ -525,10 +560,10 @@ static int submodules_from_head(git_strmap *map, git_tree *head, git_config *cfg
} else if (S_ISGITLINK(entry->mode)) {
const char *name;
- if ((name = git_strmap_get(names, entry->path)) == NULL)
+ if (git_submodule_namemap_get((char **)&name, names, entry->path) != 0)
name = entry->path;
- if (!submodule_get_or_create(&sm, git_tree_owner(head), map, name)) {
+ if (!submodule_get_or_create(&sm, git_tree_owner(head), cache, name)) {
submodule_update_from_head_data(
sm, entry->mode, &entry->id);
git_submodule_free(sm);
@@ -549,11 +584,11 @@ static int submodules_from_head(git_strmap *map, git_tree *head, git_config *cfg
/* If have_sm is true, sm is populated, otherwise map an repo are. */
typedef struct {
git_config *mods;
- git_strmap *map;
+ git_submodule_cache *cache;
git_repository *repo;
} lfc_data;
-int git_submodule__map(git_repository *repo, git_strmap *map)
+int git_submodule__map(git_submodule_cache *cache, git_repository *repo)
{
int error = 0;
git_index *idx = NULL;
@@ -563,8 +598,8 @@ int git_submodule__map(git_repository *repo, git_strmap *map)
git_config *mods = NULL;
bool has_workdir;
+ GIT_ASSERT_ARG(cache);
GIT_ASSERT_ARG(repo);
- GIT_ASSERT_ARG(map);
/* get sources that we will need to check */
if (git_repository_index(&idx, repo) < 0)
@@ -581,7 +616,7 @@ int git_submodule__map(git_repository *repo, git_strmap *map)
/* add submodule information from .gitmodules */
if (has_workdir) {
lfc_data data = { 0 };
- data.map = map;
+ data.cache = cache;
data.repo = repo;
if ((error = gitmodules_snapshot(&mods, repo)) < 0) {
@@ -597,19 +632,22 @@ int git_submodule__map(git_repository *repo, git_strmap *map)
}
/* add back submodule information from index */
if (mods && idx) {
- if ((error = submodules_from_index(map, idx, mods)) < 0)
+ if ((error = submodules_from_index(cache, idx, mods)) < 0)
goto cleanup;
}
/* add submodule information from HEAD */
if (mods && head) {
- if ((error = submodules_from_head(map, head, mods)) < 0)
+ if ((error = submodules_from_head(cache, head, mods)) < 0)
goto cleanup;
}
/* shallow scan submodules in work tree as needed */
if (has_workdir) {
- git_strmap_foreach_value(map, sm, {
- submodule_load_from_wd_lite(sm);
- });
+ git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
+
+ while (git_submodule_cache_iterate(&iter, NULL, &sm, cache) == 0) {
+ if ((error = submodule_load_from_wd_lite(sm)) < 0)
+ goto cleanup;
+ }
}
cleanup:
@@ -627,8 +665,9 @@ int git_submodule_foreach(
void *payload)
{
git_vector snapshot = GIT_VECTOR_INIT;
- git_strmap *submodules;
+ git_submodule_cache *submodules;
git_submodule *sm;
+ git_hashmap_iter_t iter;
int error;
size_t i;
@@ -637,20 +676,22 @@ int git_submodule_foreach(
return -1;
}
- if ((error = git_strmap_new(&submodules)) < 0)
- return error;
+ if ((submodules = git__calloc(1, sizeof(git_submodule_cache))) == NULL)
+ return -1;
- if ((error = git_submodule__map(repo, submodules)) < 0)
+ if ((error = git_submodule__map(submodules, repo)) < 0)
goto done;
- if (!(error = git_vector_init(
- &snapshot, git_strmap_size(submodules), submodule_cmp))) {
-
- git_strmap_foreach_value(submodules, sm, {
+ if (!(error = git_vector_init(&snapshot,
+ git_submodule_cache_size(submodules),
+ submodule_cmp))) {
+ for (iter = GIT_HASHMAP_ITER_INIT;
+ git_submodule_cache_iterate(&iter, NULL, &sm, submodules) == 0; ) {
if ((error = git_vector_insert(&snapshot, sm)) < 0)
break;
+
GIT_REFCOUNT_INC(sm);
- });
+ }
}
if (error < 0)
@@ -668,12 +709,14 @@ int git_submodule_foreach(
done:
git_vector_foreach(&snapshot, i, sm)
git_submodule_free(sm);
- git_vector_free(&snapshot);
+ git_vector_dispose(&snapshot);
- git_strmap_foreach_value(submodules, sm, {
+ for (iter = GIT_HASHMAP_ITER_INIT;
+ git_submodule_cache_iterate(&iter, NULL, &sm, submodules) == 0; )
git_submodule_free(sm);
- });
- git_strmap_free(submodules);
+
+ git_submodule_cache_dispose(submodules);
+ git__free(submodules);
return error;
}
@@ -714,7 +757,6 @@ static int submodule_repo_init(
initopt.workdir_path = workdir.ptr;
initopt.flags |=
- GIT_REPOSITORY_INIT_NO_DOTGIT_DIR |
GIT_REPOSITORY_INIT_RELATIVE_GITLINK;
error = git_repository_init_ext(&subrepo, repodir.ptr, &initopt);
@@ -1246,7 +1288,6 @@ static int submodule_repo_create(
initopt.flags =
GIT_REPOSITORY_INIT_MKPATH |
GIT_REPOSITORY_INIT_NO_REINIT |
- GIT_REPOSITORY_INIT_NO_DOTGIT_DIR |
GIT_REPOSITORY_INIT_RELATIVE_GITLINK;
/* Workdir: path to sub-repo working directory */
@@ -1338,11 +1379,11 @@ int git_submodule_update(git_submodule *sm, int init, git_submodule_update_optio
/* Get the status of the submodule to determine if it is already initialized */
if ((error = git_submodule_status(&submodule_status, sm->repo, sm->name, GIT_SUBMODULE_IGNORE_UNSPECIFIED)) < 0)
goto done;
-
+
/* If the submodule is configured but hasn't been added, skip it */
if (submodule_status == GIT_SUBMODULE_STATUS_IN_CONFIG)
goto done;
-
+
/*
* If submodule work dir is not already initialized, check to see
* what we need to do (initialize, clone, return error...)
@@ -2049,7 +2090,7 @@ static int submodule_load_each(const git_config_entry *entry, void *payload)
{
lfc_data *data = payload;
const char *namestart, *property;
- git_strmap *map = data->map;
+ git_submodule_cache *cache = data->cache;
git_str name = GIT_STR_INIT;
git_submodule *sm;
int error, isvalid;
@@ -2080,7 +2121,7 @@ static int submodule_load_each(const git_config_entry *entry, void *payload)
* a new submodule, load the config and insert it. If it's
* already inserted, we've already loaded it, so we skip.
*/
- if (git_strmap_exists(map, name.ptr)) {
+ if (git_submodule_cache_contains(cache, name.ptr)) {
error = 0;
goto done;
}
@@ -2093,7 +2134,7 @@ static int submodule_load_each(const git_config_entry *entry, void *payload)
goto done;
}
- if ((error = git_strmap_set(map, sm->name, sm)) < 0)
+ if ((error = git_submodule_cache_put(cache, sm->name, sm)) < 0)
goto done;
error = 0;
diff --git a/src/libgit2/submodule.h b/src/libgit2/submodule.h
index 7fa98248620..2690d8dd9fe 100644
--- a/src/libgit2/submodule.h
+++ b/src/libgit2/submodule.h
@@ -12,6 +12,7 @@
#include "git2/submodule.h"
#include "git2/repository.h"
#include "futils.h"
+#include "hashmap.h"
/* Notes:
*
@@ -69,9 +70,9 @@
* - `repo` is the parent repository that contains this submodule.
* - `flags` after for internal use, tracking where this submodule has been
* found (head, index, config, workdir) and known status info, etc.
- * - `head_oid` is the SHA1 for the submodule path in the repo HEAD.
- * - `index_oid` is the SHA1 for the submodule recorded in the index.
- * - `wd_oid` is the SHA1 for the HEAD of the checked out submodule.
+ * - `head_oid` is the oid for the submodule path in the repo HEAD.
+ * - `index_oid` is the oid for the submodule recorded in the index.
+ * - `wd_oid` is the oid for the HEAD of the checked out submodule.
*
* If the submodule has been added to .gitmodules but not yet git added,
* then the `index_oid` will be zero but still marked valid. If the
@@ -116,15 +117,17 @@ enum {
#define GIT_SUBMODULE_STATUS__CLEAR_INTERNAL(S) \
((S) & ~(0xFFFFFFFFu << 20))
+GIT_HASHMAP_STR_STRUCT(git_submodule_cache, git_submodule *);
+
/* Initialize an external submodule cache for the provided repo. */
-extern int git_submodule_cache_init(git_strmap **out, git_repository *repo);
+extern int git_submodule_cache_init(git_submodule_cache **out, git_repository *repo);
/* Release the resources of the submodule cache. */
-extern int git_submodule_cache_free(git_strmap *cache);
+extern int git_submodule_cache_free(git_submodule_cache *cache);
/* Submodule lookup with an explicit cache */
extern int git_submodule__lookup_with_cache(
- git_submodule **out, git_repository *repo, const char *path, git_strmap *cache);
+ git_submodule **out, git_repository *repo, const char *path, git_submodule_cache *cache);
/* Internal status fn returns status and optionally the various OIDs */
extern int git_submodule__status(
@@ -145,10 +148,6 @@ extern int git_submodule_parse_ignore(
extern int git_submodule_parse_update(
git_submodule_update_t *out, const char *value);
-extern int git_submodule__map(
- git_repository *repo,
- git_strmap *map);
-
/**
* Check whether a submodule's name is valid.
*
diff --git a/src/libgit2/sysdir.h b/src/libgit2/sysdir.h
index 1d15bbf43dd..03f59e1de81 100644
--- a/src/libgit2/sysdir.h
+++ b/src/libgit2/sysdir.h
@@ -134,10 +134,12 @@ extern int git_sysdir_set(git_sysdir_t which, const char *paths);
*/
extern int git_sysdir_reset(void);
+#ifdef GIT_WIN32
/** Sets the registry system dir to a mock; for testing. */
extern int git_win32__set_registry_system_dir(const wchar_t *mock_sysdir);
/** Find the given system dir; for testing. */
extern int git_win32__find_system_dirs(git_str *out, const char *subdir);
+#endif
#endif
diff --git a/src/libgit2/tag.c b/src/libgit2/tag.c
index 562ec13eaed..cad9e416e5c 100644
--- a/src/libgit2/tag.c
+++ b/src/libgit2/tag.c
@@ -548,7 +548,7 @@ int git_tag_list_match(git_strarray *tag_names, const char *pattern, git_reposit
error = git_tag_foreach(repo, &tag_list_cb, (void *)&filter);
if (error < 0)
- git_vector_free(&taglist);
+ git_vector_dispose(&taglist);
tag_names->strings =
(char **)git_vector_detach(&tag_names->count, NULL, &taglist);
diff --git a/src/libgit2/threadstate.c b/src/libgit2/threadstate.c
deleted file mode 100644
index 9e3ef581849..00000000000
--- a/src/libgit2/threadstate.c
+++ /dev/null
@@ -1,84 +0,0 @@
-/*
- * Copyright (C) the libgit2 contributors. All rights reserved.
- *
- * This file is part of libgit2, distributed under the GNU GPL v2 with
- * a Linking Exception. For full terms see the included COPYING file.
- */
-
-#include "threadstate.h"
-#include "runtime.h"
-
-/**
- * Handle the thread-local state
- *
- * `git_threadstate_global_init` will be called as part
- * of `git_libgit2_init` (which itself must be called
- * before calling any other function in the library).
- *
- * This function allocates a TLS index to store the per-
- * thread state.
- *
- * Any internal method that requires thread-local state
- * will then call `git_threadstate_get()` which returns a
- * pointer to the thread-local state structure; this
- * structure is lazily allocated on each thread.
- *
- * This mechanism will register a shutdown handler
- * (`git_threadstate_global_shutdown`) which will free the
- * TLS index. This shutdown handler will be called by
- * `git_libgit2_shutdown`.
- */
-
-static git_tlsdata_key tls_key;
-
-static void threadstate_dispose(git_threadstate *threadstate)
-{
- if (!threadstate)
- return;
-
- if (threadstate->error_t.message != git_str__initstr)
- git__free(threadstate->error_t.message);
- threadstate->error_t.message = NULL;
-}
-
-static void GIT_SYSTEM_CALL threadstate_free(void *threadstate)
-{
- threadstate_dispose(threadstate);
- git__free(threadstate);
-}
-
-static void git_threadstate_global_shutdown(void)
-{
- git_threadstate *threadstate;
-
- threadstate = git_tlsdata_get(tls_key);
- git_tlsdata_set(tls_key, NULL);
-
- threadstate_dispose(threadstate);
- git__free(threadstate);
-
- git_tlsdata_dispose(tls_key);
-}
-
-int git_threadstate_global_init(void)
-{
- if (git_tlsdata_init(&tls_key, &threadstate_free) != 0)
- return -1;
-
- return git_runtime_shutdown_register(git_threadstate_global_shutdown);
-}
-
-git_threadstate *git_threadstate_get(void)
-{
- git_threadstate *threadstate;
-
- if ((threadstate = git_tlsdata_get(tls_key)) != NULL)
- return threadstate;
-
- if ((threadstate = git__calloc(1, sizeof(git_threadstate))) == NULL ||
- git_str_init(&threadstate->error_buf, 0) < 0)
- return NULL;
-
- git_tlsdata_set(tls_key, threadstate);
- return threadstate;
-}
diff --git a/src/libgit2/threadstate.h b/src/libgit2/threadstate.h
deleted file mode 100644
index f9e7ba7bfe0..00000000000
--- a/src/libgit2/threadstate.h
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * Copyright (C) the libgit2 contributors. All rights reserved.
- *
- * This file is part of libgit2, distributed under the GNU GPL v2 with
- * a Linking Exception. For full terms see the included COPYING file.
- */
-#ifndef INCLUDE_threadstate_h__
-#define INCLUDE_threadstate_h__
-
-#include "common.h"
-
-typedef struct {
- git_error *last_error;
- git_error error_t;
- git_str error_buf;
- char oid_fmt[GIT_OID_SHA1_HEXSIZE+1];
-} git_threadstate;
-
-extern int git_threadstate_global_init(void);
-extern git_threadstate *git_threadstate_get(void);
-
-#define GIT_THREADSTATE (git_threadstate_get())
-
-#endif
diff --git a/src/libgit2/trailer.c b/src/libgit2/trailer.c
index 4761c9922f2..c7579fb3b97 100644
--- a/src/libgit2/trailer.c
+++ b/src/libgit2/trailer.c
@@ -24,7 +24,7 @@ static const char *const git_generated_prefixes[] = {
static int is_blank_line(const char *str)
{
const char *s = str;
- while (*s && *s != '\n' && isspace(*s))
+ while (*s && *s != '\n' && git__isspace(*s))
s++;
return !*s || *s == '\n';
}
@@ -93,7 +93,7 @@ static bool find_separator(size_t *out, const char *line, const char *separators
return true;
}
- if (!whitespace_found && (isalnum(*c) || *c == '-'))
+ if (!whitespace_found && (git__isalnum(*c) || *c == '-'))
continue;
if (c != line && (*c == ' ' || *c == '\t')) {
whitespace_found = 1;
@@ -158,7 +158,7 @@ static size_t find_patch_start(const char *str)
const char *s;
for (s = str; *s; s = next_line(s)) {
- if (git__prefixcmp(s, "---") == 0)
+ if (git__prefixcmp(s, "---") == 0 && git__isspace(s[3]))
return s - str;
}
@@ -233,12 +233,12 @@ static size_t find_trailer_start(const char *buf, size_t len)
}
find_separator(&separator_pos, bol, TRAILER_SEPARATORS);
- if (separator_pos >= 1 && !isspace(bol[0])) {
+ if (separator_pos >= 1 && !git__isspace(bol[0])) {
trailer_lines++;
possible_continuation_lines = 0;
if (recognized_prefix)
continue;
- } else if (isspace(bol[0]))
+ } else if (git__isspace(bol[0]))
possible_continuation_lines++;
else {
non_trailer_lines++;
@@ -323,7 +323,7 @@ int git_message_trailers(git_message_trailer_array *trailer_arr, const char *mes
goto ret;
}
- if (isalnum(*ptr) || *ptr == '-') {
+ if (git__isalnum(*ptr) || *ptr == '-') {
/* legal key character */
NEXT(S_KEY);
}
diff --git a/src/libgit2/transaction.c b/src/libgit2/transaction.c
index ccffa9984cc..1965498c0da 100644
--- a/src/libgit2/transaction.c
+++ b/src/libgit2/transaction.c
@@ -8,7 +8,6 @@
#include "transaction.h"
#include "repository.h"
-#include "strmap.h"
#include "refdb.h"
#include "pool.h"
#include "reflog.h"
@@ -44,17 +43,23 @@ typedef struct {
remove :1;
} transaction_node;
+GIT_HASHMAP_STR_SETUP(git_transaction_nodemap, transaction_node *);
+
struct git_transaction {
transaction_t type;
git_repository *repo;
git_refdb *db;
git_config *cfg;
+ void *cfg_data;
- git_strmap *locks;
+ git_transaction_nodemap locks;
git_pool pool;
};
-int git_transaction_config_new(git_transaction **out, git_config *cfg)
+int git_transaction_config_new(
+ git_transaction **out,
+ git_config *cfg,
+ void *data)
{
git_transaction *tx;
@@ -66,6 +71,8 @@ int git_transaction_config_new(git_transaction **out, git_config *cfg)
tx->type = TRANSACTION_CONFIG;
tx->cfg = cfg;
+ tx->cfg_data = data;
+
*out = tx;
return 0;
}
@@ -88,11 +95,6 @@ int git_transaction_new(git_transaction **out, git_repository *repo)
goto on_error;
}
- if ((error = git_strmap_new(&tx->locks)) < 0) {
- error = -1;
- goto on_error;
- }
-
if ((error = git_repository_refdb(&tx->db, repo)) < 0)
goto on_error;
@@ -124,7 +126,7 @@ int git_transaction_lock_ref(git_transaction *tx, const char *refname)
if ((error = git_refdb_lock(&node->payload, tx->db, refname)) < 0)
return error;
- if ((error = git_strmap_set(tx->locks, node->name, node)) < 0)
+ if ((error = git_transaction_nodemap_put(&tx->locks, node->name, node)) < 0)
goto cleanup;
return 0;
@@ -138,8 +140,11 @@ int git_transaction_lock_ref(git_transaction *tx, const char *refname)
static int find_locked(transaction_node **out, git_transaction *tx, const char *refname)
{
transaction_node *node;
+ int error;
+
+ error = git_transaction_nodemap_get(&node, &tx->locks, refname);
- if ((node = git_strmap_get(tx->locks, refname)) == NULL) {
+ if (error != 0) {
git_error_set(GIT_ERROR_REFERENCE, "the specified reference is not locked");
return GIT_ENOTFOUND;
}
@@ -328,18 +333,20 @@ static int update_target(git_refdb *db, transaction_node *node)
int git_transaction_commit(git_transaction *tx)
{
transaction_node *node;
+ git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
int error = 0;
GIT_ASSERT_ARG(tx);
if (tx->type == TRANSACTION_CONFIG) {
- error = git_config_unlock(tx->cfg, true);
+ error = git_config_unlock(tx->cfg, tx->cfg_data, true);
tx->cfg = NULL;
+ tx->cfg_data = NULL;
return error;
}
- git_strmap_foreach_value(tx->locks, node, {
+ while (git_transaction_nodemap_iterate(&iter, NULL, &node, &tx->locks) == 0) {
if (node->reflog) {
if ((error = tx->db->backend->reflog_write(tx->db->backend, node->reflog)) < 0)
return error;
@@ -355,7 +362,7 @@ int git_transaction_commit(git_transaction *tx)
if ((error = update_target(tx->db, node)) < 0)
return error;
}
- });
+ }
return 0;
}
@@ -364,30 +371,29 @@ void git_transaction_free(git_transaction *tx)
{
transaction_node *node;
git_pool pool;
+ git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
if (!tx)
return;
if (tx->type == TRANSACTION_CONFIG) {
- if (tx->cfg) {
- git_config_unlock(tx->cfg, false);
- git_config_free(tx->cfg);
- }
+ if (tx->cfg)
+ git_config_unlock(tx->cfg, tx->cfg_data, false);
git__free(tx);
return;
}
/* start by unlocking the ones we've left hanging, if any */
- git_strmap_foreach_value(tx->locks, node, {
+ while (git_transaction_nodemap_iterate(&iter, NULL, &node, &tx->locks) == 0) {
if (node->committed)
continue;
git_refdb_unlock(tx->db, node->payload, false, false, NULL, NULL, NULL);
- });
+ }
git_refdb_free(tx->db);
- git_strmap_free(tx->locks);
+ git_transaction_nodemap_dispose(&tx->locks);
/* tx is inside the pool, so we need to extract the data */
memcpy(&pool, &tx->pool, sizeof(git_pool));
diff --git a/src/libgit2/transaction.h b/src/libgit2/transaction.h
index 780c068303e..cb26017ae9f 100644
--- a/src/libgit2/transaction.h
+++ b/src/libgit2/transaction.h
@@ -9,6 +9,9 @@
#include "common.h"
-int git_transaction_config_new(git_transaction **out, git_config *cfg);
+int git_transaction_config_new(
+ git_transaction **out,
+ git_config *cfg,
+ void *data);
#endif
diff --git a/src/libgit2/transport.c b/src/libgit2/transport.c
index 640ccacaee3..c31fca3a490 100644
--- a/src/libgit2/transport.c
+++ b/src/libgit2/transport.c
@@ -22,6 +22,7 @@ typedef struct transport_definition {
static git_smart_subtransport_definition http_subtransport_definition = { git_smart_subtransport_http, 1, NULL };
static git_smart_subtransport_definition git_subtransport_definition = { git_smart_subtransport_git, 0, NULL };
+
#ifdef GIT_SSH
static git_smart_subtransport_definition ssh_subtransport_definition = { git_smart_subtransport_ssh, 0, NULL };
#endif
@@ -33,11 +34,13 @@ static transport_definition transports[] = {
{ "http://", git_transport_smart, &http_subtransport_definition },
{ "https://", git_transport_smart, &http_subtransport_definition },
{ "file://", git_transport_local, NULL },
+
#ifdef GIT_SSH
{ "ssh://", git_transport_smart, &ssh_subtransport_definition },
{ "ssh+git://", git_transport_smart, &ssh_subtransport_definition },
{ "git+ssh://", git_transport_smart, &ssh_subtransport_definition },
#endif
+
{ NULL, 0, 0 }
};
@@ -200,7 +203,7 @@ int git_transport_unregister(const char *scheme)
git__free(d);
if (!custom_transports.length)
- git_vector_free(&custom_transports);
+ git_vector_dispose(&custom_transports);
error = 0;
goto done;
diff --git a/src/libgit2/transports/auth.h b/src/libgit2/transports/auth.h
index 64680cc5358..9f6f8fd3b2d 100644
--- a/src/libgit2/transports/auth.h
+++ b/src/libgit2/transports/auth.h
@@ -9,8 +9,7 @@
#define INCLUDE_transports_auth_h__
#include "common.h"
-
-#include "netops.h"
+#include "net.h"
typedef enum {
GIT_HTTP_AUTH_BASIC = 1,
diff --git a/src/libgit2/transports/auth_negotiate.c b/src/libgit2/transports/auth_gssapi.c
similarity index 76%
rename from src/libgit2/transports/auth_negotiate.c
rename to src/libgit2/transports/auth_gssapi.c
index 6380504be7e..647f3ce3fa0 100644
--- a/src/libgit2/transports/auth_negotiate.c
+++ b/src/libgit2/transports/auth_gssapi.c
@@ -7,26 +7,27 @@
#include "auth_negotiate.h"
-#if defined(GIT_GSSAPI) || defined(GIT_GSSFRAMEWORK)
+#if defined(GIT_AUTH_NEGOTIATE_GSSAPI) || \
+ defined(GIT_AUTH_NEGOTIATE_GSSFRAMEWORK)
#include "git2.h"
#include "auth.h"
#include "git2/sys/credential.h"
-#ifdef GIT_GSSFRAMEWORK
-#import
-#elif defined(GIT_GSSAPI)
-#include
-#include
+#if defined(GIT_AUTH_NEGOTIATE_GSSFRAMEWORK)
+# import
+#elif defined(GIT_AUTH_NEGOTIATE_GSSAPI)
+# include
+# include
#endif
-static gss_OID_desc negotiate_oid_spnego =
+static gss_OID_desc gssapi_oid_spnego =
{ 6, (void *) "\x2b\x06\x01\x05\x05\x02" };
-static gss_OID_desc negotiate_oid_krb5 =
+static gss_OID_desc gssapi_oid_krb5 =
{ 9, (void *) "\x2a\x86\x48\x86\xf7\x12\x01\x02\x02" };
-static gss_OID negotiate_oids[] =
- { &negotiate_oid_spnego, &negotiate_oid_krb5, NULL };
+static gss_OID gssapi_oids[] =
+ { &gssapi_oid_spnego, &gssapi_oid_krb5, NULL };
typedef struct {
git_http_auth_context parent;
@@ -36,9 +37,9 @@ typedef struct {
char *challenge;
gss_ctx_id_t gss_context;
gss_OID oid;
-} http_auth_negotiate_context;
+} http_auth_gssapi_context;
-static void negotiate_err_set(
+static void gssapi_err_set(
OM_uint32 status_major,
OM_uint32 status_minor,
const char *message)
@@ -58,11 +59,11 @@ static void negotiate_err_set(
}
}
-static int negotiate_set_challenge(
+static int gssapi_set_challenge(
git_http_auth_context *c,
const char *challenge)
{
- http_auth_negotiate_context *ctx = (http_auth_negotiate_context *)c;
+ http_auth_gssapi_context *ctx = (http_auth_gssapi_context *)c;
GIT_ASSERT_ARG(ctx);
GIT_ASSERT_ARG(challenge);
@@ -76,7 +77,7 @@ static int negotiate_set_challenge(
return 0;
}
-static void negotiate_context_dispose(http_auth_negotiate_context *ctx)
+static void gssapi_context_dispose(http_auth_gssapi_context *ctx)
{
OM_uint32 status_minor;
@@ -92,12 +93,12 @@ static void negotiate_context_dispose(http_auth_negotiate_context *ctx)
ctx->challenge = NULL;
}
-static int negotiate_next_token(
+static int gssapi_next_token(
git_str *buf,
git_http_auth_context *c,
git_credential *cred)
{
- http_auth_negotiate_context *ctx = (http_auth_negotiate_context *)c;
+ http_auth_gssapi_context *ctx = (http_auth_gssapi_context *)c;
OM_uint32 status_major, status_minor;
gss_buffer_desc target_buffer = GSS_C_EMPTY_BUFFER,
input_token = GSS_C_EMPTY_BUFFER,
@@ -126,7 +127,7 @@ static int negotiate_next_token(
GSS_C_NT_HOSTBASED_SERVICE, &server);
if (GSS_ERROR(status_major)) {
- negotiate_err_set(status_major, status_minor,
+ gssapi_err_set(status_major, status_minor,
"could not parse principal");
error = -1;
goto done;
@@ -152,10 +153,10 @@ static int negotiate_next_token(
input_token.length = input_buf.size;
input_token_ptr = &input_token;
} else if (ctx->gss_context != GSS_C_NO_CONTEXT) {
- negotiate_context_dispose(ctx);
+ gssapi_context_dispose(ctx);
}
- mech = &negotiate_oid_spnego;
+ mech = &gssapi_oid_spnego;
status_major = gss_init_sec_context(
&status_minor,
@@ -173,14 +174,14 @@ static int negotiate_next_token(
NULL);
if (GSS_ERROR(status_major)) {
- negotiate_err_set(status_major, status_minor, "negotiate failure");
+ gssapi_err_set(status_major, status_minor, "negotiate failure");
error = -1;
goto done;
}
/* This message merely told us auth was complete; we do not respond. */
if (status_major == GSS_S_COMPLETE) {
- negotiate_context_dispose(ctx);
+ gssapi_context_dispose(ctx);
ctx->complete = 1;
goto done;
}
@@ -204,20 +205,20 @@ static int negotiate_next_token(
return error;
}
-static int negotiate_is_complete(git_http_auth_context *c)
+static int gssapi_is_complete(git_http_auth_context *c)
{
- http_auth_negotiate_context *ctx = (http_auth_negotiate_context *)c;
+ http_auth_gssapi_context *ctx = (http_auth_gssapi_context *)c;
GIT_ASSERT_ARG(ctx);
return (ctx->complete == 1);
}
-static void negotiate_context_free(git_http_auth_context *c)
+static void gssapi_context_free(git_http_auth_context *c)
{
- http_auth_negotiate_context *ctx = (http_auth_negotiate_context *)c;
+ http_auth_gssapi_context *ctx = (http_auth_gssapi_context *)c;
- negotiate_context_dispose(ctx);
+ gssapi_context_dispose(ctx);
ctx->configured = 0;
ctx->complete = 0;
@@ -226,8 +227,8 @@ static void negotiate_context_free(git_http_auth_context *c)
git__free(ctx);
}
-static int negotiate_init_context(
- http_auth_negotiate_context *ctx,
+static int gssapi_init_context(
+ http_auth_gssapi_context *ctx,
const git_net_url *url)
{
OM_uint32 status_major, status_minor;
@@ -239,13 +240,13 @@ static int negotiate_init_context(
status_major = gss_indicate_mechs(&status_minor, &mechanism_list);
if (GSS_ERROR(status_major)) {
- negotiate_err_set(status_major, status_minor,
+ gssapi_err_set(status_major, status_minor,
"could not query mechanisms");
return -1;
}
if (mechanism_list) {
- for (oid = negotiate_oids; *oid; oid++) {
+ for (oid = gssapi_oids; *oid; oid++) {
for (i = 0; i < mechanism_list->count; i++) {
item = &mechanism_list->elements[i];
@@ -285,14 +286,14 @@ int git_http_auth_negotiate(
git_http_auth_context **out,
const git_net_url *url)
{
- http_auth_negotiate_context *ctx;
+ http_auth_gssapi_context *ctx;
*out = NULL;
- ctx = git__calloc(1, sizeof(http_auth_negotiate_context));
+ ctx = git__calloc(1, sizeof(http_auth_gssapi_context));
GIT_ERROR_CHECK_ALLOC(ctx);
- if (negotiate_init_context(ctx, url) < 0) {
+ if (gssapi_init_context(ctx, url) < 0) {
git__free(ctx);
return -1;
}
@@ -300,15 +301,14 @@ int git_http_auth_negotiate(
ctx->parent.type = GIT_HTTP_AUTH_NEGOTIATE;
ctx->parent.credtypes = GIT_CREDENTIAL_DEFAULT;
ctx->parent.connection_affinity = 1;
- ctx->parent.set_challenge = negotiate_set_challenge;
- ctx->parent.next_token = negotiate_next_token;
- ctx->parent.is_complete = negotiate_is_complete;
- ctx->parent.free = negotiate_context_free;
+ ctx->parent.set_challenge = gssapi_set_challenge;
+ ctx->parent.next_token = gssapi_next_token;
+ ctx->parent.is_complete = gssapi_is_complete;
+ ctx->parent.free = gssapi_context_free;
*out = (git_http_auth_context *)ctx;
return 0;
}
-#endif /* GIT_GSSAPI */
-
+#endif /* GIT_AUTH_NEGOTIATE_GSS... */
diff --git a/src/libgit2/transports/auth_negotiate.h b/src/libgit2/transports/auth_negotiate.h
index 34aff295b13..e528b402a9a 100644
--- a/src/libgit2/transports/auth_negotiate.h
+++ b/src/libgit2/transports/auth_negotiate.h
@@ -12,7 +12,7 @@
#include "git2.h"
#include "auth.h"
-#if defined(GIT_GSSAPI) || defined(GIT_GSSFRAMEWORK)
+#ifdef GIT_AUTH_NEGOTIATE
extern int git_http_auth_negotiate(
git_http_auth_context **out,
@@ -22,6 +22,6 @@ extern int git_http_auth_negotiate(
#define git_http_auth_negotiate git_http_auth_dummy
-#endif /* GIT_GSSAPI */
+#endif /* GIT_AUTH_NEGOTIATE */
#endif
diff --git a/src/libgit2/transports/auth_ntlm.h b/src/libgit2/transports/auth_ntlm.h
index 40689498cae..d83d1c4cd4d 100644
--- a/src/libgit2/transports/auth_ntlm.h
+++ b/src/libgit2/transports/auth_ntlm.h
@@ -13,15 +13,7 @@
/* NTLM requires a full request/challenge/response */
#define GIT_AUTH_STEPS_NTLM 2
-#ifdef GIT_NTLM
-
-#if defined(GIT_OPENSSL)
-# define CRYPT_OPENSSL
-#elif defined(GIT_MBEDTLS)
-# define CRYPT_MBEDTLS
-#elif defined(GIT_SECURE_TRANSPORT)
-# define CRYPT_COMMONCRYPTO
-#endif
+#if defined(GIT_AUTH_NTLM)
extern int git_http_auth_ntlm(
git_http_auth_context **out,
@@ -31,7 +23,7 @@ extern int git_http_auth_ntlm(
#define git_http_auth_ntlm git_http_auth_dummy
-#endif /* GIT_NTLM */
+#endif /* GIT_AUTH_NTLM */
#endif
diff --git a/src/libgit2/transports/auth_ntlm.c b/src/libgit2/transports/auth_ntlmclient.c
similarity index 87%
rename from src/libgit2/transports/auth_ntlm.c
rename to src/libgit2/transports/auth_ntlmclient.c
index f49ce101a56..b8c6e2353c1 100644
--- a/src/libgit2/transports/auth_ntlm.c
+++ b/src/libgit2/transports/auth_ntlmclient.c
@@ -12,7 +12,7 @@
#include "auth.h"
#include "git2/sys/credential.h"
-#ifdef GIT_NTLM
+#ifdef GIT_AUTH_NTLM_BUILTIN
#include "ntlmclient.h"
@@ -23,7 +23,7 @@ typedef struct {
bool complete;
} http_auth_ntlm_context;
-static int ntlm_set_challenge(
+static int ntlmclient_set_challenge(
git_http_auth_context *c,
const char *challenge)
{
@@ -40,7 +40,7 @@ static int ntlm_set_challenge(
return 0;
}
-static int ntlm_set_credentials(http_auth_ntlm_context *ctx, git_credential *_cred)
+static int ntlmclient_set_credentials(http_auth_ntlm_context *ctx, git_credential *_cred)
{
git_credential_userpass_plaintext *cred;
const char *sep, *username;
@@ -76,7 +76,7 @@ static int ntlm_set_credentials(http_auth_ntlm_context *ctx, git_credential *_cr
return error;
}
-static int ntlm_next_token(
+static int ntlmclient_next_token(
git_str *buf,
git_http_auth_context *c,
git_credential *cred)
@@ -104,7 +104,7 @@ static int ntlm_next_token(
*/
ctx->complete = true;
- if (cred && ntlm_set_credentials(ctx, cred) != 0)
+ if (cred && ntlmclient_set_credentials(ctx, cred) != 0)
goto done;
if (challenge_len < 4) {
@@ -162,7 +162,7 @@ static int ntlm_next_token(
return error;
}
-static int ntlm_is_complete(git_http_auth_context *c)
+static int ntlmclient_is_complete(git_http_auth_context *c)
{
http_auth_ntlm_context *ctx = (http_auth_ntlm_context *)c;
@@ -170,7 +170,7 @@ static int ntlm_is_complete(git_http_auth_context *c)
return (ctx->complete == true);
}
-static void ntlm_context_free(git_http_auth_context *c)
+static void ntlmclient_context_free(git_http_auth_context *c)
{
http_auth_ntlm_context *ctx = (http_auth_ntlm_context *)c;
@@ -179,7 +179,7 @@ static void ntlm_context_free(git_http_auth_context *c)
git__free(ctx);
}
-static int ntlm_init_context(
+static int ntlmclient_init_context(
http_auth_ntlm_context *ctx,
const git_net_url *url)
{
@@ -206,7 +206,7 @@ int git_http_auth_ntlm(
ctx = git__calloc(1, sizeof(http_auth_ntlm_context));
GIT_ERROR_CHECK_ALLOC(ctx);
- if (ntlm_init_context(ctx, url) < 0) {
+ if (ntlmclient_init_context(ctx, url) < 0) {
git__free(ctx);
return -1;
}
@@ -214,14 +214,14 @@ int git_http_auth_ntlm(
ctx->parent.type = GIT_HTTP_AUTH_NTLM;
ctx->parent.credtypes = GIT_CREDENTIAL_USERPASS_PLAINTEXT;
ctx->parent.connection_affinity = 1;
- ctx->parent.set_challenge = ntlm_set_challenge;
- ctx->parent.next_token = ntlm_next_token;
- ctx->parent.is_complete = ntlm_is_complete;
- ctx->parent.free = ntlm_context_free;
+ ctx->parent.set_challenge = ntlmclient_set_challenge;
+ ctx->parent.next_token = ntlmclient_next_token;
+ ctx->parent.is_complete = ntlmclient_is_complete;
+ ctx->parent.free = ntlmclient_context_free;
*out = (git_http_auth_context *)ctx;
return 0;
}
-#endif /* GIT_NTLM */
+#endif /* GIT_AUTH_NTLM_BUILTIN */
diff --git a/src/libgit2/transports/auth_sspi.c b/src/libgit2/transports/auth_sspi.c
new file mode 100644
index 00000000000..f8269365d7f
--- /dev/null
+++ b/src/libgit2/transports/auth_sspi.c
@@ -0,0 +1,341 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include "auth_ntlm.h"
+#include "auth_negotiate.h"
+
+#ifdef GIT_WIN32
+
+#define SECURITY_WIN32
+
+#include "git2.h"
+#include "auth.h"
+#include "git2/sys/credential.h"
+
+#include
+#include
+
+typedef struct {
+ git_http_auth_context parent;
+ wchar_t *target;
+
+ const char *package_name;
+ size_t package_name_len;
+ wchar_t *package_name_w;
+ SecPkgInfoW *package_info;
+ SEC_WINNT_AUTH_IDENTITY_W identity;
+ CredHandle cred;
+ CtxtHandle context;
+
+ int has_identity : 1,
+ has_credentials : 1,
+ has_context : 1,
+ complete : 1;
+ git_str challenge;
+} http_auth_sspi_context;
+
+static void sspi_reset_context(http_auth_sspi_context *ctx)
+{
+ if (ctx->has_identity) {
+ git__free(ctx->identity.User);
+ git__free(ctx->identity.Domain);
+ git__free(ctx->identity.Password);
+
+ memset(&ctx->identity, 0, sizeof(SEC_WINNT_AUTH_IDENTITY_W));
+
+ ctx->has_identity = 0;
+ }
+
+ if (ctx->has_credentials) {
+ FreeCredentialsHandle(&ctx->cred);
+ memset(&ctx->cred, 0, sizeof(CredHandle));
+
+ ctx->has_credentials = 0;
+ }
+
+ if (ctx->has_context) {
+ DeleteSecurityContext(&ctx->context);
+ memset(&ctx->context, 0, sizeof(CtxtHandle));
+
+ ctx->has_context = 0;
+ }
+
+ ctx->complete = 0;
+
+ git_str_dispose(&ctx->challenge);
+}
+
+static int sspi_set_challenge(
+ git_http_auth_context *c,
+ const char *challenge)
+{
+ http_auth_sspi_context *ctx = (http_auth_sspi_context *)c;
+ size_t challenge_len = strlen(challenge);
+
+ git_str_clear(&ctx->challenge);
+
+ if (strncmp(challenge, ctx->package_name, ctx->package_name_len) != 0) {
+ git_error_set(GIT_ERROR_NET, "invalid %s challenge from server", ctx->package_name);
+ return -1;
+ }
+
+ /*
+ * A package type indicator without a base64 payload indicates the
+ * mechanism; it's not an actual challenge. Ignore it.
+ */
+ if (challenge[ctx->package_name_len] == 0) {
+ return 0;
+ } else if (challenge[ctx->package_name_len] != ' ') {
+ git_error_set(GIT_ERROR_NET, "invalid %s challenge from server", ctx->package_name);
+ return -1;
+ }
+
+ if (git_str_decode_base64(&ctx->challenge,
+ challenge + (ctx->package_name_len + 1),
+ challenge_len - (ctx->package_name_len + 1)) < 0) {
+ git_error_set(GIT_ERROR_NET, "invalid %s challenge from server", ctx->package_name);
+ return -1;
+ }
+
+ GIT_ASSERT(ctx->challenge.size <= ULONG_MAX);
+ return 0;
+}
+
+static int create_identity(
+ SEC_WINNT_AUTH_IDENTITY_W **out,
+ http_auth_sspi_context *ctx,
+ git_credential *cred)
+{
+ git_credential_userpass_plaintext *userpass;
+ wchar_t *username = NULL, *domain = NULL, *password = NULL;
+ int username_len = 0, domain_len = 0, password_len = 0;
+ const char *sep;
+
+ if (cred->credtype == GIT_CREDENTIAL_DEFAULT) {
+ *out = NULL;
+ return 0;
+ }
+
+ if (cred->credtype != GIT_CREDENTIAL_USERPASS_PLAINTEXT) {
+ git_error_set(GIT_ERROR_NET, "unknown credential type: %d", cred->credtype);
+ return -1;
+ }
+
+ userpass = (git_credential_userpass_plaintext *)cred;
+
+ if ((sep = strchr(userpass->username, '\\')) != NULL) {
+ GIT_ASSERT(sep - userpass->username < INT_MAX);
+
+ username_len = git_utf8_to_16_alloc(&username, sep + 1);
+ domain_len = git_utf8_to_16_alloc_with_len(&domain,
+ userpass->username, (int)(sep - userpass->username));
+ } else {
+ username_len = git_utf8_to_16_alloc(&username,
+ userpass->username);
+ }
+
+ password_len = git_utf8_to_16_alloc(&password, userpass->password);
+
+ if (username_len < 0 || domain_len < 0 || password_len < 0) {
+ git__free(username);
+ git__free(domain);
+ git__free(password);
+ return -1;
+ }
+
+ ctx->identity.Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;
+ ctx->identity.User = username;
+ ctx->identity.UserLength = (unsigned long)username_len;
+ ctx->identity.Password = password;
+ ctx->identity.PasswordLength = (unsigned long)password_len;
+ ctx->identity.Domain = domain;
+ ctx->identity.DomainLength = (unsigned long)domain_len;
+
+ ctx->has_identity = 1;
+
+ *out = &ctx->identity;
+
+ return 0;
+}
+
+static int sspi_next_token(
+ git_str *buf,
+ git_http_auth_context *c,
+ git_credential *cred)
+{
+ http_auth_sspi_context *ctx = (http_auth_sspi_context *)c;
+ SEC_WINNT_AUTH_IDENTITY_W *identity = NULL;
+ TimeStamp timestamp;
+ DWORD context_flags;
+ SecBuffer input_buf = { 0, SECBUFFER_TOKEN, NULL };
+ SecBuffer output_buf = { 0, SECBUFFER_TOKEN, NULL };
+ SecBufferDesc input_buf_desc = { SECBUFFER_VERSION, 1, &input_buf };
+ SecBufferDesc output_buf_desc = { SECBUFFER_VERSION, 1, &output_buf };
+ SECURITY_STATUS status;
+
+ if (ctx->complete)
+ sspi_reset_context(ctx);
+
+ if (!ctx->has_context) {
+ if (create_identity(&identity, ctx, cred) < 0)
+ return -1;
+
+ status = AcquireCredentialsHandleW(NULL, ctx->package_name_w,
+ SECPKG_CRED_BOTH, NULL, identity, NULL,
+ NULL, &ctx->cred, ×tamp);
+
+ if (status != SEC_E_OK) {
+ git_error_set(GIT_ERROR_OS, "could not acquire credentials");
+ return -1;
+ }
+
+ ctx->has_credentials = 1;
+ }
+
+ context_flags = ISC_REQ_ALLOCATE_MEMORY |
+ ISC_REQ_CONFIDENTIALITY |
+ ISC_REQ_MUTUAL_AUTH;
+
+ if (ctx->challenge.size > 0) {
+ input_buf.BufferType = SECBUFFER_TOKEN;
+ input_buf.cbBuffer = (unsigned long)ctx->challenge.size;
+ input_buf.pvBuffer = ctx->challenge.ptr;
+ }
+
+ status = InitializeSecurityContextW(&ctx->cred,
+ ctx->has_context ? &ctx->context : NULL,
+ ctx->target,
+ context_flags,
+ 0,
+ SECURITY_NETWORK_DREP,
+ ctx->has_context ? &input_buf_desc : NULL,
+ 0,
+ ctx->has_context ? NULL : &ctx->context,
+ &output_buf_desc,
+ &context_flags,
+ NULL);
+
+ if (status == SEC_I_COMPLETE_AND_CONTINUE ||
+ status == SEC_I_COMPLETE_NEEDED)
+ status = CompleteAuthToken(&ctx->context, &output_buf_desc);
+
+ if (status == SEC_E_OK) {
+ ctx->complete = 1;
+ } else if (status != SEC_I_CONTINUE_NEEDED) {
+ git_error_set(GIT_ERROR_OS, "could not initialize security context");
+ return -1;
+ }
+
+ ctx->has_context = 1;
+ git_str_clear(&ctx->challenge);
+
+ if (output_buf.cbBuffer > 0) {
+ git_str_put(buf, ctx->package_name, ctx->package_name_len);
+ git_str_putc(buf, ' ');
+ git_str_encode_base64(buf, output_buf.pvBuffer, output_buf.cbBuffer);
+
+ FreeContextBuffer(output_buf.pvBuffer);
+
+ if (git_str_oom(buf))
+ return -1;
+ }
+
+ return 0;
+}
+
+static int sspi_is_complete(git_http_auth_context *c)
+{
+ http_auth_sspi_context *ctx = (http_auth_sspi_context *)c;
+
+ return ctx->complete;
+}
+
+static void sspi_context_free(git_http_auth_context *c)
+{
+ http_auth_sspi_context *ctx = (http_auth_sspi_context *)c;
+
+ sspi_reset_context(ctx);
+
+ FreeContextBuffer(ctx->package_info);
+ git__free(ctx->target);
+ git__free(ctx);
+}
+
+static int sspi_init_context(
+ git_http_auth_context **out,
+ git_http_auth_t type,
+ const git_net_url *url)
+{
+ http_auth_sspi_context *ctx;
+ git_str target = GIT_STR_INIT;
+
+ *out = NULL;
+
+ ctx = git__calloc(1, sizeof(http_auth_sspi_context));
+ GIT_ERROR_CHECK_ALLOC(ctx);
+
+ switch (type) {
+ case GIT_HTTP_AUTH_NTLM:
+ ctx->package_name = "NTLM";
+ ctx->package_name_len = CONST_STRLEN("NTLM");
+ ctx->package_name_w = L"NTLM";
+ ctx->parent.credtypes = GIT_CREDENTIAL_USERPASS_PLAINTEXT |
+ GIT_CREDENTIAL_DEFAULT;
+ break;
+ case GIT_HTTP_AUTH_NEGOTIATE:
+ ctx->package_name = "Negotiate";
+ ctx->package_name_len = CONST_STRLEN("Negotiate");
+ ctx->package_name_w = L"Negotiate";
+ ctx->parent.credtypes = GIT_CREDENTIAL_DEFAULT;
+ break;
+ default:
+ git_error_set(GIT_ERROR_NET, "unknown SSPI auth type: %d", ctx->parent.type);
+ git__free(ctx);
+ return -1;
+ }
+
+ if (QuerySecurityPackageInfoW(ctx->package_name_w, &ctx->package_info) != SEC_E_OK) {
+ git_error_set(GIT_ERROR_OS, "could not query security package");
+ git__free(ctx);
+ return -1;
+ }
+
+ if (git_str_printf(&target, "http/%s", url->host) < 0 ||
+ git_utf8_to_16_alloc(&ctx->target, target.ptr) < 0) {
+ FreeContextBuffer(ctx->package_info);
+ git__free(ctx);
+ return -1;
+ }
+
+ ctx->parent.type = type;
+ ctx->parent.connection_affinity = 1;
+ ctx->parent.set_challenge = sspi_set_challenge;
+ ctx->parent.next_token = sspi_next_token;
+ ctx->parent.is_complete = sspi_is_complete;
+ ctx->parent.free = sspi_context_free;
+
+ *out = (git_http_auth_context *)ctx;
+
+ git_str_dispose(&target);
+ return 0;
+}
+
+int git_http_auth_negotiate(
+ git_http_auth_context **out,
+ const git_net_url *url)
+{
+ return sspi_init_context(out, GIT_HTTP_AUTH_NEGOTIATE, url);
+}
+
+int git_http_auth_ntlm(
+ git_http_auth_context **out,
+ const git_net_url *url)
+{
+ return sspi_init_context(out, GIT_HTTP_AUTH_NTLM, url);
+}
+
+#endif /* GIT_WIN32 */
diff --git a/src/libgit2/transports/credential.c b/src/libgit2/transports/credential.c
index 6e00b028243..b47bd63a198 100644
--- a/src/libgit2/transports/credential.c
+++ b/src/libgit2/transports/credential.c
@@ -204,7 +204,7 @@ int git_credential_ssh_key_memory_new(
const char *privatekey,
const char *passphrase)
{
-#ifdef GIT_SSH_MEMORY_CREDENTIALS
+#ifdef GIT_SSH_LIBSSH2_MEMORY_CREDENTIALS
return git_credential_ssh_key_type_new(
cred,
username,
diff --git a/src/libgit2/transports/git.c b/src/libgit2/transports/git.c
index 591e2ab0352..53611f2a7a6 100644
--- a/src/libgit2/transports/git.c
+++ b/src/libgit2/transports/git.c
@@ -7,7 +7,7 @@
#include "common.h"
-#include "netops.h"
+#include "net.h"
#include "stream.h"
#include "streams/socket.h"
#include "git2/sys/transport.h"
@@ -95,22 +95,21 @@ static int git_proto_stream_read(
size_t buf_size,
size_t *bytes_read)
{
- int error;
git_proto_stream *s = (git_proto_stream *)stream;
- gitno_buffer buf;
+ ssize_t ret;
+ int error;
*bytes_read = 0;
if (!s->sent_command && (error = send_command(s)) < 0)
return error;
- gitno_buffer_setup_fromstream(s->io, &buf, buffer, buf_size);
+ ret = git_stream_read(s->io, buffer, min(buf_size, INT_MAX));
- if ((error = gitno_recv(&buf)) < 0)
- return error;
-
- *bytes_read = buf.offset;
+ if (ret < 0)
+ return -1;
+ *bytes_read = (size_t)ret;
return 0;
}
diff --git a/src/libgit2/transports/http.c b/src/libgit2/transports/http.c
index cda76ae6199..923a825fa30 100644
--- a/src/libgit2/transports/http.c
+++ b/src/libgit2/transports/http.c
@@ -7,11 +7,9 @@
#include "common.h"
-#ifndef GIT_WINHTTP
+#ifndef GIT_HTTPS_WINHTTP
-#include "http_parser.h"
#include "net.h"
-#include "netops.h"
#include "remote.h"
#include "smart.h"
#include "auth.h"
@@ -335,10 +333,16 @@ static int lookup_proxy(
return 0;
}
- if (!proxy ||
- (error = git_net_url_parse(&transport->proxy.url, proxy)) < 0)
+ if (!proxy || !*proxy ||
+ (error = git_net_url_parse_http(&transport->proxy.url, proxy)) < 0)
goto done;
+ if (!git_net_url_valid(&transport->proxy.url)) {
+ git_error_set(GIT_ERROR_HTTP, "invalid URL: '%s'", proxy);
+ error = -1;
+ goto done;
+ }
+
*out_use = true;
done:
@@ -758,4 +762,4 @@ int git_smart_subtransport_http(git_smart_subtransport **out, git_transport *own
return 0;
}
-#endif /* !GIT_WINHTTP */
+#endif /* !GIT_HTTPS_WINHTTP */
diff --git a/src/libgit2/transports/http.h b/src/libgit2/transports/http.h
index 8e8e7226ed2..7410202a820 100644
--- a/src/libgit2/transports/http.h
+++ b/src/libgit2/transports/http.h
@@ -15,14 +15,4 @@
extern bool git_http__expect_continue;
-GIT_INLINE(int) git_http__user_agent(git_str *buf)
-{
- const char *ua = git_libgit2__user_agent();
-
- if (!ua)
- ua = "libgit2 " LIBGIT2_VERSION;
-
- return git_str_printf(buf, "git/2.0 (%s)", ua);
-}
-
#endif
diff --git a/src/libgit2/transports/httpclient.c b/src/libgit2/transports/httpclient.c
index 0ad6cd4dcb9..e25e0a73a6c 100644
--- a/src/libgit2/transports/httpclient.c
+++ b/src/libgit2/transports/httpclient.c
@@ -7,7 +7,7 @@
#include "common.h"
#include "git2.h"
-#include "http_parser.h"
+
#include "vector.h"
#include "trace.h"
#include "httpclient.h"
@@ -21,6 +21,7 @@
#include "streams/socket.h"
#include "streams/tls.h"
#include "auth.h"
+#include "httpparser.h"
static git_http_auth_scheme auth_schemes[] = {
{ GIT_HTTP_AUTH_NEGOTIATE, "Negotiate", GIT_CREDENTIAL_DEFAULT, git_http_auth_negotiate },
@@ -108,7 +109,7 @@ struct git_http_client {
git_http_server_t current_server;
http_client_state state;
- http_parser parser;
+ git_http_parser parser;
git_http_server server;
git_http_server proxy;
@@ -154,7 +155,7 @@ void git_http_response_dispose(git_http_response *response)
memset(response, 0, sizeof(git_http_response));
}
-static int on_header_complete(http_parser *parser)
+static int on_header_complete(git_http_parser *parser)
{
http_parser_context *ctx = (http_parser_context *) parser->data;
git_http_client *client = ctx->client;
@@ -219,7 +220,7 @@ static int on_header_complete(http_parser *parser)
return 0;
}
-static int on_header_field(http_parser *parser, const char *str, size_t len)
+static int on_header_field(git_http_parser *parser, const char *str, size_t len)
{
http_parser_context *ctx = (http_parser_context *) parser->data;
@@ -254,7 +255,7 @@ static int on_header_field(http_parser *parser, const char *str, size_t len)
return 0;
}
-static int on_header_value(http_parser *parser, const char *str, size_t len)
+static int on_header_value(git_http_parser *parser, const char *str, size_t len)
{
http_parser_context *ctx = (http_parser_context *) parser->data;
@@ -342,7 +343,7 @@ static int resend_needed(git_http_client *client, git_http_response *response)
return 0;
}
-static int on_headers_complete(http_parser *parser)
+static int on_headers_complete(git_http_parser *parser)
{
http_parser_context *ctx = (http_parser_context *) parser->data;
@@ -364,8 +365,8 @@ static int on_headers_complete(http_parser *parser)
return ctx->parse_status = PARSE_STATUS_ERROR;
}
- ctx->response->status = parser->status_code;
- ctx->client->keepalive = http_should_keep_alive(parser);
+ ctx->response->status = git_http_parser_status_code(parser);
+ ctx->client->keepalive = git_http_parser_keep_alive(parser);
/* Prepare for authentication */
collect_authinfo(&ctx->response->server_auth_schemetypes,
@@ -378,18 +379,15 @@ static int on_headers_complete(http_parser *parser)
ctx->response->resend_credentials = resend_needed(ctx->client,
ctx->response);
- /* Stop parsing. */
- http_parser_pause(parser, 1);
-
if (ctx->response->content_type || ctx->response->chunked)
ctx->client->state = READING_BODY;
else
ctx->client->state = DONE;
- return 0;
+ return git_http_parser_pause(parser);
}
-static int on_body(http_parser *parser, const char *buf, size_t len)
+static int on_body(git_http_parser *parser, const char *buf, size_t len)
{
http_parser_context *ctx = (http_parser_context *) parser->data;
size_t max_len;
@@ -411,7 +409,7 @@ static int on_body(http_parser *parser, const char *buf, size_t len)
return 0;
}
-static int on_message_complete(http_parser *parser)
+static int on_message_complete(git_http_parser *parser)
{
http_parser_context *ctx = (http_parser_context *) parser->data;
@@ -651,6 +649,30 @@ static int puts_host_and_port(git_str *buf, git_net_url *url, bool force_port)
return git_str_oom(buf) ? -1 : 0;
}
+static int append_user_agent(git_str *buf)
+{
+ const char *product = git_settings__user_agent_product();
+ const char *comment = git_settings__user_agent();
+
+ GIT_ASSERT(product && comment);
+
+ if (!*product)
+ return 0;
+
+ git_str_puts(buf, "User-Agent: ");
+ git_str_puts(buf, product);
+
+ if (*comment) {
+ git_str_puts(buf, " (");
+ git_str_puts(buf, comment);
+ git_str_puts(buf, ")");
+ }
+
+ git_str_puts(buf, "\r\n");
+
+ return git_str_oom(buf) ? -1 : 0;
+}
+
static int generate_connect_request(
git_http_client *client,
git_http_request *request)
@@ -665,9 +687,7 @@ static int generate_connect_request(
puts_host_and_port(buf, &client->server.url, true);
git_str_puts(buf, " HTTP/1.1\r\n");
- git_str_puts(buf, "User-Agent: ");
- git_http__user_agent(buf);
- git_str_puts(buf, "\r\n");
+ append_user_agent(buf);
git_str_puts(buf, "Host: ");
puts_host_and_port(buf, &client->server.url, true);
@@ -711,9 +731,7 @@ static int generate_request(
git_str_puts(buf, " HTTP/1.1\r\n");
- git_str_puts(buf, "User-Agent: ");
- git_http__user_agent(buf);
- git_str_puts(buf, "\r\n");
+ append_user_agent(buf);
git_str_puts(buf, "Host: ");
puts_host_and_port(buf, request->url, false);
@@ -768,25 +786,37 @@ static int check_certificate(
void *cert_cb_payload)
{
git_cert *cert;
- git_error_state last_error = {0};
+ git_error *last_error;
int error;
if ((error = git_stream_certificate(&cert, stream)) < 0)
return error;
- git_error_state_capture(&last_error, GIT_ECERTIFICATE);
+ /*
+ * Allow callers to set an error - but save ours and clear
+ * it, so that we can detect if they set one and restore it
+ * if we need to.
+ */
+ git_error_save(&last_error);
+ git_error_clear();
error = cert_cb(cert, is_valid, url->host, cert_cb_payload);
- if (error == GIT_PASSTHROUGH && !is_valid)
- return git_error_state_restore(&last_error);
- else if (error == GIT_PASSTHROUGH)
- error = 0;
- else if (error && !git_error_last())
- git_error_set(GIT_ERROR_HTTP,
- "user rejected certificate for %s", url->host);
+ if (error == GIT_PASSTHROUGH) {
+ error = is_valid ? 0 : -1;
- git_error_state_free(&last_error);
+ if (error) {
+ git_error_restore(last_error);
+ last_error = NULL;
+ }
+ } else if (error) {
+ if (!git_error_exists())
+ git_error_set(GIT_ERROR_HTTP,
+ "user rejected certificate for %s",
+ url->host);
+ }
+
+ git_error_free(last_error);
return error;
}
@@ -837,6 +867,11 @@ GIT_INLINE(int) server_setup_from_url(
git_http_server *server,
git_net_url *url)
{
+ GIT_ASSERT_ARG(url);
+ GIT_ASSERT_ARG(url->scheme);
+ GIT_ASSERT_ARG(url->host);
+ GIT_ASSERT_ARG(url->port);
+
if (!server->url.scheme || strcmp(server->url.scheme, url->scheme) ||
!server->url.host || strcmp(server->url.host, url->host) ||
!server->url.port || strcmp(server->url.port, url->port)) {
@@ -859,9 +894,29 @@ GIT_INLINE(int) server_setup_from_url(
return 0;
}
+static bool parser_settings_initialized;
+static git_http_parser_settings parser_settings;
+
+GIT_INLINE(git_http_parser_settings *) http_client_parser_settings(void)
+{
+ if (!parser_settings_initialized) {
+ parser_settings.on_header_field = on_header_field;
+ parser_settings.on_header_value = on_header_value;
+ parser_settings.on_headers_complete = on_headers_complete;
+ parser_settings.on_body = on_body;
+ parser_settings.on_message_complete = on_message_complete;
+
+ parser_settings_initialized = true;
+ }
+
+ return &parser_settings;
+}
+
static void reset_parser(git_http_client *client)
{
- http_parser_init(&client->parser, HTTP_RESPONSE);
+ git_http_parser_init(&client->parser,
+ GIT_HTTP_PARSER_RESPONSE,
+ http_client_parser_settings());
}
static int setup_hosts(
@@ -1104,27 +1159,9 @@ GIT_INLINE(int) client_read(git_http_client *client)
return (int)read_len;
}
-static bool parser_settings_initialized;
-static http_parser_settings parser_settings;
-
-GIT_INLINE(http_parser_settings *) http_client_parser_settings(void)
-{
- if (!parser_settings_initialized) {
- parser_settings.on_header_field = on_header_field;
- parser_settings.on_header_value = on_header_value;
- parser_settings.on_headers_complete = on_headers_complete;
- parser_settings.on_body = on_body;
- parser_settings.on_message_complete = on_message_complete;
-
- parser_settings_initialized = true;
- }
-
- return &parser_settings;
-}
-
GIT_INLINE(int) client_read_and_parse(git_http_client *client)
{
- http_parser *parser = &client->parser;
+ git_http_parser *parser = &client->parser;
http_parser_context *ctx = (http_parser_context *) parser->data;
unsigned char http_errno;
int read_len;
@@ -1138,11 +1175,10 @@ GIT_INLINE(int) client_read_and_parse(git_http_client *client)
if (!client->read_buf.size && (read_len = client_read(client)) < 0)
return read_len;
- parsed_len = http_parser_execute(parser,
- http_client_parser_settings(),
+ parsed_len = git_http_parser_execute(parser,
client->read_buf.ptr,
client->read_buf.size);
- http_errno = client->parser.http_errno;
+ http_errno = git_http_parser_errno(parser);
if (parsed_len > INT_MAX) {
git_error_set(GIT_ERROR_HTTP, "unexpectedly large parse");
@@ -1161,26 +1197,29 @@ GIT_INLINE(int) client_read_and_parse(git_http_client *client)
* (This can happen in response to an expect/continue request,
* where the server gives you a 100 and 200 simultaneously.)
*/
- if (http_errno == HPE_PAUSED) {
+ if (http_errno == GIT_HTTP_PARSER_PAUSED) {
+ size_t additional_size;
+
+ git_http_parser_resume(parser);
+
/*
- * http-parser has a "feature" where it will not deliver the
- * final byte when paused in a callback. Consume that byte.
- * https://github.com/nodejs/http-parser/issues/97
+ * http-parser has a "feature" where it will not deliver
+ * the final byte when paused in a callback. Consume
+ * that byte.
*/
- GIT_ASSERT(client->read_buf.size > parsed_len);
+ if ((additional_size = git_http_parser_remain_after_pause(parser)) > 0) {
+ GIT_ASSERT((client->read_buf.size - parsed_len) >= additional_size);
- http_parser_pause(parser, 0);
-
- parsed_len += http_parser_execute(parser,
- http_client_parser_settings(),
- client->read_buf.ptr + parsed_len,
- 1);
+ parsed_len += git_http_parser_execute(parser,
+ client->read_buf.ptr + parsed_len,
+ additional_size);
+ }
}
/* Most failures will be reported in http_errno */
- else if (parser->http_errno != HPE_OK) {
+ else if (git_http_parser_errno(parser) != GIT_HTTP_PARSER_OK) {
git_error_set(GIT_ERROR_HTTP, "http parser error: %s",
- http_errno_description(http_errno));
+ git_http_parser_errmsg(parser, http_errno));
return -1;
}
@@ -1188,7 +1227,7 @@ GIT_INLINE(int) client_read_and_parse(git_http_client *client)
else if (parsed_len != client->read_buf.size) {
git_error_set(GIT_ERROR_HTTP,
"http parser did not consume entire buffer: %s",
- http_errno_description(http_errno));
+ git_http_parser_errmsg(parser, http_errno));
return -1;
}
@@ -1227,7 +1266,7 @@ static void complete_response_body(git_http_client *client)
/* If there was an error, just close the connection. */
if (client_read_and_parse(client) < 0 ||
- parser_context.error != HPE_OK ||
+ parser_context.error != GIT_HTTP_PARSER_OK ||
(parser_context.parse_status != PARSE_STATUS_OK &&
parser_context.parse_status != PARSE_STATUS_NO_OUTPUT)) {
git_error_clear();
@@ -1235,6 +1274,7 @@ static void complete_response_body(git_http_client *client)
}
done:
+ client->parser.data = NULL;
git_str_clear(&client->read_buf);
}
@@ -1402,9 +1442,9 @@ int git_http_client_read_response(
git_http_response_dispose(response);
if (client->current_server == PROXY) {
- git_vector_free_deep(&client->proxy.auth_challenges);
+ git_vector_dispose_deep(&client->proxy.auth_challenges);
} else if(client->current_server == SERVER) {
- git_vector_free_deep(&client->server.auth_challenges);
+ git_vector_dispose_deep(&client->server.auth_challenges);
}
client->state = READING_RESPONSE;
@@ -1424,6 +1464,7 @@ int git_http_client_read_response(
done:
git_str_dispose(&parser_context.parse_header_name);
git_str_dispose(&parser_context.parse_header_value);
+ client->parser.data = NULL;
return error;
}
@@ -1479,6 +1520,8 @@ int git_http_client_read_body(
if (error < 0)
client->connected = 0;
+ client->parser.data = NULL;
+
return error;
}
@@ -1501,7 +1544,7 @@ int git_http_client_skip_body(git_http_client *client)
do {
error = client_read_and_parse(client);
- if (parser_context.error != HPE_OK ||
+ if (parser_context.error != GIT_HTTP_PARSER_OK ||
(parser_context.parse_status != PARSE_STATUS_OK &&
parser_context.parse_status != PARSE_STATUS_NO_OUTPUT)) {
git_error_set(GIT_ERROR_HTTP,
@@ -1513,6 +1556,8 @@ int git_http_client_skip_body(git_http_client *client)
if (error < 0)
client->connected = 0;
+ client->parser.data = NULL;
+
return error;
}
@@ -1560,7 +1605,7 @@ GIT_INLINE(void) http_server_close(git_http_server *server)
git_net_url_dispose(&server->url);
- git_vector_free_deep(&server->auth_challenges);
+ git_vector_dispose_deep(&server->auth_challenges);
free_auth_context(server);
}
diff --git a/src/libgit2/transports/httpparser.c b/src/libgit2/transports/httpparser.c
new file mode 100644
index 00000000000..84833e61737
--- /dev/null
+++ b/src/libgit2/transports/httpparser.c
@@ -0,0 +1,128 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include "httpparser.h"
+
+#include
+
+#if defined(GIT_HTTPPARSER_HTTPPARSER)
+
+#include "http_parser.h"
+
+static int on_message_begin(http_parser *p)
+{
+ git_http_parser *parser = (git_http_parser *)p;
+ return parser->settings.on_message_begin(parser);
+}
+
+static int on_url(http_parser *p, const char *str, size_t len)
+{
+ git_http_parser *parser = (git_http_parser *)p;
+ return parser->settings.on_url(parser, str, len);
+}
+
+static int on_header_field(http_parser *p, const char *str, size_t len)
+{
+ git_http_parser *parser = (git_http_parser *)p;
+ return parser->settings.on_header_field(parser, str, len);
+}
+
+static int on_header_value(http_parser *p, const char *str, size_t len)
+{
+ git_http_parser *parser = (git_http_parser *)p;
+ return parser->settings.on_header_value(parser, str, len);
+}
+
+static int on_headers_complete(http_parser *p)
+{
+ git_http_parser *parser = (git_http_parser *)p;
+ return parser->settings.on_headers_complete(parser);
+}
+
+static int on_body(http_parser *p, const char *buf, size_t len)
+{
+ git_http_parser *parser = (git_http_parser *)p;
+ return parser->settings.on_body(parser, buf, len);
+}
+
+static int on_message_complete(http_parser *p)
+{
+ git_http_parser *parser = (git_http_parser *)p;
+ return parser->settings.on_message_complete(parser);
+}
+
+void git_http_parser_init(
+ git_http_parser *parser,
+ git_http_parser_t type,
+ git_http_parser_settings *settings)
+{
+ http_parser_init(&parser->parser, (enum http_parser_type)type);
+ memcpy(&parser->settings, settings, sizeof(git_http_parser_settings));
+}
+
+size_t git_http_parser_execute(
+ git_http_parser *parser,
+ const char *data,
+ size_t len)
+{
+ struct http_parser_settings settings_proxy;
+
+ memset(&settings_proxy, 0, sizeof(struct http_parser_settings));
+
+ settings_proxy.on_message_begin = parser->settings.on_message_begin ? on_message_begin : NULL;
+ settings_proxy.on_url = parser->settings.on_url ? on_url : NULL;
+ settings_proxy.on_header_field = parser->settings.on_header_field ? on_header_field : NULL;
+ settings_proxy.on_header_value = parser->settings.on_header_value ? on_header_value : NULL;
+ settings_proxy.on_headers_complete = parser->settings.on_headers_complete ? on_headers_complete : NULL;
+ settings_proxy.on_body = parser->settings.on_body ? on_body : NULL;
+ settings_proxy.on_message_complete = parser->settings.on_message_complete ? on_message_complete : NULL;
+
+ return http_parser_execute(&parser->parser, &settings_proxy, data, len);
+}
+
+#elif defined(GIT_HTTPPARSER_LLHTTP) || defined(GIT_HTTPPARSER_BUILTIN)
+
+# include
+
+size_t git_http_parser_execute(
+ git_http_parser *parser,
+ const char* data,
+ size_t len)
+{
+ llhttp_errno_t error;
+ size_t parsed_len;
+
+ /*
+ * Unlike http_parser, which returns the number of parsed
+ * bytes in the _execute() call, llhttp returns an error
+ * code.
+ */
+
+ if (data == NULL || len == 0)
+ error = llhttp_finish(parser);
+ else
+ error = llhttp_execute(parser, data, len);
+
+ parsed_len = len;
+
+ /*
+ * Adjust number of parsed bytes in case of error.
+ */
+ if (error != HPE_OK) {
+ parsed_len = llhttp_get_error_pos(parser) - data;
+
+ /* This isn't a real pause, just a way to stop parsing early. */
+ if (error == HPE_PAUSED_UPGRADE)
+ llhttp_resume_after_upgrade(parser);
+ }
+
+ return parsed_len;
+}
+
+#else
+# error unknown http-parser
+#endif
diff --git a/src/libgit2/transports/httpparser.h b/src/libgit2/transports/httpparser.h
new file mode 100644
index 00000000000..1fe0dcf6406
--- /dev/null
+++ b/src/libgit2/transports/httpparser.h
@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#ifndef INCLUDE_transports_httpparser_h__
+#define INCLUDE_transports_httpparser_h__
+
+#include "git2_util.h"
+
+#if defined(GIT_HTTPPARSER_HTTPPARSER)
+
+# include
+
+typedef enum {
+ GIT_HTTP_PARSER_OK = HPE_OK,
+ GIT_HTTP_PARSER_PAUSED = HPE_PAUSED,
+} git_http_parser_error_t;
+
+typedef enum {
+ GIT_HTTP_PARSER_REQUEST = HTTP_REQUEST,
+ GIT_HTTP_PARSER_RESPONSE = HTTP_RESPONSE,
+} git_http_parser_t;
+
+typedef struct git_http_parser git_http_parser;
+
+typedef struct {
+ int (*on_message_begin)(git_http_parser *);
+ int (*on_url)(git_http_parser *, const char *, size_t);
+ int (*on_header_field)(git_http_parser *, const char *, size_t);
+ int (*on_header_value)(git_http_parser *, const char *, size_t);
+ int (*on_headers_complete)(git_http_parser *);
+ int (*on_body)(git_http_parser *, const char *, size_t);
+ int (*on_message_complete)(git_http_parser *);
+} git_http_parser_settings;
+
+struct git_http_parser {
+ http_parser parser;
+ git_http_parser_settings settings;
+ void *data;
+};
+
+void git_http_parser_init(
+ git_http_parser *parser,
+ git_http_parser_t type,
+ git_http_parser_settings *settings);
+
+size_t git_http_parser_execute(
+ git_http_parser *parser,
+ const char *data,
+ size_t len);
+
+# define git_http_parser_status_code(parser) parser->parser.status_code
+# define git_http_parser_keep_alive(parser) http_should_keep_alive(&parser->parser)
+# define git_http_parser_pause(parser) (http_parser_pause(&parser->parser, 1), 0)
+# define git_http_parser_resume(parser) http_parser_pause(&parser->parser, 0)
+# define git_http_parser_remain_after_pause(parser) 1
+# define git_http_parser_errno(parser) parser->parser.http_errno
+# define git_http_parser_errmsg(parser, errno) http_errno_description(errno)
+
+#elif defined(GIT_HTTPPARSER_LLHTTP) || defined(GIT_HTTPPARSER_BUILTIN)
+
+# include
+
+typedef enum {
+ GIT_HTTP_PARSER_OK = HPE_OK,
+ GIT_HTTP_PARSER_PAUSED = HPE_PAUSED,
+} git_http_parser_error_t;
+
+typedef enum {
+ GIT_HTTP_PARSER_REQUEST = HTTP_REQUEST,
+ GIT_HTTP_PARSER_RESPONSE = HTTP_RESPONSE,
+} git_http_parser_t;
+
+typedef llhttp_t git_http_parser;
+typedef llhttp_settings_t git_http_parser_settings;
+
+# define git_http_parser_init(parser, direction, settings) llhttp_init(parser, (llhttp_type_t)direction, settings)
+
+size_t git_http_parser_execute(
+ git_http_parser *parser,
+ const char *data,
+ size_t len);
+
+# define git_http_parser_status_code(parser) parser->status_code
+# define git_http_parser_keep_alive(parser) llhttp_should_keep_alive(parser)
+# define git_http_parser_pause(parser) (llhttp_pause(parser), GIT_HTTP_PARSER_PAUSED)
+# define git_http_parser_resume(parser) llhttp_resume(parser)
+# define git_http_parser_remain_after_pause(parser) 0
+# define git_http_parser_errno(parser) parser->error
+# define git_http_parser_errmsg(parser, errno) llhttp_get_error_reason(parser)
+
+#else
+# error unknown http-parser
+#endif
+
+#endif
diff --git a/src/libgit2/transports/local.c b/src/libgit2/transports/local.c
index 4d86f171310..854390534f2 100644
--- a/src/libgit2/transports/local.c
+++ b/src/libgit2/transports/local.c
@@ -58,7 +58,7 @@ static void free_heads(git_vector *heads)
git_vector_foreach(heads, i, head)
free_head(head);
- git_vector_free(heads);
+ git_vector_dispose(heads);
}
static int add_ref(transport_local *t, const char *name)
@@ -108,10 +108,6 @@ static int add_ref(transport_local *t, const char *name)
return error;
}
- /* If it's not a tag, we don't need to try to peel it */
- if (git__prefixcmp(name, GIT_REFS_TAGS_DIR))
- return 0;
-
if ((error = git_object_lookup(&obj, t->repo, &head->oid, GIT_OBJECT_ANY)) < 0)
return error;
@@ -186,7 +182,7 @@ static int store_refs(transport_local *t)
return 0;
on_error:
- git_vector_free(&t->refs);
+ git_vector_dispose(&t->refs);
git_strarray_dispose(&ref_names);
return -1;
}
@@ -295,15 +291,18 @@ static int local_ls(const git_remote_head ***out, size_t *size, git_transport *t
static int local_negotiate_fetch(
git_transport *transport,
git_repository *repo,
- const git_remote_head * const *refs,
- size_t count)
+ const git_fetch_negotiation *wants)
{
transport_local *t = (transport_local*)transport;
git_remote_head *rhead;
unsigned int i;
- GIT_UNUSED(refs);
- GIT_UNUSED(count);
+ GIT_UNUSED(wants);
+
+ if (wants->depth) {
+ git_error_set(GIT_ERROR_NET, "shallow fetch is not supported by the local transport");
+ return GIT_ENOTSUPPORTED;
+ }
/* Fill in the loids */
git_vector_foreach(&t->refs, i, rhead) {
@@ -322,6 +321,16 @@ static int local_negotiate_fetch(
return 0;
}
+static int local_shallow_roots(
+ git_oidarray *out,
+ git_transport *transport)
+{
+ GIT_UNUSED(out);
+ GIT_UNUSED(transport);
+
+ return 0;
+}
+
static int local_push_update_remote_ref(
git_repository *remote_repo,
const char *lref,
@@ -445,7 +454,7 @@ static int local_push(
default:
last = git_error_last();
- if (last && last->message)
+ if (last->klass != GIT_ERROR_NONE)
status->msg = git__strdup(last->message);
else
status->msg = git__strdup("Unspecified error encountered");
@@ -747,6 +756,7 @@ int git_transport_local(git_transport **out, git_remote *owner, void *param)
t->parent.oid_type = local_oid_type;
#endif
t->parent.negotiate_fetch = local_negotiate_fetch;
+ t->parent.shallow_roots = local_shallow_roots;
t->parent.download_pack = local_download_pack;
t->parent.push = local_push;
t->parent.close = local_close;
diff --git a/src/libgit2/transports/smart.c b/src/libgit2/transports/smart.c
index c3a764bd3d5..7bf964ac2d9 100644
--- a/src/libgit2/transports/smart.c
+++ b/src/libgit2/transports/smart.c
@@ -13,30 +13,42 @@
#include "refspec.h"
#include "proxy.h"
-static int git_smart__recv_cb(gitno_buffer *buf)
+int git_smart__recv(transport_smart *t)
{
- transport_smart *t = (transport_smart *) buf->cb_data;
- size_t old_len, bytes_read;
- int error;
+ size_t bytes_read;
+ int ret;
+ GIT_ASSERT_ARG(t);
GIT_ASSERT(t->current_stream);
- old_len = buf->offset;
+ if (git_staticstr_remain(&t->buffer) == 0) {
+ git_error_set(GIT_ERROR_NET, "out of buffer space");
+ return -1;
+ }
- if ((error = t->current_stream->read(t->current_stream, buf->data + buf->offset, buf->len - buf->offset, &bytes_read)) < 0)
- return error;
+ ret = t->current_stream->read(t->current_stream,
+ git_staticstr_offset(&t->buffer),
+ git_staticstr_remain(&t->buffer),
+ &bytes_read);
+
+ if (ret < 0)
+ return ret;
+
+ GIT_ASSERT(bytes_read <= INT_MAX);
+ GIT_ASSERT(bytes_read <= git_staticstr_remain(&t->buffer));
- buf->offset += bytes_read;
+ git_staticstr_increase(&t->buffer, bytes_read);
if (t->packetsize_cb && !t->cancelled.val) {
- error = t->packetsize_cb(bytes_read, t->packetsize_payload);
- if (error) {
+ ret = t->packetsize_cb(bytes_read, t->packetsize_payload);
+
+ if (ret) {
git_atomic32_set(&t->cancelled, 1);
return GIT_EUSER;
}
}
- return (int)(buf->offset - old_len);
+ return (int)bytes_read;
}
GIT_INLINE(int) git_smart__reset_stream(transport_smart *t, bool close_subtransport)
@@ -112,7 +124,7 @@ static void free_symrefs(git_vector *symrefs)
git__free(spec);
}
- git_vector_free(symrefs);
+ git_vector_dispose(symrefs);
}
static int git_smart__connect(
@@ -155,8 +167,6 @@ static int git_smart__connect(
/* Save off the current stream (i.e. socket) that we are working with */
t->current_stream = stream;
- gitno_buffer_setup_callback(&t->buffer, t->buffer_data, sizeof(t->buffer_data), git_smart__recv_cb, t);
-
/* 2 flushes for RPC; 1 for stateful */
if ((error = git_smart__store_refs(t, t->rpc ? 2 : 1)) < 0)
return error;
@@ -239,6 +249,9 @@ static int git_smart__capabilities(unsigned int *capabilities, git_transport *tr
*capabilities = 0;
+ if (t->caps.push_options)
+ *capabilities |= GIT_REMOTE_CAPABILITY_PUSH_OPTIONS;
+
if (t->caps.want_tip_sha1)
*capabilities |= GIT_REMOTE_CAPABILITY_TIP_OID;
@@ -313,8 +326,6 @@ int git_smart__negotiation_step(git_transport *transport, void *data, size_t len
if ((error = stream->write(stream, (const char *)data, len)) < 0)
return error;
- gitno_buffer_setup_callback(&t->buffer, t->buffer_data, sizeof(t->buffer_data), git_smart__recv_cb, t);
-
return 0;
}
@@ -339,8 +350,6 @@ int git_smart__get_push_stream(transport_smart *t, git_smart_subtransport_stream
/* Save off the current stream (i.e. socket) that we are working with */
t->current_stream = *stream;
- gitno_buffer_setup_callback(&t->buffer, t->buffer_data, sizeof(t->buffer_data), git_smart__recv_cb, t);
-
return 0;
}
@@ -364,17 +373,27 @@ static int git_smart__close(git_transport *transport)
git_vector *common = &t->common;
unsigned int i;
git_pkt *p;
+ git_smart_service_t service;
int ret;
git_smart_subtransport_stream *stream;
const char flush[] = "0000";
+ if (t->direction == GIT_DIRECTION_FETCH) {
+ service = GIT_SERVICE_UPLOADPACK;
+ } else if (t->direction == GIT_DIRECTION_PUSH) {
+ service = GIT_SERVICE_RECEIVEPACK;
+ } else {
+ git_error_set(GIT_ERROR_NET, "invalid direction");
+ return -1;
+ }
+
/*
* If we're still connected at this point and not using RPC,
* we should say goodbye by sending a flush, or git-daemon
* will complain that we disconnected unexpectedly.
*/
if (t->connected && !t->rpc &&
- !t->wrapped->action(&stream, t->wrapped, t->url, GIT_SERVICE_UPLOADPACK)) {
+ !t->wrapped->action(&stream, t->wrapped, t->url, service)) {
t->current_stream->write(t->current_stream, flush, 4);
}
@@ -383,7 +402,7 @@ static int git_smart__close(git_transport *transport)
git_vector_foreach(common, i, p)
git_pkt_free(p);
- git_vector_free(common);
+ git_vector_dispose(common);
if (t->url) {
git__free(t->url);
@@ -408,14 +427,16 @@ static void git_smart__free(git_transport *transport)
/* Free the subtransport */
t->wrapped->free(t->wrapped);
- git_vector_free(&t->heads);
+ git_vector_dispose(&t->heads);
git_vector_foreach(refs, i, p)
git_pkt_free(p);
- git_vector_free(refs);
+ git_vector_dispose(refs);
git_remote_connect_options_dispose(&t->connect_opts);
+ git_array_dispose(t->shallow_roots);
+
git__free(t->caps.object_format);
git__free(t->caps.agent);
git__free(t);
@@ -490,6 +511,7 @@ int git_transport_smart(git_transport **out, git_remote *owner, void *param)
t->parent.close = git_smart__close;
t->parent.free = git_smart__free;
t->parent.negotiate_fetch = git_smart__negotiate_fetch;
+ t->parent.shallow_roots = git_smart__shallow_roots;
t->parent.download_pack = git_smart__download_pack;
t->parent.push = git_smart__push;
t->parent.ls = git_smart__ls;
@@ -499,20 +521,16 @@ int git_transport_smart(git_transport **out, git_remote *owner, void *param)
t->owner = owner;
t->rpc = definition->rpc;
- if (git_vector_init(&t->refs, 16, ref_name_cmp) < 0) {
+ if (git_vector_init(&t->refs, 16, ref_name_cmp) < 0 ||
+ git_vector_init(&t->heads, 16, ref_name_cmp) < 0 ||
+ definition->callback(&t->wrapped, &t->parent, definition->param) < 0) {
+ git_vector_dispose(&t->refs);
+ git_vector_dispose(&t->heads);
git__free(t);
return -1;
}
- if (git_vector_init(&t->heads, 16, ref_name_cmp) < 0) {
- git__free(t);
- return -1;
- }
-
- if (definition->callback(&t->wrapped, &t->parent, definition->param) < 0) {
- git__free(t);
- return -1;
- }
+ git_staticstr_init(&t->buffer, GIT_SMART_BUFFER_SIZE);
*out = (git_transport *) t;
return 0;
diff --git a/src/libgit2/transports/smart.h b/src/libgit2/transports/smart.h
index d71160d8e60..c987d93b53d 100644
--- a/src/libgit2/transports/smart.h
+++ b/src/libgit2/transports/smart.h
@@ -11,11 +11,14 @@
#include "git2.h"
#include "vector.h"
-#include "netops.h"
#include "push.h"
#include "str.h"
+#include "oidarray.h"
+#include "staticstr.h"
#include "git2/sys/transport.h"
+#define GIT_SMART_BUFFER_SIZE 65536
+
#define GIT_SIDE_BAND_DATA 1
#define GIT_SIDE_BAND_PROGRESS 2
#define GIT_SIDE_BAND_ERROR 3
@@ -32,8 +35,10 @@
#define GIT_CAP_SYMREF "symref"
#define GIT_CAP_WANT_TIP_SHA1 "allow-tip-sha1-in-want"
#define GIT_CAP_WANT_REACHABLE_SHA1 "allow-reachable-sha1-in-want"
+#define GIT_CAP_SHALLOW "shallow"
#define GIT_CAP_OBJECT_FORMAT "object-format="
#define GIT_CAP_AGENT "agent="
+#define GIT_CAP_PUSH_OPTIONS "push-options"
extern bool git_smart__ofs_delta_enabled;
@@ -50,7 +55,9 @@ typedef enum {
GIT_PKT_PROGRESS,
GIT_PKT_OK,
GIT_PKT_NG,
- GIT_PKT_UNPACK
+ GIT_PKT_UNPACK,
+ GIT_PKT_SHALLOW,
+ GIT_PKT_UNSHALLOW
} git_pkt_type;
/* Used for multi_ack and multi_ack_detailed */
@@ -122,6 +129,11 @@ typedef struct {
int unpack_ok;
} git_pkt_unpack;
+typedef struct {
+ git_pkt_type type;
+ git_oid oid;
+} git_pkt_shallow;
+
typedef struct transport_smart_caps {
unsigned int common:1,
ofs_delta:1,
@@ -134,7 +146,9 @@ typedef struct transport_smart_caps {
report_status:1,
thin_pack:1,
want_tip_sha1:1,
- want_reachable_sha1:1;
+ want_reachable_sha1:1,
+ shallow:1,
+ push_options:1;
char *object_format;
char *agent;
} transport_smart_caps;
@@ -153,14 +167,14 @@ typedef struct {
git_vector refs;
git_vector heads;
git_vector common;
+ git_array_oid_t shallow_roots;
git_atomic32 cancelled;
packetsize_cb packetsize_cb;
void *packetsize_payload;
unsigned rpc : 1,
have_refs : 1,
connected : 1;
- gitno_buffer buffer;
- char buffer_data[65536];
+ git_staticstr_with_size(GIT_SMART_BUFFER_SIZE) buffer;
} transport_smart;
/* smart_protocol.c */
@@ -171,8 +185,9 @@ int git_smart__push(git_transport *transport, git_push *push);
int git_smart__negotiate_fetch(
git_transport *transport,
git_repository *repo,
- const git_remote_head * const *refs,
- size_t count);
+ const git_fetch_negotiation *wants);
+
+int git_smart__shallow_roots(git_oidarray *out, git_transport *transport);
int git_smart__download_pack(
git_transport *transport,
@@ -180,6 +195,8 @@ int git_smart__download_pack(
git_indexer_progress *stats);
/* smart.c */
+int git_smart__recv(transport_smart *t);
+
int git_smart__negotiation_step(git_transport *transport, void *data, size_t len);
int git_smart__get_push_stream(transport_smart *t, git_smart_subtransport_stream **out);
@@ -188,14 +205,14 @@ int git_smart__update_heads(transport_smart *t, git_vector *symrefs);
/* smart_pkt.c */
typedef struct {
git_oid_t oid_type;
- int seen_capabilities: 1;
+ unsigned int seen_capabilities: 1;
} git_pkt_parse_data;
int git_pkt_parse_line(git_pkt **head, const char **endptr, const char *line, size_t linelen, git_pkt_parse_data *data);
int git_pkt_buffer_flush(git_str *buf);
int git_pkt_send_flush(GIT_SOCKET s);
int git_pkt_buffer_done(git_str *buf);
-int git_pkt_buffer_wants(const git_remote_head * const *refs, size_t count, transport_smart_caps *caps, git_str *buf);
+int git_pkt_buffer_wants(const git_fetch_negotiation *wants, transport_smart_caps *caps, git_str *buf);
int git_pkt_buffer_have(git_oid *oid, git_str *buf);
void git_pkt_free(git_pkt *pkt);
diff --git a/src/libgit2/transports/smart_pkt.c b/src/libgit2/transports/smart_pkt.c
index 5fce42175be..29ccb83ac72 100644
--- a/src/libgit2/transports/smart_pkt.c
+++ b/src/libgit2/transports/smart_pkt.c
@@ -9,7 +9,6 @@
#include "smart.h"
#include "util.h"
-#include "netops.h"
#include "posix.h"
#include "str.h"
#include "oid.h"
@@ -44,9 +43,16 @@ static int flush_pkt(git_pkt **out)
}
/* the rest of the line will be useful for multi_ack and multi_ack_detailed */
-static int ack_pkt(git_pkt **out, const char *line, size_t len)
+static int ack_pkt(
+ git_pkt **out,
+ const char *line,
+ size_t len,
+ git_pkt_parse_data *data)
{
git_pkt_ack *pkt;
+ size_t oid_hexsize = git_oid_hexsize(data->oid_type);
+
+ GIT_ASSERT(data && data->oid_type);
pkt = git__calloc(1, sizeof(git_pkt_ack));
GIT_ERROR_CHECK_ALLOC(pkt);
@@ -57,11 +63,11 @@ static int ack_pkt(git_pkt **out, const char *line, size_t len)
line += 4;
len -= 4;
- if (len < GIT_OID_SHA1_HEXSIZE ||
- git_oid__fromstr(&pkt->oid, line, GIT_OID_SHA1) < 0)
+ if (len < oid_hexsize ||
+ git_oid_from_prefix(&pkt->oid, line, oid_hexsize, data->oid_type) < 0)
goto out_err;
- line += GIT_OID_SHA1_HEXSIZE;
- len -= GIT_OID_SHA1_HEXSIZE;
+ line += oid_hexsize;
+ len -= oid_hexsize;
if (len && line[0] == ' ') {
line++;
@@ -226,7 +232,8 @@ static int set_data(
GIT_ASSERT_ARG(data);
- if ((caps = memchr(line, '\0', len)) != NULL) {
+ if ((caps = memchr(line, '\0', len)) != NULL &&
+ len > (size_t)((caps - line) + 1)) {
caps++;
if (strncmp(caps, "object-format=", CONST_STRLEN("object-format=")) == 0)
@@ -288,7 +295,7 @@ static int ref_pkt(
oid_hexsize = git_oid_hexsize(data->oid_type);
if (len < oid_hexsize ||
- git_oid__fromstr(&pkt->head.oid, line, data->oid_type) < 0)
+ git_oid_from_prefix(&pkt->head.oid, line, oid_hexsize, data->oid_type) < 0)
goto out_err;
line += oid_hexsize;
len -= oid_hexsize;
@@ -436,6 +443,84 @@ static int unpack_pkt(git_pkt **out, const char *line, size_t len)
return 0;
}
+static int shallow_pkt(
+ git_pkt **out,
+ const char *line,
+ size_t len,
+ git_pkt_parse_data *data)
+{
+ git_pkt_shallow *pkt;
+ size_t oid_hexsize = git_oid_hexsize(data->oid_type);
+
+ GIT_ASSERT(data && data->oid_type);
+
+ pkt = git__calloc(1, sizeof(git_pkt_shallow));
+ GIT_ERROR_CHECK_ALLOC(pkt);
+
+ pkt->type = GIT_PKT_SHALLOW;
+
+ if (git__prefixncmp(line, len, "shallow "))
+ goto out_err;
+
+ line += 8;
+ len -= 8;
+
+ if (len != oid_hexsize)
+ goto out_err;
+
+ git_oid_from_prefix(&pkt->oid, line, oid_hexsize, data->oid_type);
+ line += oid_hexsize + 1;
+ len -= oid_hexsize + 1;
+
+ *out = (git_pkt *)pkt;
+
+ return 0;
+
+out_err:
+ git_error_set(GIT_ERROR_NET, "invalid packet line");
+ git__free(pkt);
+ return -1;
+}
+
+static int unshallow_pkt(
+ git_pkt **out,
+ const char *line,
+ size_t len,
+ git_pkt_parse_data *data)
+{
+ git_pkt_shallow *pkt;
+ size_t oid_hexsize = git_oid_hexsize(data->oid_type);
+
+ GIT_ASSERT(data && data->oid_type);
+
+ pkt = git__calloc(1, sizeof(git_pkt_shallow));
+ GIT_ERROR_CHECK_ALLOC(pkt);
+
+ pkt->type = GIT_PKT_UNSHALLOW;
+
+ if (git__prefixncmp(line, len, "unshallow "))
+ goto out_err;
+
+ line += 10;
+ len -= 10;
+
+ if (len != oid_hexsize)
+ goto out_err;
+
+ git_oid_from_prefix(&pkt->oid, line, oid_hexsize, data->oid_type);
+ line += oid_hexsize + 1;
+ len -= oid_hexsize + 1;
+
+ *out = (git_pkt *) pkt;
+
+ return 0;
+
+out_err:
+ git_error_set(GIT_ERROR_NET, "invalid packet line");
+ git__free(pkt);
+ return -1;
+}
+
static int parse_len(size_t *out, const char *line, size_t linelen)
{
char num[PKT_LEN_SIZE + 1];
@@ -451,10 +536,10 @@ static int parse_len(size_t *out, const char *line, size_t linelen)
num[PKT_LEN_SIZE] = '\0';
for (i = 0; i < PKT_LEN_SIZE; ++i) {
- if (!isxdigit(num[i])) {
+ if (!git__isxdigit(num[i])) {
/* Make sure there are no special characters before passing to error message */
for (k = 0; k < PKT_LEN_SIZE; ++k) {
- if(!isprint(num[k])) {
+ if(!git__isprint(num[k])) {
num[k] = '.';
}
}
@@ -553,7 +638,7 @@ int git_pkt_parse_line(
else if (*line == GIT_SIDE_BAND_ERROR)
error = sideband_error_pkt(pkt, line, len);
else if (!git__prefixncmp(line, len, "ACK"))
- error = ack_pkt(pkt, line, len);
+ error = ack_pkt(pkt, line, len, data);
else if (!git__prefixncmp(line, len, "NAK"))
error = nak_pkt(pkt);
else if (!git__prefixncmp(line, len, "ERR"))
@@ -566,6 +651,10 @@ int git_pkt_parse_line(
error = ng_pkt(pkt, line, len);
else if (!git__prefixncmp(line, len, "unpack"))
error = unpack_pkt(pkt, line, len);
+ else if (!git__prefixcmp(line, "shallow"))
+ error = shallow_pkt(pkt, line, len, data);
+ else if (!git__prefixcmp(line, "unshallow"))
+ error = unshallow_pkt(pkt, line, len, data);
else
error = ref_pkt(pkt, line, len, data);
@@ -638,6 +727,9 @@ static int buffer_want_with_caps(
if (caps->ofs_delta)
git_str_puts(&str, GIT_CAP_OFS_DELTA " ");
+ if (caps->shallow)
+ git_str_puts(&str, GIT_CAP_SHALLOW " ");
+
if (git_str_oom(&str))
return -1;
@@ -668,8 +760,7 @@ static int buffer_want_with_caps(
*/
int git_pkt_buffer_wants(
- const git_remote_head * const *refs,
- size_t count,
+ const git_fetch_negotiation *wants,
transport_smart_caps *caps,
git_str *buf)
{
@@ -679,7 +770,7 @@ int git_pkt_buffer_wants(
size_t oid_hexsize, want_len, i = 0;
#ifdef GIT_EXPERIMENTAL_SHA256
- oid_type = count > 0 ? refs[0]->oid.type : GIT_OID_SHA1;
+ oid_type = wants->refs_len > 0 ? wants->refs[0]->oid.type : GIT_OID_SHA1;
#else
oid_type = GIT_OID_SHA1;
#endif
@@ -690,20 +781,20 @@ int git_pkt_buffer_wants(
oid_hexsize + 1 /* LF */;
if (caps->common) {
- for (; i < count; ++i) {
- head = refs[i];
+ for (; i < wants->refs_len; ++i) {
+ head = wants->refs[i];
if (!head->local)
break;
}
- if (buffer_want_with_caps(refs[i], caps, oid_type, buf) < 0)
+ if (buffer_want_with_caps(wants->refs[i], caps, oid_type, buf) < 0)
return -1;
i++;
}
- for (; i < count; ++i) {
- head = refs[i];
+ for (; i < wants->refs_len; ++i) {
+ head = wants->refs[i];
if (head->local)
continue;
@@ -718,6 +809,36 @@ int git_pkt_buffer_wants(
return -1;
}
+ /* Tell the server about our shallow objects */
+ for (i = 0; i < wants->shallow_roots_len; i++) {
+ char oid[GIT_OID_MAX_HEXSIZE + 1];
+ git_str shallow_buf = GIT_STR_INIT;
+
+ git_oid_tostr(oid, GIT_OID_MAX_HEXSIZE + 1, &wants->shallow_roots[i]);
+ git_str_puts(&shallow_buf, "shallow ");
+ git_str_puts(&shallow_buf, oid);
+ git_str_putc(&shallow_buf, '\n');
+
+ git_str_printf(buf, "%04x%s", (unsigned int)git_str_len(&shallow_buf) + 4, git_str_cstr(&shallow_buf));
+
+ git_str_dispose(&shallow_buf);
+
+ if (git_str_oom(buf))
+ return -1;
+ }
+
+ if (wants->depth > 0) {
+ git_str deepen_buf = GIT_STR_INIT;
+
+ git_str_printf(&deepen_buf, "deepen %d\n", wants->depth);
+ git_str_printf(buf,"%04x%s", (unsigned int)git_str_len(&deepen_buf) + 4, git_str_cstr(&deepen_buf));
+
+ git_str_dispose(&deepen_buf);
+
+ if (git_str_oom(buf))
+ return -1;
+ }
+
return git_pkt_buffer_flush(buf);
}
diff --git a/src/libgit2/transports/smart_protocol.c b/src/libgit2/transports/smart_protocol.c
index 0d47acafe0a..87c1904589d 100644
--- a/src/libgit2/transports/smart_protocol.c
+++ b/src/libgit2/transports/smart_protocol.c
@@ -27,7 +27,6 @@ bool git_smart__ofs_delta_enabled = true;
int git_smart__store_refs(transport_smart *t, int flushes)
{
- gitno_buffer *buf = &t->buffer;
git_vector *refs = &t->refs;
int error, flush = 0, recvd;
const char *line_end = NULL;
@@ -45,8 +44,10 @@ int git_smart__store_refs(transport_smart *t, int flushes)
pkt = NULL;
do {
- if (buf->offset > 0)
- error = git_pkt_parse_line(&pkt, &line_end, buf->data, buf->offset, &pkt_parse_data);
+ if (t->buffer.len > 0)
+ error = git_pkt_parse_line(&pkt, &line_end,
+ t->buffer.data, t->buffer.len,
+ &pkt_parse_data);
else
error = GIT_EBUFS;
@@ -54,19 +55,18 @@ int git_smart__store_refs(transport_smart *t, int flushes)
return error;
if (error == GIT_EBUFS) {
- if ((recvd = gitno_recv(buf)) < 0)
+ if ((recvd = git_smart__recv(t)) < 0)
return recvd;
if (recvd == 0) {
- git_error_set(GIT_ERROR_NET, "early EOF");
+ git_error_set(GIT_ERROR_NET, "could not read refs from remote repository");
return GIT_EEOF;
}
continue;
}
- if (gitno_consume(buf, line_end) < 0)
- return -1;
+ git_staticstr_consume(&t->buffer, line_end);
if (pkt->type == GIT_PKT_ERR) {
git_error_set(GIT_ERROR_NET, "remote error: %s", ((git_pkt_err *)pkt)->error);
@@ -194,6 +194,12 @@ int git_smart__detect_caps(
continue;
}
+ if (!git__prefixcmp(ptr, GIT_CAP_PUSH_OPTIONS)) {
+ caps->common = caps->push_options = 1;
+ ptr += strlen(GIT_CAP_PUSH_OPTIONS);
+ continue;
+ }
+
if (!git__prefixcmp(ptr, GIT_CAP_THIN_PACK)) {
caps->common = caps->thin_pack = 1;
ptr += strlen(GIT_CAP_THIN_PACK);
@@ -243,6 +249,12 @@ int git_smart__detect_caps(
continue;
}
+ if (!git__prefixcmp(ptr, GIT_CAP_SHALLOW)) {
+ caps->common = caps->shallow = 1;
+ ptr += strlen(GIT_CAP_SHALLOW);
+ continue;
+ }
+
/* We don't know this capability, so skip it */
ptr = strchr(ptr, ' ');
}
@@ -250,16 +262,23 @@ int git_smart__detect_caps(
return 0;
}
-static int recv_pkt(git_pkt **out_pkt, git_pkt_type *out_type, gitno_buffer *buf)
+static int recv_pkt(
+ git_pkt **out_pkt,
+ git_pkt_type *out_type,
+ transport_smart *t)
{
- const char *ptr = buf->data, *line_end = ptr;
+ const char *ptr = t->buffer.data, *line_end = ptr;
git_pkt *pkt = NULL;
git_pkt_parse_data pkt_parse_data = { 0 };
int error = 0, ret;
+ pkt_parse_data.oid_type = t->owner->repo->oid_type;
+ pkt_parse_data.seen_capabilities = 1;
+
do {
- if (buf->offset > 0)
- error = git_pkt_parse_line(&pkt, &line_end, ptr, buf->offset, &pkt_parse_data);
+ if (t->buffer.len > 0)
+ error = git_pkt_parse_line(&pkt, &line_end, ptr,
+ t->buffer.len, &pkt_parse_data);
else
error = GIT_EBUFS;
@@ -269,16 +288,15 @@ static int recv_pkt(git_pkt **out_pkt, git_pkt_type *out_type, gitno_buffer *buf
if (error < 0 && error != GIT_EBUFS)
return error;
- if ((ret = gitno_recv(buf)) < 0) {
+ if ((ret = git_smart__recv(t)) < 0) {
return ret;
} else if (ret == 0) {
- git_error_set(GIT_ERROR_NET, "early EOF");
+ git_error_set(GIT_ERROR_NET, "could not read from remote repository");
return GIT_EEOF;
}
} while (error);
- if (gitno_consume(buf, line_end) < 0)
- return -1;
+ git_staticstr_consume(&t->buffer, line_end);
if (out_type != NULL)
*out_type = pkt->type;
@@ -293,13 +311,19 @@ static int recv_pkt(git_pkt **out_pkt, git_pkt_type *out_type, gitno_buffer *buf
static int store_common(transport_smart *t)
{
git_pkt *pkt = NULL;
- gitno_buffer *buf = &t->buffer;
int error;
do {
- if ((error = recv_pkt(&pkt, NULL, buf)) < 0)
+ if ((error = recv_pkt(&pkt, NULL, t)) < 0)
return error;
+ if (t->rpc && (pkt->type == GIT_PKT_SHALLOW ||
+ pkt->type == GIT_PKT_UNSHALLOW ||
+ pkt->type == GIT_PKT_FLUSH)) {
+ git__free(pkt);
+ continue;
+ }
+
if (pkt->type != GIT_PKT_ACK) {
git__free(pkt);
return 0;
@@ -314,7 +338,7 @@ static int store_common(transport_smart *t)
return 0;
}
-static int wait_while_ack(gitno_buffer *buf)
+static int wait_while_ack(transport_smart *t)
{
int error;
git_pkt *pkt = NULL;
@@ -323,7 +347,7 @@ static int wait_while_ack(gitno_buffer *buf)
while (1) {
git_pkt_free(pkt);
- if ((error = recv_pkt(&pkt, NULL, buf)) < 0)
+ if ((error = recv_pkt(&pkt, NULL, t)) < 0)
return error;
if (pkt->type == GIT_PKT_NAK)
@@ -344,11 +368,52 @@ static int wait_while_ack(gitno_buffer *buf)
return 0;
}
-int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, const git_remote_head * const *wants, size_t count)
+static int cap_not_sup_err(const char *cap_name)
+{
+ git_error_set(GIT_ERROR_NET, "server doesn't support %s", cap_name);
+ return GIT_EINVALID;
+}
+
+/* Disables server capabilities we're not interested in */
+static int setup_caps(
+ transport_smart_caps *caps,
+ const git_fetch_negotiation *wants)
+{
+ if (wants->depth > 0) {
+ if (!caps->shallow)
+ return cap_not_sup_err(GIT_CAP_SHALLOW);
+ } else {
+ caps->shallow = 0;
+ }
+
+ return 0;
+}
+
+static int setup_shallow_roots(
+ git_array_oid_t *out,
+ const git_fetch_negotiation *wants)
+{
+ git_array_clear(*out);
+
+ if (wants->shallow_roots_len > 0) {
+ git_array_init_to_size(*out, wants->shallow_roots_len);
+ GIT_ERROR_CHECK_ALLOC(out->ptr);
+
+ memcpy(out->ptr, wants->shallow_roots,
+ sizeof(git_oid) * wants->shallow_roots_len);
+ out->size = wants->shallow_roots_len;
+ }
+
+ return 0;
+}
+
+int git_smart__negotiate_fetch(
+ git_transport *transport,
+ git_repository *repo,
+ const git_fetch_negotiation *wants)
{
transport_smart *t = (transport_smart *)transport;
git_revwalk__push_options opts = GIT_REVWALK__PUSH_OPTIONS_INIT;
- gitno_buffer *buf = &t->buffer;
git_str data = GIT_STR_INIT;
git_revwalk *walk = NULL;
int error = -1;
@@ -356,7 +421,11 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c
unsigned int i;
git_oid oid;
- if ((error = git_pkt_buffer_wants(wants, count, &t->caps, &data)) < 0)
+ if ((error = setup_caps(&t->caps, wants)) < 0 ||
+ (error = setup_shallow_roots(&t->shallow_roots, wants)) < 0)
+ return error;
+
+ if ((error = git_pkt_buffer_wants(wants, &t->caps, &data)) < 0)
return error;
if ((error = git_revwalk_new(&walk, repo)) < 0)
@@ -366,6 +435,40 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c
if ((error = git_revwalk__push_glob(walk, "refs/*", &opts)) < 0)
goto on_error;
+ if (wants->depth > 0) {
+ git_pkt_shallow *pkt;
+
+ if ((error = git_smart__negotiation_step(&t->parent, data.ptr, data.size)) < 0)
+ goto on_error;
+
+ if (!t->rpc)
+ git_str_clear(&data);
+
+ while ((error = recv_pkt((git_pkt **)&pkt, NULL, t)) == 0) {
+ bool complete = false;
+
+ if (pkt->type == GIT_PKT_SHALLOW) {
+ error = git_oidarray__add(&t->shallow_roots, &pkt->oid);
+ } else if (pkt->type == GIT_PKT_UNSHALLOW) {
+ git_oidarray__remove(&t->shallow_roots, &pkt->oid);
+ } else if (pkt->type == GIT_PKT_FLUSH) {
+ /* Server is done, stop processing shallow oids */
+ complete = true;
+ } else {
+ git_error_set(GIT_ERROR_NET, "unexpected packet type");
+ error = -1;
+ }
+
+ git_pkt_free((git_pkt *) pkt);
+
+ if (complete || error < 0)
+ break;
+ }
+
+ if (error < 0)
+ goto on_error;
+ }
+
/*
* Our support for ACK extensions is simply to parse them. On
* the first ACK we will accept that as enough common
@@ -406,7 +509,7 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c
if ((error = store_common(t)) < 0)
goto on_error;
} else {
- if ((error = recv_pkt(NULL, &pkt_type, buf)) < 0)
+ if ((error = recv_pkt(NULL, &pkt_type, t)) < 0)
goto on_error;
if (pkt_type == GIT_PKT_ACK) {
@@ -428,7 +531,7 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c
git_pkt_ack *pkt;
unsigned int j;
- if ((error = git_pkt_buffer_wants(wants, count, &t->caps, &data)) < 0)
+ if ((error = git_pkt_buffer_wants(wants, &t->caps, &data)) < 0)
goto on_error;
git_vector_foreach(&t->common, j, pkt) {
@@ -448,7 +551,7 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c
git_pkt_ack *pkt;
unsigned int j;
- if ((error = git_pkt_buffer_wants(wants, count, &t->caps, &data)) < 0)
+ if ((error = git_pkt_buffer_wants(wants, &t->caps, &data)) < 0)
goto on_error;
git_vector_foreach(&t->common, j, pkt) {
@@ -466,10 +569,11 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c
goto on_error;
if (t->cancelled.val) {
- git_error_set(GIT_ERROR_NET, "The fetch was cancelled by the user");
+ git_error_set(GIT_ERROR_NET, "the fetch was cancelled");
error = GIT_EUSER;
goto on_error;
}
+
if ((error = git_smart__negotiation_step(&t->parent, data.ptr, data.size)) < 0)
goto on_error;
@@ -478,7 +582,7 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c
/* Now let's eat up whatever the server gives us */
if (!t->caps.multi_ack && !t->caps.multi_ack_detailed) {
- if ((error = recv_pkt(NULL, &pkt_type, buf)) < 0)
+ if ((error = recv_pkt(NULL, &pkt_type, t)) < 0)
return error;
if (pkt_type != GIT_PKT_ACK && pkt_type != GIT_PKT_NAK) {
@@ -486,7 +590,7 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c
return -1;
}
} else {
- error = wait_while_ack(buf);
+ error = wait_while_ack(t);
}
return error;
@@ -497,7 +601,29 @@ int git_smart__negotiate_fetch(git_transport *transport, git_repository *repo, c
return error;
}
-static int no_sideband(transport_smart *t, struct git_odb_writepack *writepack, gitno_buffer *buf, git_indexer_progress *stats)
+int git_smart__shallow_roots(git_oidarray *out, git_transport *transport)
+{
+ transport_smart *t = (transport_smart *)transport;
+ size_t len;
+
+ GIT_ERROR_CHECK_ALLOC_MULTIPLY(&len, t->shallow_roots.size, sizeof(git_oid));
+
+ out->count = t->shallow_roots.size;
+
+ if (len) {
+ out->ids = git__malloc(len);
+ memcpy(out->ids, t->shallow_roots.ptr, len);
+ } else {
+ out->ids = NULL;
+ }
+
+ return 0;
+}
+
+static int no_sideband(
+ transport_smart *t,
+ struct git_odb_writepack *writepack,
+ git_indexer_progress *stats)
{
int recvd;
@@ -507,12 +633,12 @@ static int no_sideband(transport_smart *t, struct git_odb_writepack *writepack,
return GIT_EUSER;
}
- if (writepack->append(writepack, buf->data, buf->offset, stats) < 0)
+ if (writepack->append(writepack, t->buffer.data, t->buffer.len, stats) < 0)
return -1;
- gitno_consume_n(buf, buf->offset);
+ git_staticstr_clear(&t->buffer);
- if ((recvd = gitno_recv(buf)) < 0)
+ if ((recvd = git_smart__recv(t)) < 0)
return recvd;
} while(recvd > 0);
@@ -554,7 +680,6 @@ int git_smart__download_pack(
git_indexer_progress *stats)
{
transport_smart *t = (transport_smart *)transport;
- gitno_buffer *buf = &t->buffer;
git_odb *odb;
struct git_odb_writepack *writepack = NULL;
int error = 0;
@@ -573,9 +698,10 @@ int git_smart__download_pack(
t->packetsize_payload = &npp;
/* We might have something in the buffer already from negotiate_fetch */
- if (t->buffer.offset > 0 && !t->cancelled.val)
- if (t->packetsize_cb(t->buffer.offset, t->packetsize_payload))
+ if (t->buffer.len > 0 && !t->cancelled.val) {
+ if (t->packetsize_cb(t->buffer.len, t->packetsize_payload))
git_atomic32_set(&t->cancelled, 1);
+ }
}
if ((error = git_repository_odb__weakptr(&odb, repo)) < 0 ||
@@ -588,7 +714,7 @@ int git_smart__download_pack(
* check which one belongs there.
*/
if (!t->caps.side_band && !t->caps.side_band_64k) {
- error = no_sideband(t, writepack, buf, stats);
+ error = no_sideband(t, writepack, stats);
goto done;
}
@@ -602,7 +728,7 @@ int git_smart__download_pack(
goto done;
}
- if ((error = recv_pkt(&pkt, NULL, buf)) >= 0) {
+ if ((error = recv_pkt(&pkt, NULL, t)) >= 0) {
/* Check cancellation after network call */
if (t->cancelled.val) {
git_error_clear();
@@ -669,33 +795,54 @@ int git_smart__download_pack(
static int gen_pktline(git_str *buf, git_push *push)
{
push_spec *spec;
+ char *option;
size_t i, len;
- char old_id[GIT_OID_SHA1_HEXSIZE+1], new_id[GIT_OID_SHA1_HEXSIZE+1];
-
- old_id[GIT_OID_SHA1_HEXSIZE] = '\0'; new_id[GIT_OID_SHA1_HEXSIZE] = '\0';
+ char old_id[GIT_OID_MAX_HEXSIZE + 1], new_id[GIT_OID_MAX_HEXSIZE + 1];
+ size_t old_id_len, new_id_len;
git_vector_foreach(&push->specs, i, spec) {
- len = 2*GIT_OID_SHA1_HEXSIZE + 7 + strlen(spec->refspec.dst);
+ len = strlen(spec->refspec.dst) + 7;
if (i == 0) {
- ++len; /* '\0' */
+ /* Need a leading \0 */
+ ++len;
+
if (push->report_status)
len += strlen(GIT_CAP_REPORT_STATUS) + 1;
+
+ if (git_vector_length(&push->remote_push_options) > 0)
+ len += strlen(GIT_CAP_PUSH_OPTIONS) + 1;
+
len += strlen(GIT_CAP_SIDE_BAND_64K) + 1;
}
+ old_id_len = git_oid_hexsize(git_oid_type(&spec->roid));
+ new_id_len = git_oid_hexsize(git_oid_type(&spec->loid));
+
+ len += (old_id_len + new_id_len);
+
git_oid_fmt(old_id, &spec->roid);
+ old_id[old_id_len] = '\0';
+
git_oid_fmt(new_id, &spec->loid);
+ new_id[new_id_len] = '\0';
- git_str_printf(buf, "%04"PRIxZ"%s %s %s", len, old_id, new_id, spec->refspec.dst);
+ git_str_printf(buf, "%04"PRIxZ"%.*s %.*s %s", len,
+ (int)old_id_len, old_id, (int)new_id_len, new_id,
+ spec->refspec.dst);
if (i == 0) {
git_str_putc(buf, '\0');
+
/* Core git always starts their capabilities string with a space */
if (push->report_status) {
git_str_putc(buf, ' ');
git_str_printf(buf, GIT_CAP_REPORT_STATUS);
}
+ if (git_vector_length(&push->remote_push_options) > 0) {
+ git_str_putc(buf, ' ');
+ git_str_printf(buf, GIT_CAP_PUSH_OPTIONS);
+ }
git_str_putc(buf, ' ');
git_str_printf(buf, GIT_CAP_SIDE_BAND_64K);
}
@@ -703,6 +850,13 @@ static int gen_pktline(git_str *buf, git_push *push)
git_str_putc(buf, '\n');
}
+ if (git_vector_length(&push->remote_push_options) > 0) {
+ git_str_printf(buf, "0000");
+ git_vector_foreach(&push->remote_push_options, i, option) {
+ git_str_printf(buf, "%04"PRIxZ"%s", strlen(option) + 4 , option);
+ }
+ }
+
git_str_puts(buf, "0000");
return git_str_oom(buf) ? -1 : 0;
}
@@ -807,15 +961,15 @@ static int parse_report(transport_smart *transport, git_push *push)
git_pkt *pkt = NULL;
git_pkt_parse_data pkt_parse_data = { 0 };
const char *line_end = NULL;
- gitno_buffer *buf = &transport->buffer;
int error, recvd;
git_str data_pkt_buf = GIT_STR_INIT;
for (;;) {
- if (buf->offset > 0)
+ if (transport->buffer.len > 0)
error = git_pkt_parse_line(&pkt, &line_end,
- buf->data, buf->offset,
- &pkt_parse_data);
+ transport->buffer.data,
+ transport->buffer.len,
+ &pkt_parse_data);
else
error = GIT_EBUFS;
@@ -825,22 +979,20 @@ static int parse_report(transport_smart *transport, git_push *push)
}
if (error == GIT_EBUFS) {
- if ((recvd = gitno_recv(buf)) < 0) {
+ if ((recvd = git_smart__recv(transport)) < 0) {
error = recvd;
goto done;
}
if (recvd == 0) {
- git_error_set(GIT_ERROR_NET, "early EOF");
+ git_error_set(GIT_ERROR_NET, "could not read report from remote repository");
error = GIT_EEOF;
goto done;
}
continue;
}
- if (gitno_consume(buf, line_end) < 0)
- return -1;
-
+ git_staticstr_consume(&transport->buffer, line_end);
error = 0;
switch (pkt->type) {
@@ -1005,7 +1157,7 @@ struct push_packbuilder_payload
git_push_transfer_progress_cb cb;
void *cb_payload;
size_t last_bytes;
- double last_progress_report_time;
+ uint64_t last_progress_report_time;
};
static int stream_thunk(void *buf, size_t size, void *data)
@@ -1017,11 +1169,11 @@ static int stream_thunk(void *buf, size_t size, void *data)
return error;
if (payload->cb) {
- double current_time = git__timer();
- double elapsed = current_time - payload->last_progress_report_time;
+ uint64_t current_time = git_time_monotonic();
+ uint64_t elapsed = current_time - payload->last_progress_report_time;
payload->last_bytes += size;
- if (elapsed < 0 || elapsed >= MIN_PROGRESS_UPDATE_INTERVAL) {
+ if (elapsed >= MIN_PROGRESS_UPDATE_INTERVAL) {
payload->last_progress_report_time = current_time;
error = payload->cb(payload->pb->nr_written, payload->pb->nr_objects, payload->last_bytes, payload->cb_payload);
}
@@ -1050,7 +1202,7 @@ int git_smart__push(git_transport *transport, git_push *push)
#ifdef PUSH_DEBUG
{
git_remote_head *head;
- char hex[GIT_OID_SHA1_HEXSIZE+1]; hex[GIT_OID_SHA1_HEXSIZE] = '\0';
+ char hex[GIT_OID_MAX_HEXSIZE+1], hex[GIT_OID_MAX_HEXSIZE] = '\0';
git_vector_foreach(&push->remote->refs, i, head) {
git_oid_fmt(hex, &head->oid);
diff --git a/src/libgit2/transports/ssh.c b/src/libgit2/transports/ssh.c
index 5500ea100bd..3f3a127f256 100644
--- a/src/libgit2/transports/ssh.c
+++ b/src/libgit2/transports/ssh.c
@@ -5,1090 +5,67 @@
* a Linking Exception. For full terms see the included COPYING file.
*/
-#include "ssh.h"
-
-#ifdef GIT_SSH
-#include
-#endif
-
-#include "runtime.h"
-#include "net.h"
-#include "netops.h"
-#include "smart.h"
-#include "streams/socket.h"
-#include "sysdir.h"
-
-#include "git2/credential.h"
-#include "git2/sys/credential.h"
-
-#ifdef GIT_SSH
-
-#define OWNING_SUBTRANSPORT(s) ((ssh_subtransport *)(s)->parent.subtransport)
-
-static const char cmd_uploadpack[] = "git-upload-pack";
-static const char cmd_receivepack[] = "git-receive-pack";
-
-typedef struct {
- git_smart_subtransport_stream parent;
- git_stream *io;
- LIBSSH2_SESSION *session;
- LIBSSH2_CHANNEL *channel;
- const char *cmd;
- git_net_url url;
- unsigned sent_command : 1;
-} ssh_stream;
-
-typedef struct {
- git_smart_subtransport parent;
- transport_smart *owner;
- ssh_stream *current_stream;
- git_credential *cred;
- char *cmd_uploadpack;
- char *cmd_receivepack;
-} ssh_subtransport;
-
-static int list_auth_methods(int *out, LIBSSH2_SESSION *session, const char *username);
-
-static void ssh_error(LIBSSH2_SESSION *session, const char *errmsg)
-{
- char *ssherr;
- libssh2_session_last_error(session, &ssherr, NULL, 0);
-
- git_error_set(GIT_ERROR_SSH, "%s: %s", errmsg, ssherr);
-}
-
-/*
- * Create a git protocol request.
- *
- * For example: git-upload-pack '/libgit2/libgit2'
- */
-static int gen_proto(git_str *request, const char *cmd, git_net_url *url)
-{
- const char *repo;
-
- repo = url->path;
-
- if (repo && repo[0] == '/' && repo[1] == '~')
- repo++;
-
- if (!repo || !repo[0]) {
- git_error_set(GIT_ERROR_NET, "malformed git protocol URL");
- return -1;
- }
-
- git_str_puts(request, cmd);
- git_str_puts(request, " '");
- git_str_puts(request, repo);
- git_str_puts(request, "'");
-
- if (git_str_oom(request))
- return -1;
-
- return 0;
-}
-
-static int send_command(ssh_stream *s)
-{
- int error;
- git_str request = GIT_STR_INIT;
-
- error = gen_proto(&request, s->cmd, &s->url);
- if (error < 0)
- goto cleanup;
-
- error = libssh2_channel_exec(s->channel, request.ptr);
- if (error < LIBSSH2_ERROR_NONE) {
- ssh_error(s->session, "SSH could not execute request");
- goto cleanup;
- }
-
- s->sent_command = 1;
-
-cleanup:
- git_str_dispose(&request);
- return error;
-}
-
-static int ssh_stream_read(
- git_smart_subtransport_stream *stream,
- char *buffer,
- size_t buf_size,
- size_t *bytes_read)
-{
- int rc;
- ssh_stream *s = GIT_CONTAINER_OF(stream, ssh_stream, parent);
-
- *bytes_read = 0;
-
- if (!s->sent_command && send_command(s) < 0)
- return -1;
-
- if ((rc = libssh2_channel_read(s->channel, buffer, buf_size)) < LIBSSH2_ERROR_NONE) {
- ssh_error(s->session, "SSH could not read data");
- return -1;
- }
-
- /*
- * If we can't get anything out of stdout, it's typically a
- * not-found error, so read from stderr and signal EOF on
- * stderr.
- */
- if (rc == 0) {
- if ((rc = libssh2_channel_read_stderr(s->channel, buffer, buf_size)) > 0) {
- git_error_set(GIT_ERROR_SSH, "%*s", rc, buffer);
- return GIT_EEOF;
- } else if (rc < LIBSSH2_ERROR_NONE) {
- ssh_error(s->session, "SSH could not read stderr");
- return -1;
- }
- }
-
-
- *bytes_read = rc;
-
- return 0;
-}
-
-static int ssh_stream_write(
- git_smart_subtransport_stream *stream,
- const char *buffer,
- size_t len)
-{
- ssh_stream *s = GIT_CONTAINER_OF(stream, ssh_stream, parent);
- size_t off = 0;
- ssize_t ret = 0;
-
- if (!s->sent_command && send_command(s) < 0)
- return -1;
-
- do {
- ret = libssh2_channel_write(s->channel, buffer + off, len - off);
- if (ret < 0)
- break;
-
- off += ret;
-
- } while (off < len);
-
- if (ret < 0) {
- ssh_error(s->session, "SSH could not write data");
- return -1;
- }
-
- return 0;
-}
-
-static void ssh_stream_free(git_smart_subtransport_stream *stream)
-{
- ssh_stream *s = GIT_CONTAINER_OF(stream, ssh_stream, parent);
- ssh_subtransport *t;
-
- if (!stream)
- return;
-
- t = OWNING_SUBTRANSPORT(s);
- t->current_stream = NULL;
-
- if (s->channel) {
- libssh2_channel_close(s->channel);
- libssh2_channel_free(s->channel);
- s->channel = NULL;
- }
-
- if (s->session) {
- libssh2_session_disconnect(s->session, "closing transport");
- libssh2_session_free(s->session);
- s->session = NULL;
- }
-
- if (s->io) {
- git_stream_close(s->io);
- git_stream_free(s->io);
- s->io = NULL;
- }
-
- git_net_url_dispose(&s->url);
- git__free(s);
-}
-
-static int ssh_stream_alloc(
- ssh_subtransport *t,
- const char *cmd,
- git_smart_subtransport_stream **stream)
-{
- ssh_stream *s;
-
- GIT_ASSERT_ARG(stream);
-
- s = git__calloc(sizeof(ssh_stream), 1);
- GIT_ERROR_CHECK_ALLOC(s);
-
- s->parent.subtransport = &t->parent;
- s->parent.read = ssh_stream_read;
- s->parent.write = ssh_stream_write;
- s->parent.free = ssh_stream_free;
-
- s->cmd = cmd;
-
- *stream = &s->parent;
- return 0;
-}
-
-static int ssh_agent_auth(LIBSSH2_SESSION *session, git_credential_ssh_key *c) {
- int rc = LIBSSH2_ERROR_NONE;
-
- struct libssh2_agent_publickey *curr, *prev = NULL;
-
- LIBSSH2_AGENT *agent = libssh2_agent_init(session);
-
- if (agent == NULL)
- return -1;
-
- rc = libssh2_agent_connect(agent);
-
- if (rc != LIBSSH2_ERROR_NONE) {
- rc = LIBSSH2_ERROR_AUTHENTICATION_FAILED;
- goto shutdown;
- }
-
- rc = libssh2_agent_list_identities(agent);
-
- if (rc != LIBSSH2_ERROR_NONE)
- goto shutdown;
-
- while (1) {
- rc = libssh2_agent_get_identity(agent, &curr, prev);
-
- if (rc < 0)
- goto shutdown;
-
- /* rc is set to 1 whenever the ssh agent ran out of keys to check.
- * Set the error code to authentication failure rather than erroring
- * out with an untranslatable error code.
- */
- if (rc == 1) {
- rc = LIBSSH2_ERROR_AUTHENTICATION_FAILED;
- goto shutdown;
- }
-
- rc = libssh2_agent_userauth(agent, c->username, curr);
-
- if (rc == 0)
- break;
-
- prev = curr;
- }
-
-shutdown:
-
- if (rc != LIBSSH2_ERROR_NONE)
- ssh_error(session, "error authenticating");
-
- libssh2_agent_disconnect(agent);
- libssh2_agent_free(agent);
-
- return rc;
-}
-
-static int _git_ssh_authenticate_session(
- LIBSSH2_SESSION *session,
- git_credential *cred)
-{
- int rc;
-
- do {
- git_error_clear();
- switch (cred->credtype) {
- case GIT_CREDENTIAL_USERPASS_PLAINTEXT: {
- git_credential_userpass_plaintext *c = (git_credential_userpass_plaintext *)cred;
- rc = libssh2_userauth_password(session, c->username, c->password);
- break;
- }
- case GIT_CREDENTIAL_SSH_KEY: {
- git_credential_ssh_key *c = (git_credential_ssh_key *)cred;
-
- if (c->privatekey)
- rc = libssh2_userauth_publickey_fromfile(
- session, c->username, c->publickey,
- c->privatekey, c->passphrase);
- else
- rc = ssh_agent_auth(session, c);
-
- break;
- }
- case GIT_CREDENTIAL_SSH_CUSTOM: {
- git_credential_ssh_custom *c = (git_credential_ssh_custom *)cred;
-
- rc = libssh2_userauth_publickey(
- session, c->username, (const unsigned char *)c->publickey,
- c->publickey_len, c->sign_callback, &c->payload);
- break;
- }
- case GIT_CREDENTIAL_SSH_INTERACTIVE: {
- void **abstract = libssh2_session_abstract(session);
- git_credential_ssh_interactive *c = (git_credential_ssh_interactive *)cred;
-
- /* ideally, we should be able to set this by calling
- * libssh2_session_init_ex() instead of libssh2_session_init().
- * libssh2's API is inconsistent here i.e. libssh2_userauth_publickey()
- * allows you to pass the `abstract` as part of the call, whereas
- * libssh2_userauth_keyboard_interactive() does not!
- *
- * The only way to set the `abstract` pointer is by calling
- * libssh2_session_abstract(), which will replace the existing
- * pointer as is done below. This is safe for now (at time of writing),
- * but may not be valid in future.
- */
- *abstract = c->payload;
-
- rc = libssh2_userauth_keyboard_interactive(
- session, c->username, c->prompt_callback);
- break;
- }
-#ifdef GIT_SSH_MEMORY_CREDENTIALS
- case GIT_CREDENTIAL_SSH_MEMORY: {
- git_credential_ssh_key *c = (git_credential_ssh_key *)cred;
-
- GIT_ASSERT(c->username);
- GIT_ASSERT(c->privatekey);
-
- rc = libssh2_userauth_publickey_frommemory(
- session,
- c->username,
- strlen(c->username),
- c->publickey,
- c->publickey ? strlen(c->publickey) : 0,
- c->privatekey,
- strlen(c->privatekey),
- c->passphrase);
- break;
- }
-#endif
- default:
- rc = LIBSSH2_ERROR_AUTHENTICATION_FAILED;
- }
- } while (LIBSSH2_ERROR_EAGAIN == rc || LIBSSH2_ERROR_TIMEOUT == rc);
-
- if (rc == LIBSSH2_ERROR_PASSWORD_EXPIRED ||
- rc == LIBSSH2_ERROR_AUTHENTICATION_FAILED ||
- rc == LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED)
- return GIT_EAUTH;
-
- if (rc != LIBSSH2_ERROR_NONE) {
- if (!git_error_last())
- ssh_error(session, "Failed to authenticate SSH session");
- return -1;
- }
-
- return 0;
-}
-
-static int request_creds(git_credential **out, ssh_subtransport *t, const char *user, int auth_methods)
-{
- int error, no_callback = 0;
- git_credential *cred = NULL;
-
- if (!t->owner->connect_opts.callbacks.credentials) {
- no_callback = 1;
- } else {
- error = t->owner->connect_opts.callbacks.credentials(
- &cred,
- t->owner->url,
- user,
- auth_methods,
- t->owner->connect_opts.callbacks.payload);
-
- if (error == GIT_PASSTHROUGH) {
- no_callback = 1;
- } else if (error < 0) {
- return error;
- } else if (!cred) {
- git_error_set(GIT_ERROR_SSH, "callback failed to initialize SSH credentials");
- return -1;
- }
- }
-
- if (no_callback) {
- git_error_set(GIT_ERROR_SSH, "authentication required but no callback set");
- return GIT_EAUTH;
- }
-
- if (!(cred->credtype & auth_methods)) {
- cred->free(cred);
- git_error_set(GIT_ERROR_SSH, "authentication callback returned unsupported credentials type");
- return GIT_EAUTH;
- }
-
- *out = cred;
-
- return 0;
-}
-
-#define SSH_DIR ".ssh"
-#define KNOWN_HOSTS_FILE "known_hosts"
-
-/*
- * Load the known_hosts file.
- *
- * Returns success but leaves the output NULL if we couldn't find the file.
- */
-static int load_known_hosts(LIBSSH2_KNOWNHOSTS **hosts, LIBSSH2_SESSION *session)
-{
- git_str path = GIT_STR_INIT, sshdir = GIT_STR_INIT;
- LIBSSH2_KNOWNHOSTS *known_hosts = NULL;
- int error;
-
- GIT_ASSERT_ARG(hosts);
-
- if ((error = git_sysdir_expand_homedir_file(&sshdir, SSH_DIR)) < 0 ||
- (error = git_str_joinpath(&path, git_str_cstr(&sshdir), KNOWN_HOSTS_FILE)) < 0)
- goto out;
-
- if ((known_hosts = libssh2_knownhost_init(session)) == NULL) {
- ssh_error(session, "error initializing known hosts");
- error = -1;
- goto out;
- }
-
- /*
- * Try to read the file and consider not finding it as not trusting the
- * host rather than an error.
- */
- error = libssh2_knownhost_readfile(known_hosts, git_str_cstr(&path), LIBSSH2_KNOWNHOST_FILE_OPENSSH);
- if (error == LIBSSH2_ERROR_FILE)
- error = 0;
- if (error < 0)
- ssh_error(session, "error reading known_hosts");
-
-out:
- *hosts = known_hosts;
-
- git_str_dispose(&sshdir);
- git_str_dispose(&path);
-
- return error;
-}
-
-static void add_hostkey_pref_if_avail(
- LIBSSH2_KNOWNHOSTS *known_hosts,
- const char *hostname,
- int port,
- git_str *prefs,
- int type,
- const char *type_name)
-{
- struct libssh2_knownhost *host = NULL;
- const char key = '\0';
- int mask = LIBSSH2_KNOWNHOST_TYPE_PLAIN | LIBSSH2_KNOWNHOST_KEYENC_RAW | type;
- int error;
-
- error = libssh2_knownhost_checkp(known_hosts, hostname, port, &key, 1, mask, &host);
- if (error == LIBSSH2_KNOWNHOST_CHECK_MISMATCH) {
- if (git_str_len(prefs) > 0) {
- git_str_putc(prefs, ',');
- }
- git_str_puts(prefs, type_name);
- }
-}
-
-/*
- * We figure out what kind of key we want to ask the remote for by trying to
- * look it up with a nonsense key and using that mismatch to figure out what key
- * we do have stored for the host.
- *
- * Populates prefs with the string to pass to libssh2_session_method_pref.
- */
-static void find_hostkey_preference(
- LIBSSH2_KNOWNHOSTS *known_hosts,
- const char *hostname,
- int port,
- git_str *prefs)
-{
- /*
- * The order here is important as it indicates the priority of what will
- * be preferred.
- */
-#ifdef LIBSSH2_KNOWNHOST_KEY_ED25519
- add_hostkey_pref_if_avail(known_hosts, hostname, port, prefs, LIBSSH2_KNOWNHOST_KEY_ED25519, "ssh-ed25519");
-#endif
-#ifdef LIBSSH2_KNOWNHOST_KEY_ECDSA_256
- add_hostkey_pref_if_avail(known_hosts, hostname, port, prefs, LIBSSH2_KNOWNHOST_KEY_ECDSA_256, "ecdsa-sha2-nistp256");
- add_hostkey_pref_if_avail(known_hosts, hostname, port, prefs, LIBSSH2_KNOWNHOST_KEY_ECDSA_384, "ecdsa-sha2-nistp384");
- add_hostkey_pref_if_avail(known_hosts, hostname, port, prefs, LIBSSH2_KNOWNHOST_KEY_ECDSA_521, "ecdsa-sha2-nistp521");
-#endif
- add_hostkey_pref_if_avail(known_hosts, hostname, port, prefs, LIBSSH2_KNOWNHOST_KEY_SSHRSA, "ssh-rsa");
-}
-
-static int _git_ssh_session_create(
- LIBSSH2_SESSION **session,
- LIBSSH2_KNOWNHOSTS **hosts,
- const char *hostname,
- int port,
- git_stream *io)
-{
- git_socket_stream *socket = GIT_CONTAINER_OF(io, git_socket_stream, parent);
- LIBSSH2_SESSION *s;
- LIBSSH2_KNOWNHOSTS *known_hosts;
- git_str prefs = GIT_STR_INIT;
- int rc = 0;
-
- GIT_ASSERT_ARG(session);
- GIT_ASSERT_ARG(hosts);
-
- s = libssh2_session_init();
- if (!s) {
- git_error_set(GIT_ERROR_NET, "failed to initialize SSH session");
- return -1;
- }
-
- if ((rc = load_known_hosts(&known_hosts, s)) < 0) {
- ssh_error(s, "error loading known_hosts");
- libssh2_session_free(s);
- return -1;
- }
-
- find_hostkey_preference(known_hosts, hostname, port, &prefs);
- if (git_str_len(&prefs) > 0) {
- do {
- rc = libssh2_session_method_pref(s, LIBSSH2_METHOD_HOSTKEY, git_str_cstr(&prefs));
- } while (LIBSSH2_ERROR_EAGAIN == rc || LIBSSH2_ERROR_TIMEOUT == rc);
- if (rc != LIBSSH2_ERROR_NONE) {
- ssh_error(s, "failed to set hostkey preference");
- goto on_error;
- }
- }
- git_str_dispose(&prefs);
-
- do {
- rc = libssh2_session_handshake(s, socket->s);
- } while (LIBSSH2_ERROR_EAGAIN == rc || LIBSSH2_ERROR_TIMEOUT == rc);
-
- if (rc != LIBSSH2_ERROR_NONE) {
- ssh_error(s, "failed to start SSH session");
- goto on_error;
- }
-
- libssh2_session_set_blocking(s, 1);
-
- *session = s;
- *hosts = known_hosts;
-
- return 0;
-
-on_error:
- libssh2_knownhost_free(known_hosts);
- libssh2_session_free(s);
- return -1;
-}
+#include "ssh_exec.h"
+#include "ssh_libssh2.h"
+#include "transports/smart.h"
-/*
- * Returns the typemask argument to pass to libssh2_knownhost_check{,p} based on
- * the type of key that libssh2_session_hostkey returns.
- */
-static int fingerprint_type_mask(int keytype)
-{
- int mask = LIBSSH2_KNOWNHOST_TYPE_PLAIN | LIBSSH2_KNOWNHOST_KEYENC_RAW;
- return mask;
-
- switch (keytype) {
- case LIBSSH2_HOSTKEY_TYPE_RSA:
- mask |= LIBSSH2_KNOWNHOST_KEY_SSHRSA;
- break;
- case LIBSSH2_HOSTKEY_TYPE_DSS:
- mask |= LIBSSH2_KNOWNHOST_KEY_SSHDSS;
- break;
-#ifdef LIBSSH2_HOSTKEY_TYPE_ECDSA_256
- case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:
- mask |= LIBSSH2_KNOWNHOST_KEY_ECDSA_256;
- break;
- case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:
- mask |= LIBSSH2_KNOWNHOST_KEY_ECDSA_384;
- break;
- case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:
- mask |= LIBSSH2_KNOWNHOST_KEY_ECDSA_521;
- break;
-#endif
-#ifdef LIBSSH2_HOSTKEY_TYPE_ED25519
- case LIBSSH2_HOSTKEY_TYPE_ED25519:
- mask |= LIBSSH2_KNOWNHOST_KEY_ED25519;
- break;
-#endif
- }
-
- return mask;
-}
-
-/*
- * Check the host against the user's known_hosts file.
- *
- * Returns 1/0 for valid/''not-valid or <0 for an error
- */
-static int check_against_known_hosts(
- LIBSSH2_SESSION *session,
- LIBSSH2_KNOWNHOSTS *known_hosts,
- const char *hostname,
- int port,
- const char *key,
- size_t key_len,
- int key_type)
-{
- int check, typemask, ret = 0;
- struct libssh2_knownhost *host = NULL;
-
- if (known_hosts == NULL)
- return 0;
-
- typemask = fingerprint_type_mask(key_type);
- check = libssh2_knownhost_checkp(known_hosts, hostname, port, key, key_len, typemask, &host);
- if (check == LIBSSH2_KNOWNHOST_CHECK_FAILURE) {
- ssh_error(session, "error checking for known host");
- return -1;
- }
-
- ret = check == LIBSSH2_KNOWNHOST_CHECK_MATCH ? 1 : 0;
-
- return ret;
-}
-
-/*
- * Perform the check for the session's certificate against known hosts if
- * possible and then ask the user if they have a callback.
- *
- * Returns 1/0 for valid/not-valid or <0 for an error
- */
-static int check_certificate(
- LIBSSH2_SESSION *session,
- LIBSSH2_KNOWNHOSTS *known_hosts,
- git_transport_certificate_check_cb check_cb,
- void *check_cb_payload,
- const char *host,
- int port)
-{
- git_cert_hostkey cert = {{ 0 }};
- const char *key;
- size_t cert_len;
- int cert_type, cert_valid = 0, error = 0;
-
- if ((key = libssh2_session_hostkey(session, &cert_len, &cert_type)) == NULL) {
- ssh_error(session, "failed to retrieve hostkey");
- return -1;
- }
-
- if ((cert_valid = check_against_known_hosts(session, known_hosts, host, port, key, cert_len, cert_type)) < 0)
- return -1;
-
- cert.parent.cert_type = GIT_CERT_HOSTKEY_LIBSSH2;
- if (key != NULL) {
- cert.type |= GIT_CERT_SSH_RAW;
- cert.hostkey = key;
- cert.hostkey_len = cert_len;
- switch (cert_type) {
- case LIBSSH2_HOSTKEY_TYPE_RSA:
- cert.raw_type = GIT_CERT_SSH_RAW_TYPE_RSA;
- break;
- case LIBSSH2_HOSTKEY_TYPE_DSS:
- cert.raw_type = GIT_CERT_SSH_RAW_TYPE_DSS;
- break;
-
-#ifdef LIBSSH2_HOSTKEY_TYPE_ECDSA_256
- case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:
- cert.raw_type = GIT_CERT_SSH_RAW_TYPE_KEY_ECDSA_256;
- break;
- case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:
- cert.raw_type = GIT_CERT_SSH_RAW_TYPE_KEY_ECDSA_384;
- break;
- case LIBSSH2_KNOWNHOST_KEY_ECDSA_521:
- cert.raw_type = GIT_CERT_SSH_RAW_TYPE_KEY_ECDSA_521;
- break;
-#endif
-
-#ifdef LIBSSH2_HOSTKEY_TYPE_ED25519
- case LIBSSH2_HOSTKEY_TYPE_ED25519:
- cert.raw_type = GIT_CERT_SSH_RAW_TYPE_KEY_ED25519;
- break;
-#endif
- default:
- cert.raw_type = GIT_CERT_SSH_RAW_TYPE_UNKNOWN;
- }
- }
-
-#ifdef LIBSSH2_HOSTKEY_HASH_SHA256
- key = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA256);
- if (key != NULL) {
- cert.type |= GIT_CERT_SSH_SHA256;
- memcpy(&cert.hash_sha256, key, 32);
- }
-#endif
-
- key = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
- if (key != NULL) {
- cert.type |= GIT_CERT_SSH_SHA1;
- memcpy(&cert.hash_sha1, key, 20);
- }
-
- key = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_MD5);
- if (key != NULL) {
- cert.type |= GIT_CERT_SSH_MD5;
- memcpy(&cert.hash_md5, key, 16);
- }
-
- if (cert.type == 0) {
- git_error_set(GIT_ERROR_SSH, "unable to get the host key");
- return -1;
- }
-
- git_error_clear();
- error = 0;
- if (!cert_valid) {
- git_error_set(GIT_ERROR_SSH, "invalid or unknown remote ssh hostkey");
- error = GIT_ECERTIFICATE;
- }
-
- if (check_cb != NULL) {
- git_cert_hostkey *cert_ptr = &cert;
- git_error_state previous_error = {0};
-
- git_error_state_capture(&previous_error, error);
- error = check_cb((git_cert *) cert_ptr, cert_valid, host, check_cb_payload);
- if (error == GIT_PASSTHROUGH) {
- error = git_error_state_restore(&previous_error);
- } else if (error < 0 && !git_error_last()) {
- git_error_set(GIT_ERROR_NET, "unknown remote host key");
- }
-
- git_error_state_free(&previous_error);
- }
-
- return error;
-}
-
-#define SSH_DEFAULT_PORT "22"
-
-static int _git_ssh_setup_conn(
- ssh_subtransport *t,
- const char *url,
- const char *cmd,
- git_smart_subtransport_stream **stream)
-{
- int auth_methods, error = 0, port;
- ssh_stream *s;
- git_credential *cred = NULL;
- LIBSSH2_SESSION *session=NULL;
- LIBSSH2_CHANNEL *channel=NULL;
- LIBSSH2_KNOWNHOSTS *known_hosts = NULL;
-
- t->current_stream = NULL;
-
- *stream = NULL;
- if (ssh_stream_alloc(t, cmd, stream) < 0)
- return -1;
-
- s = (ssh_stream *)*stream;
- s->session = NULL;
- s->channel = NULL;
-
- if ((error = git_net_url_parse_standard_or_scp(&s->url, url)) < 0 ||
- (error = git_socket_stream_new(&s->io, s->url.host, s->url.port)) < 0 ||
- (error = git_stream_connect(s->io)) < 0)
- goto done;
-
- /*
- * Try to parse the port as a number, if we can't then fall back to
- * default. It would be nice if we could get the port that was resolved
- * as part of the stream connection, but that's not something that's
- * exposed.
- */
- if (git__strntol32(&port, s->url.port, strlen(s->url.port), NULL, 10) < 0) {
- git_error_set(GIT_ERROR_NET, "invalid port to ssh: %s", s->url.port);
- error = -1;
- goto done;
- }
-
- if ((error = _git_ssh_session_create(&session, &known_hosts, s->url.host, port, s->io)) < 0)
- goto done;
-
- if ((error = check_certificate(session, known_hosts, t->owner->connect_opts.callbacks.certificate_check, t->owner->connect_opts.callbacks.payload, s->url.host, port)) < 0)
- goto done;
-
- /* we need the username to ask for auth methods */
- if (!s->url.username) {
- if ((error = request_creds(&cred, t, NULL, GIT_CREDENTIAL_USERNAME)) < 0)
- goto done;
-
- s->url.username = git__strdup(((git_credential_username *) cred)->username);
- cred->free(cred);
- cred = NULL;
- if (!s->url.username)
- goto done;
- } else if (s->url.username && s->url.password) {
- if ((error = git_credential_userpass_plaintext_new(&cred, s->url.username, s->url.password)) < 0)
- goto done;
- }
-
- if ((error = list_auth_methods(&auth_methods, session, s->url.username)) < 0)
- goto done;
-
- error = GIT_EAUTH;
- /* if we already have something to try */
- if (cred && auth_methods & cred->credtype)
- error = _git_ssh_authenticate_session(session, cred);
-
- while (error == GIT_EAUTH) {
- if (cred) {
- cred->free(cred);
- cred = NULL;
- }
-
- if ((error = request_creds(&cred, t, s->url.username, auth_methods)) < 0)
- goto done;
-
- if (strcmp(s->url.username, git_credential_get_username(cred))) {
- git_error_set(GIT_ERROR_SSH, "username does not match previous request");
- error = -1;
- goto done;
- }
-
- error = _git_ssh_authenticate_session(session, cred);
-
- if (error == GIT_EAUTH) {
- /* refresh auth methods */
- if ((error = list_auth_methods(&auth_methods, session, s->url.username)) < 0)
- goto done;
- else
- error = GIT_EAUTH;
- }
- }
-
- if (error < 0)
- goto done;
-
- channel = libssh2_channel_open_session(session);
- if (!channel) {
- error = -1;
- ssh_error(session, "Failed to open SSH channel");
- goto done;
- }
-
- libssh2_channel_set_blocking(channel, 1);
-
- s->session = session;
- s->channel = channel;
-
- t->current_stream = s;
-
-done:
- if (error < 0) {
- ssh_stream_free(*stream);
-
- if (known_hosts)
- libssh2_knownhost_free(known_hosts);
- if (session)
- libssh2_session_free(session);
- }
-
- if (cred)
- cred->free(cred);
-
- return error;
-}
-
-static int ssh_uploadpack_ls(
- ssh_subtransport *t,
- const char *url,
- git_smart_subtransport_stream **stream)
-{
- const char *cmd = t->cmd_uploadpack ? t->cmd_uploadpack : cmd_uploadpack;
-
- return _git_ssh_setup_conn(t, url, cmd, stream);
-}
-
-static int ssh_uploadpack(
- ssh_subtransport *t,
- const char *url,
- git_smart_subtransport_stream **stream)
-{
- GIT_UNUSED(url);
-
- if (t->current_stream) {
- *stream = &t->current_stream->parent;
- return 0;
- }
-
- git_error_set(GIT_ERROR_NET, "must call UPLOADPACK_LS before UPLOADPACK");
- return -1;
-}
-
-static int ssh_receivepack_ls(
- ssh_subtransport *t,
- const char *url,
- git_smart_subtransport_stream **stream)
-{
- const char *cmd = t->cmd_receivepack ? t->cmd_receivepack : cmd_receivepack;
-
-
- return _git_ssh_setup_conn(t, url, cmd, stream);
-}
-
-static int ssh_receivepack(
- ssh_subtransport *t,
- const char *url,
- git_smart_subtransport_stream **stream)
-{
- GIT_UNUSED(url);
-
- if (t->current_stream) {
- *stream = &t->current_stream->parent;
- return 0;
- }
-
- git_error_set(GIT_ERROR_NET, "must call RECEIVEPACK_LS before RECEIVEPACK");
- return -1;
-}
-
-static int _ssh_action(
- git_smart_subtransport_stream **stream,
- git_smart_subtransport *subtransport,
- const char *url,
- git_smart_service_t action)
-{
- ssh_subtransport *t = GIT_CONTAINER_OF(subtransport, ssh_subtransport, parent);
-
- switch (action) {
- case GIT_SERVICE_UPLOADPACK_LS:
- return ssh_uploadpack_ls(t, url, stream);
-
- case GIT_SERVICE_UPLOADPACK:
- return ssh_uploadpack(t, url, stream);
-
- case GIT_SERVICE_RECEIVEPACK_LS:
- return ssh_receivepack_ls(t, url, stream);
-
- case GIT_SERVICE_RECEIVEPACK:
- return ssh_receivepack(t, url, stream);
- }
+int git_smart_subtransport_ssh(
+ git_smart_subtransport **out,
+ git_transport *owner,
+ void *param)
+{
+#ifdef GIT_SSH_LIBSSH2
+ return git_smart_subtransport_ssh_libssh2(out, owner, param);
+#elif GIT_SSH_EXEC
+ return git_smart_subtransport_ssh_exec(out, owner, param);
+#else
+ GIT_UNUSED(out);
+ GIT_UNUSED(owner);
+ GIT_UNUSED(param);
- *stream = NULL;
+ git_error_set(GIT_ERROR_INVALID, "cannot create SSH transport; library was built without SSH support");
return -1;
-}
-
-static int _ssh_close(git_smart_subtransport *subtransport)
-{
- ssh_subtransport *t = GIT_CONTAINER_OF(subtransport, ssh_subtransport, parent);
-
- GIT_ASSERT(!t->current_stream);
-
- GIT_UNUSED(t);
-
- return 0;
-}
-
-static void _ssh_free(git_smart_subtransport *subtransport)
-{
- ssh_subtransport *t = GIT_CONTAINER_OF(subtransport, ssh_subtransport, parent);
-
- git__free(t->cmd_uploadpack);
- git__free(t->cmd_receivepack);
- git__free(t);
-}
-
-#define SSH_AUTH_PUBLICKEY "publickey"
-#define SSH_AUTH_PASSWORD "password"
-#define SSH_AUTH_KEYBOARD_INTERACTIVE "keyboard-interactive"
-
-static int list_auth_methods(int *out, LIBSSH2_SESSION *session, const char *username)
-{
- const char *list, *ptr;
-
- *out = 0;
-
- list = libssh2_userauth_list(session, username, strlen(username));
-
- /* either error, or the remote accepts NONE auth, which is bizarre, let's punt */
- if (list == NULL && !libssh2_userauth_authenticated(session)) {
- ssh_error(session, "remote rejected authentication");
- return GIT_EAUTH;
- }
-
- ptr = list;
- while (ptr) {
- if (*ptr == ',')
- ptr++;
-
- if (!git__prefixcmp(ptr, SSH_AUTH_PUBLICKEY)) {
- *out |= GIT_CREDENTIAL_SSH_KEY;
- *out |= GIT_CREDENTIAL_SSH_CUSTOM;
-#ifdef GIT_SSH_MEMORY_CREDENTIALS
- *out |= GIT_CREDENTIAL_SSH_MEMORY;
#endif
- ptr += strlen(SSH_AUTH_PUBLICKEY);
- continue;
- }
-
- if (!git__prefixcmp(ptr, SSH_AUTH_PASSWORD)) {
- *out |= GIT_CREDENTIAL_USERPASS_PLAINTEXT;
- ptr += strlen(SSH_AUTH_PASSWORD);
- continue;
- }
-
- if (!git__prefixcmp(ptr, SSH_AUTH_KEYBOARD_INTERACTIVE)) {
- *out |= GIT_CREDENTIAL_SSH_INTERACTIVE;
- ptr += strlen(SSH_AUTH_KEYBOARD_INTERACTIVE);
- continue;
- }
-
- /* Skip it if we don't know it */
- ptr = strchr(ptr, ',');
- }
-
- return 0;
}
-#endif
-int git_smart_subtransport_ssh(
- git_smart_subtransport **out, git_transport *owner, void *param)
+static int transport_set_paths(git_transport *t, git_strarray *paths)
{
-#ifdef GIT_SSH
- ssh_subtransport *t;
+ transport_smart *smart = (transport_smart *)t;
- GIT_ASSERT_ARG(out);
-
- GIT_UNUSED(param);
-
- t = git__calloc(sizeof(ssh_subtransport), 1);
- GIT_ERROR_CHECK_ALLOC(t);
-
- t->owner = (transport_smart *)owner;
- t->parent.action = _ssh_action;
- t->parent.close = _ssh_close;
- t->parent.free = _ssh_free;
-
- *out = (git_smart_subtransport *) t;
- return 0;
+#ifdef GIT_SSH_LIBSSH2
+ return git_smart_subtransport_ssh_libssh2_set_paths(
+ (git_smart_subtransport *)smart->wrapped,
+ paths->strings[0],
+ paths->strings[1]);
+#elif GIT_SSH_EXEC
+ return git_smart_subtransport_ssh_exec_set_paths(
+ (git_smart_subtransport *)smart->wrapped,
+ paths->strings[0],
+ paths->strings[1]);
#else
- GIT_UNUSED(owner);
- GIT_UNUSED(param);
-
- GIT_ASSERT_ARG(out);
- *out = NULL;
+ GIT_UNUSED(t);
+ GIT_UNUSED(smart);
+ GIT_UNUSED(paths);
- git_error_set(GIT_ERROR_INVALID, "cannot create SSH transport. Library was built without SSH support");
+ GIT_ASSERT(!"cannot create SSH library; library was built without SSH support");
return -1;
#endif
}
-int git_transport_ssh_with_paths(git_transport **out, git_remote *owner, void *payload)
+int git_transport_ssh_with_paths(
+ git_transport **out,
+ git_remote *owner,
+ void *payload)
{
-#ifdef GIT_SSH
git_strarray *paths = (git_strarray *) payload;
git_transport *transport;
- transport_smart *smart;
- ssh_subtransport *t;
int error;
+
git_smart_subtransport_definition ssh_definition = {
git_smart_subtransport_ssh,
0, /* no RPC */
- NULL,
+ NULL
};
if (paths->count != 2) {
@@ -1099,49 +76,10 @@ int git_transport_ssh_with_paths(git_transport **out, git_remote *owner, void *p
if ((error = git_transport_smart(&transport, owner, &ssh_definition)) < 0)
return error;
- smart = (transport_smart *) transport;
- t = (ssh_subtransport *) smart->wrapped;
-
- t->cmd_uploadpack = git__strdup(paths->strings[0]);
- GIT_ERROR_CHECK_ALLOC(t->cmd_uploadpack);
- t->cmd_receivepack = git__strdup(paths->strings[1]);
- GIT_ERROR_CHECK_ALLOC(t->cmd_receivepack);
+ if ((error = transport_set_paths(transport, paths)) < 0)
+ return error;
*out = transport;
return 0;
-#else
- GIT_UNUSED(owner);
- GIT_UNUSED(payload);
-
- GIT_ASSERT_ARG(out);
- *out = NULL;
-
- git_error_set(GIT_ERROR_INVALID, "cannot create SSH transport. Library was built without SSH support");
- return -1;
-#endif
-}
-
-#ifdef GIT_SSH
-static void shutdown_ssh(void)
-{
- libssh2_exit();
}
-#endif
-
-int git_transport_ssh_global_init(void)
-{
-#ifdef GIT_SSH
- if (libssh2_init(0) < 0) {
- git_error_set(GIT_ERROR_SSH, "unable to initialize libssh2");
- return -1;
- }
-
- return git_runtime_shutdown_register(shutdown_ssh);
-#else
-
- /* Nothing to initialize */
- return 0;
-
-#endif
-}
diff --git a/src/libgit2/transports/ssh_exec.c b/src/libgit2/transports/ssh_exec.c
new file mode 100644
index 00000000000..5b4bbb87e2d
--- /dev/null
+++ b/src/libgit2/transports/ssh_exec.c
@@ -0,0 +1,347 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include "ssh_exec.h"
+
+#ifdef GIT_SSH_EXEC
+
+#include "common.h"
+
+#include "config.h"
+#include "net.h"
+#include "path.h"
+#include "futils.h"
+#include "process.h"
+#include "transports/smart.h"
+
+typedef struct {
+ git_smart_subtransport_stream parent;
+} ssh_exec_subtransport_stream;
+
+typedef struct {
+ git_smart_subtransport parent;
+ git_transport *owner;
+
+ ssh_exec_subtransport_stream *current_stream;
+
+ char *cmd_uploadpack;
+ char *cmd_receivepack;
+
+ git_smart_service_t action;
+ git_process *process;
+} ssh_exec_subtransport;
+
+static int ssh_exec_subtransport_stream_read(
+ git_smart_subtransport_stream *s,
+ char *buffer,
+ size_t buf_size,
+ size_t *bytes_read)
+{
+ ssh_exec_subtransport *transport;
+ ssh_exec_subtransport_stream *stream = (ssh_exec_subtransport_stream *)s;
+ ssize_t ret;
+
+ GIT_ASSERT_ARG(stream);
+ GIT_ASSERT(stream->parent.subtransport);
+
+ transport = (ssh_exec_subtransport *)stream->parent.subtransport;
+
+ if ((ret = git_process_read(transport->process, buffer, buf_size)) < 0) {
+ return (int)ret;
+ }
+
+ *bytes_read = (size_t)ret;
+ return 0;
+}
+
+static int ssh_exec_subtransport_stream_write(
+ git_smart_subtransport_stream *s,
+ const char *buffer,
+ size_t len)
+{
+ ssh_exec_subtransport *transport;
+ ssh_exec_subtransport_stream *stream = (ssh_exec_subtransport_stream *)s;
+ ssize_t ret;
+
+ GIT_ASSERT(stream && stream->parent.subtransport);
+
+ transport = (ssh_exec_subtransport *)stream->parent.subtransport;
+
+ while (len > 0) {
+ if ((ret = git_process_write(transport->process, buffer, len)) < 0)
+ return (int)ret;
+
+ len -= ret;
+ }
+
+ return 0;
+}
+
+static void ssh_exec_subtransport_stream_free(git_smart_subtransport_stream *s)
+{
+ ssh_exec_subtransport_stream *stream = (ssh_exec_subtransport_stream *)s;
+
+ git__free(stream);
+}
+
+static int ssh_exec_subtransport_stream_init(
+ ssh_exec_subtransport_stream **out,
+ ssh_exec_subtransport *transport)
+{
+ GIT_ASSERT_ARG(out);
+
+ *out = git__calloc(sizeof(ssh_exec_subtransport_stream), 1);
+ GIT_ERROR_CHECK_ALLOC(*out);
+
+ (*out)->parent.subtransport = &transport->parent;
+ (*out)->parent.read = ssh_exec_subtransport_stream_read;
+ (*out)->parent.write = ssh_exec_subtransport_stream_write;
+ (*out)->parent.free = ssh_exec_subtransport_stream_free;
+
+ return 0;
+}
+
+GIT_INLINE(int) ensure_transport_state(
+ ssh_exec_subtransport *transport,
+ git_smart_service_t expected,
+ git_smart_service_t next)
+{
+ if (transport->action != expected && transport->action != next) {
+ git_error_set(GIT_ERROR_NET, "invalid transport state");
+
+ return -1;
+ }
+
+ return 0;
+}
+
+static int get_ssh_cmdline(
+ git_str *out,
+ ssh_exec_subtransport *transport,
+ git_net_url *url,
+ const char *command)
+{
+ git_remote *remote = ((transport_smart *)transport->owner)->owner;
+ git_repository *repo = remote->repo;
+ git_config *cfg;
+ git_str ssh_cmd = GIT_STR_INIT;
+ const char *default_ssh_cmd = "ssh";
+ int error;
+
+ /*
+ * Safety check: like git, we forbid paths that look like an
+ * option as that could lead to injection to ssh that can make
+ * us do unexpected things
+ */
+ if (git_process__is_cmdline_option(url->username)) {
+ git_error_set(GIT_ERROR_NET, "cannot ssh: username '%s' is ambiguous with command-line option", url->username);
+ return -1;
+ } else if (git_process__is_cmdline_option(url->host)) {
+ git_error_set(GIT_ERROR_NET, "cannot ssh: host '%s' is ambiguous with command-line option", url->host);
+ return -1;
+ } else if (git_process__is_cmdline_option(url->path)) {
+ git_error_set(GIT_ERROR_NET, "cannot ssh: path '%s' is ambiguous with command-line option", url->path);
+ return -1;
+ }
+
+ if ((error = git_repository_config_snapshot(&cfg, repo)) < 0)
+ return error;
+
+ if ((error = git__getenv(&ssh_cmd, "GIT_SSH")) == 0)
+ ;
+ else if (error != GIT_ENOTFOUND)
+ goto done;
+ else if ((error = git_config__get_string_buf(&ssh_cmd, cfg, "core.sshcommand")) < 0 && error != GIT_ENOTFOUND)
+ goto done;
+
+ error = git_str_printf(out, "%s %s %s \"%s%s%s\" \"%s\" \"%s\"",
+ ssh_cmd.size > 0 ? ssh_cmd.ptr : default_ssh_cmd,
+ url->port_specified ? "-p" : "",
+ url->port_specified ? url->port : "",
+ url->username ? url->username : "",
+ url->username ? "@" : "",
+ url->host,
+ command,
+ url->path);
+
+done:
+ git_str_dispose(&ssh_cmd);
+ git_config_free(cfg);
+ return error;
+}
+
+static int start_ssh(
+ ssh_exec_subtransport *transport,
+ git_smart_service_t action,
+ const char *sshpath)
+{
+ const char *env[] = { "GIT_DIR=" };
+
+ git_process_options process_opts = GIT_PROCESS_OPTIONS_INIT;
+ git_net_url url = GIT_NET_URL_INIT;
+ git_str ssh_cmdline = GIT_STR_INIT;
+ const char *command;
+ int error;
+
+ process_opts.capture_in = 1;
+ process_opts.capture_out = 1;
+ process_opts.capture_err = 0;
+
+ switch (action) {
+ case GIT_SERVICE_UPLOADPACK_LS:
+ command = transport->cmd_uploadpack ?
+ transport->cmd_uploadpack : "git-upload-pack";
+ break;
+ case GIT_SERVICE_RECEIVEPACK_LS:
+ command = transport->cmd_receivepack ?
+ transport->cmd_receivepack : "git-receive-pack";
+ break;
+ default:
+ git_error_set(GIT_ERROR_NET, "invalid action");
+ error = -1;
+ goto done;
+ }
+
+ if (git_net_str_is_url(sshpath))
+ error = git_net_url_parse(&url, sshpath);
+ else
+ error = git_net_url_parse_scp(&url, sshpath);
+
+ if (error < 0)
+ goto done;
+
+ if ((error = get_ssh_cmdline(&ssh_cmdline, transport, &url, command)) < 0)
+ goto done;
+
+ if ((error = git_process_new_from_cmdline(&transport->process,
+ ssh_cmdline.ptr, env, ARRAY_SIZE(env), &process_opts)) < 0 ||
+ (error = git_process_start(transport->process)) < 0) {
+ git_process_free(transport->process);
+ transport->process = NULL;
+ goto done;
+ }
+
+done:
+ git_str_dispose(&ssh_cmdline);
+ git_net_url_dispose(&url);
+ return error;
+}
+
+static int ssh_exec_subtransport_action(
+ git_smart_subtransport_stream **out,
+ git_smart_subtransport *t,
+ const char *sshpath,
+ git_smart_service_t action)
+{
+ ssh_exec_subtransport *transport = (ssh_exec_subtransport *)t;
+ ssh_exec_subtransport_stream *stream = NULL;
+ git_smart_service_t expected;
+ int error;
+
+ switch (action) {
+ case GIT_SERVICE_UPLOADPACK_LS:
+ case GIT_SERVICE_RECEIVEPACK_LS:
+ if ((error = ensure_transport_state(transport, 0, 0)) < 0 ||
+ (error = ssh_exec_subtransport_stream_init(&stream, transport)) < 0 ||
+ (error = start_ssh(transport, action, sshpath)) < 0)
+ goto on_error;
+
+ transport->current_stream = stream;
+ break;
+
+ case GIT_SERVICE_UPLOADPACK:
+ case GIT_SERVICE_RECEIVEPACK:
+ expected = (action == GIT_SERVICE_UPLOADPACK) ?
+ GIT_SERVICE_UPLOADPACK_LS : GIT_SERVICE_RECEIVEPACK_LS;
+
+ if ((error = ensure_transport_state(transport, expected, action)) < 0)
+ goto on_error;
+
+ break;
+
+ default:
+ git_error_set(GIT_ERROR_INVALID, "invalid service request");
+ goto on_error;
+ }
+
+ transport->action = action;
+ *out = &transport->current_stream->parent;
+
+ return 0;
+
+on_error:
+ if (stream != NULL)
+ ssh_exec_subtransport_stream_free(&stream->parent);
+
+ return -1;
+}
+
+static int ssh_exec_subtransport_close(git_smart_subtransport *t)
+{
+ ssh_exec_subtransport *transport = (ssh_exec_subtransport *)t;
+
+ if (transport->process) {
+ git_process_close(transport->process);
+ git_process_free(transport->process);
+ transport->process = NULL;
+ }
+
+ transport->action = 0;
+
+ return 0;
+}
+
+static void ssh_exec_subtransport_free(git_smart_subtransport *t)
+{
+ ssh_exec_subtransport *transport = (ssh_exec_subtransport *)t;
+
+ git__free(transport->cmd_uploadpack);
+ git__free(transport->cmd_receivepack);
+ git__free(transport);
+}
+
+int git_smart_subtransport_ssh_exec(
+ git_smart_subtransport **out,
+ git_transport *owner,
+ void *payload)
+{
+ ssh_exec_subtransport *transport;
+
+ GIT_UNUSED(payload);
+
+ transport = git__calloc(sizeof(ssh_exec_subtransport), 1);
+ GIT_ERROR_CHECK_ALLOC(transport);
+
+ transport->owner = owner;
+ transport->parent.action = ssh_exec_subtransport_action;
+ transport->parent.close = ssh_exec_subtransport_close;
+ transport->parent.free = ssh_exec_subtransport_free;
+
+ *out = (git_smart_subtransport *) transport;
+ return 0;
+}
+
+int git_smart_subtransport_ssh_exec_set_paths(
+ git_smart_subtransport *subtransport,
+ const char *cmd_uploadpack,
+ const char *cmd_receivepack)
+{
+ ssh_exec_subtransport *t = (ssh_exec_subtransport *)subtransport;
+
+ git__free(t->cmd_uploadpack);
+ git__free(t->cmd_receivepack);
+
+ t->cmd_uploadpack = git__strdup(cmd_uploadpack);
+ GIT_ERROR_CHECK_ALLOC(t->cmd_uploadpack);
+
+ t->cmd_receivepack = git__strdup(cmd_receivepack);
+ GIT_ERROR_CHECK_ALLOC(t->cmd_receivepack);
+
+ return 0;
+}
+
+#endif
diff --git a/src/libgit2/transports/ssh_exec.h b/src/libgit2/transports/ssh_exec.h
new file mode 100644
index 00000000000..4bcba06b16b
--- /dev/null
+++ b/src/libgit2/transports/ssh_exec.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_transports_ssh_exec_h__
+#define INCLUDE_transports_ssh_exec_h__
+
+#include "common.h"
+
+#include "git2.h"
+#include "git2/transport.h"
+#include "git2/sys/transport.h"
+
+int git_smart_subtransport_ssh_exec(
+ git_smart_subtransport **out,
+ git_transport *owner,
+ void *param);
+
+int git_smart_subtransport_ssh_exec_set_paths(
+ git_smart_subtransport *subtransport,
+ const char *cmd_uploadpack,
+ const char *cmd_receivepack);
+
+#endif
diff --git a/src/libgit2/transports/ssh_libssh2.c b/src/libgit2/transports/ssh_libssh2.c
new file mode 100644
index 00000000000..6469c8d6480
--- /dev/null
+++ b/src/libgit2/transports/ssh_libssh2.c
@@ -0,0 +1,1126 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include "ssh_libssh2.h"
+
+#ifdef GIT_SSH_LIBSSH2
+
+#include
+
+#include "runtime.h"
+#include "net.h"
+#include "smart.h"
+#include "process.h"
+#include "streams/socket.h"
+#include "sysdir.h"
+
+#include "git2/credential.h"
+#include "git2/sys/credential.h"
+
+#define OWNING_SUBTRANSPORT(s) ((ssh_subtransport *)(s)->parent.subtransport)
+
+extern int git_socket_stream__timeout;
+
+static const char cmd_uploadpack[] = "git-upload-pack";
+static const char cmd_receivepack[] = "git-receive-pack";
+
+typedef struct {
+ git_smart_subtransport_stream parent;
+ git_stream *io;
+ LIBSSH2_SESSION *session;
+ LIBSSH2_CHANNEL *channel;
+ const char *cmd;
+ git_net_url url;
+ unsigned sent_command : 1;
+} ssh_stream;
+
+typedef struct {
+ git_smart_subtransport parent;
+ transport_smart *owner;
+ ssh_stream *current_stream;
+ git_credential *cred;
+ char *cmd_uploadpack;
+ char *cmd_receivepack;
+} ssh_subtransport;
+
+static int list_auth_methods(int *out, LIBSSH2_SESSION *session, const char *username);
+
+static void ssh_error(LIBSSH2_SESSION *session, const char *errmsg)
+{
+ char *ssherr;
+ libssh2_session_last_error(session, &ssherr, NULL, 0);
+
+ git_error_set(GIT_ERROR_SSH, "%s: %s", errmsg, ssherr);
+}
+
+/*
+ * Create a git protocol request.
+ *
+ * For example: git-upload-pack '/libgit2/libgit2'
+ */
+static int gen_proto(git_str *request, const char *cmd, git_net_url *url)
+{
+ const char *repo;
+
+ repo = url->path;
+
+ if (repo && repo[0] == '/' && repo[1] == '~')
+ repo++;
+
+ if (!repo || !repo[0]) {
+ git_error_set(GIT_ERROR_NET, "malformed git protocol URL");
+ return -1;
+ }
+
+ git_str_puts(request, cmd);
+ git_str_puts(request, " '");
+ git_str_puts(request, repo);
+ git_str_puts(request, "'");
+
+ if (git_str_oom(request))
+ return -1;
+
+ return 0;
+}
+
+static int send_command(ssh_stream *s)
+{
+ int error;
+ git_str request = GIT_STR_INIT;
+
+ error = gen_proto(&request, s->cmd, &s->url);
+ if (error < 0)
+ goto cleanup;
+
+ error = libssh2_channel_exec(s->channel, request.ptr);
+ if (error < LIBSSH2_ERROR_NONE) {
+ ssh_error(s->session, "SSH could not execute request");
+ goto cleanup;
+ }
+
+ s->sent_command = 1;
+
+cleanup:
+ git_str_dispose(&request);
+ return error;
+}
+
+static int ssh_stream_read(
+ git_smart_subtransport_stream *stream,
+ char *buffer,
+ size_t buf_size,
+ size_t *bytes_read)
+{
+ ssh_stream *s = GIT_CONTAINER_OF(stream, ssh_stream, parent);
+ ssize_t rc;
+
+ *bytes_read = 0;
+
+ if (!s->sent_command && send_command(s) < 0)
+ return -1;
+
+ if ((rc = libssh2_channel_read(s->channel, buffer, buf_size)) < LIBSSH2_ERROR_NONE) {
+ ssh_error(s->session, "SSH could not read data");
+ return -1;
+ }
+
+ /*
+ * If we can't get anything out of stdout, it's typically a
+ * not-found error, so read from stderr and signal EOF on
+ * stderr.
+ */
+ if (rc == 0) {
+ if ((rc = libssh2_channel_read_stderr(s->channel, buffer, buf_size)) > 0) {
+ git_error_set(GIT_ERROR_SSH, "%*s", (int)rc, buffer);
+ return GIT_EEOF;
+ } else if (rc < LIBSSH2_ERROR_NONE) {
+ ssh_error(s->session, "SSH could not read stderr");
+ return -1;
+ }
+ }
+
+ *bytes_read = rc;
+
+ return 0;
+}
+
+static int ssh_stream_write(
+ git_smart_subtransport_stream *stream,
+ const char *buffer,
+ size_t len)
+{
+ ssh_stream *s = GIT_CONTAINER_OF(stream, ssh_stream, parent);
+ size_t off = 0;
+ ssize_t ret = 0;
+
+ if (!s->sent_command && send_command(s) < 0)
+ return -1;
+
+ do {
+ ret = libssh2_channel_write(s->channel, buffer + off, len - off);
+ if (ret < 0)
+ break;
+
+ off += ret;
+
+ } while (off < len);
+
+ if (ret < 0) {
+ ssh_error(s->session, "SSH could not write data");
+ return -1;
+ }
+
+ return 0;
+}
+
+static void ssh_stream_free(git_smart_subtransport_stream *stream)
+{
+ ssh_stream *s = GIT_CONTAINER_OF(stream, ssh_stream, parent);
+ ssh_subtransport *t;
+
+ if (!stream)
+ return;
+
+ t = OWNING_SUBTRANSPORT(s);
+ t->current_stream = NULL;
+
+ if (s->channel) {
+ libssh2_channel_close(s->channel);
+ libssh2_channel_free(s->channel);
+ s->channel = NULL;
+ }
+
+ if (s->session) {
+ libssh2_session_disconnect(s->session, "closing transport");
+ libssh2_session_free(s->session);
+ s->session = NULL;
+ }
+
+ if (s->io) {
+ git_stream_close(s->io);
+ git_stream_free(s->io);
+ s->io = NULL;
+ }
+
+ git_net_url_dispose(&s->url);
+ git__free(s);
+}
+
+static int ssh_stream_alloc(
+ ssh_subtransport *t,
+ const char *cmd,
+ git_smart_subtransport_stream **stream)
+{
+ ssh_stream *s;
+
+ GIT_ASSERT_ARG(stream);
+
+ s = git__calloc(sizeof(ssh_stream), 1);
+ GIT_ERROR_CHECK_ALLOC(s);
+
+ s->parent.subtransport = &t->parent;
+ s->parent.read = ssh_stream_read;
+ s->parent.write = ssh_stream_write;
+ s->parent.free = ssh_stream_free;
+
+ s->cmd = cmd;
+
+ *stream = &s->parent;
+ return 0;
+}
+
+static int ssh_agent_auth(LIBSSH2_SESSION *session, git_credential_ssh_key *c) {
+ int rc = LIBSSH2_ERROR_NONE;
+
+ struct libssh2_agent_publickey *curr, *prev = NULL;
+
+ LIBSSH2_AGENT *agent = libssh2_agent_init(session);
+
+ if (agent == NULL)
+ return -1;
+
+ rc = libssh2_agent_connect(agent);
+
+ if (rc != LIBSSH2_ERROR_NONE) {
+ rc = LIBSSH2_ERROR_AUTHENTICATION_FAILED;
+ goto shutdown;
+ }
+
+ rc = libssh2_agent_list_identities(agent);
+
+ if (rc != LIBSSH2_ERROR_NONE)
+ goto shutdown;
+
+ while (1) {
+ rc = libssh2_agent_get_identity(agent, &curr, prev);
+
+ if (rc < 0)
+ goto shutdown;
+
+ /* rc is set to 1 whenever the ssh agent ran out of keys to check.
+ * Set the error code to authentication failure rather than erroring
+ * out with an untranslatable error code.
+ */
+ if (rc == 1) {
+ rc = LIBSSH2_ERROR_AUTHENTICATION_FAILED;
+ goto shutdown;
+ }
+
+ rc = libssh2_agent_userauth(agent, c->username, curr);
+
+ if (rc == 0)
+ break;
+
+ prev = curr;
+ }
+
+shutdown:
+
+ if (rc != LIBSSH2_ERROR_NONE)
+ ssh_error(session, "error authenticating");
+
+ libssh2_agent_disconnect(agent);
+ libssh2_agent_free(agent);
+
+ return rc;
+}
+
+static int _git_ssh_authenticate_session(
+ LIBSSH2_SESSION *session,
+ git_credential *cred)
+{
+ int rc;
+
+ do {
+ git_error_clear();
+ switch (cred->credtype) {
+ case GIT_CREDENTIAL_USERPASS_PLAINTEXT: {
+ git_credential_userpass_plaintext *c = (git_credential_userpass_plaintext *)cred;
+ rc = libssh2_userauth_password(session, c->username, c->password);
+ break;
+ }
+ case GIT_CREDENTIAL_SSH_KEY: {
+ git_credential_ssh_key *c = (git_credential_ssh_key *)cred;
+
+ if (c->privatekey)
+ rc = libssh2_userauth_publickey_fromfile(
+ session, c->username, c->publickey,
+ c->privatekey, c->passphrase);
+ else
+ rc = ssh_agent_auth(session, c);
+
+ break;
+ }
+ case GIT_CREDENTIAL_SSH_CUSTOM: {
+ git_credential_ssh_custom *c = (git_credential_ssh_custom *)cred;
+
+ rc = libssh2_userauth_publickey(
+ session, c->username, (const unsigned char *)c->publickey,
+ c->publickey_len, c->sign_callback, &c->payload);
+ break;
+ }
+ case GIT_CREDENTIAL_SSH_INTERACTIVE: {
+ void **abstract = libssh2_session_abstract(session);
+ git_credential_ssh_interactive *c = (git_credential_ssh_interactive *)cred;
+
+ /* ideally, we should be able to set this by calling
+ * libssh2_session_init_ex() instead of libssh2_session_init().
+ * libssh2's API is inconsistent here i.e. libssh2_userauth_publickey()
+ * allows you to pass the `abstract` as part of the call, whereas
+ * libssh2_userauth_keyboard_interactive() does not!
+ *
+ * The only way to set the `abstract` pointer is by calling
+ * libssh2_session_abstract(), which will replace the existing
+ * pointer as is done below. This is safe for now (at time of writing),
+ * but may not be valid in future.
+ */
+ *abstract = c->payload;
+
+ rc = libssh2_userauth_keyboard_interactive(
+ session, c->username, c->prompt_callback);
+ break;
+ }
+#ifdef GIT_SSH_LIBSSH2_MEMORY_CREDENTIALS
+ case GIT_CREDENTIAL_SSH_MEMORY: {
+ git_credential_ssh_key *c = (git_credential_ssh_key *)cred;
+
+ GIT_ASSERT(c->username);
+ GIT_ASSERT(c->privatekey);
+
+ rc = libssh2_userauth_publickey_frommemory(
+ session,
+ c->username,
+ strlen(c->username),
+ c->publickey,
+ c->publickey ? strlen(c->publickey) : 0,
+ c->privatekey,
+ strlen(c->privatekey),
+ c->passphrase);
+ break;
+ }
+#endif
+ default:
+ rc = LIBSSH2_ERROR_AUTHENTICATION_FAILED;
+ }
+ } while (LIBSSH2_ERROR_EAGAIN == rc || LIBSSH2_ERROR_TIMEOUT == rc);
+
+ if (rc == LIBSSH2_ERROR_PASSWORD_EXPIRED ||
+ rc == LIBSSH2_ERROR_AUTHENTICATION_FAILED ||
+ rc == LIBSSH2_ERROR_PUBLICKEY_UNVERIFIED)
+ return GIT_EAUTH;
+
+ if (rc != LIBSSH2_ERROR_NONE) {
+ if (git_error_last()->klass == GIT_ERROR_NONE)
+ ssh_error(session, "failed to authenticate SSH session");
+ return -1;
+ }
+
+ return 0;
+}
+
+static int request_creds(git_credential **out, ssh_subtransport *t, const char *user, int auth_methods)
+{
+ int error, no_callback = 0;
+ git_credential *cred = NULL;
+
+ if (!t->owner->connect_opts.callbacks.credentials) {
+ no_callback = 1;
+ } else {
+ error = t->owner->connect_opts.callbacks.credentials(
+ &cred,
+ t->owner->url,
+ user,
+ auth_methods,
+ t->owner->connect_opts.callbacks.payload);
+
+ if (error == GIT_PASSTHROUGH) {
+ no_callback = 1;
+ } else if (error < 0) {
+ return error;
+ } else if (!cred) {
+ git_error_set(GIT_ERROR_SSH, "callback failed to initialize SSH credentials");
+ return -1;
+ }
+ }
+
+ if (no_callback) {
+ git_error_set(GIT_ERROR_SSH, "authentication required but no callback set");
+ return GIT_EAUTH;
+ }
+
+ if (!(cred->credtype & auth_methods)) {
+ cred->free(cred);
+ git_error_set(GIT_ERROR_SSH, "authentication callback returned unsupported credentials type");
+ return GIT_EAUTH;
+ }
+
+ *out = cred;
+
+ return 0;
+}
+
+#define SSH_DIR ".ssh"
+#define KNOWN_HOSTS_FILE "known_hosts"
+
+/*
+ * Load the known_hosts file.
+ *
+ * Returns success but leaves the output NULL if we couldn't find the file.
+ */
+static int load_known_hosts(LIBSSH2_KNOWNHOSTS **hosts, LIBSSH2_SESSION *session)
+{
+ git_str path = GIT_STR_INIT, sshdir = GIT_STR_INIT;
+ LIBSSH2_KNOWNHOSTS *known_hosts = NULL;
+ int error;
+
+ GIT_ASSERT_ARG(hosts);
+
+ if ((error = git_sysdir_expand_homedir_file(&sshdir, SSH_DIR)) < 0 ||
+ (error = git_str_joinpath(&path, git_str_cstr(&sshdir), KNOWN_HOSTS_FILE)) < 0)
+ goto out;
+
+ if ((known_hosts = libssh2_knownhost_init(session)) == NULL) {
+ ssh_error(session, "error initializing known hosts");
+ error = -1;
+ goto out;
+ }
+
+ /*
+ * Try to read the file and consider not finding it as not trusting the
+ * host rather than an error.
+ */
+ error = libssh2_knownhost_readfile(known_hosts, git_str_cstr(&path), LIBSSH2_KNOWNHOST_FILE_OPENSSH);
+ if (error == LIBSSH2_ERROR_FILE)
+ error = 0;
+ if (error < 0)
+ ssh_error(session, "error reading known_hosts");
+
+out:
+ *hosts = known_hosts;
+
+ git_str_dispose(&sshdir);
+ git_str_dispose(&path);
+
+ return error;
+}
+
+static void add_hostkey_pref_if_avail(
+ LIBSSH2_KNOWNHOSTS *known_hosts,
+ const char *hostname,
+ int port,
+ git_str *prefs,
+ int type,
+ const char *type_name)
+{
+ struct libssh2_knownhost *host = NULL;
+ const char key = '\0';
+ int mask = LIBSSH2_KNOWNHOST_TYPE_PLAIN | LIBSSH2_KNOWNHOST_KEYENC_RAW | type;
+ int error;
+
+ error = libssh2_knownhost_checkp(known_hosts, hostname, port, &key, 1, mask, &host);
+ if (error == LIBSSH2_KNOWNHOST_CHECK_MISMATCH) {
+ if (git_str_len(prefs) > 0) {
+ git_str_putc(prefs, ',');
+ }
+ git_str_puts(prefs, type_name);
+ }
+}
+
+/*
+ * We figure out what kind of key we want to ask the remote for by trying to
+ * look it up with a nonsense key and using that mismatch to figure out what key
+ * we do have stored for the host.
+ *
+ * Populates prefs with the string to pass to libssh2_session_method_pref.
+ */
+static void find_hostkey_preference(
+ LIBSSH2_KNOWNHOSTS *known_hosts,
+ const char *hostname,
+ int port,
+ git_str *prefs)
+{
+ /*
+ * The order here is important as it indicates the priority of what will
+ * be preferred.
+ */
+#ifdef LIBSSH2_KNOWNHOST_KEY_ED25519
+ add_hostkey_pref_if_avail(known_hosts, hostname, port, prefs, LIBSSH2_KNOWNHOST_KEY_ED25519, "ssh-ed25519");
+#endif
+#ifdef LIBSSH2_KNOWNHOST_KEY_ECDSA_256
+ add_hostkey_pref_if_avail(known_hosts, hostname, port, prefs, LIBSSH2_KNOWNHOST_KEY_ECDSA_256, "ecdsa-sha2-nistp256");
+ add_hostkey_pref_if_avail(known_hosts, hostname, port, prefs, LIBSSH2_KNOWNHOST_KEY_ECDSA_384, "ecdsa-sha2-nistp384");
+ add_hostkey_pref_if_avail(known_hosts, hostname, port, prefs, LIBSSH2_KNOWNHOST_KEY_ECDSA_521, "ecdsa-sha2-nistp521");
+#endif
+ add_hostkey_pref_if_avail(known_hosts, hostname, port, prefs, LIBSSH2_KNOWNHOST_KEY_SSHRSA, "rsa-sha2-512");
+ add_hostkey_pref_if_avail(known_hosts, hostname, port, prefs, LIBSSH2_KNOWNHOST_KEY_SSHRSA, "rsa-sha2-256");
+ add_hostkey_pref_if_avail(known_hosts, hostname, port, prefs, LIBSSH2_KNOWNHOST_KEY_SSHRSA, "ssh-rsa");
+}
+
+static int _git_ssh_session_create(
+ LIBSSH2_SESSION **session,
+ LIBSSH2_KNOWNHOSTS **hosts,
+ const char *hostname,
+ int port,
+ git_stream *io)
+{
+ git_socket_stream *socket = GIT_CONTAINER_OF(io, git_socket_stream, parent);
+ LIBSSH2_SESSION *s;
+ LIBSSH2_KNOWNHOSTS *known_hosts;
+ git_str prefs = GIT_STR_INIT;
+ int rc = 0;
+
+ GIT_ASSERT_ARG(session);
+ GIT_ASSERT_ARG(hosts);
+
+ s = libssh2_session_init();
+ if (!s) {
+ git_error_set(GIT_ERROR_NET, "failed to initialize SSH session");
+ return -1;
+ }
+
+ if (git_socket_stream__timeout > 0) {
+ libssh2_session_set_timeout(s, git_socket_stream__timeout);
+ }
+
+ if ((rc = load_known_hosts(&known_hosts, s)) < 0) {
+ ssh_error(s, "error loading known_hosts");
+ libssh2_session_free(s);
+ return -1;
+ }
+
+ find_hostkey_preference(known_hosts, hostname, port, &prefs);
+ if (git_str_len(&prefs) > 0) {
+ do {
+ rc = libssh2_session_method_pref(s, LIBSSH2_METHOD_HOSTKEY, git_str_cstr(&prefs));
+ } while (LIBSSH2_ERROR_EAGAIN == rc || LIBSSH2_ERROR_TIMEOUT == rc);
+ if (rc != LIBSSH2_ERROR_NONE) {
+ ssh_error(s, "failed to set hostkey preference");
+ goto on_error;
+ }
+ }
+ git_str_dispose(&prefs);
+
+ do {
+ rc = libssh2_session_handshake(s, socket->s);
+ } while (LIBSSH2_ERROR_EAGAIN == rc || LIBSSH2_ERROR_TIMEOUT == rc);
+
+ if (rc != LIBSSH2_ERROR_NONE) {
+ ssh_error(s, "failed to start SSH session");
+ goto on_error;
+ }
+
+ libssh2_session_set_blocking(s, 1);
+
+ *session = s;
+ *hosts = known_hosts;
+
+ return 0;
+
+on_error:
+ libssh2_knownhost_free(known_hosts);
+ libssh2_session_free(s);
+ return -1;
+}
+
+
+/*
+ * Returns the typemask argument to pass to libssh2_knownhost_check{,p} based on
+ * the type of key that libssh2_session_hostkey returns.
+ */
+static int fingerprint_type_mask(int keytype)
+{
+ int mask = LIBSSH2_KNOWNHOST_TYPE_PLAIN | LIBSSH2_KNOWNHOST_KEYENC_RAW;
+ return mask;
+
+ switch (keytype) {
+ case LIBSSH2_HOSTKEY_TYPE_RSA:
+ mask |= LIBSSH2_KNOWNHOST_KEY_SSHRSA;
+ break;
+ case LIBSSH2_HOSTKEY_TYPE_DSS:
+ mask |= LIBSSH2_KNOWNHOST_KEY_SSHDSS;
+ break;
+#ifdef LIBSSH2_HOSTKEY_TYPE_ECDSA_256
+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:
+ mask |= LIBSSH2_KNOWNHOST_KEY_ECDSA_256;
+ break;
+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:
+ mask |= LIBSSH2_KNOWNHOST_KEY_ECDSA_384;
+ break;
+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_521:
+ mask |= LIBSSH2_KNOWNHOST_KEY_ECDSA_521;
+ break;
+#endif
+#ifdef LIBSSH2_HOSTKEY_TYPE_ED25519
+ case LIBSSH2_HOSTKEY_TYPE_ED25519:
+ mask |= LIBSSH2_KNOWNHOST_KEY_ED25519;
+ break;
+#endif
+ }
+
+ return mask;
+}
+
+/*
+ * Check the host against the user's known_hosts file.
+ *
+ * Returns 1/0 for valid/''not-valid or <0 for an error
+ */
+static int check_against_known_hosts(
+ LIBSSH2_SESSION *session,
+ LIBSSH2_KNOWNHOSTS *known_hosts,
+ const char *hostname,
+ int port,
+ const char *key,
+ size_t key_len,
+ int key_type)
+{
+ int check, typemask, ret = 0;
+ struct libssh2_knownhost *host = NULL;
+
+ if (known_hosts == NULL)
+ return 0;
+
+ typemask = fingerprint_type_mask(key_type);
+ check = libssh2_knownhost_checkp(known_hosts, hostname, port, key, key_len, typemask, &host);
+ if (check == LIBSSH2_KNOWNHOST_CHECK_FAILURE) {
+ ssh_error(session, "error checking for known host");
+ return -1;
+ }
+
+ ret = check == LIBSSH2_KNOWNHOST_CHECK_MATCH ? 1 : 0;
+
+ return ret;
+}
+
+/*
+ * Perform the check for the session's certificate against known hosts if
+ * possible and then ask the user if they have a callback.
+ *
+ * Returns 1/0 for valid/not-valid or <0 for an error
+ */
+static int check_certificate(
+ LIBSSH2_SESSION *session,
+ LIBSSH2_KNOWNHOSTS *known_hosts,
+ git_transport_certificate_check_cb check_cb,
+ void *check_cb_payload,
+ const char *host,
+ int port)
+{
+ git_cert_hostkey cert = {{ 0 }};
+ const char *key;
+ size_t cert_len;
+ int cert_type, cert_valid = 0, error = GIT_ECERTIFICATE;
+
+ if ((key = libssh2_session_hostkey(session, &cert_len, &cert_type)) == NULL) {
+ ssh_error(session, "failed to retrieve hostkey");
+ return -1;
+ }
+
+ if ((cert_valid = check_against_known_hosts(session, known_hosts, host, port, key, cert_len, cert_type)) < 0)
+ return -1;
+
+ cert.parent.cert_type = GIT_CERT_HOSTKEY_LIBSSH2;
+ if (key != NULL) {
+ cert.type |= GIT_CERT_SSH_RAW;
+ cert.hostkey = key;
+ cert.hostkey_len = cert_len;
+ switch (cert_type) {
+ case LIBSSH2_HOSTKEY_TYPE_RSA:
+ cert.raw_type = GIT_CERT_SSH_RAW_TYPE_RSA;
+ break;
+ case LIBSSH2_HOSTKEY_TYPE_DSS:
+ cert.raw_type = GIT_CERT_SSH_RAW_TYPE_DSS;
+ break;
+
+#ifdef LIBSSH2_HOSTKEY_TYPE_ECDSA_256
+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_256:
+ cert.raw_type = GIT_CERT_SSH_RAW_TYPE_KEY_ECDSA_256;
+ break;
+ case LIBSSH2_HOSTKEY_TYPE_ECDSA_384:
+ cert.raw_type = GIT_CERT_SSH_RAW_TYPE_KEY_ECDSA_384;
+ break;
+ case LIBSSH2_KNOWNHOST_KEY_ECDSA_521:
+ cert.raw_type = GIT_CERT_SSH_RAW_TYPE_KEY_ECDSA_521;
+ break;
+#endif
+
+#ifdef LIBSSH2_HOSTKEY_TYPE_ED25519
+ case LIBSSH2_HOSTKEY_TYPE_ED25519:
+ cert.raw_type = GIT_CERT_SSH_RAW_TYPE_KEY_ED25519;
+ break;
+#endif
+ default:
+ cert.raw_type = GIT_CERT_SSH_RAW_TYPE_UNKNOWN;
+ }
+ }
+
+#ifdef LIBSSH2_HOSTKEY_HASH_SHA256
+ key = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA256);
+ if (key != NULL) {
+ cert.type |= GIT_CERT_SSH_SHA256;
+ memcpy(&cert.hash_sha256, key, 32);
+ }
+#endif
+
+ key = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_SHA1);
+ if (key != NULL) {
+ cert.type |= GIT_CERT_SSH_SHA1;
+ memcpy(&cert.hash_sha1, key, 20);
+ }
+
+ key = libssh2_hostkey_hash(session, LIBSSH2_HOSTKEY_HASH_MD5);
+ if (key != NULL) {
+ cert.type |= GIT_CERT_SSH_MD5;
+ memcpy(&cert.hash_md5, key, 16);
+ }
+
+ if (cert.type == 0) {
+ git_error_set(GIT_ERROR_SSH, "unable to get the host key");
+ return -1;
+ }
+
+ if (check_cb != NULL) {
+ git_cert_hostkey *cert_ptr = &cert;
+
+ error = check_cb((git_cert *)cert_ptr, cert_valid, host,
+ check_cb_payload);
+
+ if (error == 0)
+ cert_valid = 1;
+ else if (error != GIT_PASSTHROUGH)
+ cert_valid = 0;
+ }
+
+ if (!cert_valid) {
+ git_error_set(GIT_ERROR_SSH, "invalid or unknown remote ssh hostkey");
+ return (error == GIT_PASSTHROUGH) ? GIT_ECERTIFICATE : error;
+ }
+
+ return 0;
+}
+
+#define SSH_DEFAULT_PORT "22"
+
+static int _git_ssh_setup_conn(
+ ssh_subtransport *t,
+ const char *url,
+ const char *cmd,
+ git_smart_subtransport_stream **stream)
+{
+ int auth_methods, error = 0, port;
+ ssh_stream *s;
+ git_credential *cred = NULL;
+ LIBSSH2_SESSION *session=NULL;
+ LIBSSH2_CHANNEL *channel=NULL;
+ LIBSSH2_KNOWNHOSTS *known_hosts = NULL;
+
+ t->current_stream = NULL;
+
+ *stream = NULL;
+ if (ssh_stream_alloc(t, cmd, stream) < 0)
+ return -1;
+
+ s = (ssh_stream *)*stream;
+ s->session = NULL;
+ s->channel = NULL;
+
+ if (git_net_str_is_url(url))
+ error = git_net_url_parse(&s->url, url);
+ else
+ error = git_net_url_parse_scp(&s->url, url);
+
+ if (error < 0)
+ goto done;
+
+ /* Safety check: like git, we forbid paths that look like an option as
+ * that could lead to injection on the remote side */
+ if (git_process__is_cmdline_option(s->url.path)) {
+ git_error_set(GIT_ERROR_NET, "cannot ssh: path '%s' is ambiguous with command-line option", s->url.path);
+ error = -1;
+ goto done;
+ }
+
+
+ if ((error = git_socket_stream_new(&s->io, s->url.host, s->url.port)) < 0 ||
+ (error = git_stream_connect(s->io)) < 0)
+ goto done;
+
+ /*
+ * Try to parse the port as a number, if we can't then fall back to
+ * default. It would be nice if we could get the port that was resolved
+ * as part of the stream connection, but that's not something that's
+ * exposed.
+ */
+ if (git__strntol32(&port, s->url.port, strlen(s->url.port), NULL, 10) < 0)
+ port = -1;
+
+ if ((error = _git_ssh_session_create(&session, &known_hosts, s->url.host, port, s->io)) < 0)
+ goto done;
+
+ if ((error = check_certificate(session, known_hosts, t->owner->connect_opts.callbacks.certificate_check, t->owner->connect_opts.callbacks.payload, s->url.host, port)) < 0)
+ goto done;
+
+ /* we need the username to ask for auth methods */
+ if (!s->url.username) {
+ if ((error = request_creds(&cred, t, NULL, GIT_CREDENTIAL_USERNAME)) < 0)
+ goto done;
+
+ s->url.username = git__strdup(((git_credential_username *) cred)->username);
+ cred->free(cred);
+ cred = NULL;
+ if (!s->url.username)
+ goto done;
+ } else if (s->url.username && s->url.password) {
+ if ((error = git_credential_userpass_plaintext_new(&cred, s->url.username, s->url.password)) < 0)
+ goto done;
+ }
+
+ if ((error = list_auth_methods(&auth_methods, session, s->url.username)) < 0)
+ goto done;
+
+ error = GIT_EAUTH;
+ /* if we already have something to try */
+ if (cred && auth_methods & cred->credtype)
+ error = _git_ssh_authenticate_session(session, cred);
+
+ while (error == GIT_EAUTH) {
+ if (cred) {
+ cred->free(cred);
+ cred = NULL;
+ }
+
+ if ((error = request_creds(&cred, t, s->url.username, auth_methods)) < 0)
+ goto done;
+
+ if (strcmp(s->url.username, git_credential_get_username(cred))) {
+ git_error_set(GIT_ERROR_SSH, "username does not match previous request");
+ error = -1;
+ goto done;
+ }
+
+ error = _git_ssh_authenticate_session(session, cred);
+
+ if (error == GIT_EAUTH) {
+ /* refresh auth methods */
+ if ((error = list_auth_methods(&auth_methods, session, s->url.username)) < 0)
+ goto done;
+ else
+ error = GIT_EAUTH;
+ }
+ }
+
+ if (error < 0)
+ goto done;
+
+ channel = libssh2_channel_open_session(session);
+ if (!channel) {
+ error = -1;
+ ssh_error(session, "Failed to open SSH channel");
+ goto done;
+ }
+
+ libssh2_channel_set_blocking(channel, 1);
+
+ s->session = session;
+ s->channel = channel;
+
+ t->current_stream = s;
+
+done:
+ if (known_hosts)
+ libssh2_knownhost_free(known_hosts);
+
+ if (error < 0) {
+ ssh_stream_free(*stream);
+
+ if (session)
+ libssh2_session_free(session);
+ }
+
+ if (cred)
+ cred->free(cred);
+
+ return error;
+}
+
+static int ssh_uploadpack_ls(
+ ssh_subtransport *t,
+ const char *url,
+ git_smart_subtransport_stream **stream)
+{
+ const char *cmd = t->cmd_uploadpack ? t->cmd_uploadpack : cmd_uploadpack;
+
+ return _git_ssh_setup_conn(t, url, cmd, stream);
+}
+
+static int ssh_uploadpack(
+ ssh_subtransport *t,
+ const char *url,
+ git_smart_subtransport_stream **stream)
+{
+ GIT_UNUSED(url);
+
+ if (t->current_stream) {
+ *stream = &t->current_stream->parent;
+ return 0;
+ }
+
+ git_error_set(GIT_ERROR_NET, "must call UPLOADPACK_LS before UPLOADPACK");
+ return -1;
+}
+
+static int ssh_receivepack_ls(
+ ssh_subtransport *t,
+ const char *url,
+ git_smart_subtransport_stream **stream)
+{
+ const char *cmd = t->cmd_receivepack ? t->cmd_receivepack : cmd_receivepack;
+
+
+ return _git_ssh_setup_conn(t, url, cmd, stream);
+}
+
+static int ssh_receivepack(
+ ssh_subtransport *t,
+ const char *url,
+ git_smart_subtransport_stream **stream)
+{
+ GIT_UNUSED(url);
+
+ if (t->current_stream) {
+ *stream = &t->current_stream->parent;
+ return 0;
+ }
+
+ git_error_set(GIT_ERROR_NET, "must call RECEIVEPACK_LS before RECEIVEPACK");
+ return -1;
+}
+
+static int _ssh_action(
+ git_smart_subtransport_stream **stream,
+ git_smart_subtransport *subtransport,
+ const char *url,
+ git_smart_service_t action)
+{
+ ssh_subtransport *t = GIT_CONTAINER_OF(subtransport, ssh_subtransport, parent);
+
+ switch (action) {
+ case GIT_SERVICE_UPLOADPACK_LS:
+ return ssh_uploadpack_ls(t, url, stream);
+
+ case GIT_SERVICE_UPLOADPACK:
+ return ssh_uploadpack(t, url, stream);
+
+ case GIT_SERVICE_RECEIVEPACK_LS:
+ return ssh_receivepack_ls(t, url, stream);
+
+ case GIT_SERVICE_RECEIVEPACK:
+ return ssh_receivepack(t, url, stream);
+ }
+
+ *stream = NULL;
+ return -1;
+}
+
+static int _ssh_close(git_smart_subtransport *subtransport)
+{
+ ssh_subtransport *t = GIT_CONTAINER_OF(subtransport, ssh_subtransport, parent);
+
+ GIT_ASSERT(!t->current_stream);
+
+ GIT_UNUSED(t);
+
+ return 0;
+}
+
+static void _ssh_free(git_smart_subtransport *subtransport)
+{
+ ssh_subtransport *t = GIT_CONTAINER_OF(subtransport, ssh_subtransport, parent);
+
+ git__free(t->cmd_uploadpack);
+ git__free(t->cmd_receivepack);
+ git__free(t);
+}
+
+#define SSH_AUTH_PUBLICKEY "publickey"
+#define SSH_AUTH_PASSWORD "password"
+#define SSH_AUTH_KEYBOARD_INTERACTIVE "keyboard-interactive"
+
+static int list_auth_methods(int *out, LIBSSH2_SESSION *session, const char *username)
+{
+ const char *list, *ptr;
+
+ *out = 0;
+
+ list = libssh2_userauth_list(session, username,
+ (unsigned int)strlen(username));
+
+ /* either error, or the remote accepts NONE auth, which is bizarre, let's punt */
+ if (list == NULL && !libssh2_userauth_authenticated(session)) {
+ ssh_error(session, "remote rejected authentication");
+ return GIT_EAUTH;
+ }
+
+ ptr = list;
+ while (ptr) {
+ if (*ptr == ',')
+ ptr++;
+
+ if (!git__prefixcmp(ptr, SSH_AUTH_PUBLICKEY)) {
+ *out |= GIT_CREDENTIAL_SSH_KEY;
+ *out |= GIT_CREDENTIAL_SSH_CUSTOM;
+#ifdef GIT_SSH_LIBSSH2_MEMORY_CREDENTIALS
+ *out |= GIT_CREDENTIAL_SSH_MEMORY;
+#endif
+ ptr += strlen(SSH_AUTH_PUBLICKEY);
+ continue;
+ }
+
+ if (!git__prefixcmp(ptr, SSH_AUTH_PASSWORD)) {
+ *out |= GIT_CREDENTIAL_USERPASS_PLAINTEXT;
+ ptr += strlen(SSH_AUTH_PASSWORD);
+ continue;
+ }
+
+ if (!git__prefixcmp(ptr, SSH_AUTH_KEYBOARD_INTERACTIVE)) {
+ *out |= GIT_CREDENTIAL_SSH_INTERACTIVE;
+ ptr += strlen(SSH_AUTH_KEYBOARD_INTERACTIVE);
+ continue;
+ }
+
+ /* Skip it if we don't know it */
+ ptr = strchr(ptr, ',');
+ }
+
+ return 0;
+}
+
+int git_smart_subtransport_ssh_libssh2(
+ git_smart_subtransport **out,
+ git_transport *owner,
+ void *param)
+{
+ ssh_subtransport *t;
+
+ GIT_ASSERT_ARG(out);
+
+ GIT_UNUSED(param);
+
+ t = git__calloc(sizeof(ssh_subtransport), 1);
+ GIT_ERROR_CHECK_ALLOC(t);
+
+ t->owner = (transport_smart *)owner;
+ t->parent.action = _ssh_action;
+ t->parent.close = _ssh_close;
+ t->parent.free = _ssh_free;
+
+ *out = (git_smart_subtransport *) t;
+ return 0;
+}
+
+int git_smart_subtransport_ssh_libssh2_set_paths(
+ git_smart_subtransport *subtransport,
+ const char *cmd_uploadpack,
+ const char *cmd_receivepack)
+{
+ ssh_subtransport *t = (ssh_subtransport *)subtransport;
+
+ git__free(t->cmd_uploadpack);
+ git__free(t->cmd_receivepack);
+
+ t->cmd_uploadpack = git__strdup(cmd_uploadpack);
+ GIT_ERROR_CHECK_ALLOC(t->cmd_uploadpack);
+
+ t->cmd_receivepack = git__strdup(cmd_receivepack);
+ GIT_ERROR_CHECK_ALLOC(t->cmd_receivepack);
+
+ return 0;
+}
+
+static void shutdown_libssh2(void)
+{
+ libssh2_exit();
+}
+
+int git_transport_ssh_libssh2_global_init(void)
+{
+ if (libssh2_init(0) < 0) {
+ git_error_set(GIT_ERROR_SSH, "unable to initialize libssh2");
+ return -1;
+ }
+
+ return git_runtime_shutdown_register(shutdown_libssh2);
+}
+
+#else /* GIT_SSH */
+
+int git_transport_ssh_libssh2_global_init(void)
+{
+ return 0;
+}
+
+#endif
diff --git a/src/libgit2/transports/ssh_libssh2.h b/src/libgit2/transports/ssh_libssh2.h
new file mode 100644
index 00000000000..3f8cc2a8ad9
--- /dev/null
+++ b/src/libgit2/transports/ssh_libssh2.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_transports_libssh2_h__
+#define INCLUDE_transports_libssh2_h__
+
+#include "common.h"
+
+#include "git2.h"
+#include "git2/transport.h"
+#include "git2/sys/transport.h"
+
+int git_transport_ssh_libssh2_global_init(void);
+
+int git_smart_subtransport_ssh_libssh2(
+ git_smart_subtransport **out,
+ git_transport *owner,
+ void *param);
+
+int git_smart_subtransport_ssh_libssh2_set_paths(
+ git_smart_subtransport *subtransport,
+ const char *cmd_uploadpack,
+ const char *cmd_receivepack);
+
+#endif
diff --git a/src/libgit2/transports/winhttp.c b/src/libgit2/transports/winhttp.c
index 09822760799..7141c284634 100644
--- a/src/libgit2/transports/winhttp.c
+++ b/src/libgit2/transports/winhttp.c
@@ -7,13 +7,12 @@
#include "common.h"
-#ifdef GIT_WINHTTP
+#ifdef GIT_HTTPS_WINHTTP
#include "git2.h"
#include "git2/transport.h"
#include "posix.h"
#include "str.h"
-#include "netops.h"
#include "smart.h"
#include "remote.h"
#include "repository.h"
@@ -158,10 +157,10 @@ static int apply_userpass_credentials(HINTERNET request, DWORD target, int mecha
goto done;
}
- if ((error = user_len = git__utf8_to_16_alloc(&user, c->username)) < 0)
+ if ((error = user_len = git_utf8_to_16_alloc(&user, c->username)) < 0)
goto done;
- if ((error = pass_len = git__utf8_to_16_alloc(&pass, c->password)) < 0)
+ if ((error = pass_len = git_utf8_to_16_alloc(&pass, c->password)) < 0)
goto done;
if (!WinHttpSetCredentials(request, target, native_scheme, user, pass, NULL)) {
@@ -242,7 +241,7 @@ static int acquire_fallback_cred(
HRESULT hCoInitResult;
/* Convert URL to wide characters */
- if (git__utf8_to_16_alloc(&wide_url, url) < 0) {
+ if (git_utf8_to_16_alloc(&wide_url, url) < 0) {
git_error_set(GIT_ERROR_OS, "failed to convert string to wide form");
return -1;
}
@@ -294,7 +293,7 @@ static int certificate_check(winhttp_stream *s, int valid)
/* If there is no override, we should fail if WinHTTP doesn't think it's fine */
if (t->owner->connect_opts.callbacks.certificate_check == NULL && !valid) {
- if (!git_error_last())
+ if (git_error_last()->klass == GIT_ERROR_NONE)
git_error_set(GIT_ERROR_HTTP, "unknown certificate check failure");
return GIT_ECERTIFICATE;
@@ -318,7 +317,7 @@ static int certificate_check(winhttp_stream *s, int valid)
if (error == GIT_PASSTHROUGH)
error = valid ? 0 : GIT_ECERTIFICATE;
- if (error < 0 && !git_error_last())
+ if (error < 0 && git_error_last()->klass == GIT_ERROR_NONE)
git_error_set(GIT_ERROR_HTTP, "user cancelled certificate check");
return error;
@@ -397,7 +396,7 @@ static int winhttp_stream_connect(winhttp_stream *s)
return -1;
/* Convert URL to wide characters */
- if (git__utf8_to_16_alloc(&s->request_uri, git_str_cstr(&buf)) < 0) {
+ if (git_utf8_to_16_alloc(&s->request_uri, git_str_cstr(&buf)) < 0) {
git_error_set(GIT_ERROR_OS, "failed to convert string to wide form");
goto on_error;
}
@@ -437,17 +436,17 @@ static int winhttp_stream_connect(winhttp_stream *s)
GIT_ERROR_CHECK_ALLOC(proxy_url);
}
- if (proxy_url) {
+ if (proxy_url && *proxy_url) {
git_str processed_url = GIT_STR_INIT;
WINHTTP_PROXY_INFO proxy_info;
wchar_t *proxy_wide;
git_net_url_dispose(&t->proxy.url);
- if ((error = git_net_url_parse(&t->proxy.url, proxy_url)) < 0)
+ if ((error = git_net_url_parse_http(&t->proxy.url, proxy_url)) < 0)
goto on_error;
- if (strcmp(t->proxy.url.scheme, "http") != 0 && strcmp(t->proxy.url.scheme, "https") != 0) {
+ if (!git_net_url_valid(&t->proxy.url)) {
git_error_set(GIT_ERROR_HTTP, "invalid URL: '%s'", proxy_url);
error = -1;
goto on_error;
@@ -473,7 +472,7 @@ static int winhttp_stream_connect(winhttp_stream *s)
}
/* Convert URL to wide characters */
- error = git__utf8_to_16_alloc(&proxy_wide, processed_url.ptr);
+ error = git_utf8_to_16_alloc(&proxy_wide, processed_url.ptr);
git_str_dispose(&processed_url);
if (error < 0)
goto on_error;
@@ -531,7 +530,7 @@ static int winhttp_stream_connect(winhttp_stream *s)
s->service) < 0)
goto on_error;
- if (git__utf8_to_16(ct, MAX_CONTENT_TYPE_LEN, git_str_cstr(&buf)) < 0) {
+ if (git_utf8_to_16(ct, MAX_CONTENT_TYPE_LEN, git_str_cstr(&buf)) < 0) {
git_error_set(GIT_ERROR_OS, "failed to convert content-type to wide characters");
goto on_error;
}
@@ -548,7 +547,7 @@ static int winhttp_stream_connect(winhttp_stream *s)
s->service) < 0)
goto on_error;
- if (git__utf8_to_16(ct, MAX_CONTENT_TYPE_LEN, git_str_cstr(&buf)) < 0) {
+ if (git_utf8_to_16(ct, MAX_CONTENT_TYPE_LEN, git_str_cstr(&buf)) < 0) {
git_error_set(GIT_ERROR_OS, "failed to convert accept header to wide characters");
goto on_error;
}
@@ -568,7 +567,7 @@ static int winhttp_stream_connect(winhttp_stream *s)
git_str_puts(&buf, t->owner->connect_opts.custom_headers.strings[i]);
/* Convert header to wide characters */
- if ((error = git__utf8_to_16_alloc(&custom_header_wide, git_str_cstr(&buf))) < 0)
+ if ((error = git_utf8_to_16_alloc(&custom_header_wide, git_str_cstr(&buf))) < 0)
goto on_error;
if (!WinHttpAddRequestHeaders(s->request, custom_header_wide, (ULONG)-1L,
@@ -747,6 +746,33 @@ static void CALLBACK winhttp_status(
}
}
+static int user_agent(bool *exists, git_str *out)
+{
+ const char *product = git_settings__user_agent_product();
+ const char *comment = git_settings__user_agent();
+
+ GIT_ASSERT(product && comment);
+
+ if (!*product) {
+ *exists = false;
+ return 0;
+ }
+
+ git_str_puts(out, product);
+
+ if (*comment) {
+ git_str_puts(out, " (");
+ git_str_puts(out, comment);
+ git_str_puts(out, ")");
+ }
+
+ if (git_str_oom(out))
+ return -1;
+
+ *exists = true;
+ return 0;
+}
+
static int winhttp_connect(
winhttp_subtransport *t)
{
@@ -758,6 +784,7 @@ static int winhttp_connect(
int error = -1;
int default_timeout = TIMEOUT_INFINITE;
int default_connect_timeout = DEFAULT_CONNECT_TIMEOUT;
+ bool has_ua = true;
DWORD protocols =
WINHTTP_FLAG_SECURE_PROTOCOL_TLS1 |
WINHTTP_FLAG_SECURE_PROTOCOL_TLS1_1 |
@@ -783,16 +810,16 @@ static int winhttp_connect(
}
/* Prepare host */
- if (git__utf8_to_16_alloc(&wide_host, host) < 0) {
+ if (git_utf8_to_16_alloc(&wide_host, host) < 0) {
git_error_set(GIT_ERROR_OS, "unable to convert host to wide characters");
goto on_error;
}
-
- if (git_http__user_agent(&ua) < 0)
+ if (user_agent(&has_ua, &ua) < 0)
goto on_error;
- if (git__utf8_to_16_alloc(&wide_ua, git_str_cstr(&ua)) < 0) {
+ if (has_ua &&
+ git_utf8_to_16_alloc(&wide_ua, git_str_cstr(&ua)) < 0) {
git_error_set(GIT_ERROR_OS, "unable to convert host to wide characters");
goto on_error;
}
@@ -934,7 +961,7 @@ static int send_request(winhttp_stream *s, size_t len, bool chunked)
(!request_failed && s->status_sending_request_reached)) {
git_error_clear();
if ((error = certificate_check(s, cert_valid)) < 0) {
- if (!git_error_last())
+ if (git_error_last()->klass == GIT_ERROR_NONE)
git_error_set(GIT_ERROR_OS, "user cancelled certificate check");
return error;
@@ -1182,7 +1209,7 @@ static int winhttp_stream_read(
}
/* Convert the Location header to UTF-8 */
- if (git__utf16_to_8_alloc(&location8, location) < 0) {
+ if (git_utf8_from_16_alloc(&location8, location) < 0) {
git_error_set(GIT_ERROR_OS, "failed to convert Location header to UTF-8");
git__free(location);
return -1;
@@ -1254,7 +1281,7 @@ static int winhttp_stream_read(
else
p_snprintf(expected_content_type_8, MAX_CONTENT_TYPE_LEN, "application/x-git-%s-advertisement", s->service);
- if (git__utf8_to_16(expected_content_type, MAX_CONTENT_TYPE_LEN, expected_content_type_8) < 0) {
+ if (git_utf8_to_16(expected_content_type, MAX_CONTENT_TYPE_LEN, expected_content_type_8) < 0) {
git_error_set(GIT_ERROR_OS, "failed to convert expected content-type to wide characters");
return -1;
}
@@ -1688,4 +1715,4 @@ int git_smart_subtransport_http(git_smart_subtransport **out, git_transport *own
return 0;
}
-#endif /* GIT_WINHTTP */
+#endif /* GIT_HTTPS_WINHTTP */
diff --git a/src/libgit2/tree-cache.c b/src/libgit2/tree-cache.c
index 19fad85aea3..f3c895f4cf8 100644
--- a/src/libgit2/tree-cache.c
+++ b/src/libgit2/tree-cache.c
@@ -71,12 +71,16 @@ const git_tree_cache *git_tree_cache_get(const git_tree_cache *tree, const char
}
}
-static int read_tree_internal(git_tree_cache **out,
- const char **buffer_in, const char *buffer_end,
- git_pool *pool)
+static int read_tree_internal(
+ git_tree_cache **out,
+ const char **buffer_in,
+ const char *buffer_end,
+ git_oid_t oid_type,
+ git_pool *pool)
{
git_tree_cache *tree = NULL;
const char *name_start, *buffer;
+ size_t oid_size = git_oid_size(oid_type);
int count;
buffer = name_start = *buffer_in;
@@ -87,7 +91,7 @@ static int read_tree_internal(git_tree_cache **out,
if (++buffer >= buffer_end)
goto corrupted;
- if (git_tree_cache_new(&tree, name_start, pool) < 0)
+ if (git_tree_cache_new(&tree, name_start, oid_type, pool) < 0)
return -1;
/* Blank-terminated ASCII decimal number of entries in this tree */
@@ -108,14 +112,14 @@ static int read_tree_internal(git_tree_cache **out,
if (*buffer != '\n' || ++buffer > buffer_end)
goto corrupted;
- /* The SHA1 is only there if it's not invalidated */
+ /* The OID is only there if it's not invalidated */
if (tree->entry_count >= 0) {
/* 160-bit SHA-1 for this tree and it's children */
- if (buffer + GIT_OID_SHA1_SIZE > buffer_end)
+ if (buffer + oid_size > buffer_end)
goto corrupted;
- git_oid__fromraw(&tree->oid, (const unsigned char *)buffer, GIT_OID_SHA1);
- buffer += GIT_OID_SHA1_SIZE;
+ git_oid_from_raw(&tree->oid, (const unsigned char *)buffer, oid_type);
+ buffer += oid_size;
}
/* Parse children: */
@@ -130,7 +134,7 @@ static int read_tree_internal(git_tree_cache **out,
memset(tree->children, 0x0, bufsize);
for (i = 0; i < tree->children_count; ++i) {
- if (read_tree_internal(&tree->children[i], &buffer, buffer_end, pool) < 0)
+ if (read_tree_internal(&tree->children[i], &buffer, buffer_end, oid_type, pool) < 0)
goto corrupted;
}
}
@@ -144,11 +148,16 @@ static int read_tree_internal(git_tree_cache **out,
return -1;
}
-int git_tree_cache_read(git_tree_cache **tree, const char *buffer, size_t buffer_size, git_pool *pool)
+int git_tree_cache_read(
+ git_tree_cache **tree,
+ const char *buffer,
+ size_t buffer_size,
+ git_oid_t oid_type,
+ git_pool *pool)
{
const char *buffer_end = buffer + buffer_size;
- if (read_tree_internal(tree, &buffer, buffer_end, pool) < 0)
+ if (read_tree_internal(tree, &buffer, buffer_end, oid_type, pool) < 0)
return -1;
if (buffer < buffer_end) {
@@ -201,7 +210,7 @@ static int read_tree_recursive(git_tree_cache *cache, const git_tree *tree, git_
continue;
}
- if ((error = git_tree_cache_new(&cache->children[j], git_tree_entry_name(entry), pool)) < 0)
+ if ((error = git_tree_cache_new(&cache->children[j], git_tree_entry_name(entry), cache->oid_type, pool)) < 0)
return error;
if ((error = git_tree_lookup(&subtree, repo, git_tree_entry_id(entry))) < 0)
@@ -219,12 +228,12 @@ static int read_tree_recursive(git_tree_cache *cache, const git_tree *tree, git_
return 0;
}
-int git_tree_cache_read_tree(git_tree_cache **out, const git_tree *tree, git_pool *pool)
+int git_tree_cache_read_tree(git_tree_cache **out, const git_tree *tree, git_oid_t oid_type, git_pool *pool)
{
int error;
git_tree_cache *cache;
- if ((error = git_tree_cache_new(&cache, "", pool)) < 0)
+ if ((error = git_tree_cache_new(&cache, "", oid_type, pool)) < 0)
return error;
if ((error = read_tree_recursive(cache, tree, pool)) < 0)
@@ -234,7 +243,7 @@ int git_tree_cache_read_tree(git_tree_cache **out, const git_tree *tree, git_poo
return 0;
}
-int git_tree_cache_new(git_tree_cache **out, const char *name, git_pool *pool)
+int git_tree_cache_new(git_tree_cache **out, const char *name, git_oid_t oid_type, git_pool *pool)
{
size_t name_len, alloc_size;
git_tree_cache *tree;
@@ -248,6 +257,7 @@ int git_tree_cache_new(git_tree_cache **out, const char *name, git_pool *pool)
memset(tree, 0x0, sizeof(git_tree_cache));
/* NUL-terminated tree name */
+ tree->oid_type = oid_type;
tree->namelen = name_len;
memcpy(tree->name, name, name_len);
tree->name[name_len] = '\0';
@@ -263,7 +273,7 @@ static void write_tree(git_str *out, git_tree_cache *tree)
git_str_printf(out, "%s%c%"PRIdZ" %"PRIuZ"\n", tree->name, 0, tree->entry_count, tree->children_count);
if (tree->entry_count != -1)
- git_str_put(out, (char *)&tree->oid.id, GIT_OID_SHA1_SIZE);
+ git_str_put(out, (char *)&tree->oid.id, git_oid_size(tree->oid_type));
for (i = 0; i < tree->children_count; i++)
write_tree(out, tree->children[i]);
diff --git a/src/libgit2/tree-cache.h b/src/libgit2/tree-cache.h
index a27e3046614..e4a73f277e0 100644
--- a/src/libgit2/tree-cache.h
+++ b/src/libgit2/tree-cache.h
@@ -18,6 +18,8 @@ typedef struct git_tree_cache {
struct git_tree_cache **children;
size_t children_count;
+ git_oid_t oid_type;
+
ssize_t entry_count;
git_oid oid;
size_t namelen;
@@ -25,14 +27,14 @@ typedef struct git_tree_cache {
} git_tree_cache;
int git_tree_cache_write(git_str *out, git_tree_cache *tree);
-int git_tree_cache_read(git_tree_cache **tree, const char *buffer, size_t buffer_size, git_pool *pool);
+int git_tree_cache_read(git_tree_cache **tree, const char *buffer, size_t buffer_size, git_oid_t oid_type, git_pool *pool);
void git_tree_cache_invalidate_path(git_tree_cache *tree, const char *path);
const git_tree_cache *git_tree_cache_get(const git_tree_cache *tree, const char *path);
-int git_tree_cache_new(git_tree_cache **out, const char *name, git_pool *pool);
+int git_tree_cache_new(git_tree_cache **out, const char *name, git_oid_t oid_type, git_pool *pool);
/**
* Read a tree as the root of the tree cache (like for `git read-tree`)
*/
-int git_tree_cache_read_tree(git_tree_cache **out, const git_tree *tree, git_pool *pool);
+int git_tree_cache_read_tree(git_tree_cache **out, const git_tree *tree, git_oid_t oid_type, git_pool *pool);
void git_tree_cache_free(git_tree_cache *tree);
#endif
diff --git a/src/libgit2/tree.c b/src/libgit2/tree.c
index 9293d9422ba..2c89d516e74 100644
--- a/src/libgit2/tree.c
+++ b/src/libgit2/tree.c
@@ -21,6 +21,8 @@
#define TREE_ENTRY_CHECK_NAMELEN(n) \
if (n > UINT16_MAX) { git_error_set(GIT_ERROR_INVALID, "tree entry path too long"); }
+GIT_HASHMAP_STR_FUNCTIONS(git_treebuilder_entrymap, GIT_HASHMAP_INLINE, git_tree_entry *);
+
static bool valid_filemode(const int filemode)
{
return (filemode == GIT_FILEMODE_TREE
@@ -347,7 +349,7 @@ size_t git_treebuilder_entrycount(git_treebuilder *bld)
{
GIT_ASSERT_ARG_WITH_RETVAL(bld, 0);
- return git_strmap_size(bld->map);
+ return git_treebuilder_entrymap_size(&bld->map);
}
GIT_INLINE(void) set_error(const char *str, const char *path)
@@ -381,7 +383,7 @@ static int parse_mode(uint16_t *mode_out, const char *buffer, size_t buffer_len,
if ((error = git__strntol32(&mode, buffer, buffer_len, buffer_out, 8)) < 0)
return error;
- if (mode < 0 || mode > UINT16_MAX)
+ if (mode < 0 || (uint32_t)mode > UINT16_MAX)
return -1;
*mode_out = mode;
@@ -433,7 +435,7 @@ int git_tree__parse_raw(void *_tree, const char *data, size_t size, git_oid_t oi
entry->filename = buffer;
buffer += filename_len + 1;
- git_oid__fromraw(&entry->oid, (unsigned char *)buffer, oid_type);
+ git_oid_from_raw(&entry->oid, (unsigned char *)buffer, oid_type);
buffer += oid_size;
}
@@ -512,10 +514,12 @@ static int git_treebuilder__write_with_buffer(
git_tree_entry *entry;
git_vector entries = GIT_VECTOR_INIT;
size_t oid_size = git_oid_size(bld->repo->oid_type);
+ git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
git_str_clear(buf);
- entrycount = git_strmap_size(bld->map);
+ entrycount = git_treebuilder_entrymap_size(&bld->map);
+
if ((error = git_vector_init(&entries, entrycount, entry_sort_cmp)) < 0)
goto out;
@@ -523,10 +527,10 @@ static int git_treebuilder__write_with_buffer(
(error = git_str_grow(buf, entrycount * 72)) < 0)
goto out;
- git_strmap_foreach_value(bld->map, entry, {
+ while (git_treebuilder_entrymap_iterate(&iter, NULL, &entry, &bld->map) == 0) {
if ((error = git_vector_insert(&entries, entry)) < 0)
goto out;
- });
+ }
git_vector_sort(&entries);
@@ -547,7 +551,7 @@ static int git_treebuilder__write_with_buffer(
error = git_odb_write(oid, odb, buf->ptr, buf->size, GIT_OBJECT_TREE);
out:
- git_vector_free(&entries);
+ git_vector_dispose(&entries);
return error;
}
@@ -570,7 +574,7 @@ static int append_entry(
entry->attr = (uint16_t)filemode;
- if ((error = git_strmap_set(bld->map, entry->filename, entry)) < 0) {
+ if ((error = git_treebuilder_entrymap_put(&bld->map, entry->filename, entry)) < 0) {
git_tree_entry_free(entry);
git_error_set(GIT_ERROR_TREE, "failed to append entry %s to the tree builder", filename);
return -1;
@@ -731,7 +735,7 @@ int git_tree__write_index(
return ret;
/* Read the tree cache into the index */
- ret = git_tree_cache_read_tree(&index->tree, tree, &index->tree_pool);
+ ret = git_tree_cache_read_tree(&index->tree, tree, index->oid_type, &index->tree_pool);
git_tree_free(tree);
return ret;
@@ -753,11 +757,6 @@ int git_treebuilder_new(
bld->repo = repo;
- if (git_strmap_new(&bld->map) < 0) {
- git__free(bld);
- return -1;
- }
-
if (source != NULL) {
git_tree_entry *entry_src;
@@ -796,13 +795,13 @@ int git_treebuilder_insert(
if ((error = check_entry(bld->repo, filename, id, filemode)) < 0)
return error;
- if ((entry = git_strmap_get(bld->map, filename)) != NULL) {
+ if (git_treebuilder_entrymap_get(&entry, &bld->map, filename) == 0) {
git_oid_cpy(&entry->oid, id);
} else {
entry = alloc_entry(filename, strlen(filename), id);
GIT_ERROR_CHECK_ALLOC(entry);
- if ((error = git_strmap_set(bld->map, entry->filename, entry)) < 0) {
+ if (git_treebuilder_entrymap_put(&bld->map, entry->filename, entry) < 0) {
git_tree_entry_free(entry);
git_error_set(GIT_ERROR_TREE, "failed to insert %s", filename);
return -1;
@@ -819,10 +818,15 @@ int git_treebuilder_insert(
static git_tree_entry *treebuilder_get(git_treebuilder *bld, const char *filename)
{
+ git_tree_entry *entry;
+
GIT_ASSERT_ARG_WITH_RETVAL(bld, NULL);
GIT_ASSERT_ARG_WITH_RETVAL(filename, NULL);
- return git_strmap_get(bld->map, filename);
+ if (git_treebuilder_entrymap_get(&entry, &bld->map, filename) != 0)
+ return NULL;
+
+ return entry;
}
const git_tree_entry *git_treebuilder_get(git_treebuilder *bld, const char *filename)
@@ -837,7 +841,7 @@ int git_treebuilder_remove(git_treebuilder *bld, const char *filename)
if (entry == NULL)
return tree_error("failed to remove entry: file isn't in the tree", filename);
- git_strmap_delete(bld->map, filename);
+ git_treebuilder_entrymap_remove(&bld->map, filename);
git_tree_entry_free(entry);
return 0;
@@ -858,16 +862,17 @@ int git_treebuilder_filter(
{
const char *filename;
git_tree_entry *entry;
+ git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
GIT_ASSERT_ARG(bld);
GIT_ASSERT_ARG(filter);
- git_strmap_foreach(bld->map, filename, entry, {
- if (filter(entry, payload)) {
- git_strmap_delete(bld->map, filename);
- git_tree_entry_free(entry);
- }
- });
+ while (git_treebuilder_entrymap_iterate(&iter, &filename, &entry, &bld->map) == 0) {
+ if (filter(entry, payload)) {
+ git_treebuilder_entrymap_remove(&bld->map, filename);
+ git_tree_entry_free(entry);
+ }
+ }
return 0;
}
@@ -875,11 +880,14 @@ int git_treebuilder_filter(
int git_treebuilder_clear(git_treebuilder *bld)
{
git_tree_entry *e;
+ git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
GIT_ASSERT_ARG(bld);
- git_strmap_foreach_value(bld->map, e, git_tree_entry_free(e));
- git_strmap_clear(bld->map);
+ while (git_treebuilder_entrymap_iterate(&iter, NULL, &e, &bld->map) == 0)
+ git_tree_entry_free(e);
+
+ git_treebuilder_entrymap_clear(&bld->map);
return 0;
}
@@ -891,7 +899,7 @@ void git_treebuilder_free(git_treebuilder *bld)
git_str_dispose(&bld->write_cache);
git_treebuilder_clear(bld);
- git_strmap_free(bld->map);
+ git_treebuilder_entrymap_dispose(&bld->map);
git__free(bld);
}
@@ -1312,7 +1320,7 @@ int git_tree_create_updated(git_oid *out, git_repository *repo, git_tree *baseli
git_str_dispose(&component);
git_array_clear(stack);
- git_vector_free(&entries);
+ git_vector_dispose(&entries);
return error;
}
diff --git a/src/libgit2/tree.h b/src/libgit2/tree.h
index 5088450ab9b..8deec60408e 100644
--- a/src/libgit2/tree.h
+++ b/src/libgit2/tree.h
@@ -13,7 +13,6 @@
#include "repository.h"
#include "odb.h"
#include "vector.h"
-#include "strmap.h"
#include "pool.h"
struct git_tree_entry {
@@ -29,9 +28,11 @@ struct git_tree {
git_array_t(git_tree_entry) entries;
};
+GIT_HASHMAP_STR_STRUCT(git_treebuilder_entrymap, git_tree_entry *);
+
struct git_treebuilder {
git_repository *repo;
- git_strmap *map;
+ git_treebuilder_entrymap map;
git_str write_cache;
};
diff --git a/src/libgit2/worktree.c b/src/libgit2/worktree.c
index 82e1d2d7e18..00ff9e7da6c 100644
--- a/src/libgit2/worktree.c
+++ b/src/libgit2/worktree.c
@@ -335,11 +335,21 @@ int git_worktree_add(git_worktree **out, git_repository *repo,
goto out;
}
- if (git_branch_is_checked_out(wtopts.ref)) {
- git_error_set(GIT_ERROR_WORKTREE, "reference is already checked out");
- err = -1;
+ if ((err = git_reference_dup(&ref, wtopts.ref)) < 0)
goto out;
- }
+ } else if (wtopts.checkout_existing && git_branch_lookup(&ref, repo, name, GIT_BRANCH_LOCAL) == 0) {
+ /* Do nothing */
+ } else if ((err = git_repository_head(&head, repo)) < 0 ||
+ (err = git_commit_lookup(&commit, repo, &head->target.oid)) < 0 ||
+ (err = git_branch_create(&ref, repo, name, commit, false)) < 0) {
+ goto out;
+ }
+
+ if (git_branch_is_checked_out(ref)) {
+ git_error_set(GIT_ERROR_WORKTREE, "reference %s is already checked out",
+ git_reference_name(ref));
+ err = -1;
+ goto out;
}
/* Create gitdir directory ".git/worktrees/" */
@@ -392,19 +402,6 @@ int git_worktree_add(git_worktree **out, git_repository *repo,
|| (err = write_wtfile(gitdir.ptr, "gitdir", &buf)) < 0)
goto out;
- /* Set up worktree reference */
- if (wtopts.ref) {
- if ((err = git_reference_dup(&ref, wtopts.ref)) < 0)
- goto out;
- } else {
- if ((err = git_repository_head(&head, repo)) < 0)
- goto out;
- if ((err = git_commit_lookup(&commit, repo, &head->target.oid)) < 0)
- goto out;
- if ((err = git_branch_create(&ref, repo, name, commit, false)) < 0)
- goto out;
- }
-
/* Set worktree's HEAD */
if ((err = git_repository_create_head(gitdir.ptr, git_reference_name(ref))) < 0)
goto out;
@@ -565,6 +562,8 @@ int git_worktree_is_prunable(git_worktree *wt,
git_worktree_prune_options *opts)
{
git_worktree_prune_options popts = GIT_WORKTREE_PRUNE_OPTIONS_INIT;
+ git_str path = GIT_STR_INIT;
+ int ret = 0;
GIT_ERROR_CHECK_VERSION(
opts, GIT_WORKTREE_PRUNE_OPTIONS_VERSION,
@@ -575,27 +574,40 @@ int git_worktree_is_prunable(git_worktree *wt,
if ((popts.flags & GIT_WORKTREE_PRUNE_LOCKED) == 0) {
git_str reason = GIT_STR_INIT;
- int error;
- if ((error = git_worktree__is_locked(&reason, wt)) < 0)
- return error;
+ if ((ret = git_worktree__is_locked(&reason, wt)) < 0)
+ goto out;
+
+ if (ret) {
+ git_error_set(GIT_ERROR_WORKTREE,
+ "not pruning locked working tree: '%s'",
+ reason.size ? reason.ptr : "is locked");
- if (error) {
- if (!reason.size)
- git_str_attach_notowned(&reason, "no reason given", 15);
- git_error_set(GIT_ERROR_WORKTREE, "not pruning locked working tree: '%s'", reason.ptr);
git_str_dispose(&reason);
- return 0;
+ ret = 0;
+ goto out;
}
}
if ((popts.flags & GIT_WORKTREE_PRUNE_VALID) == 0 &&
git_worktree_validate(wt) == 0) {
git_error_set(GIT_ERROR_WORKTREE, "not pruning valid working tree");
- return 0;
+ goto out;
+ }
+
+ if ((ret = git_str_printf(&path, "%s/worktrees/%s", wt->commondir_path, wt->name) < 0))
+ goto out;
+
+ if (!git_fs_path_exists(path.ptr)) {
+ git_error_set(GIT_ERROR_WORKTREE, "worktree gitdir ('%s') does not exist", path.ptr);
+ goto out;
}
- return 1;
+ ret = 1;
+
+out:
+ git_str_dispose(&path);
+ return ret;
}
int git_worktree_prune(git_worktree *wt,
diff --git a/src/util/CMakeLists.txt b/src/util/CMakeLists.txt
index 2207041ef1a..0811057f3a3 100644
--- a/src/util/CMakeLists.txt
+++ b/src/util/CMakeLists.txt
@@ -1,15 +1,12 @@
# util: a shared library for common utility functions for libgit2 projects
add_library(util OBJECT)
-set_target_properties(util PROPERTIES C_STANDARD 90)
-set_target_properties(util PROPERTIES C_EXTENSIONS OFF)
configure_file(git2_features.h.in git2_features.h)
set(UTIL_INCLUDES
"${PROJECT_BINARY_DIR}/src/util"
"${PROJECT_BINARY_DIR}/include"
- "${PROJECT_BINARY_DIR}/include/git2"
"${PROJECT_SOURCE_DIR}/src/util"
"${PROJECT_SOURCE_DIR}/include")
@@ -32,19 +29,21 @@ endif()
# Hash backend selection
#
-if(USE_SHA1 STREQUAL "CollisionDetection")
+if(USE_SHA1 STREQUAL "builtin")
file(GLOB UTIL_SRC_SHA1 hash/collisiondetect.* hash/sha1dc/*)
target_compile_definitions(util PRIVATE SHA1DC_NO_STANDARD_INCLUDES=1)
target_compile_definitions(util PRIVATE SHA1DC_CUSTOM_INCLUDE_SHA1_C=\"git2_util.h\")
target_compile_definitions(util PRIVATE SHA1DC_CUSTOM_INCLUDE_UBC_CHECK_C=\"git2_util.h\")
-elseif(USE_SHA1 STREQUAL "OpenSSL" OR USE_SHA1 STREQUAL "OpenSSL-Dynamic")
+elseif(USE_SHA1 STREQUAL "openssl" OR
+ USE_SHA1 STREQUAL "openssl-dynamic" OR
+ USE_SHA1 STREQUAL "openssl-fips")
add_definitions(-DOPENSSL_API_COMPAT=0x10100000L)
file(GLOB UTIL_SRC_SHA1 hash/openssl.*)
-elseif(USE_SHA1 STREQUAL "CommonCrypto")
+elseif(USE_SHA1 STREQUAL "commoncrypto")
file(GLOB UTIL_SRC_SHA1 hash/common_crypto.*)
-elseif(USE_SHA1 STREQUAL "mbedTLS")
+elseif(USE_SHA1 STREQUAL "mbedtls")
file(GLOB UTIL_SRC_SHA1 hash/mbedtls.*)
-elseif(USE_SHA1 STREQUAL "Win32")
+elseif(USE_SHA1 STREQUAL "win32")
file(GLOB UTIL_SRC_SHA1 hash/win32.*)
else()
message(FATAL_ERROR "Asked for unknown SHA1 backend: ${USE_SHA1}")
@@ -52,19 +51,21 @@ endif()
list(SORT UTIL_SRC_SHA1)
-if(USE_SHA256 STREQUAL "Builtin")
+if(USE_SHA256 STREQUAL "builtin")
file(GLOB UTIL_SRC_SHA256 hash/builtin.* hash/rfc6234/*)
-elseif(USE_SHA256 STREQUAL "OpenSSL" OR USE_SHA256 STREQUAL "OpenSSL-Dynamic")
+elseif(USE_SHA256 STREQUAL "openssl" OR
+ USE_SHA256 STREQUAL "openssl-dynamic" OR
+ USE_SHA256 STREQUAL "openssl-fips")
add_definitions(-DOPENSSL_API_COMPAT=0x10100000L)
file(GLOB UTIL_SRC_SHA256 hash/openssl.*)
-elseif(USE_SHA256 STREQUAL "CommonCrypto")
+elseif(USE_SHA256 STREQUAL "commoncrypto")
file(GLOB UTIL_SRC_SHA256 hash/common_crypto.*)
-elseif(USE_SHA256 STREQUAL "mbedTLS")
+elseif(USE_SHA256 STREQUAL "mbedtls")
file(GLOB UTIL_SRC_SHA256 hash/mbedtls.*)
-elseif(USE_SHA256 STREQUAL "Win32")
+elseif(USE_SHA256 STREQUAL "win32")
file(GLOB UTIL_SRC_SHA256 hash/win32.*)
else()
- message(FATAL_ERROR "Asked for unknown SHA256 backend: ${USE_SHA256}")
+ message(FATAL_ERROR "asked for unknown SHA256 backend: ${USE_SHA256}")
endif()
list(SORT UTIL_SRC_SHA256)
diff --git a/src/util/alloc.c b/src/util/alloc.c
index 2820d84a219..1059cb65744 100644
--- a/src/util/alloc.c
+++ b/src/util/alloc.c
@@ -8,27 +8,89 @@
#include "alloc.h"
#include "runtime.h"
-#include "allocators/failalloc.h"
#include "allocators/stdalloc.h"
+#include "allocators/debugalloc.h"
+#include "allocators/failalloc.h"
#include "allocators/win32_leakcheck.h"
/* Fail any allocation until git_libgit2_init is called. */
git_allocator git__allocator = {
git_failalloc_malloc,
- git_failalloc_calloc,
- git_failalloc_strdup,
- git_failalloc_strndup,
- git_failalloc_substrdup,
git_failalloc_realloc,
- git_failalloc_reallocarray,
- git_failalloc_mallocarray,
git_failalloc_free
};
+void *git__calloc(size_t nelem, size_t elsize)
+{
+ size_t newsize;
+ void *ptr;
+
+ if (GIT_MULTIPLY_SIZET_OVERFLOW(&newsize, nelem, elsize))
+ return NULL;
+
+ if ((ptr = git__malloc(newsize)))
+ memset(ptr, 0, newsize);
+
+ return ptr;
+}
+
+void *git__reallocarray(void *ptr, size_t nelem, size_t elsize)
+{
+ size_t newsize;
+
+ if (GIT_MULTIPLY_SIZET_OVERFLOW(&newsize, nelem, elsize))
+ return NULL;
+
+ return git__realloc(ptr, newsize);
+}
+
+void *git__mallocarray(size_t nelem, size_t elsize)
+{
+ return git__reallocarray(NULL, nelem, elsize);
+}
+
+char *git__strdup(const char *str)
+{
+ size_t len = strlen(str) + 1;
+ void *ptr = git__malloc(len);
+
+ if (ptr)
+ memcpy(ptr, str, len);
+
+ return ptr;
+}
+
+char *git__strndup(const char *str, size_t n)
+{
+ size_t len = p_strnlen(str, n);
+ char *ptr = git__malloc(len + 1);
+
+ if (ptr) {
+ memcpy(ptr, str, len);
+ ptr[len] = '\0';
+ }
+
+ return ptr;
+}
+
+char *git__substrdup(const char *str, size_t n)
+{
+ char *ptr = git__malloc(n + 1);
+
+ if (ptr) {
+ memcpy(ptr, str, n);
+ ptr[n] = '\0';
+ }
+
+ return ptr;
+}
+
static int setup_default_allocator(void)
{
-#if defined(GIT_WIN32_LEAKCHECK)
+#if defined(GIT_DEBUG_LEAKCHECK_WIN32)
return git_win32_leakcheck_init_allocator(&git__allocator);
+#elif defined(GIT_DEBUG_STRICT_ALLOC)
+ return git_debugalloc_init_allocator(&git__allocator);
#else
return git_stdalloc_init_allocator(&git__allocator);
#endif
diff --git a/src/util/alloc.h b/src/util/alloc.h
index 04fb7e10175..32b614b25cc 100644
--- a/src/util/alloc.h
+++ b/src/util/alloc.h
@@ -10,17 +10,42 @@
#include "git2/sys/alloc.h"
+#include "git2_util.h"
+
extern git_allocator git__allocator;
-#define git__malloc(len) git__allocator.gmalloc(len, __FILE__, __LINE__)
-#define git__calloc(nelem, elsize) git__allocator.gcalloc(nelem, elsize, __FILE__, __LINE__)
-#define git__strdup(str) git__allocator.gstrdup(str, __FILE__, __LINE__)
-#define git__strndup(str, n) git__allocator.gstrndup(str, n, __FILE__, __LINE__)
-#define git__substrdup(str, n) git__allocator.gsubstrdup(str, n, __FILE__, __LINE__)
-#define git__realloc(ptr, size) git__allocator.grealloc(ptr, size, __FILE__, __LINE__)
-#define git__reallocarray(ptr, nelem, elsize) git__allocator.greallocarray(ptr, nelem, elsize, __FILE__, __LINE__)
-#define git__mallocarray(nelem, elsize) git__allocator.gmallocarray(nelem, elsize, __FILE__, __LINE__)
-#define git__free git__allocator.gfree
+GIT_INLINE(void *) git__malloc(size_t len)
+{
+ void *p = git__allocator.gmalloc(len, __FILE__, __LINE__);
+
+ if (!p)
+ git_error_set_oom();
+
+ return p;
+}
+
+GIT_INLINE(void *) git__realloc(void *ptr, size_t size)
+{
+ void *p = git__allocator.grealloc(ptr, size, __FILE__, __LINE__);
+
+ if (!p)
+ git_error_set_oom();
+
+ return p;
+}
+
+GIT_INLINE(void) git__free(void *ptr)
+{
+ git__allocator.gfree(ptr);
+}
+
+extern void *git__calloc(size_t nelem, size_t elsize);
+extern void *git__mallocarray(size_t nelem, size_t elsize);
+extern void *git__reallocarray(void *ptr, size_t nelem, size_t elsize);
+
+extern char *git__strdup(const char *str);
+extern char *git__strndup(const char *str, size_t n);
+extern char *git__substrdup(const char *str, size_t n);
/**
* This function is being called by our global setup routines to
diff --git a/src/util/allocators/debugalloc.c b/src/util/allocators/debugalloc.c
new file mode 100644
index 00000000000..44022cd785a
--- /dev/null
+++ b/src/util/allocators/debugalloc.c
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include "debugalloc.h"
+
+static void *debugalloc__malloc(size_t len, const char *file, int line)
+{
+ unsigned char *ptr;
+ size_t total = len + sizeof(size_t);
+
+ GIT_UNUSED(file);
+ GIT_UNUSED(line);
+
+ if (!len || (ptr = malloc(total)) == NULL)
+ return NULL;
+
+ memcpy(ptr, &len, sizeof(size_t));
+ return ptr + sizeof(size_t);
+}
+
+static void *debugalloc__realloc(void *_ptr, size_t len, const char *file, int line)
+{
+ unsigned char *ptr = _ptr, *newptr;
+ size_t original_len;
+ size_t total = len + sizeof(size_t);
+
+ GIT_UNUSED(file);
+ GIT_UNUSED(line);
+
+ if (!len && !ptr)
+ return NULL;
+
+ if (!len) {
+ free(ptr - sizeof(size_t));
+ return NULL;
+ }
+
+ if ((newptr = malloc(total)) == NULL)
+ return NULL;
+
+ if (ptr) {
+ memcpy(&original_len, ptr - sizeof(size_t), sizeof(size_t));
+ memcpy(newptr + sizeof(size_t), ptr, min(len, original_len));
+
+ memset(ptr - sizeof(size_t), 0xfd, original_len + sizeof(size_t));
+ free(ptr - sizeof(size_t));
+ }
+
+ memcpy(newptr, &len, sizeof(size_t));
+ return newptr + sizeof(size_t);
+}
+
+static void debugalloc__free(void *_ptr)
+{
+ unsigned char *ptr = _ptr;
+
+ if (!ptr)
+ return;
+
+ free(ptr - sizeof(size_t));
+}
+
+int git_debugalloc_init_allocator(git_allocator *allocator)
+{
+ allocator->gmalloc = debugalloc__malloc;
+ allocator->grealloc = debugalloc__realloc;
+ allocator->gfree = debugalloc__free;
+ return 0;
+}
diff --git a/src/cli/cli.h b/src/util/allocators/debugalloc.h
similarity index 57%
rename from src/cli/cli.h
rename to src/util/allocators/debugalloc.h
index 7dede678519..dea0ca31cc1 100644
--- a/src/cli/cli.h
+++ b/src/util/allocators/debugalloc.h
@@ -5,16 +5,13 @@
* a Linking Exception. For full terms see the included COPYING file.
*/
-#ifndef CLI_cli_h__
-#define CLI_cli_h__
-
-#define PROGRAM_NAME "git2"
+#ifndef INCLUDE_allocators_debugalloc_h__
+#define INCLUDE_allocators_debugalloc_h__
#include "git2_util.h"
-#include "error.h"
-#include "opt.h"
-#include "opt_usage.h"
-#include "sighandler.h"
+#include "alloc.h"
+
+int git_debugalloc_init_allocator(git_allocator *allocator);
-#endif /* CLI_cli_h__ */
+#endif
diff --git a/src/util/allocators/failalloc.c b/src/util/allocators/failalloc.c
index 5257d1dece0..c1025e32fef 100644
--- a/src/util/allocators/failalloc.c
+++ b/src/util/allocators/failalloc.c
@@ -16,45 +16,6 @@ void *git_failalloc_malloc(size_t len, const char *file, int line)
return NULL;
}
-void *git_failalloc_calloc(size_t nelem, size_t elsize, const char *file, int line)
-{
- GIT_UNUSED(nelem);
- GIT_UNUSED(elsize);
- GIT_UNUSED(file);
- GIT_UNUSED(line);
-
- return NULL;
-}
-
-char *git_failalloc_strdup(const char *str, const char *file, int line)
-{
- GIT_UNUSED(str);
- GIT_UNUSED(file);
- GIT_UNUSED(line);
-
- return NULL;
-}
-
-char *git_failalloc_strndup(const char *str, size_t n, const char *file, int line)
-{
- GIT_UNUSED(str);
- GIT_UNUSED(n);
- GIT_UNUSED(file);
- GIT_UNUSED(line);
-
- return NULL;
-}
-
-char *git_failalloc_substrdup(const char *start, size_t n, const char *file, int line)
-{
- GIT_UNUSED(start);
- GIT_UNUSED(n);
- GIT_UNUSED(file);
- GIT_UNUSED(line);
-
- return NULL;
-}
-
void *git_failalloc_realloc(void *ptr, size_t size, const char *file, int line)
{
GIT_UNUSED(ptr);
@@ -65,27 +26,6 @@ void *git_failalloc_realloc(void *ptr, size_t size, const char *file, int line)
return NULL;
}
-void *git_failalloc_reallocarray(void *ptr, size_t nelem, size_t elsize, const char *file, int line)
-{
- GIT_UNUSED(ptr);
- GIT_UNUSED(nelem);
- GIT_UNUSED(elsize);
- GIT_UNUSED(file);
- GIT_UNUSED(line);
-
- return NULL;
-}
-
-void *git_failalloc_mallocarray(size_t nelem, size_t elsize, const char *file, int line)
-{
- GIT_UNUSED(nelem);
- GIT_UNUSED(elsize);
- GIT_UNUSED(file);
- GIT_UNUSED(line);
-
- return NULL;
-}
-
void git_failalloc_free(void *ptr)
{
GIT_UNUSED(ptr);
diff --git a/src/util/allocators/failalloc.h b/src/util/allocators/failalloc.h
index 91264a0bb91..a3788e634ee 100644
--- a/src/util/allocators/failalloc.h
+++ b/src/util/allocators/failalloc.h
@@ -11,13 +11,7 @@
#include "git2_util.h"
extern void *git_failalloc_malloc(size_t len, const char *file, int line);
-extern void *git_failalloc_calloc(size_t nelem, size_t elsize, const char *file, int line);
-extern char *git_failalloc_strdup(const char *str, const char *file, int line);
-extern char *git_failalloc_strndup(const char *str, size_t n, const char *file, int line);
-extern char *git_failalloc_substrdup(const char *start, size_t n, const char *file, int line);
extern void *git_failalloc_realloc(void *ptr, size_t size, const char *file, int line);
-extern void *git_failalloc_reallocarray(void *ptr, size_t nelem, size_t elsize, const char *file, int line);
-extern void *git_failalloc_mallocarray(size_t nelem, size_t elsize, const char *file, int line);
extern void git_failalloc_free(void *ptr);
#endif
diff --git a/src/util/allocators/stdalloc.c b/src/util/allocators/stdalloc.c
index 2b36d9f3df3..65ec40fbe9d 100644
--- a/src/util/allocators/stdalloc.c
+++ b/src/util/allocators/stdalloc.c
@@ -9,125 +9,18 @@
static void *stdalloc__malloc(size_t len, const char *file, int line)
{
- void *ptr;
-
- GIT_UNUSED(file);
- GIT_UNUSED(line);
-
-#ifdef GIT_DEBUG_STRICT_ALLOC
- if (!len)
- return NULL;
-#endif
-
- ptr = malloc(len);
-
- if (!ptr)
- git_error_set_oom();
-
- return ptr;
-}
-
-static void *stdalloc__calloc(size_t nelem, size_t elsize, const char *file, int line)
-{
- void *ptr;
-
- GIT_UNUSED(file);
- GIT_UNUSED(line);
-
-#ifdef GIT_DEBUG_STRICT_ALLOC
- if (!elsize || !nelem)
- return NULL;
-#endif
-
- ptr = calloc(nelem, elsize);
-
- if (!ptr)
- git_error_set_oom();
-
- return ptr;
-}
-
-static char *stdalloc__strdup(const char *str, const char *file, int line)
-{
- char *ptr;
-
GIT_UNUSED(file);
GIT_UNUSED(line);
- ptr = strdup(str);
-
- if (!ptr)
- git_error_set_oom();
-
- return ptr;
-}
-
-static char *stdalloc__strndup(const char *str, size_t n, const char *file, int line)
-{
- size_t length = 0, alloclength;
- char *ptr;
-
- length = p_strnlen(str, n);
-
- if (GIT_ADD_SIZET_OVERFLOW(&alloclength, length, 1) ||
- !(ptr = stdalloc__malloc(alloclength, file, line)))
- return NULL;
-
- if (length)
- memcpy(ptr, str, length);
-
- ptr[length] = '\0';
-
- return ptr;
-}
-
-static char *stdalloc__substrdup(const char *start, size_t n, const char *file, int line)
-{
- char *ptr;
- size_t alloclen;
-
- if (GIT_ADD_SIZET_OVERFLOW(&alloclen, n, 1) ||
- !(ptr = stdalloc__malloc(alloclen, file, line)))
- return NULL;
-
- memcpy(ptr, start, n);
- ptr[n] = '\0';
- return ptr;
+ return malloc(len);
}
static void *stdalloc__realloc(void *ptr, size_t size, const char *file, int line)
{
- void *new_ptr;
-
GIT_UNUSED(file);
GIT_UNUSED(line);
-#ifdef GIT_DEBUG_STRICT_ALLOC
- if (!size)
- return NULL;
-#endif
-
- new_ptr = realloc(ptr, size);
-
- if (!new_ptr)
- git_error_set_oom();
-
- return new_ptr;
-}
-
-static void *stdalloc__reallocarray(void *ptr, size_t nelem, size_t elsize, const char *file, int line)
-{
- size_t newsize;
-
- if (GIT_MULTIPLY_SIZET_OVERFLOW(&newsize, nelem, elsize))
- return NULL;
-
- return stdalloc__realloc(ptr, newsize, file, line);
-}
-
-static void *stdalloc__mallocarray(size_t nelem, size_t elsize, const char *file, int line)
-{
- return stdalloc__reallocarray(NULL, nelem, elsize, file, line);
+ return realloc(ptr, size);
}
static void stdalloc__free(void *ptr)
@@ -138,13 +31,7 @@ static void stdalloc__free(void *ptr)
int git_stdalloc_init_allocator(git_allocator *allocator)
{
allocator->gmalloc = stdalloc__malloc;
- allocator->gcalloc = stdalloc__calloc;
- allocator->gstrdup = stdalloc__strdup;
- allocator->gstrndup = stdalloc__strndup;
- allocator->gsubstrdup = stdalloc__substrdup;
allocator->grealloc = stdalloc__realloc;
- allocator->greallocarray = stdalloc__reallocarray;
- allocator->gmallocarray = stdalloc__mallocarray;
allocator->gfree = stdalloc__free;
return 0;
}
diff --git a/src/util/allocators/win32_leakcheck.c b/src/util/allocators/win32_leakcheck.c
index fe06a14af73..f17f432718f 100644
--- a/src/util/allocators/win32_leakcheck.c
+++ b/src/util/allocators/win32_leakcheck.c
@@ -7,7 +7,7 @@
#include "win32_leakcheck.h"
-#if defined(GIT_WIN32_LEAKCHECK)
+#if defined(GIT_DEBUG_LEAKCHECK_WIN32)
#include "win32/w32_leakcheck.h"
@@ -18,53 +18,6 @@ static void *leakcheck_malloc(size_t len, const char *file, int line)
return ptr;
}
-static void *leakcheck_calloc(size_t nelem, size_t elsize, const char *file, int line)
-{
- void *ptr = _calloc_dbg(nelem, elsize, _NORMAL_BLOCK, git_win32_leakcheck_stacktrace(1,file), line);
- if (!ptr) git_error_set_oom();
- return ptr;
-}
-
-static char *leakcheck_strdup(const char *str, const char *file, int line)
-{
- char *ptr = _strdup_dbg(str, _NORMAL_BLOCK, git_win32_leakcheck_stacktrace(1,file), line);
- if (!ptr) git_error_set_oom();
- return ptr;
-}
-
-static char *leakcheck_strndup(const char *str, size_t n, const char *file, int line)
-{
- size_t length = 0, alloclength;
- char *ptr;
-
- length = p_strnlen(str, n);
-
- if (GIT_ADD_SIZET_OVERFLOW(&alloclength, length, 1) ||
- !(ptr = leakcheck_malloc(alloclength, file, line)))
- return NULL;
-
- if (length)
- memcpy(ptr, str, length);
-
- ptr[length] = '\0';
-
- return ptr;
-}
-
-static char *leakcheck_substrdup(const char *start, size_t n, const char *file, int line)
-{
- char *ptr;
- size_t alloclen;
-
- if (GIT_ADD_SIZET_OVERFLOW(&alloclen, n, 1) ||
- !(ptr = leakcheck_malloc(alloclen, file, line)))
- return NULL;
-
- memcpy(ptr, start, n);
- ptr[n] = '\0';
- return ptr;
-}
-
static void *leakcheck_realloc(void *ptr, size_t size, const char *file, int line)
{
void *new_ptr = _realloc_dbg(ptr, size, _NORMAL_BLOCK, git_win32_leakcheck_stacktrace(1,file), line);
@@ -72,21 +25,6 @@ static void *leakcheck_realloc(void *ptr, size_t size, const char *file, int lin
return new_ptr;
}
-static void *leakcheck_reallocarray(void *ptr, size_t nelem, size_t elsize, const char *file, int line)
-{
- size_t newsize;
-
- if (GIT_MULTIPLY_SIZET_OVERFLOW(&newsize, nelem, elsize))
- return NULL;
-
- return leakcheck_realloc(ptr, newsize, file, line);
-}
-
-static void *leakcheck_mallocarray(size_t nelem, size_t elsize, const char *file, int line)
-{
- return leakcheck_reallocarray(NULL, nelem, elsize, file, line);
-}
-
static void leakcheck_free(void *ptr)
{
free(ptr);
@@ -95,13 +33,7 @@ static void leakcheck_free(void *ptr)
int git_win32_leakcheck_init_allocator(git_allocator *allocator)
{
allocator->gmalloc = leakcheck_malloc;
- allocator->gcalloc = leakcheck_calloc;
- allocator->gstrdup = leakcheck_strdup;
- allocator->gstrndup = leakcheck_strndup;
- allocator->gsubstrdup = leakcheck_substrdup;
allocator->grealloc = leakcheck_realloc;
- allocator->greallocarray = leakcheck_reallocarray;
- allocator->gmallocarray = leakcheck_mallocarray;
allocator->gfree = leakcheck_free;
return 0;
}
diff --git a/src/util/array.h b/src/util/array.h
index cbab52ad1f3..515e6e3ab46 100644
--- a/src/util/array.h
+++ b/src/util/array.h
@@ -33,44 +33,48 @@
#define git_array_init_to_size(a, desired) \
do { (a).size = 0; (a).asize = desired; (a).ptr = git__calloc(desired, sizeof(*(a).ptr)); } while (0)
+#define git_array_dispose(a) \
+ do { git__free((a).ptr); } while (0)
+
#define git_array_clear(a) \
do { git__free((a).ptr); git_array_init(a); } while (0)
#define GIT_ERROR_CHECK_ARRAY(a) GIT_ERROR_CHECK_ALLOC((a).ptr)
-
-typedef git_array_t(char) git_array_generic_t;
-
-/* use a generic array for growth, return 0 on success */
-GIT_INLINE(int) git_array_grow(void *_a, size_t item_size)
+GIT_INLINE(void *) git_array__alloc(void *arr, size_t *size, size_t *asize, size_t item_size)
{
- volatile git_array_generic_t *a = _a;
size_t new_size;
- char *new_array;
+ void *new_array;
+
+ if (*size < *asize)
+ return arr;
- if (a->size < 8) {
+ if (*size < 8) {
new_size = 8;
} else {
- if (GIT_MULTIPLY_SIZET_OVERFLOW(&new_size, a->size, 3))
+ if (GIT_MULTIPLY_SIZET_OVERFLOW(&new_size, *asize, 3))
goto on_oom;
+
new_size /= 2;
}
- if ((new_array = git__reallocarray(a->ptr, new_size, item_size)) == NULL)
+ if ((new_array = git__reallocarray(arr, new_size, item_size)) == NULL)
goto on_oom;
- a->ptr = new_array;
- a->asize = new_size;
- return 0;
+ *asize = new_size;
+
+ return new_array;
on_oom:
- git_array_clear(*a);
- return -1;
+ git__free(arr);
+ *size = 0;
+ *asize = 0;
+ return NULL;
}
#define git_array_alloc(a) \
- (((a).size < (a).asize || git_array_grow(&(a), sizeof(*(a).ptr)) == 0) ? \
- &(a).ptr[(a).size++] : (void *)NULL)
+ (((a).size < (a).asize || \
+ ((a).ptr = git_array__alloc((a).ptr, &(a).size, &(a).asize, sizeof(*(a).ptr))) != NULL) ? &(a).ptr[(a).size++] : (void *)NULL)
#define git_array_last(a) ((a).size ? &(a).ptr[(a).size - 1] : (void *)NULL)
@@ -85,12 +89,14 @@ GIT_INLINE(int) git_array_grow(void *_a, size_t item_size)
#define git_array_foreach(a, i, element) \
for ((i) = 0; (i) < (a).size && ((element) = &(a).ptr[(i)]); (i)++)
+typedef int (*git_array_compare_cb)(const void *, const void *);
+
GIT_INLINE(int) git_array__search(
size_t *out,
void *array_ptr,
size_t item_size,
size_t array_len,
- int (*compare)(const void *, const void *),
+ git_array_compare_cb compare,
const void *key)
{
size_t lim;
diff --git a/src/util/cc-compat.h b/src/util/cc-compat.h
index a0971e86c98..ae81970eae8 100644
--- a/src/util/cc-compat.h
+++ b/src/util/cc-compat.h
@@ -43,8 +43,12 @@
__typeof__(x) _unused __attribute__((unused)); \
_unused = (x); \
} while (0)
+# define GIT_UNUSED_ARG __attribute__((unused))
+# define GIT_UNUSED_FUNCTION __attribute__((unused))
#else
# define GIT_UNUSED(x) ((void)(x))
+# define GIT_UNUSED_ARG
+# define GIT_UNUSED_FUNCTION
#endif
/* Define the printf format specifier to use for size_t output */
diff --git a/src/util/ctype_compat.h b/src/util/ctype_compat.h
new file mode 100644
index 00000000000..462c8a17f17
--- /dev/null
+++ b/src/util/ctype_compat.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_ctype_compat_h__
+#define INCLUDE_ctype_compat_h__
+
+/*
+ * The Microsoft C runtime (MSVCRT) may take a heavy lock on the
+ * locale in order to figure out how the `ctype` functions work.
+ * This is deeply slow. Provide our own to avoid that.
+ */
+
+#ifdef GIT_WIN32
+
+GIT_INLINE(int) git__tolower(int c)
+{
+ return (c >= 'A' && c <= 'Z') ? (c + 32) : c;
+}
+
+GIT_INLINE(int) git__toupper(int c)
+{
+ return (c >= 'a' && c <= 'z') ? (c - 32) : c;
+}
+
+GIT_INLINE(bool) git__isalpha(int c)
+{
+ return ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'));
+}
+
+GIT_INLINE(bool) git__isdigit(int c)
+{
+ return (c >= '0' && c <= '9');
+}
+
+GIT_INLINE(bool) git__isalnum(int c)
+{
+ return git__isalpha(c) || git__isdigit(c);
+}
+
+GIT_INLINE(bool) git__isspace(int c)
+{
+ return (c == ' ' || c == '\t' || c == '\n' || c == '\f' || c == '\r' || c == '\v');
+}
+
+GIT_INLINE(bool) git__isxdigit(int c)
+{
+ return ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'));
+}
+
+GIT_INLINE(bool) git__isprint(int c)
+{
+ return (c >= ' ' && c <= '~');
+}
+
+#else
+# define git__tolower(a) tolower((unsigned char)(a))
+# define git__toupper(a) toupper((unsigned char)(a))
+
+# define git__isalpha(a) (!!isalpha((unsigned char)(a)))
+# define git__isdigit(a) (!!isdigit((unsigned char)(a)))
+# define git__isalnum(a) (!!isalnum((unsigned char)(a)))
+# define git__isspace(a) (!!isspace((unsigned char)(a)))
+# define git__isxdigit(a) (!!isxdigit((unsigned char)(a)))
+# define git__isprint(a) (!!isprint((unsigned char)(a)))
+#endif
+
+#endif
diff --git a/src/util/date.c b/src/util/date.c
index 4d757e21a00..0ff5287aef7 100644
--- a/src/util/date.c
+++ b/src/util/date.c
@@ -129,9 +129,9 @@ static size_t match_string(const char *date, const char *str)
for (i = 0; *date; date++, str++, i++) {
if (*date == *str)
continue;
- if (toupper(*date) == toupper(*str))
+ if (git__toupper(*date) == git__toupper(*str))
continue;
- if (!isalnum(*date))
+ if (!git__isalnum(*date))
break;
return 0;
}
@@ -143,7 +143,7 @@ static int skip_alpha(const char *date)
int i = 0;
do {
i++;
- } while (isalpha(date[i]));
+ } while (git__isalpha(date[i]));
return i;
}
@@ -251,7 +251,7 @@ static size_t match_multi_number(unsigned long num, char c, const char *date, ch
num2 = strtol(end+1, &end, 10);
num3 = -1;
- if (*end == c && isdigit(end[1]))
+ if (*end == c && git__isdigit(end[1]))
num3 = strtol(end+1, &end, 10);
/* Time? Date? */
@@ -349,7 +349,7 @@ static size_t match_digit(const char *date, struct tm *tm, int *offset, int *tm_
case '.':
case '/':
case '-':
- if (isdigit(end[1])) {
+ if (git__isdigit(end[1])) {
size_t match = match_multi_number(num, *end, date, end, tm);
if (match)
return match;
@@ -364,7 +364,7 @@ static size_t match_digit(const char *date, struct tm *tm, int *offset, int *tm_
n = 0;
do {
n++;
- } while (isdigit(date[n]));
+ } while (git__isdigit(date[n]));
/* Four-digit year or a timezone? */
if (n == 4) {
@@ -514,11 +514,11 @@ static int parse_date_basic(const char *date, git_time_t *timestamp, int *offset
if (!c || c == '\n')
break;
- if (isalpha(c))
+ if (git__isalpha(c))
match = match_alpha(date, &tm, offset);
- else if (isdigit(c))
+ else if (git__isdigit(c))
match = match_digit(date, &tm, offset, &tm_gmt);
- else if ((c == '-' || c == '+') && isdigit(date[1]))
+ else if ((c == '-' || c == '+') && git__isdigit(date[1]))
match = match_tz(date, offset);
if (!match) {
@@ -682,7 +682,7 @@ static const char *approxidate_alpha(const char *date, struct tm *tm, struct tm
const char *end = date;
int i;
- while (isalpha(*++end))
+ while (git__isalpha(*++end))
/* scan to non-alpha */;
for (i = 0; i < 12; i++) {
@@ -783,7 +783,7 @@ static const char *approxidate_digit(const char *date, struct tm *tm, int *num)
case '.':
case '/':
case '-':
- if (isdigit(end[1])) {
+ if (git__isdigit(end[1])) {
size_t match = match_multi_number(number, *end, date, end, tm);
if (match)
return date + match;
@@ -843,13 +843,13 @@ static git_time_t approxidate_str(const char *date,
if (!c)
break;
date++;
- if (isdigit(c)) {
+ if (git__isdigit(c)) {
pending_number(&tm, &number);
date = approxidate_digit(date-1, &tm, &number);
touched = 1;
continue;
}
- if (isalpha(c))
+ if (git__isalpha(c))
date = approxidate_alpha(date-1, &tm, &now, &number, &touched);
}
pending_number(&tm, &number);
@@ -858,7 +858,7 @@ static git_time_t approxidate_str(const char *date,
return update_tm(&tm, &now, 0);
}
-int git_date_parse(git_time_t *out, const char *date)
+int git_date_offset_parse(git_time_t *out, int *out_offset, const char *date)
{
time_t time_sec;
git_time_t timestamp;
@@ -866,6 +866,7 @@ int git_date_parse(git_time_t *out, const char *date)
if (!parse_date_basic(date, ×tamp, &offset)) {
*out = timestamp;
+ *out_offset = offset;
return 0;
}
@@ -876,6 +877,13 @@ int git_date_parse(git_time_t *out, const char *date)
return error_ret;
}
+int git_date_parse(git_time_t *out, const char *date)
+{
+ int offset;
+
+ return git_date_offset_parse(out, &offset, date);
+}
+
int git_date_rfc2822_fmt(git_str *out, git_time_t time, int offset)
{
time_t t;
diff --git a/src/util/date.h b/src/util/date.h
index 7ebd3c30e41..785fc064bf5 100644
--- a/src/util/date.h
+++ b/src/util/date.h
@@ -10,9 +10,21 @@
#include "util.h"
#include "str.h"
+/*
+ * Parse a string into a value as a git_time_t with a timezone offset.
+ *
+ * Sample valid input:
+ * - "yesterday"
+ * - "July 17, 2003"
+ * - "2003-7-17 08:23i+03"
+ */
+extern int git_date_offset_parse(git_time_t *out, int *out_offset, const char *date);
+
/*
* Parse a string into a value as a git_time_t.
*
+ * Timezone offset is ignored.
+ *
* Sample valid input:
* - "yesterday"
* - "July 17, 2003"
diff --git a/src/util/errors.c b/src/util/errors.c
new file mode 100644
index 00000000000..feed6a835f5
--- /dev/null
+++ b/src/util/errors.c
@@ -0,0 +1,401 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include "git2_util.h"
+
+#include "errors.h"
+#include "posix.h"
+#include "str.h"
+#include "runtime.h"
+
+/*
+ * Some static error data that is used when we're out of memory, TLS
+ * has not been setup, or TLS has failed.
+ */
+
+static git_error oom_error = {
+ "Out of memory",
+ GIT_ERROR_NOMEMORY
+};
+
+static git_error uninitialized_error = {
+ "library has not been initialized",
+ GIT_ERROR_INVALID
+};
+
+static git_error tlsdata_error = {
+ "thread-local data initialization failure",
+ GIT_ERROR_THREAD
+};
+
+static git_error no_error = {
+ "no error",
+ GIT_ERROR_NONE
+};
+
+#define IS_STATIC_ERROR(err) \
+ ((err) == &oom_error || (err) == &uninitialized_error || \
+ (err) == &tlsdata_error || (err) == &no_error)
+
+/* Per-thread error state (TLS) */
+
+static git_tlsdata_key tls_key;
+
+struct error_threadstate {
+ /* The error message buffer. */
+ git_str message;
+
+ /* Error information, set by `git_error_set` and friends. */
+ git_error error;
+
+ /*
+ * The last error to occur; points to the error member of this
+ * struct _or_ a static error.
+ */
+ git_error *last;
+};
+
+static void threadstate_dispose(struct error_threadstate *threadstate)
+{
+ if (!threadstate)
+ return;
+
+ git_str_dispose(&threadstate->message);
+}
+
+static struct error_threadstate *threadstate_get(void)
+{
+ struct error_threadstate *threadstate;
+
+ if ((threadstate = git_tlsdata_get(tls_key)) != NULL)
+ return threadstate;
+
+ /*
+ * Avoid git__malloc here, since if it fails, it sets an error
+ * message, which requires thread state, which would allocate
+ * here, which would fail, which would set an error message...
+ */
+
+ if ((threadstate = git__allocator.gmalloc(
+ sizeof(struct error_threadstate),
+ __FILE__, __LINE__)) == NULL)
+ return NULL;
+
+ memset(threadstate, 0, sizeof(struct error_threadstate));
+
+ if (git_str_init(&threadstate->message, 0) < 0) {
+ git__allocator.gfree(threadstate);
+ return NULL;
+ }
+
+ git_tlsdata_set(tls_key, threadstate);
+ return threadstate;
+}
+
+static void GIT_SYSTEM_CALL threadstate_free(void *threadstate)
+{
+ threadstate_dispose(threadstate);
+ git__free(threadstate);
+}
+
+static void git_error_global_shutdown(void)
+{
+ struct error_threadstate *threadstate;
+
+ threadstate = git_tlsdata_get(tls_key);
+ git_tlsdata_set(tls_key, NULL);
+
+ threadstate_dispose(threadstate);
+ git__free(threadstate);
+
+ git_tlsdata_dispose(tls_key);
+}
+
+int git_error_global_init(void)
+{
+ if (git_tlsdata_init(&tls_key, &threadstate_free) != 0)
+ return -1;
+
+ return git_runtime_shutdown_register(git_error_global_shutdown);
+}
+
+static void set_error_from_buffer(int error_class)
+{
+ struct error_threadstate *threadstate = threadstate_get();
+ git_error *error;
+ git_str *buf;
+
+ if (!threadstate)
+ return;
+
+ error = &threadstate->error;
+ buf = &threadstate->message;
+
+ error->message = buf->ptr;
+ error->klass = error_class;
+
+ threadstate->last = error;
+}
+
+static void set_error(int error_class, char *string)
+{
+ struct error_threadstate *threadstate = threadstate_get();
+ git_str *buf;
+
+ if (!threadstate)
+ return;
+
+ buf = &threadstate->message;
+
+ git_str_clear(buf);
+
+ if (string)
+ git_str_puts(buf, string);
+
+ if (!git_str_oom(buf))
+ set_error_from_buffer(error_class);
+}
+
+void git_error_set_oom(void)
+{
+ struct error_threadstate *threadstate = threadstate_get();
+
+ if (!threadstate)
+ return;
+
+ threadstate->last = &oom_error;
+}
+
+void git_error_set(int error_class, const char *fmt, ...)
+{
+ va_list ap;
+
+ va_start(ap, fmt);
+ git_error_vset(error_class, fmt, ap);
+ va_end(ap);
+}
+
+void git_error_vset(int error_class, const char *fmt, va_list ap)
+{
+#ifdef GIT_WIN32
+ DWORD win32_error_code = (error_class == GIT_ERROR_OS) ? GetLastError() : 0;
+#endif
+
+ struct error_threadstate *threadstate = threadstate_get();
+ int error_code = (error_class == GIT_ERROR_OS) ? errno : 0;
+ git_str *buf;
+
+ if (!threadstate)
+ return;
+
+ buf = &threadstate->message;
+
+ git_str_clear(buf);
+
+ if (fmt) {
+ git_str_vprintf(buf, fmt, ap);
+ if (error_class == GIT_ERROR_OS)
+ git_str_PUTS(buf, ": ");
+ }
+
+ if (error_class == GIT_ERROR_OS) {
+#ifdef GIT_WIN32
+ char *win32_error = git_win32_get_error_message(win32_error_code);
+ if (win32_error) {
+ git_str_puts(buf, win32_error);
+ git__free(win32_error);
+
+ SetLastError(0);
+ }
+ else
+#endif
+ if (error_code)
+ git_str_puts(buf, strerror(error_code));
+
+ if (error_code)
+ errno = 0;
+ }
+
+ if (!git_str_oom(buf))
+ set_error_from_buffer(error_class);
+}
+
+int git_error_set_str(int error_class, const char *string)
+{
+ struct error_threadstate *threadstate = threadstate_get();
+ git_str *buf;
+
+ GIT_ASSERT_ARG(string);
+
+ if (!threadstate)
+ return -1;
+
+ buf = &threadstate->message;
+
+ git_str_clear(buf);
+ git_str_puts(buf, string);
+
+ if (git_str_oom(buf))
+ return -1;
+
+ set_error_from_buffer(error_class);
+ return 0;
+}
+
+void git_error_clear(void)
+{
+ struct error_threadstate *threadstate = threadstate_get();
+
+ if (!threadstate)
+ return;
+
+ if (threadstate->last != NULL) {
+ set_error(0, NULL);
+ threadstate->last = NULL;
+ }
+
+ errno = 0;
+#ifdef GIT_WIN32
+ SetLastError(0);
+#endif
+}
+
+bool git_error_exists(void)
+{
+ struct error_threadstate *threadstate;
+
+ if ((threadstate = threadstate_get()) == NULL)
+ return true;
+
+ return threadstate->last != NULL;
+}
+
+const git_error *git_error_last(void)
+{
+ struct error_threadstate *threadstate;
+
+ /* If the library is not initialized, return a static error. */
+ if (!git_runtime_init_count())
+ return &uninitialized_error;
+
+ if ((threadstate = threadstate_get()) == NULL)
+ return &tlsdata_error;
+
+ if (!threadstate->last)
+ return &no_error;
+
+ return threadstate->last;
+}
+
+int git_error_save(git_error **out)
+{
+ struct error_threadstate *threadstate = threadstate_get();
+ git_error *error, *dup;
+
+ if (!threadstate) {
+ *out = &tlsdata_error;
+ return -1;
+ }
+
+ error = threadstate->last;
+
+ if (!error || error == &no_error) {
+ *out = &no_error;
+ return 0;
+ } else if (IS_STATIC_ERROR(error)) {
+ *out = error;
+ return 0;
+ }
+
+ if ((dup = git__malloc(sizeof(git_error))) == NULL) {
+ *out = &oom_error;
+ return -1;
+ }
+
+ dup->klass = error->klass;
+ dup->message = git__strdup(error->message);
+
+ if (!dup->message) {
+ *out = &oom_error;
+ return -1;
+ }
+
+ *out = dup;
+ return 0;
+}
+
+int git_error_restore(git_error *error)
+{
+ struct error_threadstate *threadstate = threadstate_get();
+
+ GIT_ASSERT_ARG(error);
+
+ if (IS_STATIC_ERROR(error) && threadstate)
+ threadstate->last = error;
+ else
+ set_error(error->klass, error->message);
+
+ git_error_free(error);
+ return 0;
+}
+
+void git_error_free(git_error *error)
+{
+ if (!error)
+ return;
+
+ if (IS_STATIC_ERROR(error))
+ return;
+
+ git__free(error->message);
+ git__free(error);
+}
+
+int git_error_system_last(void)
+{
+#ifdef GIT_WIN32
+ return GetLastError();
+#else
+ return errno;
+#endif
+}
+
+void git_error_system_set(int code)
+{
+#ifdef GIT_WIN32
+ SetLastError(code);
+#else
+ errno = code;
+#endif
+}
+
+/* Deprecated error values and functions */
+
+#ifndef GIT_DEPRECATE_HARD
+
+#include "git2/deprecated.h"
+
+const git_error *giterr_last(void)
+{
+ return git_error_last();
+}
+
+void giterr_clear(void)
+{
+ git_error_clear();
+}
+
+void giterr_set_str(int error_class, const char *string)
+{
+ git_error_set_str(error_class, string);
+}
+
+void giterr_set_oom(void)
+{
+ git_error_set_oom();
+}
+#endif
diff --git a/src/libgit2/errors.h b/src/util/errors.h
similarity index 67%
rename from src/libgit2/errors.h
rename to src/util/errors.h
index 772c7bad18b..8d5877550b1 100644
--- a/src/libgit2/errors.h
+++ b/src/util/errors.h
@@ -8,13 +8,22 @@
#ifndef INCLUDE_errors_h__
#define INCLUDE_errors_h__
-#include "common.h"
+#include "git2_util.h"
+#include "git2/sys/errors.h"
+
+/* Initialize the error thread-state. */
+int git_error_global_init(void);
/*
* `vprintf`-style formatting for the error message for this thread.
*/
void git_error_vset(int error_class, const char *fmt, va_list ap);
+/**
+ * Determines whether an error exists.
+ */
+bool git_error_exists(void);
+
/**
* Set error message for user callback if needed.
*
@@ -27,9 +36,8 @@ GIT_INLINE(int) git_error_set_after_callback_function(
int error_code, const char *action)
{
if (error_code) {
- const git_error *e = git_error_last();
- if (!e || !e->message)
- git_error_set(e ? e->klass : GIT_ERROR_CALLBACK,
+ if (!git_error_exists())
+ git_error_set(GIT_ERROR_CALLBACK,
"%s callback returned %d", action, error_code);
}
return error_code;
@@ -53,28 +61,24 @@ int git_error_system_last(void);
*/
void git_error_system_set(int code);
-/**
- * Structure to preserve libgit2 error state
- */
-typedef struct {
- int error_code;
- unsigned int oom : 1;
- git_error error_msg;
-} git_error_state;
-
/**
* Capture current error state to restore later, returning error code.
* If `error_code` is zero, this does not clear the current error state.
* You must either restore this error state, or free it.
+ *
+ * This function returns 0 on success, or -1 on failure. If the function
+ * fails, the `out` structure is set to the failure error message and
+ * the normal system error message is not updated.
*/
-extern int git_error_state_capture(git_error_state *state, int error_code);
+extern int git_error_save(git_error **out);
/**
- * Restore error state to a previous value, returning saved error code.
+ * Restore thread error state to the given value. The given value is
+ * freed and `git_error_free` need not be called on it.
*/
-extern int git_error_state_restore(git_error_state *state);
+extern int git_error_restore(git_error *error);
/** Free an error state. */
-extern void git_error_state_free(git_error_state *state);
+extern void git_error_free(git_error *error);
#endif
diff --git a/src/util/filebuf.c b/src/util/filebuf.c
index e014d43b25f..7afb76b88ec 100644
--- a/src/util/filebuf.c
+++ b/src/util/filebuf.c
@@ -302,11 +302,16 @@ int git_filebuf_open_withsize(git_filebuf *file, const char *path, int flags, mo
}
/* If we are hashing on-write, allocate a new hash context */
- if (flags & GIT_FILEBUF_HASH_CONTENTS) {
+ if (flags & GIT_FILEBUF_HASH_SHA1) {
file->compute_digest = 1;
if (git_hash_ctx_init(&file->digest, GIT_HASH_ALGORITHM_SHA1) < 0)
goto cleanup;
+ } else if (flags & GIT_FILEBUF_HASH_SHA256) {
+ file->compute_digest = 1;
+
+ if (git_hash_ctx_init(&file->digest, GIT_HASH_ALGORITHM_SHA256) < 0)
+ goto cleanup;
}
compression = flags >> GIT_FILEBUF_DEFLATE_SHIFT;
diff --git a/src/util/filebuf.h b/src/util/filebuf.h
index 4a61ae4e3bf..e23b9ed2adc 100644
--- a/src/util/filebuf.h
+++ b/src/util/filebuf.h
@@ -17,13 +17,14 @@
# define GIT_FILEBUF_THREADS
#endif
-#define GIT_FILEBUF_HASH_CONTENTS (1 << 0)
-#define GIT_FILEBUF_APPEND (1 << 2)
+#define GIT_FILEBUF_HASH_SHA1 (1 << 0)
+#define GIT_FILEBUF_HASH_SHA256 (1 << 1)
+#define GIT_FILEBUF_APPEND (1 << 2)
#define GIT_FILEBUF_CREATE_LEADING_DIRS (1 << 3)
-#define GIT_FILEBUF_TEMPORARY (1 << 4)
-#define GIT_FILEBUF_DO_NOT_BUFFER (1 << 5)
-#define GIT_FILEBUF_FSYNC (1 << 6)
-#define GIT_FILEBUF_DEFLATE_SHIFT (7)
+#define GIT_FILEBUF_TEMPORARY (1 << 4)
+#define GIT_FILEBUF_DO_NOT_BUFFER (1 << 5)
+#define GIT_FILEBUF_FSYNC (1 << 6)
+#define GIT_FILEBUF_DEFLATE_SHIFT (7)
#define GIT_FILELOCK_EXTENSION ".lock\0"
#define GIT_FILELOCK_EXTLENGTH 6
@@ -91,4 +92,16 @@ int git_filebuf_hash(unsigned char *out, git_filebuf *file);
int git_filebuf_flush(git_filebuf *file);
int git_filebuf_stats(time_t *mtime, size_t *size, git_filebuf *file);
+GIT_INLINE(int) git_filebuf_hash_flags(git_hash_algorithm_t algorithm)
+{
+ switch (algorithm) {
+ case GIT_HASH_ALGORITHM_SHA1:
+ return GIT_FILEBUF_HASH_SHA1;
+ case GIT_HASH_ALGORITHM_SHA256:
+ return GIT_FILEBUF_HASH_SHA256;
+ default:
+ return 0;
+ }
+}
+
#endif
diff --git a/src/util/fs_path.c b/src/util/fs_path.c
index b52867e779f..e24836becaa 100644
--- a/src/util/fs_path.c
+++ b/src/util/fs_path.c
@@ -419,6 +419,16 @@ int git_fs_path_to_dir(git_str *path)
return git_str_oom(path) ? -1 : 0;
}
+size_t git_fs_path_dirlen(const char *path)
+{
+ size_t len = strlen(path);
+
+ while (len > 1 && path[len - 1] == '/')
+ len--;
+
+ return len;
+}
+
void git_fs_path_string_to_dir(char *path, size_t size)
{
size_t end = strlen(path);
@@ -974,7 +984,7 @@ bool git_fs_path_has_non_ascii(const char *path, size_t pathlen)
return false;
}
-#ifdef GIT_USE_ICONV
+#ifdef GIT_I18N_ICONV
int git_fs_path_iconv_init_precompose(git_fs_path_iconv_t *ic)
{
@@ -1126,7 +1136,7 @@ int git_fs_path_direach(
DIR *dir;
struct dirent *de;
-#ifdef GIT_USE_ICONV
+#ifdef GIT_I18N_ICONV
git_fs_path_iconv_t ic = GIT_PATH_ICONV_INIT;
#endif
@@ -1145,7 +1155,7 @@ int git_fs_path_direach(
return -1;
}
-#ifdef GIT_USE_ICONV
+#ifdef GIT_I18N_ICONV
if ((flags & GIT_FS_PATH_DIR_PRECOMPOSE_UNICODE) != 0)
(void)git_fs_path_iconv_init_precompose(&ic);
#endif
@@ -1157,7 +1167,7 @@ int git_fs_path_direach(
if (git_fs_path_is_dot_or_dotdot(de_path))
continue;
-#ifdef GIT_USE_ICONV
+#ifdef GIT_I18N_ICONV
if ((error = git_fs_path_iconv(&ic, &de_path, &de_len)) < 0)
break;
#endif
@@ -1181,7 +1191,7 @@ int git_fs_path_direach(
closedir(dir);
-#ifdef GIT_USE_ICONV
+#ifdef GIT_I18N_ICONV
git_fs_path_iconv_clear(&ic);
#endif
@@ -1385,7 +1395,7 @@ int git_fs_path_diriter_init(
return -1;
}
-#ifdef GIT_USE_ICONV
+#ifdef GIT_I18N_ICONV
if ((flags & GIT_FS_PATH_DIR_PRECOMPOSE_UNICODE) != 0)
(void)git_fs_path_iconv_init_precompose(&diriter->ic);
#endif
@@ -1422,7 +1432,7 @@ int git_fs_path_diriter_next(git_fs_path_diriter *diriter)
filename = de->d_name;
filename_len = strlen(filename);
-#ifdef GIT_USE_ICONV
+#ifdef GIT_I18N_ICONV
if ((diriter->flags & GIT_FS_PATH_DIR_PRECOMPOSE_UNICODE) != 0 &&
(error = git_fs_path_iconv(&diriter->ic, &filename, &filename_len)) < 0)
return error;
@@ -1489,7 +1499,7 @@ void git_fs_path_diriter_free(git_fs_path_diriter *diriter)
diriter->dir = NULL;
}
-#ifdef GIT_USE_ICONV
+#ifdef GIT_I18N_ICONV
git_fs_path_iconv_clear(&diriter->ic);
#endif
@@ -1938,12 +1948,13 @@ static int sudo_uid_lookup(uid_t *out)
{
git_str uid_str = GIT_STR_INIT;
int64_t uid;
- int error;
+ int error = -1;
- if ((error = git__getenv(&uid_str, "SUDO_UID")) == 0 &&
- (error = git__strntol64(&uid, uid_str.ptr, uid_str.size, NULL, 10)) == 0 &&
- uid == (int64_t)((uid_t)uid)) {
+ if (git__getenv(&uid_str, "SUDO_UID") == 0 &&
+ git__strntol64(&uid, uid_str.ptr, uid_str.size, NULL, 10) == 0 &&
+ uid == (int64_t)((uid_t)uid)) {
*out = (uid_t)uid;
+ error = 0;
}
git_str_dispose(&uid_str);
@@ -2015,7 +2026,7 @@ int git_fs_path_find_executable(git_str *fullpath, const char *executable)
git_win32_path fullpath_w, executable_w;
int error;
- if (git__utf8_to_16(executable_w, GIT_WIN_PATH_MAX, executable) < 0)
+ if (git_utf8_to_16(executable_w, GIT_WIN_PATH_MAX, executable) < 0)
return -1;
error = git_win32_path_find_executable(fullpath_w, executable_w);
diff --git a/src/util/fs_path.h b/src/util/fs_path.h
index e5ca6737818..78b4c3dc0d9 100644
--- a/src/util/fs_path.h
+++ b/src/util/fs_path.h
@@ -86,6 +86,29 @@ extern int git_fs_path_to_dir(git_str *path);
*/
extern void git_fs_path_string_to_dir(char *path, size_t size);
+/**
+ * Provides the length of the given path string with no trailing
+ * slashes.
+ */
+size_t git_fs_path_dirlen(const char *path);
+
+/**
+ * Returns nonzero if the given path is a filesystem root; on Windows, this
+ * means a drive letter (eg `A:/`, `C:\`). On POSIX this is `/`.
+ */
+GIT_INLINE(int) git_fs_path_is_root(const char *name)
+{
+#ifdef GIT_WIN32
+ if (((name[0] >= 'A' && name[0] <= 'Z') || (name[0] >= 'a' && name[0] <= 'z')) &&
+ name[1] == ':' &&
+ (name[2] == '/' || name[2] == '\\') &&
+ name[3] == '\0')
+ return 1;
+#endif
+
+ return (name[0] == '/' && name[1] == '\0');
+}
+
/**
* Taken from git.git; returns nonzero if the given path is "." or "..".
*/
@@ -426,7 +449,7 @@ extern bool git_fs_path_has_non_ascii(const char *path, size_t pathlen);
#define GIT_PATH_NATIVE_ENCODING "UTF-8"
#endif
-#ifdef GIT_USE_ICONV
+#ifdef GIT_I18N_ICONV
#include
@@ -450,7 +473,7 @@ extern void git_fs_path_iconv_clear(git_fs_path_iconv_t *ic);
*/
extern int git_fs_path_iconv(git_fs_path_iconv_t *ic, const char **in, size_t *inlen);
-#endif /* GIT_USE_ICONV */
+#endif /* GIT_I18N_ICONV */
extern bool git_fs_path_does_decompose_unicode(const char *root);
@@ -488,7 +511,7 @@ struct git_fs_path_diriter
DIR *dir;
-#ifdef GIT_USE_ICONV
+#ifdef GIT_I18N_ICONV
git_fs_path_iconv_t ic;
#endif
};
diff --git a/src/util/futils.c b/src/util/futils.c
index 084f1cd2820..25c3a1be180 100644
--- a/src/util/futils.c
+++ b/src/util/futils.c
@@ -8,9 +8,9 @@
#include "futils.h"
#include "runtime.h"
-#include "strmap.h"
#include "hash.h"
#include "rand.h"
+#include "hashmap_str.h"
#include
@@ -221,14 +221,14 @@ int git_futils_readbuffer_fd_full(git_str *buf, git_file fd)
int git_futils_readbuffer_updated(
git_str *out,
const char *path,
- unsigned char checksum[GIT_HASH_SHA1_SIZE],
+ unsigned char checksum[GIT_HASH_SHA256_SIZE],
int *updated)
{
int error;
git_file fd;
struct stat st;
git_str buf = GIT_STR_INIT;
- unsigned char checksum_new[GIT_HASH_SHA1_SIZE];
+ unsigned char checksum_new[GIT_HASH_SHA256_SIZE];
GIT_ASSERT_ARG(out);
GIT_ASSERT_ARG(path && *path);
@@ -261,7 +261,10 @@ int git_futils_readbuffer_updated(
p_close(fd);
if (checksum) {
- if ((error = git_hash_buf(checksum_new, buf.ptr, buf.size, GIT_HASH_ALGORITHM_SHA1)) < 0) {
+ error = git_hash_buf(checksum_new, buf.ptr,
+ buf.size, GIT_HASH_ALGORITHM_SHA256);
+
+ if (error < 0) {
git_str_dispose(&buf);
return error;
}
@@ -269,7 +272,7 @@ int git_futils_readbuffer_updated(
/*
* If we were given a checksum, we only want to use it if it's different
*/
- if (!memcmp(checksum, checksum_new, GIT_HASH_SHA1_SIZE)) {
+ if (!memcmp(checksum, checksum_new, GIT_HASH_SHA256_SIZE)) {
git_str_dispose(&buf);
if (updated)
*updated = 0;
@@ -277,7 +280,7 @@ int git_futils_readbuffer_updated(
return 0;
}
- memcpy(checksum, checksum_new, GIT_HASH_SHA1_SIZE);
+ memcpy(checksum, checksum_new, GIT_HASH_SHA256_SIZE);
}
/*
@@ -650,7 +653,8 @@ int git_futils_mkdir_relative(
*tail = '\0';
st.st_mode = 0;
- if (opts->dir_map && git_strmap_exists(opts->dir_map, make_path.ptr))
+ if (opts->cache_pathset &&
+ git_hashset_str_contains(opts->cache_pathset, make_path.ptr))
continue;
/* See what's going on with this path component */
@@ -685,17 +689,17 @@ int git_futils_mkdir_relative(
make_path.ptr, &st, (lastch == '\0'), mode, flags, opts)) < 0)
goto done;
- if (opts->dir_map && opts->pool) {
+ if (opts->cache_pathset && opts->cache_pool) {
char *cache_path;
size_t alloc_size;
GIT_ERROR_CHECK_ALLOC_ADD(&alloc_size, make_path.size, 1);
- cache_path = git_pool_malloc(opts->pool, alloc_size);
+ cache_path = git_pool_malloc(opts->cache_pool, alloc_size);
GIT_ERROR_CHECK_ALLOC(cache_path);
memcpy(cache_path, make_path.ptr, make_path.size + 1);
- if ((error = git_strmap_set(opts->dir_map, cache_path, cache_path)) < 0)
+ if ((error = git_hashset_str_add(opts->cache_pathset, cache_path)) < 0)
goto done;
}
}
@@ -1154,7 +1158,7 @@ int git_futils_filestamp_check(
return GIT_ENOTFOUND;
if (stamp->mtime.tv_sec == st.st_mtime &&
-#if defined(GIT_USE_NSEC)
+#if defined(GIT_NSEC)
stamp->mtime.tv_nsec == st.st_mtime_nsec &&
#endif
stamp->size == (uint64_t)st.st_size &&
@@ -1162,7 +1166,7 @@ int git_futils_filestamp_check(
return 0;
stamp->mtime.tv_sec = st.st_mtime;
-#if defined(GIT_USE_NSEC)
+#if defined(GIT_NSEC)
stamp->mtime.tv_nsec = st.st_mtime_nsec;
#endif
stamp->size = (uint64_t)st.st_size;
@@ -1186,7 +1190,7 @@ void git_futils_filestamp_set_from_stat(
{
if (st) {
stamp->mtime.tv_sec = st->st_mtime;
-#if defined(GIT_USE_NSEC)
+#if defined(GIT_NSEC)
stamp->mtime.tv_nsec = st->st_mtime_nsec;
#else
stamp->mtime.tv_nsec = 0;
diff --git a/src/util/futils.h b/src/util/futils.h
index 3f207afb2f2..7ae869be6ec 100644
--- a/src/util/futils.h
+++ b/src/util/futils.h
@@ -13,8 +13,8 @@
#include "posix.h"
#include "fs_path.h"
#include "pool.h"
-#include "strmap.h"
#include "hash.h"
+#include "hashmap_str.h"
/**
* Filebuffer methods
@@ -25,7 +25,7 @@ extern int git_futils_readbuffer(git_str *obj, const char *path);
extern int git_futils_readbuffer_updated(
git_str *obj,
const char *path,
- unsigned char checksum[GIT_HASH_SHA1_SIZE],
+ unsigned char checksum[GIT_HASH_SHA256_SIZE],
int *updated);
extern int git_futils_readbuffer_fd_full(git_str *obj, git_file fd);
extern int git_futils_readbuffer_fd(git_str *obj, git_file fd, size_t len);
@@ -109,8 +109,17 @@ struct git_futils_mkdir_perfdata
struct git_futils_mkdir_options
{
- git_strmap *dir_map;
- git_pool *pool;
+ /*
+ * Callers can optionally pass an allocation pool and a
+ * hashset of strings; mkdir will populate these with the
+ * path(s) it creates; this can be useful for repeated calls
+ * to mkdir. This will reduce I/O by avoiding testing for the
+ * existence of intermediate directories that it knows already
+ * exist (because it created them).
+ */
+ git_pool *cache_pool;
+ git_hashset_str *cache_pathset;
+
struct git_futils_mkdir_perfdata perfdata;
};
diff --git a/src/util/git2_features.h.in b/src/util/git2_features.h.in
index fbf0cab60ea..a440561f8d4 100644
--- a/src/util/git2_features.h.in
+++ b/src/util/git2_features.h.in
@@ -1,62 +1,101 @@
#ifndef INCLUDE_features_h__
#define INCLUDE_features_h__
+/* Debugging options */
+
#cmakedefine GIT_DEBUG_POOL 1
#cmakedefine GIT_DEBUG_STRICT_ALLOC 1
#cmakedefine GIT_DEBUG_STRICT_OPEN 1
+#cmakedefine GIT_DEBUG_LEAKCHECK_WIN32 1
-#cmakedefine GIT_THREADS 1
-#cmakedefine GIT_WIN32_LEAKCHECK 1
-
-#cmakedefine GIT_ARCH_64 1
-#cmakedefine GIT_ARCH_32 1
-
-#cmakedefine GIT_USE_ICONV 1
-#cmakedefine GIT_USE_NSEC 1
-#cmakedefine GIT_USE_STAT_MTIM 1
-#cmakedefine GIT_USE_STAT_MTIMESPEC 1
-#cmakedefine GIT_USE_STAT_MTIME_NSEC 1
-#cmakedefine GIT_USE_FUTIMENS 1
-
-#cmakedefine GIT_REGEX_REGCOMP_L
-#cmakedefine GIT_REGEX_REGCOMP
-#cmakedefine GIT_REGEX_PCRE
-#cmakedefine GIT_REGEX_PCRE2
-#cmakedefine GIT_REGEX_BUILTIN 1
-
-#cmakedefine GIT_QSORT_R_BSD
-#cmakedefine GIT_QSORT_R_GNU
-#cmakedefine GIT_QSORT_S
-
-#cmakedefine GIT_SSH 1
-#cmakedefine GIT_SSH_MEMORY_CREDENTIALS 1
+/* Feature enablement and provider / backend selection */
-#cmakedefine GIT_NTLM 1
-#cmakedefine GIT_GSSAPI 1
-#cmakedefine GIT_GSSFRAMEWORK 1
-
-#cmakedefine GIT_WINHTTP 1
-#cmakedefine GIT_HTTPS 1
-#cmakedefine GIT_OPENSSL 1
-#cmakedefine GIT_OPENSSL_DYNAMIC 1
-#cmakedefine GIT_SECURE_TRANSPORT 1
-#cmakedefine GIT_MBEDTLS 1
+#cmakedefine GIT_THREADS 1
+#cmakedefine GIT_THREADS_PTHREADS 1
+#cmakedefine GIT_THREADS_WIN32 1
-#cmakedefine GIT_SHA1_COLLISIONDETECT 1
-#cmakedefine GIT_SHA1_WIN32 1
-#cmakedefine GIT_SHA1_COMMON_CRYPTO 1
+#cmakedefine GIT_SHA1_BUILTIN 1
#cmakedefine GIT_SHA1_OPENSSL 1
+#cmakedefine GIT_SHA1_OPENSSL_FIPS 1
#cmakedefine GIT_SHA1_OPENSSL_DYNAMIC 1
#cmakedefine GIT_SHA1_MBEDTLS 1
+#cmakedefine GIT_SHA1_COMMON_CRYPTO 1
+#cmakedefine GIT_SHA1_WIN32 1
#cmakedefine GIT_SHA256_BUILTIN 1
#cmakedefine GIT_SHA256_WIN32 1
#cmakedefine GIT_SHA256_COMMON_CRYPTO 1
#cmakedefine GIT_SHA256_OPENSSL 1
+#cmakedefine GIT_SHA256_OPENSSL_FIPS 1
#cmakedefine GIT_SHA256_OPENSSL_DYNAMIC 1
#cmakedefine GIT_SHA256_MBEDTLS 1
+#cmakedefine GIT_COMPRESSION_BUILTIN 1
+#cmakedefine GIT_COMPRESSION_ZLIB 1
+
+#cmakedefine GIT_NSEC 1
+#cmakedefine GIT_NSEC_MTIM 1
+#cmakedefine GIT_NSEC_MTIMESPEC 1
+#cmakedefine GIT_NSEC_MTIME_NSEC 1
+#cmakedefine GIT_NSEC_WIN32 1
+
+#cmakedefine GIT_I18N 1
+#cmakedefine GIT_I18N_ICONV 1
+
+#cmakedefine GIT_REGEX_REGCOMP_L 1
+#cmakedefine GIT_REGEX_REGCOMP 1
+#cmakedefine GIT_REGEX_PCRE 1
+#cmakedefine GIT_REGEX_PCRE2 1
+#cmakedefine GIT_REGEX_BUILTIN 1
+
+#cmakedefine GIT_SSH 1
+#cmakedefine GIT_SSH_EXEC 1
+#cmakedefine GIT_SSH_LIBSSH2 1
+#cmakedefine GIT_SSH_LIBSSH2_MEMORY_CREDENTIALS 1
+
+#cmakedefine GIT_HTTPS 1
+#cmakedefine GIT_HTTPS_OPENSSL 1
+#cmakedefine GIT_HTTPS_OPENSSL_DYNAMIC 1
+#cmakedefine GIT_HTTPS_SECURETRANSPORT 1
+#cmakedefine GIT_HTTPS_MBEDTLS 1
+#cmakedefine GIT_HTTPS_SCHANNEL 1
+#cmakedefine GIT_HTTPS_WINHTTP 1
+
+#cmakedefine GIT_HTTPPARSER_HTTPPARSER 1
+#cmakedefine GIT_HTTPPARSER_LLHTTP 1
+#cmakedefine GIT_HTTPPARSER_BUILTIN 1
+
+#cmakedefine GIT_AUTH_NTLM 1
+#cmakedefine GIT_AUTH_NTLM_BUILTIN 1
+#cmakedefine GIT_AUTH_NTLM_SSPI 1
+
+#cmakedefine GIT_AUTH_NEGOTIATE 1
+#cmakedefine GIT_AUTH_NEGOTIATE_GSSFRAMEWORK 1
+#cmakedefine GIT_AUTH_NEGOTIATE_GSSAPI 1
+#cmakedefine GIT_AUTH_NEGOTIATE_SSPI 1
+
+/* Platform details */
+
+#cmakedefine GIT_ARCH_64 1
+#cmakedefine GIT_ARCH_32 1
+
+#cmakedefine GIT_QSORT_BSD 1
+#cmakedefine GIT_QSORT_GNU 1
+#cmakedefine GIT_QSORT_C11 1
+#cmakedefine GIT_QSORT_MSC 1
+
+#cmakedefine GIT_FUTIMENS 1
+
#cmakedefine GIT_RAND_GETENTROPY 1
#cmakedefine GIT_RAND_GETLOADAVG 1
+#cmakedefine GIT_IO_POLL 1
+#cmakedefine GIT_IO_WSAPOLL 1
+#cmakedefine GIT_IO_SELECT 1
+
+/* Compile-time information */
+
+#cmakedefine GIT_BUILD_CPU "@GIT_BUILD_CPU@"
+#cmakedefine GIT_BUILD_COMMIT "@GIT_BUILD_COMMIT@"
+
#endif
diff --git a/src/util/git2_util.h b/src/util/git2_util.h
index c62dc24199d..d47ce5f43e9 100644
--- a/src/util/git2_util.h
+++ b/src/util/git2_util.h
@@ -12,6 +12,7 @@
#endif
#include "git2/common.h"
+#include "git2/sys/errors.h"
#include "cc-compat.h"
typedef struct git_str git_str;
@@ -48,6 +49,10 @@ typedef struct git_str git_str;
# define GIT_WARN_UNUSED_RESULT
#endif
+#if (defined(_WIN32)) && !defined(__CYGWIN__)
+# define GIT_WIN32 1
+#endif
+
#include
#include
#include
@@ -164,5 +169,6 @@ typedef struct git_str git_str;
if (GIT_MULTIPLY_SIZET_OVERFLOW(out, nelem, elsize)) { return -1; }
#include "util.h"
+#include "ctype_compat.h"
#endif
diff --git a/src/util/hash/builtin.c b/src/util/hash/builtin.c
index cc4aa58fe8d..b4736efbc66 100644
--- a/src/util/hash/builtin.c
+++ b/src/util/hash/builtin.c
@@ -32,13 +32,23 @@ int git_hash_sha256_init(git_hash_sha256_ctx *ctx)
return 0;
}
-int git_hash_sha256_update(git_hash_sha256_ctx *ctx, const void *data, size_t len)
+int git_hash_sha256_update(git_hash_sha256_ctx *ctx, const void *_data, size_t len)
{
+ const unsigned char *data = _data;
GIT_ASSERT_ARG(ctx);
- if (SHA256Input(&ctx->c, data, len)) {
- git_error_set(GIT_ERROR_SHA, "SHA256 error");
- return -1;
+
+ while (len > 0) {
+ unsigned int chunk = (len > UINT_MAX) ? UINT_MAX : (unsigned int)len;
+
+ if (SHA256Input(&ctx->c, data, chunk)) {
+ git_error_set(GIT_ERROR_SHA, "SHA256 error");
+ return -1;
+ }
+
+ data += chunk;
+ len -= chunk;
}
+
return 0;
}
diff --git a/src/util/hash/openssl.c b/src/util/hash/openssl.c
index eaf91e74c1d..8d58cfbc15b 100644
--- a/src/util/hash/openssl.c
+++ b/src/util/hash/openssl.c
@@ -7,7 +7,7 @@
#include "openssl.h"
-#ifdef GIT_OPENSSL_DYNAMIC
+#if defined(GIT_SHA1_OPENSSL_DYNAMIC) || defined(GIT_SHA256_OPENSSL_DYNAMIC)
# include
static int handle_count;
@@ -31,7 +31,8 @@ static int git_hash_openssl_global_init(void)
(openssl_handle = dlopen("libssl.so.1.0.0", RTLD_NOW)) == NULL &&
(openssl_handle = dlopen("libssl.1.0.0.dylib", RTLD_NOW)) == NULL &&
(openssl_handle = dlopen("libssl.so.10", RTLD_NOW)) == NULL &&
- (openssl_handle = dlopen("libssl.so.3", RTLD_NOW)) == NULL) {
+ (openssl_handle = dlopen("libssl.so.3", RTLD_NOW)) == NULL &&
+ (openssl_handle = dlopen("libssl.3.dylib", RTLD_NOW)) == NULL) {
git_error_set(GIT_ERROR_SSL, "could not load ssl libraries");
return -1;
}
@@ -46,17 +47,13 @@ static int git_hash_openssl_global_init(void)
#endif
-#ifdef GIT_SHA1_OPENSSL
-
-# ifdef GIT_OPENSSL_DYNAMIC
+#ifdef GIT_SHA1_OPENSSL_DYNAMIC
static int (*SHA1_Init)(SHA_CTX *c);
static int (*SHA1_Update)(SHA_CTX *c, const void *data, size_t len);
static int (*SHA1_Final)(unsigned char *md, SHA_CTX *c);
-# endif
int git_hash_sha1_global_init(void)
{
-#ifdef GIT_OPENSSL_DYNAMIC
if (git_hash_openssl_global_init() < 0)
return -1;
@@ -67,10 +64,17 @@ int git_hash_sha1_global_init(void)
git_error_set(GIT_ERROR_SSL, "could not load hash function: %s", msg ? msg : "unknown error");
return -1;
}
-#endif
return 0;
}
+#elif GIT_SHA1_OPENSSL
+int git_hash_sha1_global_init(void)
+{
+ return 0;
+}
+#endif
+
+#if defined(GIT_SHA1_OPENSSL) || defined(GIT_SHA1_OPENSSL_DYNAMIC)
int git_hash_sha1_ctx_init(git_hash_sha1_ctx *ctx)
{
@@ -120,17 +124,89 @@ int git_hash_sha1_final(unsigned char *out, git_hash_sha1_ctx *ctx)
#endif
-#ifdef GIT_SHA256_OPENSSL
+#ifdef GIT_SHA1_OPENSSL_FIPS
+
+static const EVP_MD *SHA1_ENGINE_DIGEST_TYPE = NULL;
+
+int git_hash_sha1_global_init(void)
+{
+ SHA1_ENGINE_DIGEST_TYPE = EVP_sha1();
+ return SHA1_ENGINE_DIGEST_TYPE != NULL ? 0 : -1;
+}
+
+int git_hash_sha1_ctx_init(git_hash_sha1_ctx *ctx)
+{
+ return git_hash_sha1_init(ctx);
+}
+
+void git_hash_sha1_ctx_cleanup(git_hash_sha1_ctx *ctx)
+{
+#if OPENSSL_VERSION_NUMBER < 0x10100000L
+ EVP_MD_CTX_destroy(ctx->c);
+#else
+ EVP_MD_CTX_free(ctx->c);
+#endif
+}
+
+int git_hash_sha1_init(git_hash_sha1_ctx *ctx)
+{
+ GIT_ASSERT_ARG(ctx);
+ GIT_ASSERT(SHA1_ENGINE_DIGEST_TYPE);
+
+#if OPENSSL_VERSION_NUMBER < 0x10100000L
+ ctx->c = EVP_MD_CTX_create();
+#else
+ ctx->c = EVP_MD_CTX_new();
+#endif
+
+ GIT_ASSERT(ctx->c);
+
+ if (EVP_DigestInit_ex(ctx->c, SHA1_ENGINE_DIGEST_TYPE, NULL) != 1) {
+ git_hash_sha1_ctx_cleanup(ctx);
+ git_error_set(GIT_ERROR_SHA, "failed to initialize sha1 context");
+ return -1;
+ }
+
+ return 0;
+}
+
+int git_hash_sha1_update(git_hash_sha1_ctx *ctx, const void *data, size_t len)
+{
+ GIT_ASSERT_ARG(ctx && ctx->c);
+
+ if (EVP_DigestUpdate(ctx->c, data, len) != 1) {
+ git_error_set(GIT_ERROR_SHA, "failed to update sha1");
+ return -1;
+ }
+
+ return 0;
+}
-# ifdef GIT_OPENSSL_DYNAMIC
+int git_hash_sha1_final(unsigned char *out, git_hash_sha1_ctx *ctx)
+{
+ unsigned int len = 0;
+
+ GIT_ASSERT_ARG(ctx && ctx->c);
+
+ if (EVP_DigestFinal(ctx->c, out, &len) != 1) {
+ git_error_set(GIT_ERROR_SHA, "failed to finalize sha1");
+ return -1;
+ }
+
+ ctx->c = NULL;
+
+ return 0;
+}
+
+#endif
+
+#ifdef GIT_SHA256_OPENSSL_DYNAMIC
static int (*SHA256_Init)(SHA256_CTX *c);
static int (*SHA256_Update)(SHA256_CTX *c, const void *data, size_t len);
static int (*SHA256_Final)(unsigned char *md, SHA256_CTX *c);
-#endif
int git_hash_sha256_global_init(void)
{
-#ifdef GIT_OPENSSL_DYNAMIC
if (git_hash_openssl_global_init() < 0)
return -1;
@@ -141,10 +217,17 @@ int git_hash_sha256_global_init(void)
git_error_set(GIT_ERROR_SSL, "could not load hash function: %s", msg ? msg : "unknown error");
return -1;
}
-#endif
return 0;
}
+#elif GIT_SHA256_OPENSSL
+int git_hash_sha256_global_init(void)
+{
+ return 0;
+}
+#endif
+
+#if defined(GIT_SHA256_OPENSSL) || defined(GIT_SHA256_OPENSSL_DYNAMIC)
int git_hash_sha256_ctx_init(git_hash_sha256_ctx *ctx)
{
@@ -193,3 +276,79 @@ int git_hash_sha256_final(unsigned char *out, git_hash_sha256_ctx *ctx)
}
#endif
+
+#ifdef GIT_SHA256_OPENSSL_FIPS
+
+static const EVP_MD *SHA256_ENGINE_DIGEST_TYPE = NULL;
+
+int git_hash_sha256_global_init(void)
+{
+ SHA256_ENGINE_DIGEST_TYPE = EVP_sha256();
+ return SHA256_ENGINE_DIGEST_TYPE != NULL ? 0 : -1;
+}
+
+int git_hash_sha256_ctx_init(git_hash_sha256_ctx *ctx)
+{
+ return git_hash_sha256_init(ctx);
+}
+
+void git_hash_sha256_ctx_cleanup(git_hash_sha256_ctx *ctx)
+{
+#if OPENSSL_VERSION_NUMBER < 0x10100000L
+ EVP_MD_CTX_destroy(ctx->c);
+#else
+ EVP_MD_CTX_free(ctx->c);
+#endif
+}
+
+int git_hash_sha256_init(git_hash_sha256_ctx *ctx)
+{
+ GIT_ASSERT_ARG(ctx);
+ GIT_ASSERT(SHA256_ENGINE_DIGEST_TYPE);
+
+#if OPENSSL_VERSION_NUMBER < 0x10100000L
+ ctx->c = EVP_MD_CTX_create();
+#else
+ ctx->c = EVP_MD_CTX_new();
+#endif
+
+ GIT_ASSERT(ctx->c);
+
+ if (EVP_DigestInit_ex(ctx->c, SHA256_ENGINE_DIGEST_TYPE, NULL) != 1) {
+ git_hash_sha256_ctx_cleanup(ctx);
+ git_error_set(GIT_ERROR_SHA, "failed to initialize sha256 context");
+ return -1;
+ }
+
+ return 0;
+}
+
+int git_hash_sha256_update(git_hash_sha256_ctx *ctx, const void *data, size_t len)
+{
+ GIT_ASSERT_ARG(ctx && ctx->c);
+
+ if (EVP_DigestUpdate(ctx->c, data, len) != 1) {
+ git_error_set(GIT_ERROR_SHA, "failed to update sha256");
+ return -1;
+ }
+
+ return 0;
+}
+
+int git_hash_sha256_final(unsigned char *out, git_hash_sha256_ctx *ctx)
+{
+ unsigned int len = 0;
+
+ GIT_ASSERT_ARG(ctx && ctx->c);
+
+ if (EVP_DigestFinal(ctx->c, out, &len) != 1) {
+ git_error_set(GIT_ERROR_SHA, "failed to finalize sha256");
+ return -1;
+ }
+
+ ctx->c = NULL;
+
+ return 0;
+}
+
+#endif
diff --git a/src/util/hash/openssl.h b/src/util/hash/openssl.h
index 7cb089abc1e..2ab73c9893c 100644
--- a/src/util/hash/openssl.h
+++ b/src/util/hash/openssl.h
@@ -10,36 +10,54 @@
#include "hash/sha.h"
-#ifndef GIT_OPENSSL_DYNAMIC
+#if defined(GIT_SHA1_OPENSSL_FIPS) || defined(GIT_SHA256_OPENSSL_FIPS)
+# include
+#endif
+
+#if defined(GIT_SHA1_OPENSSL) || defined(GIT_SHA256_OPENSSL)
# include
-#else
+#endif
+#if defined(GIT_SHA1_OPENSSL_DYNAMIC)
typedef struct {
unsigned int h0, h1, h2, h3, h4;
unsigned int Nl, Nh;
unsigned int data[16];
unsigned int num;
} SHA_CTX;
+#endif
+#if defined(GIT_SHA256_OPENSSL_DYNAMIC)
typedef struct {
unsigned int h[8];
unsigned int Nl, Nh;
unsigned int data[16];
unsigned int num, md_len;
} SHA256_CTX;
-
#endif
-#ifdef GIT_SHA1_OPENSSL
+#if defined(GIT_SHA1_OPENSSL) || defined(GIT_SHA1_OPENSSL_DYNAMIC)
struct git_hash_sha1_ctx {
SHA_CTX c;
};
#endif
-#ifdef GIT_SHA256_OPENSSL
+#ifdef GIT_SHA1_OPENSSL_FIPS
+struct git_hash_sha1_ctx {
+ EVP_MD_CTX* c;
+};
+#endif
+
+#if defined(GIT_SHA256_OPENSSL) || defined(GIT_SHA256_OPENSSL_DYNAMIC)
struct git_hash_sha256_ctx {
SHA256_CTX c;
};
#endif
+#ifdef GIT_SHA256_OPENSSL_FIPS
+struct git_hash_sha256_ctx {
+ EVP_MD_CTX* c;
+};
+#endif
+
#endif
diff --git a/src/util/hash/sha.h b/src/util/hash/sha.h
index 4f596234c37..f9d04814237 100644
--- a/src/util/hash/sha.h
+++ b/src/util/hash/sha.h
@@ -13,11 +13,20 @@
typedef struct git_hash_sha1_ctx git_hash_sha1_ctx;
typedef struct git_hash_sha256_ctx git_hash_sha256_ctx;
+#if defined(GIT_SHA1_BUILTIN)
+# include "collisiondetect.h"
+#endif
+
#if defined(GIT_SHA1_COMMON_CRYPTO) || defined(GIT_SHA256_COMMON_CRYPTO)
# include "common_crypto.h"
#endif
-#if defined(GIT_SHA1_OPENSSL) || defined(GIT_SHA256_OPENSSL)
+#if defined(GIT_SHA1_OPENSSL) || \
+ defined(GIT_SHA1_OPENSSL_DYNAMIC) || \
+ defined(GIT_SHA1_OPENSSL_FIPS) || \
+ defined(GIT_SHA256_OPENSSL) || \
+ defined(GIT_SHA256_OPENSSL_DYNAMIC) || \
+ defined(GIT_SHA256_OPENSSL_FIPS)
# include "openssl.h"
#endif
@@ -29,10 +38,6 @@ typedef struct git_hash_sha256_ctx git_hash_sha256_ctx;
# include "mbedtls.h"
#endif
-#if defined(GIT_SHA1_COLLISIONDETECT)
-# include "collisiondetect.h"
-#endif
-
#if defined(GIT_SHA256_BUILTIN)
# include "builtin.h"
#endif
diff --git a/src/util/hashmap.h b/src/util/hashmap.h
new file mode 100644
index 00000000000..c29844f3892
--- /dev/null
+++ b/src/util/hashmap.h
@@ -0,0 +1,424 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_hashmap_h__
+#define INCLUDE_hashmap_h__
+
+/*
+ * This is a variation on khash.h from khlib 2013-05-02 (0.2.8)
+ *
+ * The MIT License
+ *
+ * Copyright (c) 2008, 2009, 2011 by Attractive Chaos
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include
+#include
+#include
+
+#define GIT_HASHMAP_INIT {0}
+#define GIT_HASHSET_INIT {0}
+
+#define GIT_HASHMAP_EMPTY
+#define GIT_HASHMAP_INLINE GIT_INLINE(GIT_HASHMAP_EMPTY)
+
+#define GIT_HASHMAP_IS_EMPTY(flag, i) ((flag[i>>4]>>((i&0xfU)<<1))&2)
+#define GIT_HASHMAP_IS_DELETE(flag, i) ((flag[i>>4]>>((i&0xfU)<<1))&1)
+#define GIT_HASHMAP_IS_EITHER(flag, i) ((flag[i>>4]>>((i&0xfU)<<1))&3)
+#define GIT_HASHMAP_SET_EMPTY_FALSE(flag, i) (flag[i>>4]&=~(2ul<<((i&0xfU)<<1)))
+#define GIT_HASHMAP_SET_DELETE_TRUE(flag, i) (flag[i>>4]|=1ul<<((i&0xfU)<<1))
+#define GIT_HASHMAP_SET_DELETE_FALSE(flag, i) (flag[i>>4]&=~(1ul<<((i&0xfU)<<1)))
+#define GIT_HASHMAP_SET_BOTH_FALSE(flag, i) (flag[i>>4]&=~(3ul<<((i&0xfU)<<1)))
+
+#define GIT_HASHMAP_FLAGSIZE(m) ((m) < 16? 1 : (m)>>4)
+#define GIT_HASHMAP_ROUNDUP(x) (--(x), (x)|=(x)>>1, \
+ (x)|=(x)>>2, (x)|=(x)>>4, (x)|=(x)>>8, (x)|=(x)>>16, ++(x))
+
+#define GIT_HASHSET_VAL_T void *
+
+typedef uint32_t git_hashmap_iter_t;
+#define GIT_HASHMAP_ITER_INIT 0
+
+#define GIT_HASHMAP_STRUCT_MEMBERS(key_t, val_t) \
+ uint32_t n_buckets, \
+ size, \
+ n_occupied, \
+ upper_bound; \
+ uint32_t *flags; \
+ key_t *keys; \
+ val_t *vals;
+
+#define GIT_HASHMAP_STRUCT(name, key_t, val_t) \
+ typedef struct { \
+ GIT_HASHMAP_STRUCT_MEMBERS(key_t, val_t) \
+ } name;
+#define GIT_HASHSET_STRUCT(name, key_t) \
+ GIT_HASHMAP_STRUCT(name, key_t, void *)
+
+
+#define GIT_HASHMAP__COMMON_PROTOTYPES(name, key_t, val_t) \
+ extern uint32_t name##_size(name *h); \
+ extern bool name##_contains(name *h, key_t key); \
+ extern int name##_remove(name *h, key_t key); \
+ extern void name##_clear(name *h); \
+ extern void name##_dispose(name *h);
+
+#define GIT_HASHMAP_PROTOTYPES(name, key_t, val_t) \
+ GIT_HASHMAP__COMMON_PROTOTYPES(name, key_t, val_t) \
+ extern int name##_get(val_t *out, name *h, key_t key); \
+ extern int name##_put(name *h, key_t key, val_t val); \
+ extern int name##_iterate(git_hashmap_iter_t *iter, key_t *key, val_t *val, name *h); \
+ extern int name##_foreach(name *h, int (*cb)(key_t, val_t));
+
+#define GIT_HASHSET_PROTOTYPES(name, key_t) \
+ GIT_HASHMAP__COMMON_PROTOTYPES(name, key_t, GIT_HASHSET_VAL_T) \
+ extern int name##_add(name *h, key_t key); \
+ extern int name##_iterate(git_hashmap_iter_t *iter, key_t *key, name *h); \
+ extern int name##_foreach(name *h, int (*cb)(key_t)); \
+
+
+#define GIT_HASHMAP__COMMON_FUNCTIONS(name, is_map, scope, key_t, val_t, __hash_fn, __equal_fn) \
+ GIT_UNUSED_FUNCTION scope uint32_t name##_size(name *h) \
+ { \
+ return h->size; \
+ } \
+ GIT_INLINE(int) name##__idx(uint32_t *out, name *h, key_t key) \
+ { \
+ if (h->n_buckets) { \
+ uint32_t k, i, last, mask, step = 0; \
+ GIT_ASSERT((h)->flags); \
+ mask = h->n_buckets - 1; \
+ k = __hash_fn(key); \
+ i = k & mask; \
+ last = i; \
+ while (!GIT_HASHMAP_IS_EMPTY(h->flags, i) && \
+ (GIT_HASHMAP_IS_DELETE(h->flags, i) || !__equal_fn(h->keys[i], key))) { \
+ i = (i + (++step)) & mask; \
+ if (i == last) \
+ return GIT_ENOTFOUND; \
+ } \
+ if (GIT_HASHMAP_IS_EITHER(h->flags, i)) \
+ return GIT_ENOTFOUND; \
+ *out = i; \
+ return 0; \
+ } \
+ return GIT_ENOTFOUND; \
+ } \
+ GIT_UNUSED_FUNCTION scope bool name##_contains(name *h, key_t key) \
+ { \
+ uint32_t idx; \
+ return name##__idx(&idx, h, key) == 0; \
+ } \
+ GIT_INLINE(int) name##__remove_at_idx(name *h, uint32_t idx) \
+ { \
+ if (idx < h->n_buckets && !GIT_HASHMAP_IS_EITHER(h->flags, idx)) { \
+ GIT_HASHMAP_SET_DELETE_TRUE(h->flags, idx); \
+ --h->size; \
+ return 0; \
+ } \
+ return GIT_ENOTFOUND; \
+ } \
+ GIT_UNUSED_FUNCTION scope int name##_remove(name *h, key_t key) \
+ { \
+ uint32_t idx; \
+ int error; \
+ if ((error = name##__idx(&idx, h, key)) == 0) \
+ error = name##__remove_at_idx(h, idx); \
+ return error; \
+ } \
+ GIT_INLINE(int) name##__resize(name *h, uint32_t new_n_buckets) \
+ { \
+ /* This function uses 0.25*n_buckets bytes of working \
+ * space instead of [sizeof(key_t+val_t)+.25]*n_buckets. \
+ */ \
+ double git_hashmap__upper_bound = 0.77; \
+ uint32_t *new_flags = 0; \
+ uint32_t j = 1; \
+ { \
+ GIT_HASHMAP_ROUNDUP(new_n_buckets); \
+ if (new_n_buckets < 4) \
+ new_n_buckets = 4; \
+ if (h->size >= (uint32_t)(new_n_buckets * git_hashmap__upper_bound + 0.5)) { \
+ /* Requested size is too small */ \
+ j = 0; \
+ } else { \
+ /* Shrink or expand; rehash */ \
+ new_flags = git__reallocarray(NULL, GIT_HASHMAP_FLAGSIZE(new_n_buckets), sizeof(uint32_t)); \
+ if (!new_flags) \
+ return -1; \
+ memset(new_flags, 0xaa, GIT_HASHMAP_FLAGSIZE(new_n_buckets) * sizeof(uint32_t)); \
+ if (h->n_buckets < new_n_buckets) { \
+ /* Expand */ \
+ key_t *new_keys = git__reallocarray(h->keys, new_n_buckets, sizeof(key_t)); \
+ if (!new_keys) { \
+ git__free(new_flags); \
+ return -1; \
+ } \
+ h->keys = new_keys; \
+ if (is_map) { \
+ val_t *new_vals = git__reallocarray(h->vals, new_n_buckets, sizeof(val_t)); \
+ if (!new_vals) { \
+ git__free(new_flags); \
+ return -1; \
+ } \
+ h->vals = new_vals; \
+ } \
+ } \
+ } \
+ } \
+ if (j) { \
+ /* Rehashing is needed */ \
+ for (j = 0; j != h->n_buckets; ++j) { \
+ if (GIT_HASHMAP_IS_EITHER(h->flags, j) == 0) { \
+ key_t key = h->keys[j]; \
+ val_t val; \
+ uint32_t new_mask; \
+ new_mask = new_n_buckets - 1; \
+ if (is_map) \
+ val = h->vals[j]; \
+ GIT_HASHMAP_SET_DELETE_TRUE(h->flags, j); \
+ while (1) { \
+ /* Kick-out process; sort of like in Cuckoo hashing */ \
+ uint32_t k, i, step = 0; \
+ k = __hash_fn(key); \
+ i = k & new_mask; \
+ while (!GIT_HASHMAP_IS_EMPTY(new_flags, i)) \
+ i = (i + (++step)) & new_mask; \
+ GIT_HASHMAP_SET_EMPTY_FALSE(new_flags, i); \
+ if (i < h->n_buckets && GIT_HASHMAP_IS_EITHER(h->flags, i) == 0) { \
+ /* Kick out the existing element */ \
+ { \
+ key_t tmp = h->keys[i]; \
+ h->keys[i] = key; \
+ key = tmp; \
+ } \
+ if (is_map) { \
+ val_t tmp = h->vals[i]; \
+ h->vals[i] = val; \
+ val = tmp; \
+ } \
+ /* Mark it as deleted in the old hash table */ \
+ GIT_HASHMAP_SET_DELETE_TRUE(h->flags, i); \
+ } else { \
+ /* Write the element and jump out of the loop */ \
+ h->keys[i] = key; \
+ if (is_map) \
+ h->vals[i] = val; \
+ break; \
+ } \
+ } \
+ } \
+ } \
+ if (h->n_buckets > new_n_buckets) { \
+ /* Shrink the hash table */ \
+ h->keys = git__reallocarray(h->keys, new_n_buckets, sizeof(key_t)); \
+ if (is_map) \
+ h->vals = git__reallocarray(h->vals, new_n_buckets, sizeof(val_t)); \
+ } \
+ /* free the working space */ \
+ git__free(h->flags); \
+ h->flags = new_flags; \
+ h->n_buckets = new_n_buckets; \
+ h->n_occupied = h->size; \
+ h->upper_bound = (uint32_t)(h->n_buckets * git_hashmap__upper_bound + 0.5); \
+ } \
+ return 0; \
+ } \
+ GIT_INLINE(int) name##__put_idx(uint32_t *idx, bool *key_exists, name *h, key_t key) \
+ { \
+ uint32_t x; \
+ if (h->n_occupied >= h->upper_bound) { \
+ /* Update the hash table */ \
+ if (h->n_buckets > (h->size<<1)) { \
+ /* Clear "deleted" elements */ \
+ if (name##__resize(h, h->n_buckets - 1) < 0) \
+ return -1; \
+ } else if (name##__resize(h, h->n_buckets + 1) < 0) { \
+ return -1; \
+ } \
+ } \
+ GIT_ASSERT((h)->flags); \
+ GIT_ASSERT((h)->keys); \
+ /* TODO: to implement automatically shrinking; resize() already support shrinking */ \
+ { \
+ uint32_t k, i, site, last, mask = h->n_buckets - 1, step = 0; \
+ x = site = h->n_buckets; \
+ k = __hash_fn(key); \
+ i = k & mask; \
+ if (GIT_HASHMAP_IS_EMPTY(h->flags, i)) { \
+ /* for speed up */ \
+ x = i; \
+ } else { \
+ last = i; \
+ while (!GIT_HASHMAP_IS_EMPTY(h->flags, i) && (GIT_HASHMAP_IS_DELETE(h->flags, i) || !__equal_fn(h->keys[i], key))) { \
+ if (GIT_HASHMAP_IS_DELETE(h->flags, i)) \
+ site = i; \
+ i = (i + (++step)) & mask; \
+ if (i == last) { \
+ x = site; \
+ break; \
+ } \
+ } \
+ if (x == h->n_buckets) { \
+ if (GIT_HASHMAP_IS_EMPTY(h->flags, i) && site != h->n_buckets) \
+ x = site; \
+ else \
+ x = i; \
+ } \
+ } \
+ } \
+ if (GIT_HASHMAP_IS_EMPTY(h->flags, x)) { \
+ /* not present at all */ \
+ h->keys[x] = key; \
+ GIT_HASHMAP_SET_BOTH_FALSE(h->flags, x); \
+ ++h->size; \
+ ++h->n_occupied; \
+ *key_exists = 1; \
+ } else if (GIT_HASHMAP_IS_DELETE(h->flags, x)) { \
+ /* deleted */ \
+ h->keys[x] = key; \
+ GIT_HASHMAP_SET_BOTH_FALSE(h->flags, x); \
+ ++h->size; \
+ *key_exists = 1; \
+ } else { \
+ /* Don't touch h->keys[x] if present and not deleted */ \
+ *key_exists = 0; \
+ } \
+ *idx = x; \
+ return 0; \
+ } \
+ GIT_UNUSED_FUNCTION scope void name##_clear(name *h) \
+ { \
+ if (h && h->flags) { \
+ memset(h->flags, 0xaa, GIT_HASHMAP_FLAGSIZE(h->n_buckets) * sizeof(uint32_t)); \
+ h->size = h->n_occupied = 0; \
+ } \
+ } \
+ GIT_UNUSED_FUNCTION scope void name##_dispose(name *h) \
+ { \
+ git__free(h->flags); \
+ git__free(h->keys); \
+ git__free(h->vals); \
+ memset(h, 0, sizeof(name)); \
+ }
+
+#define GIT_HASHMAP_FUNCTIONS(name, scope, key_t, val_t, __hash_fn, __equal_fn) \
+ GIT_HASHMAP__COMMON_FUNCTIONS(name, true, scope, key_t, val_t, __hash_fn, __equal_fn) \
+ \
+ GIT_UNUSED_FUNCTION scope int name##_get(val_t *out, name *h, key_t key) \
+ { \
+ uint32_t idx; \
+ int error; \
+ if ((error = name##__idx(&idx, h, key)) == 0) \
+ *out = (h)->vals[idx]; \
+ return error; \
+ } \
+ GIT_UNUSED_FUNCTION scope int name##_put(name *h, key_t key, val_t val) \
+ { \
+ uint32_t idx; \
+ bool key_exists; \
+ int error = name##__put_idx(&idx, &key_exists, h, key); \
+ if (error) \
+ return error; \
+ GIT_ASSERT((h)->vals); \
+ if (!key_exists) \
+ (h)->keys[idx] = key; \
+ (h)->vals[idx] = val; \
+ return 0; \
+ } \
+ GIT_UNUSED_FUNCTION scope int name##_iterate(git_hashmap_iter_t *iter, key_t *key, val_t *val, name *h) \
+ { \
+ for (; *iter < h->n_buckets; (*iter)++) { \
+ if (GIT_HASHMAP_IS_EITHER(h->flags, *iter)) \
+ continue; \
+ if (key) \
+ *key = h->keys[*iter]; \
+ if (val) \
+ *val = h->vals[*iter]; \
+ (*iter)++; \
+ return 0; \
+ } \
+ return GIT_ITEROVER; \
+ } \
+ GIT_UNUSED_FUNCTION scope int name##_foreach(name *h, int (*cb)(key_t, val_t)) \
+ { \
+ uint32_t idx = 0; \
+ key_t key; \
+ val_t val; \
+ int ret; \
+ while ((ret = name##_iterate(&idx, &key, &val, h)) == 0) { \
+ if ((ret = cb(key, val)) != 0) \
+ return ret; \
+ } \
+ return ret == GIT_ITEROVER ? 0 : ret; \
+ }
+
+#define GIT_HASHSET_FUNCTIONS(name, scope, key_t, __hash_fn, __equal_fn) \
+ GIT_HASHMAP__COMMON_FUNCTIONS(name, false, scope, key_t, void *, __hash_fn, __equal_fn) \
+ \
+ GIT_UNUSED_FUNCTION scope int name##_add(name *h, key_t key) \
+ { \
+ uint32_t idx; \
+ bool key_exists; \
+ int error = name##__put_idx(&idx, &key_exists, h, key); \
+ if (error) \
+ return error; \
+ if (!key_exists) { \
+ (h)->keys[idx] = key; \
+ } \
+ return 0; \
+ } \
+ GIT_UNUSED_FUNCTION scope int name##_iterate(git_hashmap_iter_t *iter, key_t *key, name *h) \
+ { \
+ for (; *iter < h->n_buckets; (*iter)++) { \
+ if (GIT_HASHMAP_IS_EITHER(h->flags, *iter)) \
+ continue; \
+ *key = h->keys[*iter]; \
+ return 0; \
+ } \
+ return GIT_ITEROVER; \
+ } \
+ GIT_UNUSED_FUNCTION scope int name##_foreach(name *h, int (*cb)(key_t)) \
+ { \
+ git_hashmap_iter_t iter = 0; \
+ key_t key; \
+ int ret; \
+ while ((ret = name##_iterate(&iter, &key, h)) == 0) { \
+ if ((ret = cb(key)) != 0) \
+ return ret; \
+ } \
+ return ret == GIT_ITEROVER ? 0 : ret; \
+ }
+
+
+#define GIT_HASHSET_SETUP(name, key_t, __hash_fn, __equal_fn) \
+ GIT_HASHSET_STRUCT(name, key_t) \
+ GIT_HASHSET_FUNCTIONS(name, GIT_HASHMAP_INLINE, key_t, __hash_fn, __equal_fn)
+#define GIT_HASHMAP_SETUP(name, key_t, val_t, __hash_fn, __equal_fn) \
+ GIT_HASHMAP_STRUCT(name, key_t, val_t) \
+ GIT_HASHMAP_FUNCTIONS(name, GIT_HASHMAP_INLINE, key_t, val_t, __hash_fn, __equal_fn)
+
+#endif
diff --git a/src/util/hashmap_str.h b/src/util/hashmap_str.h
new file mode 100644
index 00000000000..099aac5a879
--- /dev/null
+++ b/src/util/hashmap_str.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_hashmap_str_h__
+#define INCLUDE_hashmap_str_h__
+
+#include "hashmap.h"
+
+GIT_INLINE(uint32_t) git_hashmap_str_hash(const char *s)
+{
+ uint32_t h = (uint32_t)*s;
+
+ if (h) {
+ for (++s; *s; ++s)
+ h = (h << 5) - h + (uint32_t)*s;
+ }
+
+ return h;
+}
+
+GIT_INLINE(bool) git_hashmap_str_equal(const char *one, const char *two)
+{
+ return strcmp(one, two) == 0;
+}
+
+#define GIT_HASHMAP_STR_STRUCT(name, val_t) \
+ GIT_HASHMAP_STRUCT(name, const char *, val_t)
+#define GIT_HASHMAP_STR_PROTOTYPES(name, val_t) \
+ GIT_HASHMAP_PROTOTYPES(name, const char *, val_t)
+#define GIT_HASHMAP_STR_FUNCTIONS(name, scope, val_t) \
+ GIT_HASHMAP_FUNCTIONS(name, scope, const char *, val_t, git_hashmap_str_hash, git_hashmap_str_equal)
+
+#define GIT_HASHMAP_STR_SETUP(name, val_t) \
+ GIT_HASHMAP_STR_STRUCT(name, val_t) \
+ GIT_HASHMAP_STR_FUNCTIONS(name, GIT_HASHMAP_INLINE, val_t)
+
+GIT_HASHSET_SETUP(git_hashset_str, const char *, git_hashmap_str_hash, git_hashmap_str_equal);
+GIT_HASHMAP_SETUP(git_hashmap_str, const char *, void *, git_hashmap_str_hash, git_hashmap_str_equal);
+
+#endif
diff --git a/src/util/integer.h b/src/util/integer.h
index 63277177bf3..a9e416cc342 100644
--- a/src/util/integer.h
+++ b/src/util/integer.h
@@ -89,7 +89,9 @@ GIT_INLINE(int) git__is_int(int64_t p)
/* Use Microsoft's safe integer handling functions where available */
#elif defined(_MSC_VER)
-# define ENABLE_INTSAFE_SIGNED_FUNCTIONS
+# if !defined(ENABLE_INTSAFE_SIGNED_FUNCTIONS)
+# define ENABLE_INTSAFE_SIGNED_FUNCTIONS
+# endif
# include
# define git__add_sizet_overflow(out, one, two) \
diff --git a/src/util/khash.h b/src/util/khash.h
deleted file mode 100644
index c9b7f131f0a..00000000000
--- a/src/util/khash.h
+++ /dev/null
@@ -1,615 +0,0 @@
-/* The MIT License
-
- Copyright (c) 2008, 2009, 2011 by Attractive Chaos
-
- Permission is hereby granted, free of charge, to any person obtaining
- a copy of this software and associated documentation files (the
- "Software"), to deal in the Software without restriction, including
- without limitation the rights to use, copy, modify, merge, publish,
- distribute, sublicense, and/or sell copies of the Software, and to
- permit persons to whom the Software is furnished to do so, subject to
- the following conditions:
-
- The above copyright notice and this permission notice shall be
- included in all copies or substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- SOFTWARE.
-*/
-
-/*
- An example:
-
-#include "khash.h"
-KHASH_MAP_INIT_INT(32, char)
-int main() {
- int ret, is_missing;
- khiter_t k;
- khash_t(32) *h = kh_init(32);
- k = kh_put(32, h, 5, &ret);
- kh_value(h, k) = 10;
- k = kh_get(32, h, 10);
- is_missing = (k == kh_end(h));
- k = kh_get(32, h, 5);
- kh_del(32, h, k);
- for (k = kh_begin(h); k != kh_end(h); ++k)
- if (kh_exist(h, k)) kh_value(h, k) = 1;
- kh_destroy(32, h);
- return 0;
-}
-*/
-
-/*
- 2013-05-02 (0.2.8):
-
- * Use quadratic probing. When the capacity is power of 2, stepping function
- i*(i+1)/2 guarantees to traverse each bucket. It is better than double
- hashing on cache performance and is more robust than linear probing.
-
- In theory, double hashing should be more robust than quadratic probing.
- However, my implementation is probably not for large hash tables, because
- the second hash function is closely tied to the first hash function,
- which reduce the effectiveness of double hashing.
-
- Reference: http://research.cs.vt.edu/AVresearch/hashing/quadratic.php
-
- 2011-12-29 (0.2.7):
-
- * Minor code clean up; no actual effect.
-
- 2011-09-16 (0.2.6):
-
- * The capacity is a power of 2. This seems to dramatically improve the
- speed for simple keys. Thank Zilong Tan for the suggestion. Reference:
-
- - http://code.google.com/p/ulib/
- - http://nothings.org/computer/judy/
-
- * Allow to optionally use linear probing which usually has better
- performance for random input. Double hashing is still the default as it
- is more robust to certain non-random input.
-
- * Added Wang's integer hash function (not used by default). This hash
- function is more robust to certain non-random input.
-
- 2011-02-14 (0.2.5):
-
- * Allow to declare global functions.
-
- 2009-09-26 (0.2.4):
-
- * Improve portability
-
- 2008-09-19 (0.2.3):
-
- * Corrected the example
- * Improved interfaces
-
- 2008-09-11 (0.2.2):
-
- * Improved speed a little in kh_put()
-
- 2008-09-10 (0.2.1):
-
- * Added kh_clear()
- * Fixed a compiling error
-
- 2008-09-02 (0.2.0):
-
- * Changed to token concatenation which increases flexibility.
-
- 2008-08-31 (0.1.2):
-
- * Fixed a bug in kh_get(), which has not been tested previously.
-
- 2008-08-31 (0.1.1):
-
- * Added destructor
-*/
-
-
-#ifndef __AC_KHASH_H
-#define __AC_KHASH_H
-
-/*!
- @header
-
- Generic hash table library.
- */
-
-#define AC_VERSION_KHASH_H "0.2.8"
-
-#include
-#include
-#include
-
-/* compiler specific configuration */
-
-typedef uint32_t khint32_t;
-typedef uint64_t khint64_t;
-
-#ifndef kh_inline
-#ifdef _MSC_VER
-#define kh_inline __inline
-#elif defined(__GNUC__)
-#define kh_inline __inline__
-#else
-#define kh_inline
-#endif
-#endif /* kh_inline */
-
-typedef khint32_t khint_t;
-typedef khint_t khiter_t;
-
-#define __ac_isempty(flag, i) ((flag[i>>4]>>((i&0xfU)<<1))&2)
-#define __ac_isdel(flag, i) ((flag[i>>4]>>((i&0xfU)<<1))&1)
-#define __ac_iseither(flag, i) ((flag[i>>4]>>((i&0xfU)<<1))&3)
-#define __ac_set_isdel_false(flag, i) (flag[i>>4]&=~(1ul<<((i&0xfU)<<1)))
-#define __ac_set_isempty_false(flag, i) (flag[i>>4]&=~(2ul<<((i&0xfU)<<1)))
-#define __ac_set_isboth_false(flag, i) (flag[i>>4]&=~(3ul<<((i&0xfU)<<1)))
-#define __ac_set_isdel_true(flag, i) (flag[i>>4]|=1ul<<((i&0xfU)<<1))
-
-#define __ac_fsize(m) ((m) < 16? 1 : (m)>>4)
-
-#ifndef kroundup32
-#define kroundup32(x) (--(x), (x)|=(x)>>1, (x)|=(x)>>2, (x)|=(x)>>4, (x)|=(x)>>8, (x)|=(x)>>16, ++(x))
-#endif
-
-#ifndef kcalloc
-#define kcalloc(N,Z) calloc(N,Z)
-#endif
-#ifndef kmalloc
-#define kmalloc(Z) malloc(Z)
-#endif
-#ifndef krealloc
-#define krealloc(P,Z) realloc(P,Z)
-#endif
-#ifndef kreallocarray
-#define kreallocarray(P,N,Z) ((SIZE_MAX - N < Z) ? NULL : krealloc(P, (N*Z)))
-#endif
-#ifndef kfree
-#define kfree(P) free(P)
-#endif
-
-static const double __ac_HASH_UPPER = 0.77;
-
-#define __KHASH_TYPE(name, khkey_t, khval_t) \
- typedef struct kh_##name##_s { \
- khint_t n_buckets, size, n_occupied, upper_bound; \
- khint32_t *flags; \
- khkey_t *keys; \
- khval_t *vals; \
- } kh_##name##_t;
-
-#define __KHASH_PROTOTYPES(name, khkey_t, khval_t) \
- extern kh_##name##_t *kh_init_##name(void); \
- extern void kh_destroy_##name(kh_##name##_t *h); \
- extern void kh_clear_##name(kh_##name##_t *h); \
- extern khint_t kh_get_##name(const kh_##name##_t *h, khkey_t key); \
- extern int kh_resize_##name(kh_##name##_t *h, khint_t new_n_buckets); \
- extern khint_t kh_put_##name(kh_##name##_t *h, khkey_t key, int *ret); \
- extern void kh_del_##name(kh_##name##_t *h, khint_t x);
-
-#define __KHASH_IMPL(name, SCOPE, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \
- SCOPE kh_##name##_t *kh_init_##name(void) { \
- return (kh_##name##_t*)kcalloc(1, sizeof(kh_##name##_t)); \
- } \
- SCOPE void kh_destroy_##name(kh_##name##_t *h) \
- { \
- if (h) { \
- kfree((void *)h->keys); kfree(h->flags); \
- kfree((void *)h->vals); \
- kfree(h); \
- } \
- } \
- SCOPE void kh_clear_##name(kh_##name##_t *h) \
- { \
- if (h && h->flags) { \
- memset(h->flags, 0xaa, __ac_fsize(h->n_buckets) * sizeof(khint32_t)); \
- h->size = h->n_occupied = 0; \
- } \
- } \
- SCOPE khint_t kh_get_##name(const kh_##name##_t *h, khkey_t key) \
- { \
- if (h->n_buckets) { \
- khint_t k, i, last, mask, step = 0; \
- mask = h->n_buckets - 1; \
- k = __hash_func(key); i = k & mask; \
- last = i; \
- while (!__ac_isempty(h->flags, i) && (__ac_isdel(h->flags, i) || !__hash_equal(h->keys[i], key))) { \
- i = (i + (++step)) & mask; \
- if (i == last) return h->n_buckets; \
- } \
- return __ac_iseither(h->flags, i)? h->n_buckets : i; \
- } else return 0; \
- } \
- SCOPE int kh_resize_##name(kh_##name##_t *h, khint_t new_n_buckets) \
- { /* This function uses 0.25*n_buckets bytes of working space instead of [sizeof(key_t+val_t)+.25]*n_buckets. */ \
- khint32_t *new_flags = 0; \
- khint_t j = 1; \
- { \
- kroundup32(new_n_buckets); \
- if (new_n_buckets < 4) new_n_buckets = 4; \
- if (h->size >= (khint_t)(new_n_buckets * __ac_HASH_UPPER + 0.5)) j = 0; /* requested size is too small */ \
- else { /* hash table size to be changed (shrink or expand); rehash */ \
- new_flags = (khint32_t*)kreallocarray(NULL, __ac_fsize(new_n_buckets), sizeof(khint32_t)); \
- if (!new_flags) return -1; \
- memset(new_flags, 0xaa, __ac_fsize(new_n_buckets) * sizeof(khint32_t)); \
- if (h->n_buckets < new_n_buckets) { /* expand */ \
- khkey_t *new_keys = (khkey_t*)kreallocarray((void *)h->keys, new_n_buckets, sizeof(khkey_t)); \
- if (!new_keys) { kfree(new_flags); return -1; } \
- h->keys = new_keys; \
- if (kh_is_map) { \
- khval_t *new_vals = (khval_t*)kreallocarray((void *)h->vals, new_n_buckets, sizeof(khval_t)); \
- if (!new_vals) { kfree(new_flags); return -1; } \
- h->vals = new_vals; \
- } \
- } /* otherwise shrink */ \
- } \
- } \
- if (j) { /* rehashing is needed */ \
- for (j = 0; j != h->n_buckets; ++j) { \
- if (__ac_iseither(h->flags, j) == 0) { \
- khkey_t key = h->keys[j]; \
- khval_t val; \
- khint_t new_mask; \
- new_mask = new_n_buckets - 1; \
- if (kh_is_map) val = h->vals[j]; \
- __ac_set_isdel_true(h->flags, j); \
- while (1) { /* kick-out process; sort of like in Cuckoo hashing */ \
- khint_t k, i, step = 0; \
- k = __hash_func(key); \
- i = k & new_mask; \
- while (!__ac_isempty(new_flags, i)) i = (i + (++step)) & new_mask; \
- __ac_set_isempty_false(new_flags, i); \
- if (i < h->n_buckets && __ac_iseither(h->flags, i) == 0) { /* kick out the existing element */ \
- { khkey_t tmp = h->keys[i]; h->keys[i] = key; key = tmp; } \
- if (kh_is_map) { khval_t tmp = h->vals[i]; h->vals[i] = val; val = tmp; } \
- __ac_set_isdel_true(h->flags, i); /* mark it as deleted in the old hash table */ \
- } else { /* write the element and jump out of the loop */ \
- h->keys[i] = key; \
- if (kh_is_map) h->vals[i] = val; \
- break; \
- } \
- } \
- } \
- } \
- if (h->n_buckets > new_n_buckets) { /* shrink the hash table */ \
- h->keys = (khkey_t*)kreallocarray((void *)h->keys, new_n_buckets, sizeof(khkey_t)); \
- if (kh_is_map) h->vals = (khval_t*)kreallocarray((void *)h->vals, new_n_buckets, sizeof(khval_t)); \
- } \
- kfree(h->flags); /* free the working space */ \
- h->flags = new_flags; \
- h->n_buckets = new_n_buckets; \
- h->n_occupied = h->size; \
- h->upper_bound = (khint_t)(h->n_buckets * __ac_HASH_UPPER + 0.5); \
- } \
- return 0; \
- } \
- SCOPE khint_t kh_put_##name(kh_##name##_t *h, khkey_t key, int *ret) \
- { \
- khint_t x; \
- if (h->n_occupied >= h->upper_bound) { /* update the hash table */ \
- if (h->n_buckets > (h->size<<1)) { \
- if (kh_resize_##name(h, h->n_buckets - 1) < 0) { /* clear "deleted" elements */ \
- *ret = -1; return h->n_buckets; \
- } \
- } else if (kh_resize_##name(h, h->n_buckets + 1) < 0) { /* expand the hash table */ \
- *ret = -1; return h->n_buckets; \
- } \
- } /* TODO: to implement automatically shrinking; resize() already support shrinking */ \
- { \
- khint_t k, i, site, last, mask = h->n_buckets - 1, step = 0; \
- x = site = h->n_buckets; k = __hash_func(key); i = k & mask; \
- if (__ac_isempty(h->flags, i)) x = i; /* for speed up */ \
- else { \
- last = i; \
- while (!__ac_isempty(h->flags, i) && (__ac_isdel(h->flags, i) || !__hash_equal(h->keys[i], key))) { \
- if (__ac_isdel(h->flags, i)) site = i; \
- i = (i + (++step)) & mask; \
- if (i == last) { x = site; break; } \
- } \
- if (x == h->n_buckets) { \
- if (__ac_isempty(h->flags, i) && site != h->n_buckets) x = site; \
- else x = i; \
- } \
- } \
- } \
- if (__ac_isempty(h->flags, x)) { /* not present at all */ \
- h->keys[x] = key; \
- __ac_set_isboth_false(h->flags, x); \
- ++h->size; ++h->n_occupied; \
- *ret = 1; \
- } else if (__ac_isdel(h->flags, x)) { /* deleted */ \
- h->keys[x] = key; \
- __ac_set_isboth_false(h->flags, x); \
- ++h->size; \
- *ret = 2; \
- } else *ret = 0; /* Don't touch h->keys[x] if present and not deleted */ \
- return x; \
- } \
- SCOPE void kh_del_##name(kh_##name##_t *h, khint_t x) \
- { \
- if (x != h->n_buckets && !__ac_iseither(h->flags, x)) { \
- __ac_set_isdel_true(h->flags, x); \
- --h->size; \
- } \
- }
-
-#define KHASH_DECLARE(name, khkey_t, khval_t) \
- __KHASH_TYPE(name, khkey_t, khval_t) \
- __KHASH_PROTOTYPES(name, khkey_t, khval_t)
-
-#define KHASH_INIT2(name, SCOPE, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \
- __KHASH_TYPE(name, khkey_t, khval_t) \
- __KHASH_IMPL(name, SCOPE, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal)
-
-#define KHASH_INIT(name, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \
- KHASH_INIT2(name, static kh_inline, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal)
-
-/* --- BEGIN OF HASH FUNCTIONS --- */
-
-/*! @function
- @abstract Integer hash function
- @param key The integer [khint32_t]
- @return The hash value [khint_t]
- */
-#define kh_int_hash_func(key) (khint32_t)(key)
-/*! @function
- @abstract Integer comparison function
- */
-#define kh_int_hash_equal(a, b) ((a) == (b))
-/*! @function
- @abstract 64-bit integer hash function
- @param key The integer [khint64_t]
- @return The hash value [khint_t]
- */
-#define kh_int64_hash_func(key) (khint32_t)((key)>>33^(key)^(key)<<11)
-/*! @function
- @abstract 64-bit integer comparison function
- */
-#define kh_int64_hash_equal(a, b) ((a) == (b))
-/*! @function
- @abstract const char* hash function
- @param s Pointer to a null terminated string
- @return The hash value
- */
-static kh_inline khint_t __ac_X31_hash_string(const char *s)
-{
- khint_t h = (khint_t)*s;
- if (h) for (++s ; *s; ++s) h = (h << 5) - h + (khint_t)*s;
- return h;
-}
-/*! @function
- @abstract Another interface to const char* hash function
- @param key Pointer to a null terminated string [const char*]
- @return The hash value [khint_t]
- */
-#define kh_str_hash_func(key) __ac_X31_hash_string(key)
-/*! @function
- @abstract Const char* comparison function
- */
-#define kh_str_hash_equal(a, b) (strcmp(a, b) == 0)
-
-static kh_inline khint_t __ac_Wang_hash(khint_t key)
-{
- key += ~(key << 15);
- key ^= (key >> 10);
- key += (key << 3);
- key ^= (key >> 6);
- key += ~(key << 11);
- key ^= (key >> 16);
- return key;
-}
-#define kh_int_hash_func2(k) __ac_Wang_hash((khint_t)key)
-
-/* --- END OF HASH FUNCTIONS --- */
-
-/* Other convenient macros... */
-
-/*!
- @abstract Type of the hash table.
- @param name Name of the hash table [symbol]
- */
-#define khash_t(name) kh_##name##_t
-
-/*! @function
- @abstract Initiate a hash table.
- @param name Name of the hash table [symbol]
- @return Pointer to the hash table [khash_t(name)*]
- */
-#define kh_init(name) kh_init_##name()
-
-/*! @function
- @abstract Destroy a hash table.
- @param name Name of the hash table [symbol]
- @param h Pointer to the hash table [khash_t(name)*]
- */
-#define kh_destroy(name, h) kh_destroy_##name(h)
-
-/*! @function
- @abstract Reset a hash table without deallocating memory.
- @param name Name of the hash table [symbol]
- @param h Pointer to the hash table [khash_t(name)*]
- */
-#define kh_clear(name, h) kh_clear_##name(h)
-
-/*! @function
- @abstract Resize a hash table.
- @param name Name of the hash table [symbol]
- @param h Pointer to the hash table [khash_t(name)*]
- @param s New size [khint_t]
- */
-#define kh_resize(name, h, s) kh_resize_##name(h, s)
-
-/*! @function
- @abstract Insert a key to the hash table.
- @param name Name of the hash table [symbol]
- @param h Pointer to the hash table [khash_t(name)*]
- @param k Key [type of keys]
- @param r Extra return code: -1 if the operation failed;
- 0 if the key is present in the hash table;
- 1 if the bucket is empty (never used); 2 if the element in
- the bucket has been deleted [int*]
- @return Iterator to the inserted element [khint_t]
- */
-#define kh_put(name, h, k, r) kh_put_##name(h, k, r)
-
-/*! @function
- @abstract Retrieve a key from the hash table.
- @param name Name of the hash table [symbol]
- @param h Pointer to the hash table [khash_t(name)*]
- @param k Key [type of keys]
- @return Iterator to the found element, or kh_end(h) if the element is absent [khint_t]
- */
-#define kh_get(name, h, k) kh_get_##name(h, k)
-
-/*! @function
- @abstract Remove a key from the hash table.
- @param name Name of the hash table [symbol]
- @param h Pointer to the hash table [khash_t(name)*]
- @param k Iterator to the element to be deleted [khint_t]
- */
-#define kh_del(name, h, k) kh_del_##name(h, k)
-
-/*! @function
- @abstract Test whether a bucket contains data.
- @param h Pointer to the hash table [khash_t(name)*]
- @param x Iterator to the bucket [khint_t]
- @return 1 if containing data; 0 otherwise [int]
- */
-#define kh_exist(h, x) (!__ac_iseither((h)->flags, (x)))
-
-/*! @function
- @abstract Get key given an iterator
- @param h Pointer to the hash table [khash_t(name)*]
- @param x Iterator to the bucket [khint_t]
- @return Key [type of keys]
- */
-#define kh_key(h, x) ((h)->keys[x])
-
-/*! @function
- @abstract Get value given an iterator
- @param h Pointer to the hash table [khash_t(name)*]
- @param x Iterator to the bucket [khint_t]
- @return Value [type of values]
- @discussion For hash sets, calling this results in segfault.
- */
-#define kh_val(h, x) ((h)->vals[x])
-
-/*! @function
- @abstract Alias of kh_val()
- */
-#define kh_value(h, x) ((h)->vals[x])
-
-/*! @function
- @abstract Get the start iterator
- @param h Pointer to the hash table [khash_t(name)*]
- @return The start iterator [khint_t]
- */
-#define kh_begin(h) (khint_t)(0)
-
-/*! @function
- @abstract Get the end iterator
- @param h Pointer to the hash table [khash_t(name)*]
- @return The end iterator [khint_t]
- */
-#define kh_end(h) ((h)->n_buckets)
-
-/*! @function
- @abstract Get the number of elements in the hash table
- @param h Pointer to the hash table [khash_t(name)*]
- @return Number of elements in the hash table [khint_t]
- */
-#define kh_size(h) ((h)->size)
-
-/*! @function
- @abstract Get the number of buckets in the hash table
- @param h Pointer to the hash table [khash_t(name)*]
- @return Number of buckets in the hash table [khint_t]
- */
-#define kh_n_buckets(h) ((h)->n_buckets)
-
-/*! @function
- @abstract Iterate over the entries in the hash table
- @param h Pointer to the hash table [khash_t(name)*]
- @param kvar Variable to which key will be assigned
- @param vvar Variable to which value will be assigned
- @param code Block of code to execute
- */
-#define kh_foreach(h, kvar, vvar, code) { khint_t __i; \
- for (__i = kh_begin(h); __i != kh_end(h); ++__i) { \
- if (!kh_exist(h,__i)) continue; \
- (kvar) = kh_key(h,__i); \
- (vvar) = kh_val(h,__i); \
- code; \
- } }
-
-/*! @function
- @abstract Iterate over the values in the hash table
- @param h Pointer to the hash table [khash_t(name)*]
- @param vvar Variable to which value will be assigned
- @param code Block of code to execute
- */
-#define kh_foreach_value(h, vvar, code) { khint_t __i; \
- for (__i = kh_begin(h); __i != kh_end(h); ++__i) { \
- if (!kh_exist(h,__i)) continue; \
- (vvar) = kh_val(h,__i); \
- code; \
- } }
-
-/* More convenient interfaces */
-
-/*! @function
- @abstract Instantiate a hash set containing integer keys
- @param name Name of the hash table [symbol]
- */
-#define KHASH_SET_INIT_INT(name) \
- KHASH_INIT(name, khint32_t, char, 0, kh_int_hash_func, kh_int_hash_equal)
-
-/*! @function
- @abstract Instantiate a hash map containing integer keys
- @param name Name of the hash table [symbol]
- @param khval_t Type of values [type]
- */
-#define KHASH_MAP_INIT_INT(name, khval_t) \
- KHASH_INIT(name, khint32_t, khval_t, 1, kh_int_hash_func, kh_int_hash_equal)
-
-/*! @function
- @abstract Instantiate a hash map containing 64-bit integer keys
- @param name Name of the hash table [symbol]
- */
-#define KHASH_SET_INIT_INT64(name) \
- KHASH_INIT(name, khint64_t, char, 0, kh_int64_hash_func, kh_int64_hash_equal)
-
-/*! @function
- @abstract Instantiate a hash map containing 64-bit integer keys
- @param name Name of the hash table [symbol]
- @param khval_t Type of values [type]
- */
-#define KHASH_MAP_INIT_INT64(name, khval_t) \
- KHASH_INIT(name, khint64_t, khval_t, 1, kh_int64_hash_func, kh_int64_hash_equal)
-
-typedef const char *kh_cstr_t;
-/*! @function
- @abstract Instantiate a hash map containing const char* keys
- @param name Name of the hash table [symbol]
- */
-#define KHASH_SET_INIT_STR(name) \
- KHASH_INIT(name, kh_cstr_t, char, 0, kh_str_hash_func, kh_str_hash_equal)
-
-/*! @function
- @abstract Instantiate a hash map containing const char* keys
- @param name Name of the hash table [symbol]
- @param khval_t Type of values [type]
- */
-#define KHASH_MAP_INIT_STR(name, khval_t) \
- KHASH_INIT(name, kh_cstr_t, khval_t, 1, kh_str_hash_func, kh_str_hash_equal)
-
-#endif /* __AC_KHASH_H */
diff --git a/src/util/net.c b/src/util/net.c
index ac7befe0738..d7ca48a590c 100644
--- a/src/util/net.c
+++ b/src/util/net.c
@@ -11,7 +11,6 @@
#include "posix.h"
#include "str.h"
-#include "http_parser.h"
#include "runtime.h"
#define DEFAULT_PORT_HTTP "80"
@@ -19,6 +18,80 @@
#define DEFAULT_PORT_GIT "9418"
#define DEFAULT_PORT_SSH "22"
+#define GIT_NET_URL_PARSER_INIT { 0 }
+
+typedef struct {
+ unsigned int hierarchical : 1;
+
+ const char *scheme;
+ const char *user;
+ const char *password;
+ const char *host;
+ const char *port;
+ const char *path;
+ const char *query;
+ const char *fragment;
+
+ size_t scheme_len;
+ size_t user_len;
+ size_t password_len;
+ size_t host_len;
+ size_t port_len;
+ size_t path_len;
+ size_t query_len;
+ size_t fragment_len;
+} git_net_url_parser;
+
+bool git_net_hostname_matches_cert(
+ const char *hostname,
+ const char *pattern)
+{
+ for (;;) {
+ char c = git__tolower(*pattern++);
+
+ if (c == '\0')
+ return *hostname ? false : true;
+
+ if (c == '*') {
+ c = *pattern;
+
+ /* '*' at the end matches everything left */
+ if (c == '\0')
+ return true;
+
+ /*
+ * We've found a pattern, so move towards the
+ * next matching char. The '.' is handled
+ * specially because wildcards aren't allowed
+ * to cross subdomains.
+ */
+ while(*hostname) {
+ char h = git__tolower(*hostname);
+
+ if (h == c)
+ return git_net_hostname_matches_cert(hostname++, pattern);
+ else if (h == '.')
+ return git_net_hostname_matches_cert(hostname, pattern);
+
+ hostname++;
+ }
+
+ return false;
+ }
+
+ if (c != git__tolower(*hostname++))
+ return false;
+ }
+
+ return false;
+}
+
+#define is_valid_scheme_char(c) \
+ (((c) >= 'a' && (c) <= 'z') || \
+ ((c) >= 'A' && (c) <= 'Z') || \
+ ((c) >= '0' && (c) <= '9') || \
+ (c) == '+' || (c) == '-' || (c) == '.')
+
bool git_net_str_is_url(const char *str)
{
const char *c;
@@ -27,10 +100,7 @@ bool git_net_str_is_url(const char *str)
if (*c == ':' && *(c+1) == '/' && *(c+2) == '/')
return true;
- if ((*c < 'a' || *c > 'z') &&
- (*c < 'A' || *c > 'Z') &&
- (*c < '0' || *c > '9') &&
- (*c != '+' && *c != '-' && *c != '.'))
+ if (!is_valid_scheme_char(*c))
break;
}
@@ -53,6 +123,16 @@ static const char *default_port_for_scheme(const char *scheme)
return NULL;
}
+static bool is_ssh_scheme(const char *scheme, size_t scheme_len)
+{
+ if (!scheme_len)
+ return false;
+
+ return strncasecmp(scheme, "ssh", scheme_len) == 0 ||
+ strncasecmp(scheme, "ssh+git", scheme_len) == 0 ||
+ strncasecmp(scheme, "git+ssh", scheme_len) == 0;
+}
+
int git_net_url_dup(git_net_url *out, git_net_url *in)
{
if (in->scheme) {
@@ -100,12 +180,9 @@ static int url_invalid(const char *message)
}
static int url_parse_authority(
- const char **user_start, size_t *user_len,
- const char **password_start, size_t *password_len,
- const char **host_start, size_t *host_len,
- const char **port_start, size_t *port_len,
- const char *authority_start, size_t len,
- const char *scheme_start, size_t scheme_len)
+ git_net_url_parser *parser,
+ const char *authority,
+ size_t len)
{
const char *c, *hostport_end, *host_end = NULL,
*userpass_end, *user_end = NULL;
@@ -121,14 +198,14 @@ static int url_parse_authority(
* walk the authority backwards so that we can parse google code's
* ssh urls that are not rfc compliant and allow @ in the username
*/
- for (hostport_end = authority_start + len, c = hostport_end - 1;
- c >= authority_start && !user_end;
+ for (hostport_end = authority + len, c = hostport_end - 1;
+ c >= authority && !user_end;
c--) {
switch (state) {
case HOSTPORT:
if (*c == ':') {
- *port_start = c + 1;
- *port_len = hostport_end - *port_start;
+ parser->port = c + 1;
+ parser->port_len = hostport_end - parser->port;
host_end = c;
state = HOST;
break;
@@ -156,9 +233,10 @@ static int url_parse_authority(
}
else if (*c == '@') {
- *host_start = c + 1;
- *host_len = host_end ? host_end - *host_start :
- hostport_end - *host_start;
+ parser->host = c + 1;
+ parser->host_len = host_end ?
+ host_end - parser->host :
+ hostport_end - parser->host;
userpass_end = c;
state = USERPASS;
}
@@ -171,8 +249,8 @@ static int url_parse_authority(
case IPV6:
if (*c == '[') {
- *host_start = c + 1;
- *host_len = host_end - *host_start;
+ parser->host = c + 1;
+ parser->host_len = host_end - parser->host;
state = HOST_END;
}
@@ -196,12 +274,12 @@ static int url_parse_authority(
case USERPASS:
if (*c == '@' &&
- strncasecmp(scheme_start, "ssh", scheme_len))
+ !is_ssh_scheme(parser->scheme, parser->scheme_len))
return url_invalid("malformed hostname");
if (*c == ':') {
- *password_start = c + 1;
- *password_len = userpass_end - *password_start;
+ parser->password = c + 1;
+ parser->password_len = userpass_end - parser->password;
user_end = c;
state = USER;
break;
@@ -216,24 +294,24 @@ static int url_parse_authority(
switch (state) {
case HOSTPORT:
- *host_start = authority_start;
- *host_len = (hostport_end - *host_start);
+ parser->host = authority;
+ parser->host_len = (hostport_end - parser->host);
break;
case HOST:
- *host_start = authority_start;
- *host_len = (host_end - *host_start);
+ parser->host = authority;
+ parser->host_len = (host_end - parser->host);
break;
case IPV6:
return url_invalid("malformed hostname");
case HOST_END:
break;
case USERPASS:
- *user_start = authority_start;
- *user_len = (userpass_end - *user_start);
+ parser->user = authority;
+ parser->user_len = (userpass_end - parser->user);
break;
case USER:
- *user_start = authority_start;
- *user_len = (user_end - *user_start);
+ parser->user = authority;
+ parser->user_len = (user_end - parser->user);
break;
default:
GIT_ASSERT(!"unhandled state");
@@ -242,97 +320,30 @@ static int url_parse_authority(
return 0;
}
-int git_net_url_parse(git_net_url *url, const char *given)
+static int url_parse_path(
+ git_net_url_parser *parser,
+ const char *path,
+ size_t len)
{
- const char *c, *scheme_start, *authority_start, *user_start,
- *password_start, *host_start, *port_start, *path_start,
- *query_start, *fragment_start, *default_port;
- git_str scheme = GIT_STR_INIT, user = GIT_STR_INIT,
- password = GIT_STR_INIT, host = GIT_STR_INIT,
- port = GIT_STR_INIT, path = GIT_STR_INIT,
- query = GIT_STR_INIT, fragment = GIT_STR_INIT;
- size_t scheme_len = 0, user_len = 0, password_len = 0, host_len = 0,
- port_len = 0, path_len = 0, query_len = 0, fragment_len = 0;
- bool hierarchical = false;
- int error = 0;
+ const char *c, *end;
- enum {
- SCHEME,
- AUTHORITY_START, AUTHORITY,
- PATH_START, PATH,
- QUERY,
- FRAGMENT
- } state = SCHEME;
+ enum { PATH, QUERY, FRAGMENT } state = PATH;
- memset(url, 0, sizeof(git_net_url));
+ parser->path = path;
+ end = path + len;
- for (c = scheme_start = given; *c; c++) {
+ for (c = path; c < end; c++) {
switch (state) {
- case SCHEME:
- if (*c == ':') {
- scheme_len = (c - scheme_start);
-
- if (*(c+1) == '/' && *(c+2) == '/') {
- c += 2;
- hierarchical = true;
- state = AUTHORITY_START;
- } else {
- state = PATH_START;
- }
- } else if ((*c < 'A' || *c > 'Z') &&
- (*c < 'a' || *c > 'z') &&
- (*c < '0' || *c > '9') &&
- (*c != '+' && *c != '-' && *c != '.')) {
- /*
- * an illegal scheme character means that we
- * were just given a relative path
- */
- path_start = given;
- state = PATH;
- break;
- }
- break;
-
- case AUTHORITY_START:
- authority_start = c;
- state = AUTHORITY;
-
- /* fall through */
-
- case AUTHORITY:
- if (*c != '/')
- break;
-
- /*
- * authority is sufficiently complex that we parse
- * it separately
- */
- if ((error = url_parse_authority(
- &user_start, &user_len,
- &password_start,&password_len,
- &host_start, &host_len,
- &port_start, &port_len,
- authority_start, (c - authority_start),
- scheme_start, scheme_len)) < 0)
- goto done;
-
- /* fall through */
-
- case PATH_START:
- path_start = c;
- state = PATH;
- /* fall through */
-
case PATH:
switch (*c) {
case '?':
- path_len = (c - path_start);
- query_start = c + 1;
+ parser->path_len = (c - parser->path);
+ parser->query = c + 1;
state = QUERY;
break;
case '#':
- path_len = (c - path_start);
- fragment_start = c + 1;
+ parser->path_len = (c - parser->path);
+ parser->fragment = c + 1;
state = FRAGMENT;
break;
}
@@ -340,8 +351,8 @@ int git_net_url_parse(git_net_url *url, const char *given)
case QUERY:
if (*c == '#') {
- query_len = (c - query_start);
- fragment_start = c + 1;
+ parser->query_len = (c - parser->query);
+ parser->fragment = c + 1;
state = FRAGMENT;
}
break;
@@ -355,82 +366,74 @@ int git_net_url_parse(git_net_url *url, const char *given)
}
switch (state) {
- case SCHEME:
- /*
- * if we never saw a ':' then we were given a relative
- * path, not a bare scheme
- */
- path_start = given;
- path_len = (c - scheme_start);
- break;
- case AUTHORITY_START:
- break;
- case AUTHORITY:
- if ((error = url_parse_authority(
- &user_start, &user_len,
- &password_start,&password_len,
- &host_start, &host_len,
- &port_start, &port_len,
- authority_start, (c - authority_start),
- scheme_start, scheme_len)) < 0)
- goto done;
- break;
- case PATH_START:
- break;
case PATH:
- path_len = (c - path_start);
+ parser->path_len = (c - parser->path);
break;
case QUERY:
- query_len = (c - query_start);
+ parser->query_len = (c - parser->query);
break;
case FRAGMENT:
- fragment_len = (c - fragment_start);
+ parser->fragment_len = (c - parser->fragment);
break;
- default:
- GIT_ASSERT(!"unhandled state");
}
- if (scheme_len) {
- if ((error = git_str_put(&scheme, scheme_start, scheme_len)) < 0)
+ return 0;
+}
+
+static int url_parse_finalize(git_net_url *url, git_net_url_parser *parser)
+{
+ git_str scheme = GIT_STR_INIT, user = GIT_STR_INIT,
+ password = GIT_STR_INIT, host = GIT_STR_INIT,
+ port = GIT_STR_INIT, path = GIT_STR_INIT,
+ query = GIT_STR_INIT, fragment = GIT_STR_INIT;
+ const char *default_port;
+ int port_specified = 0;
+ int error = 0;
+
+ if (parser->scheme_len) {
+ if ((error = git_str_put(&scheme, parser->scheme, parser->scheme_len)) < 0)
goto done;
git__strntolower(scheme.ptr, scheme.size);
}
- if (user_len &&
- (error = git_str_decode_percent(&user, user_start, user_len)) < 0)
+ if (parser->user_len &&
+ (error = git_str_decode_percent(&user, parser->user, parser->user_len)) < 0)
goto done;
- if (password_len &&
- (error = git_str_decode_percent(&password, password_start, password_len)) < 0)
+ if (parser->password_len &&
+ (error = git_str_decode_percent(&password, parser->password, parser->password_len)) < 0)
goto done;
- if (host_len &&
- (error = git_str_decode_percent(&host, host_start, host_len)) < 0)
+ if (parser->host_len &&
+ (error = git_str_decode_percent(&host, parser->host, parser->host_len)) < 0)
goto done;
- if (port_len)
- error = git_str_put(&port, port_start, port_len);
- else if (scheme_len && (default_port = default_port_for_scheme(scheme.ptr)) != NULL)
+ if (parser->port_len) {
+ port_specified = 1;
+ error = git_str_put(&port, parser->port, parser->port_len);
+ } else if (parser->scheme_len &&
+ (default_port = default_port_for_scheme(scheme.ptr)) != NULL) {
error = git_str_puts(&port, default_port);
+ }
if (error < 0)
goto done;
- if (path_len)
- error = git_str_put(&path, path_start, path_len);
- else if (hierarchical)
+ if (parser->path_len)
+ error = git_str_put(&path, parser->path, parser->path_len);
+ else if (parser->hierarchical)
error = git_str_puts(&path, "/");
if (error < 0)
goto done;
- if (query_len &&
- (error = git_str_decode_percent(&query, query_start, query_len)) < 0)
+ if (parser->query_len &&
+ (error = git_str_decode_percent(&query, parser->query, parser->query_len)) < 0)
goto done;
- if (fragment_len &&
- (error = git_str_decode_percent(&fragment, fragment_start, fragment_len)) < 0)
+ if (parser->fragment_len &&
+ (error = git_str_decode_percent(&fragment, parser->fragment, parser->fragment_len)) < 0)
goto done;
url->scheme = git_str_detach(&scheme);
@@ -441,6 +444,7 @@ int git_net_url_parse(git_net_url *url, const char *given)
url->fragment = git_str_detach(&fragment);
url->username = git_str_detach(&user);
url->password = git_str_detach(&password);
+ url->port_specified = port_specified;
error = 0;
@@ -457,6 +461,157 @@ int git_net_url_parse(git_net_url *url, const char *given)
return error;
}
+int git_net_url_parse(git_net_url *url, const char *given)
+{
+ git_net_url_parser parser = GIT_NET_URL_PARSER_INIT;
+ const char *c, *authority, *path;
+ size_t authority_len = 0, path_len = 0;
+ int error = 0;
+
+ enum {
+ SCHEME_START, SCHEME,
+ AUTHORITY_START, AUTHORITY,
+ PATH_START, PATH
+ } state = SCHEME_START;
+
+ memset(url, 0, sizeof(git_net_url));
+
+ for (c = given; *c; c++) {
+ switch (state) {
+ case SCHEME_START:
+ parser.scheme = c;
+ state = SCHEME;
+
+ /* fall through */
+
+ case SCHEME:
+ if (*c == ':') {
+ parser.scheme_len = (c - parser.scheme);
+
+ if (parser.scheme_len &&
+ *(c+1) == '/' && *(c+2) == '/') {
+ c += 2;
+ parser.hierarchical = 1;
+ state = AUTHORITY_START;
+ } else {
+ state = PATH_START;
+ }
+ } else if (!is_valid_scheme_char(*c)) {
+ /*
+ * an illegal scheme character means that we
+ * were just given a relative path
+ */
+ path = given;
+ state = PATH;
+ break;
+ }
+ break;
+
+ case AUTHORITY_START:
+ authority = c;
+ state = AUTHORITY;
+
+ /* fall through */
+ case AUTHORITY:
+ if (*c != '/')
+ break;
+
+ authority_len = (c - authority);
+
+ /* fall through */
+ case PATH_START:
+ path = c;
+ state = PATH;
+ break;
+
+ case PATH:
+ break;
+
+ default:
+ GIT_ASSERT(!"unhandled state");
+ }
+ }
+
+ switch (state) {
+ case SCHEME:
+ /*
+ * if we never saw a ':' then we were given a relative
+ * path, not a bare scheme
+ */
+ path = given;
+ path_len = (c - path);
+ break;
+ case AUTHORITY_START:
+ break;
+ case AUTHORITY:
+ authority_len = (c - authority);
+ break;
+ case PATH_START:
+ break;
+ case PATH:
+ path_len = (c - path);
+ break;
+ default:
+ GIT_ASSERT(!"unhandled state");
+ }
+
+ if (authority_len &&
+ (error = url_parse_authority(&parser, authority, authority_len)) < 0)
+ goto done;
+
+ if (path_len &&
+ (error = url_parse_path(&parser, path, path_len)) < 0)
+ goto done;
+
+ error = url_parse_finalize(url, &parser);
+
+done:
+ return error;
+}
+
+int git_net_url_parse_http(
+ git_net_url *url,
+ const char *given)
+{
+ git_net_url_parser parser = GIT_NET_URL_PARSER_INIT;
+ const char *c, *authority, *path = NULL;
+ size_t authority_len = 0, path_len = 0;
+ int error;
+
+ /* Hopefully this is a proper URL with a scheme. */
+ if (git_net_str_is_url(given))
+ return git_net_url_parse(url, given);
+
+ memset(url, 0, sizeof(git_net_url));
+
+ /* Without a scheme, we are in the host (authority) section. */
+ for (c = authority = given; *c; c++) {
+ if (!path && *c == '/') {
+ authority_len = (c - authority);
+ path = c;
+ }
+ }
+
+ if (path)
+ path_len = (c - path);
+ else
+ authority_len = (c - authority);
+
+ parser.scheme = "http";
+ parser.scheme_len = 4;
+ parser.hierarchical = 1;
+
+ if (authority_len &&
+ (error = url_parse_authority(&parser, authority, authority_len)) < 0)
+ return error;
+
+ if (path_len &&
+ (error = url_parse_path(&parser, path, path_len)) < 0)
+ return error;
+
+ return url_parse_finalize(url, &parser);
+}
+
static int scp_invalid(const char *message)
{
git_error_set(GIT_ERROR_NET, "invalid scp-style path: %s", message);
@@ -506,7 +661,7 @@ static bool has_at(const char *str)
int git_net_url_parse_scp(git_net_url *url, const char *given)
{
const char *default_port = default_port_for_scheme("ssh");
- const char *c, *user, *host, *port, *path = NULL;
+ const char *c, *user, *host, *port = NULL, *path = NULL;
size_t user_len = 0, host_len = 0, port_len = 0;
unsigned short bracket = 0;
@@ -635,10 +790,12 @@ int git_net_url_parse_scp(git_net_url *url, const char *given)
GIT_ASSERT(host_len);
GIT_ERROR_CHECK_ALLOC(url->host = git__strndup(host, host_len));
- if (port_len)
+ if (port_len) {
+ url->port_specified = 1;
GIT_ERROR_CHECK_ALLOC(url->port = git__strndup(port, port_len));
- else
+ } else {
GIT_ERROR_CHECK_ALLOC(url->port = git__strdup(default_port));
+ }
GIT_ASSERT(path);
GIT_ERROR_CHECK_ALLOC(url->path = git__strdup(path));
diff --git a/src/util/net.h b/src/util/net.h
index 17f0bc4f079..360a55db493 100644
--- a/src/util/net.h
+++ b/src/util/net.h
@@ -9,6 +9,23 @@
#include "git2_util.h"
+/*
+ * Hostname handling
+ */
+
+/*
+ * See if a given hostname matches a certificate name pattern, according
+ * to RFC2818 rules (which specifies HTTP over TLS). Mainly, an asterisk
+ * matches anything, but is limited to a single url component.
+ */
+extern bool git_net_hostname_matches_cert(
+ const char *hostname,
+ const char *pattern);
+
+/*
+ * URL handling
+ */
+
typedef struct git_net_url {
char *scheme;
char *host;
@@ -18,6 +35,8 @@ typedef struct git_net_url {
char *fragment;
char *username;
char *password;
+
+ unsigned int port_specified;
} git_net_url;
#define GIT_NET_URL_INIT { NULL }
@@ -40,6 +59,14 @@ extern int git_net_url_parse_scp(git_net_url *url, const char *str);
*/
extern int git_net_url_parse_standard_or_scp(git_net_url *url, const char *str);
+/**
+ * Parses a string containing an HTTP endpoint that may not be a
+ * well-formed URL. For example, "localhost" or "localhost:port".
+ */
+extern int git_net_url_parse_http(
+ git_net_url *url,
+ const char *str);
+
/** Appends a path and/or query string to the given URL */
extern int git_net_url_joinpath(
git_net_url *out,
diff --git a/src/util/pool.c b/src/util/pool.c
index 16ffa398d65..afbae452a7b 100644
--- a/src/util/pool.c
+++ b/src/util/pool.c
@@ -144,7 +144,7 @@ int git_pool_init(git_pool *pool, size_t item_size)
void git_pool_clear(git_pool *pool)
{
- git_vector_free_deep(&pool->allocations);
+ git_vector_dispose_deep(&pool->allocations);
}
static void *pool_alloc(git_pool *pool, size_t size) {
diff --git a/src/util/pool.h b/src/util/pool.h
index 0238431b0a0..75a28c3babc 100644
--- a/src/util/pool.h
+++ b/src/util/pool.h
@@ -83,6 +83,11 @@ typedef struct {
*/
extern int git_pool_init(git_pool *pool, size_t item_size);
+GIT_INLINE(bool) git_pool_is_initialized(git_pool *pool)
+{
+ return (pool->item_size > 0);
+}
+
/**
* Free all items in pool
*/
diff --git a/src/util/posix.c b/src/util/posix.c
index b1f85dc9412..cfc0e0751be 100644
--- a/src/util/posix.c
+++ b/src/util/posix.c
@@ -301,3 +301,57 @@ int p_munmap(git_map *map)
}
#endif
+
+#if defined(GIT_IO_POLL) || defined(GIT_IO_WSAPOLL)
+
+/* Handled by posix.h; this test simplifies the final else */
+
+#elif defined(GIT_IO_SELECT)
+
+int p_poll(struct pollfd *fds, unsigned int nfds, int timeout_ms)
+{
+ fd_set read_fds, write_fds, except_fds;
+ struct timeval timeout = { 0, 0 };
+ unsigned int i;
+ int max_fd = -1, ret;
+
+ FD_ZERO(&read_fds);
+ FD_ZERO(&write_fds);
+ FD_ZERO(&except_fds);
+
+ for (i = 0; i < nfds; i++) {
+ if ((fds[i].events & POLLIN))
+ FD_SET(fds[i].fd, &read_fds);
+
+ if ((fds[i].events & POLLOUT))
+ FD_SET(fds[i].fd, &write_fds);
+
+ if ((fds[i].events & POLLPRI))
+ FD_SET(fds[i].fd, &except_fds);
+
+ max_fd = MAX(max_fd, fds[i].fd);
+ }
+
+ if (timeout_ms > 0) {
+ timeout.tv_sec = timeout_ms / 1000;
+ timeout.tv_usec = (timeout_ms % 1000) * 1000;
+ }
+
+ if ((ret = select(max_fd + 1, &read_fds, &write_fds, &except_fds,
+ timeout_ms < 0 ? NULL : &timeout)) < 0)
+ goto done;
+
+ for (i = 0; i < nfds; i++) {
+ fds[i].revents = 0 |
+ FD_ISSET(fds[i].fd, &read_fds) ? POLLIN : 0 |
+ FD_ISSET(fds[i].fd, &write_fds) ? POLLOUT : 0 |
+ FD_ISSET(fds[i].fd, &except_fds) ? POLLPRI : 0;
+ }
+
+done:
+ return ret;
+}
+
+#else
+# error no poll compatible implementation
+#endif
diff --git a/src/util/posix.h b/src/util/posix.h
index 607aa9dceb3..74707453a6d 100644
--- a/src/util/posix.h
+++ b/src/util/posix.h
@@ -195,4 +195,26 @@ extern const char *p_gai_strerror(int ret);
# define p_gai_strerror(c) gai_strerror(c)
#endif /* NO_ADDRINFO */
+#ifdef GIT_IO_POLL
+# include
+# define p_poll poll
+#elif GIT_IO_WSAPOLL
+# include
+# define p_poll WSAPoll
+#else
+# define POLLIN 0x01
+# define POLLPRI 0x02
+# define POLLOUT 0x04
+# define POLLERR 0x08
+# define POLLHUP 0x10
+
+struct pollfd {
+ int fd;
+ short events;
+ short revents;
+};
+
+extern int p_poll(struct pollfd *fds, unsigned int nfds, int timeout);
+#endif
+
#endif
diff --git a/src/util/pqueue.h b/src/util/pqueue.h
index 97232b4a9fd..a8ef018454e 100644
--- a/src/util/pqueue.h
+++ b/src/util/pqueue.h
@@ -33,7 +33,7 @@ extern int git_pqueue_init(
size_t init_size,
git_vector_cmp cmp);
-#define git_pqueue_free git_vector_free
+#define git_pqueue_free git_vector_dispose
#define git_pqueue_clear git_vector_clear
#define git_pqueue_size git_vector_length
#define git_pqueue_get git_vector_get
diff --git a/src/util/process.h b/src/util/process.h
new file mode 100644
index 00000000000..3ada6696d22
--- /dev/null
+++ b/src/util/process.h
@@ -0,0 +1,222 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#ifndef INCLUDE_process_h__
+#define INCLUDE_process_h__
+
+typedef struct git_process git_process;
+
+typedef struct {
+ unsigned int capture_in : 1,
+ capture_out : 1,
+ capture_err : 1,
+ exclude_env : 1;
+
+ char *cwd;
+} git_process_options;
+
+typedef enum {
+ GIT_PROCESS_STATUS_NONE,
+ GIT_PROCESS_STATUS_NORMAL,
+ GIT_PROCESS_STATUS_ERROR
+} git_process_result_status;
+
+#define GIT_PROCESS_RESULT_INIT { GIT_PROCESS_STATUS_NONE }
+
+typedef struct {
+ git_process_result_status status;
+ int exitcode;
+ int signal;
+} git_process_result;
+
+#define GIT_PROCESS_OPTIONS_INIT { 0 }
+
+#ifdef GIT_WIN32
+# define p_pid_t DWORD
+#else
+# define p_pid_t pid_t
+#endif
+
+/**
+ * Create a new process. The command to run should be specified as the
+ * element of the `arg` array, execv-style. This should be the full path
+ * to the command to run, the PATH is not obeyed.
+ *
+ * This function will add the given environment variables (in `env`)
+ * to the current environment. Operations on environment variables
+ * are not thread safe, so you may not modify the environment during
+ * this call. You can avoid this by setting `exclude_env` in the
+ * options and providing the entire environment yourself.
+ *
+ * @param out location to store the process
+ * @param args the command (with arguments) to run
+ * @param args_len the length of the args array
+ * @param env environment variables to add (or NULL)
+ * @param env_len the length of the env len
+ * @param opts the options for creating the process
+ * @return 0 or an error code
+ */
+extern int git_process_new(
+ git_process **out,
+ const char **args,
+ size_t args_len,
+ const char **env,
+ size_t env_len,
+ git_process_options *opts);
+
+/**
+ * Create a new process. The command to run should be specified as the
+ * `cmdline` option - which is the full text of the command line as it
+ * would be specified or run by a user. The command to run will be
+ * looked up in the PATH.
+ *
+ * On Unix, this will be executed by the system's shell (`/bin/sh`)
+ * and may contain _Bourne-style_ shell quoting rules. On Windows,
+ * this will be passed to `CreateProcess`, and similarly, may
+ * contain _Windows-style_ shell quoting rules.
+ *
+ * This function will add the given environment variables (in `env`)
+ * to the current environment. Operations on environment variables
+ * are not thread safe, so you may not modify the environment during
+ * this call. You can avoid this by setting `exclude_env` in the
+ * options and providing the entire environment yourself.
+ */
+extern int git_process_new_from_cmdline(
+ git_process **out,
+ const char *cmdline,
+ const char **env,
+ size_t env_len,
+ git_process_options *opts);
+
+#ifdef GIT_WIN32
+
+extern int git_process__appname(
+ git_str *out,
+ const char *cmdline);
+
+/* Windows path parsing is tricky; this helper function is for testing. */
+extern int git_process__cmdline(
+ git_str *out,
+ const char **in,
+ size_t in_len);
+
+#endif
+
+/*
+ * Whether the given string looks like a command line option (starts
+ * with a dash). This is useful for examining strings that will become
+ * cmdline arguments to ensure that they are not erroneously treated
+ * as an option. For example, arguments to `ssh`.
+ */
+GIT_INLINE(bool) git_process__is_cmdline_option(const char *str)
+{
+ return (str && str[0] == '-');
+}
+
+/**
+ * Start the process.
+ *
+ * @param process the process to start
+ * @return 0 or an error code
+ */
+extern int git_process_start(git_process *process);
+
+/**
+ * Returns the process id of the process.
+ *
+ * @param out pointer to a pid_t to store the process id
+ * @param process the process to query
+ * @return 0 or an error code
+ */
+extern int git_process_id(p_pid_t *out, git_process *process);
+
+/**
+ * Read from the process's stdout. The process must have been created with
+ * `capture_out` set to true.
+ *
+ * @param process the process to read from
+ * @param buf the buf to read into
+ * @param count maximum number of bytes to read
+ * @return number of bytes read or an error code
+ */
+extern ssize_t git_process_read(git_process *process, void *buf, size_t count);
+
+/**
+ * Read from the process's stderr. The process must have been created with
+ * `capture_err` set to true.
+ *
+ * @param process the process to read from
+ * @param buf the buf to read into
+ * @param count maximum number of bytes to read
+ * @return number of bytes read or an error code
+ */
+extern ssize_t git_process_read_err(git_process *process, void *buf, size_t count);
+
+/**
+ * Write to the process's stdin. The process must have been created with
+ * `capture_in` set to true.
+ *
+ * @param process the process to write to
+ * @param buf the buf to write
+ * @param count maximum number of bytes to write
+ * @return number of bytes written or an error code
+ */
+extern ssize_t git_process_write(git_process *process, const void *buf, size_t count);
+
+/**
+ * Wait for the process to finish.
+ *
+ * @param result the result of the process or NULL
+ * @param process the process to wait on
+ */
+extern int git_process_wait(git_process_result *result, git_process *process);
+
+/**
+ * Close the input pipe from the child.
+ *
+ * @param process the process to close the pipe on
+ */
+extern int git_process_close_in(git_process *process);
+
+/**
+ * Close the output pipe from the child.
+ *
+ * @param process the process to close the pipe on
+ */
+extern int git_process_close_out(git_process *process);
+
+/**
+ * Close the error pipe from the child.
+ *
+ * @param process the process to close the pipe on
+ */
+extern int git_process_close_err(git_process *process);
+
+/**
+ * Close all resources that are used by the process. This does not
+ * wait for the process to complete.
+ *
+ * @parma process the process to close
+ */
+extern int git_process_close(git_process *process);
+
+/**
+ * Place a human-readable error message in the given git buffer.
+ *
+ * @param msg the buffer to store the message
+ * @param result the process result that produced an error
+ */
+extern int git_process_result_msg(git_str *msg, git_process_result *result);
+
+/**
+ * Free a process structure
+ *
+ * @param process the process to free
+ */
+extern void git_process_free(git_process *process);
+
+#endif
diff --git a/src/util/rand.c b/src/util/rand.c
index 940faf94796..2b137a57b56 100644
--- a/src/util/rand.c
+++ b/src/util/rand.c
@@ -10,10 +10,6 @@ See
-#endif
-
#if defined(GIT_WIN32)
# include
#endif
@@ -32,7 +28,6 @@ GIT_INLINE(int) getseed(uint64_t *seed)
HCRYPTPROV provider;
SYSTEMTIME systemtime;
FILETIME filetime, idletime, kerneltime, usertime;
- bits convert;
if (CryptAcquireContext(&provider, 0, 0, PROV_RSA_FULL,
CRYPT_VERIFYCONTEXT|CRYPT_SILENT)) {
@@ -67,7 +62,7 @@ GIT_INLINE(int) getseed(uint64_t *seed)
*seed ^= ((uint64_t)GetCurrentProcessId() << 32);
*seed ^= ((uint64_t)GetCurrentThreadId() << 48);
- convert.f = git__timer(); *seed ^= (convert.d);
+ *seed ^= git_time_monotonic();
/* Mix in the addresses of some functions and variables */
*seed ^= (((uint64_t)((uintptr_t)seed) << 32));
@@ -81,9 +76,12 @@ GIT_INLINE(int) getseed(uint64_t *seed)
GIT_INLINE(int) getseed(uint64_t *seed)
{
struct timeval tv;
+ int fd;
+
+# if defined(GIT_RAND_GETLOADAVG)
double loadavg[3];
bits convert;
- int fd;
+# endif
# if defined(GIT_RAND_GETENTROPY)
GIT_UNUSED((fd = 0));
@@ -127,11 +125,9 @@ GIT_INLINE(int) getseed(uint64_t *seed)
convert.f = loadavg[0]; *seed ^= (convert.d >> 36);
convert.f = loadavg[1]; *seed ^= (convert.d);
convert.f = loadavg[2]; *seed ^= (convert.d >> 16);
-# else
- GIT_UNUSED(loadavg[0]);
# endif
- convert.f = git__timer(); *seed ^= (convert.d);
+ *seed ^= git_time_monotonic();
/* Mix in the addresses of some variables */
*seed ^= ((uint64_t)((size_t)((void *)seed)) << 32);
diff --git a/src/util/regexp.c b/src/util/regexp.c
index 08700882bc3..eb45822474d 100644
--- a/src/util/regexp.c
+++ b/src/util/regexp.c
@@ -125,7 +125,7 @@ int git_regexp_search(const git_regexp *r, const char *string, size_t nmatches,
if ((data = pcre2_match_data_create(nmatches, NULL)) == NULL) {
git_error_set_oom();
- goto out;
+ return -1;
}
if ((error = pcre2_match(*r, (const unsigned char *) string, strlen(string),
diff --git a/src/util/sortedcache.c b/src/util/sortedcache.c
index 7ff900efe33..05b94347267 100644
--- a/src/util/sortedcache.c
+++ b/src/util/sortedcache.c
@@ -6,6 +6,7 @@
*/
#include "sortedcache.h"
+#include "hashmap.h"
int git_sortedcache_new(
git_sortedcache **out,
@@ -26,8 +27,7 @@ int git_sortedcache_new(
GIT_ERROR_CHECK_ALLOC(sc);
if (git_pool_init(&sc->pool, 1) < 0 ||
- git_vector_init(&sc->items, 4, item_cmp) < 0 ||
- git_strmap_new(&sc->map) < 0)
+ git_vector_init(&sc->items, 4, item_cmp) < 0)
goto fail;
if (git_rwlock_init(&sc->lock)) {
@@ -46,8 +46,7 @@ int git_sortedcache_new(
return 0;
fail:
- git_strmap_free(sc->map);
- git_vector_free(&sc->items);
+ git_vector_dispose(&sc->items);
git_pool_clear(&sc->pool);
git__free(sc);
return -1;
@@ -65,7 +64,7 @@ const char *git_sortedcache_path(git_sortedcache *sc)
static void sortedcache_clear(git_sortedcache *sc)
{
- git_strmap_clear(sc->map);
+ git_hashmap_str_clear(&sc->map);
if (sc->free_item) {
size_t i;
@@ -88,8 +87,8 @@ static void sortedcache_free(git_sortedcache *sc)
return;
sortedcache_clear(sc);
- git_vector_free(&sc->items);
- git_strmap_free(sc->map);
+ git_vector_dispose(&sc->items);
+ git_hashmap_str_dispose(&sc->map);
git_sortedcache_wunlock(sc);
@@ -274,7 +273,7 @@ int git_sortedcache_upsert(void **out, git_sortedcache *sc, const char *key)
char *item_key;
void *item;
- if ((item = git_strmap_get(sc->map, key)) != NULL)
+ if (git_hashmap_str_get(&item, &sc->map, key) == 0)
goto done;
keylen = strlen(key);
@@ -294,11 +293,11 @@ int git_sortedcache_upsert(void **out, git_sortedcache *sc, const char *key)
item_key = ((char *)item) + sc->item_path_offset;
memcpy(item_key, key, keylen);
- if ((error = git_strmap_set(sc->map, item_key, item)) < 0)
+ if ((error = git_hashmap_str_put(&sc->map, item_key, item)) < 0)
goto done;
if ((error = git_vector_insert(&sc->items, item)) < 0)
- git_strmap_delete(sc->map, item_key);
+ git_hashmap_str_remove(&sc->map, item_key);
done:
if (out)
@@ -307,9 +306,11 @@ int git_sortedcache_upsert(void **out, git_sortedcache *sc, const char *key)
}
/* lookup item by key */
-void *git_sortedcache_lookup(const git_sortedcache *sc, const char *key)
+void *git_sortedcache_lookup(git_sortedcache *sc, const char *key)
{
- return git_strmap_get(sc->map, key);
+ void *value;
+
+ return git_hashmap_str_get(&value, &sc->map, key) == 0 ? value : NULL;
}
/* find out how many items are in the cache */
@@ -370,7 +371,7 @@ int git_sortedcache_remove(git_sortedcache *sc, size_t pos)
(void)git_vector_remove(&sc->items, pos);
- git_strmap_delete(sc->map, item + sc->item_path_offset);
+ git_hashmap_str_remove(&sc->map, item + sc->item_path_offset);
if (sc->free_item)
sc->free_item(sc->free_item_payload, item);
diff --git a/src/util/sortedcache.h b/src/util/sortedcache.h
index 3eee4659f58..d4383e96517 100644
--- a/src/util/sortedcache.h
+++ b/src/util/sortedcache.h
@@ -14,7 +14,7 @@
#include "vector.h"
#include "thread.h"
#include "pool.h"
-#include "strmap.h"
+#include "hashmap_str.h"
#include
@@ -36,7 +36,7 @@ typedef struct {
void *free_item_payload;
git_pool pool;
git_vector items;
- git_strmap *map;
+ git_hashmap_str map;
git_futils_filestamp stamp;
char path[GIT_FLEX_ARRAY];
} git_sortedcache;
@@ -163,7 +163,7 @@ GIT_WARN_UNUSED_RESULT int git_sortedcache_rlock(git_sortedcache *sc);
void git_sortedcache_runlock(git_sortedcache *sc);
/* Lookup item by key - returns NULL if not found */
-void *git_sortedcache_lookup(const git_sortedcache *sc, const char *key);
+void *git_sortedcache_lookup(git_sortedcache *sc, const char *key);
/* Get how many items are in the cache
*
diff --git a/src/util/staticstr.h b/src/util/staticstr.h
new file mode 100644
index 00000000000..b7d0790c4fd
--- /dev/null
+++ b/src/util/staticstr.h
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_stackstr_h__
+#define INCLUDE_stackstr_h__
+
+#include "git2_util.h"
+
+typedef struct {
+ /* Length of / number of bytes used by `data`. */
+ size_t len;
+
+ /* Size of the allocated `data` buffer. */
+ size_t size;
+
+ /* The actual string buffer data. */
+ char data[GIT_FLEX_ARRAY];
+} git_staticstr;
+
+#define git_staticstr_with_size(__size) \
+ struct { \
+ size_t len; \
+ size_t size; \
+ char data[__size]; \
+ }
+
+#define git_staticstr_init(__str, __size) \
+ do { \
+ (__str)->len = 0; \
+ (__str)->size = __size; \
+ (__str)->data[0] = '\0'; \
+ } while(0)
+
+#define git_staticstr_offset(__str) \
+ ((__str)->data + (__str)->len)
+
+#define git_staticstr_remain(__str) \
+ ((__str)->len > (__str)->size ? 0 : ((__str)->size - (__str)->len))
+
+#define git_staticstr_increase(__str, __len) \
+ do { ((__str)->len += __len); } while(0)
+
+#define git_staticstr_consume_bytes(__str, __len) \
+ do { git_staticstr_consume(__str, (__str)->data + __len); } while(0)
+
+#define git_staticstr_consume(__str, __end) \
+ do { \
+ if (__end > (__str)->data && \
+ __end <= (__str)->data + (__str)->len) { \
+ size_t __consumed = __end - (__str)->data; \
+ memmove((__str)->data, __end, (__str)->len - __consumed); \
+ (__str)->len -= __consumed; \
+ (__str)->data[(__str)->len] = '\0'; \
+ } \
+ } while(0)
+
+#define git_staticstr_clear(__str) \
+ do { \
+ (__str)->len = 0; \
+ (__str)->data[0] = 0; \
+ } while(0)
+
+#endif
diff --git a/src/util/str.c b/src/util/str.c
index 0d405bfda50..0b07c814702 100644
--- a/src/util/str.c
+++ b/src/util/str.c
@@ -485,8 +485,8 @@ int git_str_decode_percent(
for (str_pos = 0; str_pos < str_len; buf->size++, str_pos++) {
if (str[str_pos] == '%' &&
str_len > str_pos + 2 &&
- isxdigit(str[str_pos + 1]) &&
- isxdigit(str[str_pos + 2])) {
+ git__isxdigit(str[str_pos + 1]) &&
+ git__isxdigit(str[str_pos + 2])) {
buf->ptr[buf->size] = (HEX_DECODE(str[str_pos + 1]) << 4) +
HEX_DECODE(str[str_pos + 2]);
str_pos += 2;
diff --git a/src/util/strlist.c b/src/util/strlist.c
new file mode 100644
index 00000000000..df5640c2a1f
--- /dev/null
+++ b/src/util/strlist.c
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include
+
+#include "git2_util.h"
+#include "vector.h"
+#include "strlist.h"
+
+int git_strlist_copy(char ***out, const char **in, size_t len)
+{
+ char **dup;
+ size_t i;
+
+ dup = git__calloc(len, sizeof(char *));
+ GIT_ERROR_CHECK_ALLOC(dup);
+
+ for (i = 0; i < len; i++) {
+ dup[i] = git__strdup(in[i]);
+ GIT_ERROR_CHECK_ALLOC(dup[i]);
+ }
+
+ *out = dup;
+ return 0;
+}
+
+int git_strlist_copy_with_null(char ***out, const char **in, size_t len)
+{
+ char **dup;
+ size_t new_len, i;
+
+ GIT_ERROR_CHECK_ALLOC_ADD(&new_len, len, 1);
+
+ dup = git__calloc(new_len, sizeof(char *));
+ GIT_ERROR_CHECK_ALLOC(dup);
+
+ for (i = 0; i < len; i++) {
+ dup[i] = git__strdup(in[i]);
+ GIT_ERROR_CHECK_ALLOC(dup[i]);
+ }
+
+ *out = dup;
+ return 0;
+}
+
+bool git_strlist_contains_prefix(
+ const char **strings,
+ size_t len,
+ const char *str,
+ size_t n)
+{
+ size_t i;
+
+ for (i = 0; i < len; i++) {
+ if (strncmp(strings[i], str, n) == 0)
+ return true;
+ }
+
+ return false;
+}
+
+bool git_strlist_contains_key(
+ const char **strings,
+ size_t len,
+ const char *key,
+ char delimiter)
+{
+ const char *c;
+
+ for (c = key; *c; c++) {
+ if (*c == delimiter)
+ break;
+ }
+
+ return *c ?
+ git_strlist_contains_prefix(strings, len, key, (c - key)) :
+ false;
+}
+
+void git_strlist_free(char **strings, size_t len)
+{
+ size_t i;
+
+ if (!strings)
+ return;
+
+ for (i = 0; i < len; i++)
+ git__free(strings[i]);
+
+ git__free(strings);
+}
+
+void git_strlist_free_with_null(char **strings)
+{
+ char **s;
+
+ if (!strings)
+ return;
+
+ for (s = strings; *s; s++)
+ git__free(*s);
+
+ git__free(strings);
+}
diff --git a/src/util/strlist.h b/src/util/strlist.h
new file mode 100644
index 00000000000..68fbf8fb263
--- /dev/null
+++ b/src/util/strlist.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#ifndef INCLUDE_runtime_h__
+#define INCLUDE_runtime_h__
+
+#include "git2_util.h"
+
+extern int git_strlist_copy(char ***out, const char **in, size_t len);
+
+extern int git_strlist_copy_with_null(
+ char ***out,
+ const char **in,
+ size_t len);
+
+extern bool git_strlist_contains_prefix(
+ const char **strings,
+ size_t len,
+ const char *str,
+ size_t n);
+
+extern bool git_strlist_contains_key(
+ const char **strings,
+ size_t len,
+ const char *key,
+ char delimiter);
+
+extern void git_strlist_free(char **strings, size_t len);
+
+extern void git_strlist_free_with_null(char **strings);
+
+#endif
diff --git a/src/util/strmap.c b/src/util/strmap.c
deleted file mode 100644
index c6e5b6dc70b..00000000000
--- a/src/util/strmap.c
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
- * Copyright (C) the libgit2 contributors. All rights reserved.
- *
- * This file is part of libgit2, distributed under the GNU GPL v2 with
- * a Linking Exception. For full terms see the included COPYING file.
- */
-
-#include "strmap.h"
-
-#define kmalloc git__malloc
-#define kcalloc git__calloc
-#define krealloc git__realloc
-#define kreallocarray git__reallocarray
-#define kfree git__free
-#include "khash.h"
-
-__KHASH_TYPE(str, const char *, void *)
-
-__KHASH_IMPL(str, static kh_inline, const char *, void *, 1, kh_str_hash_func, kh_str_hash_equal)
-
-int git_strmap_new(git_strmap **out)
-{
- *out = kh_init(str);
- GIT_ERROR_CHECK_ALLOC(*out);
-
- return 0;
-}
-
-void git_strmap_free(git_strmap *map)
-{
- kh_destroy(str, map);
-}
-
-void git_strmap_clear(git_strmap *map)
-{
- kh_clear(str, map);
-}
-
-size_t git_strmap_size(git_strmap *map)
-{
- return kh_size(map);
-}
-
-void *git_strmap_get(git_strmap *map, const char *key)
-{
- size_t idx = kh_get(str, map, key);
- if (idx == kh_end(map) || !kh_exist(map, idx))
- return NULL;
- return kh_val(map, idx);
-}
-
-int git_strmap_set(git_strmap *map, const char *key, void *value)
-{
- size_t idx;
- int rval;
-
- idx = kh_put(str, map, key, &rval);
- if (rval < 0)
- return -1;
-
- if (rval == 0)
- kh_key(map, idx) = key;
-
- kh_val(map, idx) = value;
-
- return 0;
-}
-
-int git_strmap_delete(git_strmap *map, const char *key)
-{
- khiter_t idx = kh_get(str, map, key);
- if (idx == kh_end(map))
- return GIT_ENOTFOUND;
- kh_del(str, map, idx);
- return 0;
-}
-
-int git_strmap_exists(git_strmap *map, const char *key)
-{
- return kh_get(str, map, key) != kh_end(map);
-}
-
-int git_strmap_iterate(void **value, git_strmap *map, size_t *iter, const char **key)
-{
- size_t i = *iter;
-
- while (i < map->n_buckets && !kh_exist(map, i))
- i++;
-
- if (i >= map->n_buckets)
- return GIT_ITEROVER;
-
- if (key)
- *key = kh_key(map, i);
- if (value)
- *value = kh_val(map, i);
- *iter = ++i;
-
- return 0;
-}
diff --git a/src/util/strmap.h b/src/util/strmap.h
deleted file mode 100644
index b64d3dcb55d..00000000000
--- a/src/util/strmap.h
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
- * Copyright (C) the libgit2 contributors. All rights reserved.
- *
- * This file is part of libgit2, distributed under the GNU GPL v2 with
- * a Linking Exception. For full terms see the included COPYING file.
- */
-#ifndef INCLUDE_strmap_h__
-#define INCLUDE_strmap_h__
-
-#include "git2_util.h"
-
-/** A map with C strings as key. */
-typedef struct kh_str_s git_strmap;
-
-/**
- * Allocate a new string map.
- *
- * @param out Pointer to the map that shall be allocated.
- * @return 0 on success, an error code if allocation has failed.
- */
-int git_strmap_new(git_strmap **out);
-
-/**
- * Free memory associated with the map.
- *
- * Note that this function will _not_ free keys or values added
- * to this map.
- *
- * @param map Pointer to the map that is to be free'd. May be
- * `NULL`.
- */
-void git_strmap_free(git_strmap *map);
-
-/**
- * Clear all entries from the map.
- *
- * This function will remove all entries from the associated map.
- * Memory associated with it will not be released, though.
- *
- * @param map Pointer to the map that shall be cleared. May be
- * `NULL`.
- */
-void git_strmap_clear(git_strmap *map);
-
-/**
- * Return the number of elements in the map.
- *
- * @parameter map map containing the elements
- * @return number of elements in the map
- */
-size_t git_strmap_size(git_strmap *map);
-
-/**
- * Return value associated with the given key.
- *
- * @param map map to search key in
- * @param key key to search for
- * @return value associated with the given key or NULL if the key was not found
- */
-void *git_strmap_get(git_strmap *map, const char *key);
-
-/**
- * Set the entry for key to value.
- *
- * If the map has no corresponding entry for the given key, a new
- * entry will be created with the given value. If an entry exists
- * already, its value will be updated to match the given value.
- *
- * @param map map to create new entry in
- * @param key key to set
- * @param value value to associate the key with; may be NULL
- * @return zero if the key was successfully set, a negative error
- * code otherwise
- */
-int git_strmap_set(git_strmap *map, const char *key, void *value);
-
-/**
- * Delete an entry from the map.
- *
- * Delete the given key and its value from the map. If no such
- * key exists, this will do nothing.
- *
- * @param map map to delete key in
- * @param key key to delete
- * @return `0` if the key has been deleted, GIT_ENOTFOUND if no
- * such key was found, a negative code in case of an
- * error
- */
-int git_strmap_delete(git_strmap *map, const char *key);
-
-/**
- * Check whether a key exists in the given map.
- *
- * @param map map to query for the key
- * @param key key to search for
- * @return 0 if the key has not been found, 1 otherwise
- */
-int git_strmap_exists(git_strmap *map, const char *key);
-
-/**
- * Iterate over entries of the map.
- *
- * This functions allows to iterate over all key-value entries of
- * the map. The current position is stored in the `iter` variable
- * and should be initialized to `0` before the first call to this
- * function.
- *
- * @param map map to iterate over
- * @param value pointer to the variable where to store the current
- * value. May be NULL.
- * @param iter iterator storing the current position. Initialize
- * with zero previous to the first call.
- * @param key pointer to the variable where to store the current
- * key. May be NULL.
- * @return `0` if the next entry was correctly retrieved.
- * GIT_ITEROVER if no entries are left. A negative error
- * code otherwise.
- */
-int git_strmap_iterate(void **value, git_strmap *map, size_t *iter, const char **key);
-
-#define git_strmap_foreach(h, kvar, vvar, code) { size_t __i = 0; \
- while (git_strmap_iterate((void **) &(vvar), h, &__i, &(kvar)) == 0) { \
- code; \
- } }
-
-#define git_strmap_foreach_value(h, vvar, code) { size_t __i = 0; \
- while (git_strmap_iterate((void **) &(vvar), h, &__i, NULL) == 0) { \
- code; \
- } }
-
-#endif
diff --git a/src/util/unix/posix.h b/src/util/unix/posix.h
index 778477e8e2f..0c5c1065549 100644
--- a/src/util/unix/posix.h
+++ b/src/util/unix/posix.h
@@ -23,16 +23,16 @@ typedef int GIT_SOCKET;
#define p_lstat(p,b) lstat(p,b)
#define p_stat(p,b) stat(p, b)
-#if defined(GIT_USE_STAT_MTIMESPEC)
+#if defined(GIT_NSEC_MTIMESPEC)
# define st_atime_nsec st_atimespec.tv_nsec
# define st_mtime_nsec st_mtimespec.tv_nsec
# define st_ctime_nsec st_ctimespec.tv_nsec
-#elif defined(GIT_USE_STAT_MTIM)
+#elif defined(GIT_NSEC_MTIM)
# define st_atime_nsec st_atim.tv_nsec
# define st_mtime_nsec st_mtim.tv_nsec
# define st_ctime_nsec st_ctim.tv_nsec
-#elif !defined(GIT_USE_STAT_MTIME_NSEC) && defined(GIT_USE_NSEC)
-# error GIT_USE_NSEC defined but unknown struct stat nanosecond type
+#elif !defined(GIT_NSEC_MTIME_NSEC) && defined(GIT_NSEC)
+# error GIT_NSEC defined but unknown struct stat nanosecond type
#endif
#define p_utimes(f, t) utimes(f, t)
@@ -54,8 +54,6 @@ GIT_INLINE(int) p_fsync(int fd)
#define p_send(s,b,l,f) send(s,b,l,f)
#define p_inet_pton(a, b, c) inet_pton(a, b, c)
-#define p_strcasecmp(s1, s2) strcasecmp(s1, s2)
-#define p_strncasecmp(s1, s2, c) strncasecmp(s1, s2, c)
#define p_vsnprintf(b, c, f, a) vsnprintf(b, c, f, a)
#define p_snprintf snprintf
#define p_chdir(p) chdir(p)
@@ -84,7 +82,7 @@ GIT_INLINE(int) p_fsync(int fd)
#define p_timeval timeval
-#ifdef GIT_USE_FUTIMENS
+#ifdef GIT_FUTIMENS
GIT_INLINE(int) p_futimes(int f, const struct p_timeval t[2])
{
struct timespec s[2];
diff --git a/src/util/unix/process.c b/src/util/unix/process.c
new file mode 100644
index 00000000000..a1a2cf11648
--- /dev/null
+++ b/src/util/unix/process.c
@@ -0,0 +1,629 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include
+#include
+#include
+#include
+
+#include "git2_util.h"
+#include "vector.h"
+#include "process.h"
+#include "strlist.h"
+
+#ifdef __APPLE__
+ #include
+ #define environ (*_NSGetEnviron())
+#else
+ extern char **environ;
+#endif
+
+struct git_process {
+ char **args;
+ char **env;
+
+ char *cwd;
+
+ unsigned int capture_in : 1,
+ capture_out : 1,
+ capture_err : 1;
+
+ pid_t pid;
+
+ int child_in;
+ int child_out;
+ int child_err;
+ git_process_result_status status;
+};
+
+GIT_INLINE(bool) is_delete_env(const char *env)
+{
+ char *c = strchr(env, '=');
+
+ if (c == NULL)
+ return false;
+
+ return *(c+1) == '\0';
+}
+
+static int merge_env(
+ char ***out,
+ const char **env,
+ size_t env_len,
+ bool exclude_env)
+{
+ git_vector merged = GIT_VECTOR_INIT;
+ char **kv, *dup;
+ size_t max, cnt;
+ int error = 0;
+
+ for (max = env_len, kv = environ; !exclude_env && *kv; kv++)
+ max++;
+
+ if ((error = git_vector_init(&merged, max, NULL)) < 0)
+ goto on_error;
+
+ for (cnt = 0; env && cnt < env_len; cnt++) {
+ if (is_delete_env(env[cnt]))
+ continue;
+
+ dup = git__strdup(env[cnt]);
+ GIT_ERROR_CHECK_ALLOC(dup);
+
+ if ((error = git_vector_insert(&merged, dup)) < 0)
+ goto on_error;
+ }
+
+ if (!exclude_env) {
+ for (kv = environ; *kv; kv++) {
+ if (env && git_strlist_contains_key(env, env_len, *kv, '='))
+ continue;
+
+ dup = git__strdup(*kv);
+ GIT_ERROR_CHECK_ALLOC(dup);
+
+ if ((error = git_vector_insert(&merged, dup)) < 0)
+ goto on_error;
+ }
+ }
+
+ if (merged.length == 0) {
+ *out = NULL;
+ error = 0;
+ goto on_error;
+ }
+
+ git_vector_insert(&merged, NULL);
+
+ *out = (char **)merged.contents;
+
+ return 0;
+
+on_error:
+ git_vector_dispose_deep(&merged);
+ return error;
+}
+
+int git_process_new(
+ git_process **out,
+ const char **args,
+ size_t args_len,
+ const char **env,
+ size_t env_len,
+ git_process_options *opts)
+{
+ git_process *process;
+
+ GIT_ASSERT_ARG(out && args && args_len > 0);
+
+ *out = NULL;
+
+ process = git__calloc(sizeof(git_process), 1);
+ GIT_ERROR_CHECK_ALLOC(process);
+
+ if (git_strlist_copy_with_null(&process->args, args, args_len) < 0 ||
+ merge_env(&process->env, env, env_len, opts ? opts->exclude_env : false) < 0) {
+ git_process_free(process);
+ return -1;
+ }
+
+ if (opts) {
+ process->capture_in = opts->capture_in;
+ process->capture_out = opts->capture_out;
+ process->capture_err = opts->capture_err;
+
+ if (opts->cwd) {
+ process->cwd = git__strdup(opts->cwd);
+ GIT_ERROR_CHECK_ALLOC(process->cwd);
+ }
+ }
+
+ process->child_in = -1;
+ process->child_out = -1;
+ process->child_err = -1;
+ process->status = -1;
+
+ *out = process;
+ return 0;
+}
+
+extern int git_process_new_from_cmdline(
+ git_process **out,
+ const char *cmdline,
+ const char **env,
+ size_t env_len,
+ git_process_options *opts)
+{
+ const char *args[] = { "/bin/sh", "-c", cmdline };
+
+ return git_process_new(out,
+ args, ARRAY_SIZE(args), env, env_len, opts);
+}
+
+#define CLOSE_FD(fd) \
+ if (fd >= 0) { \
+ close(fd); \
+ fd = -1; \
+ }
+
+static int try_read_status(size_t *out, int fd, void *buf, size_t len)
+{
+ size_t read_len = 0;
+ int ret = -1;
+
+ while (ret && read_len < len) {
+ ret = read(fd, buf + read_len, len - read_len);
+
+ if (ret < 0 && errno != EAGAIN && errno != EINTR) {
+ git_error_set(GIT_ERROR_OS, "could not read child status");
+ return -1;
+ }
+
+ read_len += ret;
+ }
+
+ *out = read_len;
+ return 0;
+}
+
+
+static int read_status(int fd)
+{
+ size_t status_len = sizeof(int) * 3, read_len = 0;
+ char buffer[status_len], fn[128];
+ int error, fn_error, os_error, fn_len = 0;
+
+ if ((error = try_read_status(&read_len, fd, buffer, status_len)) < 0)
+ return error;
+
+ /* Immediate EOF indicates the exec succeeded. */
+ if (read_len == 0)
+ return 0;
+
+ if (read_len < status_len) {
+ git_error_set(GIT_ERROR_INVALID, "child status truncated");
+ return -1;
+ }
+
+ memcpy(&fn_error, &buffer[0], sizeof(int));
+ memcpy(&os_error, &buffer[sizeof(int)], sizeof(int));
+ memcpy(&fn_len, &buffer[sizeof(int) * 2], sizeof(int));
+
+ if (fn_len > 0) {
+ fn_len = min(fn_len, (int)(ARRAY_SIZE(fn) - 1));
+
+ if ((error = try_read_status(&read_len, fd, fn, fn_len)) < 0)
+ return error;
+
+ fn[fn_len] = '\0';
+ } else {
+ fn[0] = '\0';
+ }
+
+ if (fn_error) {
+ errno = os_error;
+ git_error_set(GIT_ERROR_OS, "could not %s", fn[0] ? fn : "(unknown)");
+ }
+
+ return fn_error;
+}
+
+static bool try_write_status(int fd, const void *buf, size_t len)
+{
+ size_t write_len;
+ int ret;
+
+ for (write_len = 0; write_len < len; ) {
+ ret = write(fd, buf + write_len, len - write_len);
+
+ if (ret <= 0)
+ break;
+
+ write_len += ret;
+ }
+
+ return (len == write_len);
+}
+
+static void write_status(int fd, const char *fn, int error, int os_error)
+{
+ size_t status_len = sizeof(int) * 3, fn_len;
+ char buffer[status_len];
+
+ fn_len = strlen(fn);
+
+ if (fn_len > INT_MAX)
+ fn_len = INT_MAX;
+
+ memcpy(&buffer[0], &error, sizeof(int));
+ memcpy(&buffer[sizeof(int)], &os_error, sizeof(int));
+ memcpy(&buffer[sizeof(int) * 2], &fn_len, sizeof(int));
+
+ /* Do our best effort to write all the status. */
+ if (!try_write_status(fd, buffer, status_len))
+ return;
+
+ if (fn_len)
+ try_write_status(fd, fn, fn_len);
+}
+
+int git_process_start(git_process *process)
+{
+ int in[2] = { -1, -1 }, out[2] = { -1, -1 },
+ err[2] = { -1, -1 }, status[2] = { -1, -1 };
+ int fdflags, state, error;
+ pid_t pid;
+
+ /* Set up the pipes to read from/write to the process */
+ if ((process->capture_in && pipe(in) < 0) ||
+ (process->capture_out && pipe(out) < 0) ||
+ (process->capture_err && pipe(err) < 0)) {
+ git_error_set(GIT_ERROR_OS, "could not create pipe");
+ goto on_error;
+ }
+
+ /* Set up a self-pipe for status from the forked process. */
+ if (pipe(status) < 0 ||
+ (fdflags = fcntl(status[1], F_GETFD)) < 0 ||
+ fcntl(status[1], F_SETFD, fdflags | FD_CLOEXEC) < 0) {
+ git_error_set(GIT_ERROR_OS, "could not create pipe");
+ goto on_error;
+ }
+
+ switch (pid = fork()) {
+ case -1:
+ git_error_set(GIT_ERROR_OS, "could not fork");
+ goto on_error;
+
+ /* Child: start the process. */
+ case 0:
+ /* Close the opposing side of the pipes */
+ CLOSE_FD(status[0]);
+
+ if (process->capture_in) {
+ CLOSE_FD(in[1]);
+ dup2(in[0], STDIN_FILENO);
+ }
+
+ if (process->capture_out) {
+ CLOSE_FD(out[0]);
+ dup2(out[1], STDOUT_FILENO);
+ }
+
+ if (process->capture_err) {
+ CLOSE_FD(err[0]);
+ dup2(err[1], STDERR_FILENO);
+ }
+
+ if (process->cwd && (error = chdir(process->cwd)) < 0) {
+ write_status(status[1], "chdir", error, errno);
+ exit(0);
+ }
+
+ /*
+ * Exec the process and write the results back if the
+ * call fails. If it succeeds, we'll close the status
+ * pipe (via CLOEXEC) and the parent will know.
+ */
+ error = execve(process->args[0],
+ process->args,
+ process->env);
+
+ write_status(status[1], "execve", error, errno);
+ exit(0);
+
+ /* Parent: make sure the child process exec'd correctly. */
+ default:
+ /* Close the opposing side of the pipes */
+ CLOSE_FD(status[1]);
+
+ if (process->capture_in) {
+ CLOSE_FD(in[0]);
+ process->child_in = in[1];
+ }
+
+ if (process->capture_out) {
+ CLOSE_FD(out[1]);
+ process->child_out = out[0];
+ }
+
+ if (process->capture_err) {
+ CLOSE_FD(err[1]);
+ process->child_err = err[0];
+ }
+
+ /* Try to read the status */
+ process->status = status[0];
+ if ((error = read_status(status[0])) < 0) {
+ waitpid(process->pid, &state, 0);
+ goto on_error;
+ }
+
+ process->pid = pid;
+ return 0;
+ }
+
+on_error:
+ CLOSE_FD(in[0]); CLOSE_FD(in[1]);
+ CLOSE_FD(out[0]); CLOSE_FD(out[1]);
+ CLOSE_FD(err[0]); CLOSE_FD(err[1]);
+ CLOSE_FD(status[0]); CLOSE_FD(status[1]);
+ return -1;
+}
+
+int git_process_id(p_pid_t *out, git_process *process)
+{
+ GIT_ASSERT(out && process);
+
+ if (!process->pid) {
+ git_error_set(GIT_ERROR_INVALID, "process not running");
+ return -1;
+ }
+
+ *out = process->pid;
+ return 0;
+}
+
+static ssize_t process_read(int fd, void *buf, size_t count)
+{
+ ssize_t ret;
+
+ if (count > SSIZE_MAX)
+ count = SSIZE_MAX;
+
+ if ((ret = read(fd, buf, count)) < 0) {
+ git_error_set(GIT_ERROR_OS, "could not read from child process");
+ return -1;
+ }
+
+ return ret;
+}
+
+ssize_t git_process_read(git_process *process, void *buf, size_t count)
+{
+ GIT_ASSERT_ARG(process);
+ GIT_ASSERT(process->capture_out);
+
+ return process_read(process->child_out, buf, count);
+}
+
+ssize_t git_process_read_err(git_process *process, void *buf, size_t count)
+{
+ GIT_ASSERT_ARG(process);
+ GIT_ASSERT(process->capture_err);
+
+ return process_read(process->child_err, buf, count);
+}
+
+#ifdef GIT_THREADS
+
+# define signal_state sigset_t
+
+/*
+ * Since signal-handling is process-wide, we cannot simply use
+ * SIG_IGN to avoid SIGPIPE. Instead: http://www.microhowto.info:80/howto/ignore_sigpipe_without_affecting_other_threads_in_a_process.html
+ */
+
+GIT_INLINE(int) disable_signals(sigset_t *saved_mask)
+{
+ sigset_t sigpipe_mask;
+
+ sigemptyset(&sigpipe_mask);
+ sigaddset(&sigpipe_mask, SIGPIPE);
+
+ if (pthread_sigmask(SIG_BLOCK, &sigpipe_mask, saved_mask) < 0) {
+ git_error_set(GIT_ERROR_OS, "could not configure signal mask");
+ return -1;
+ }
+
+ return 0;
+}
+
+GIT_INLINE(int) restore_signals(sigset_t *saved_mask)
+{
+ sigset_t sigpipe_mask, pending;
+ int signal;
+
+ sigemptyset(&sigpipe_mask);
+ sigaddset(&sigpipe_mask, SIGPIPE);
+
+ if (sigpending(&pending) < 0) {
+ git_error_set(GIT_ERROR_OS, "could not examine pending signals");
+ return -1;
+ }
+
+ if (sigismember(&pending, SIGPIPE) == 1 &&
+ sigwait(&sigpipe_mask, &signal) < 0) {
+ git_error_set(GIT_ERROR_OS, "could not wait for (blocking) signal delivery");
+ return -1;
+ }
+
+ if (pthread_sigmask(SIG_SETMASK, saved_mask, 0) < 0) {
+ git_error_set(GIT_ERROR_OS, "could not configure signal mask");
+ return -1;
+ }
+
+ return 0;
+}
+
+#else
+
+# define signal_state struct sigaction
+
+GIT_INLINE(int) disable_signals(struct sigaction *saved_handler)
+{
+ struct sigaction ign_handler = { 0 };
+
+ ign_handler.sa_handler = SIG_IGN;
+
+ if (sigaction(SIGPIPE, &ign_handler, saved_handler) < 0) {
+ git_error_set(GIT_ERROR_OS, "could not configure signal handler");
+ return -1;
+ }
+
+ return 0;
+}
+
+GIT_INLINE(int) restore_signals(struct sigaction *saved_handler)
+{
+ if (sigaction(SIGPIPE, saved_handler, NULL) < 0) {
+ git_error_set(GIT_ERROR_OS, "could not configure signal handler");
+ return -1;
+ }
+
+ return 0;
+}
+
+#endif
+
+ssize_t git_process_write(git_process *process, const void *buf, size_t count)
+{
+ signal_state saved_signal;
+ ssize_t ret;
+
+ GIT_ASSERT_ARG(process);
+ GIT_ASSERT(process->capture_in);
+
+ if (count > SSIZE_MAX)
+ count = SSIZE_MAX;
+
+ if (disable_signals(&saved_signal) < 0)
+ return -1;
+
+ if ((ret = write(process->child_in, buf, count)) < 0)
+ git_error_set(GIT_ERROR_OS, "could not write to child process");
+
+ if (restore_signals(&saved_signal) < 0)
+ return -1;
+
+ return (ret < 0) ? -1 : ret;
+}
+
+int git_process_close_in(git_process *process)
+{
+ if (!process->capture_in) {
+ git_error_set(GIT_ERROR_INVALID, "input is not open");
+ return -1;
+ }
+
+ CLOSE_FD(process->child_in);
+ return 0;
+}
+
+int git_process_close_out(git_process *process)
+{
+ if (!process->capture_out) {
+ git_error_set(GIT_ERROR_INVALID, "output is not open");
+ return -1;
+ }
+
+ CLOSE_FD(process->child_out);
+ return 0;
+}
+
+int git_process_close_err(git_process *process)
+{
+ if (!process->capture_err) {
+ git_error_set(GIT_ERROR_INVALID, "error is not open");
+ return -1;
+ }
+
+ CLOSE_FD(process->child_err);
+ return 0;
+}
+
+int git_process_close(git_process *process)
+{
+ CLOSE_FD(process->child_in);
+ CLOSE_FD(process->child_out);
+ CLOSE_FD(process->child_err);
+
+ return 0;
+}
+
+int git_process_wait(git_process_result *result, git_process *process)
+{
+ int state;
+
+ if (result)
+ memset(result, 0, sizeof(git_process_result));
+
+ if (!process->pid) {
+ git_error_set(GIT_ERROR_INVALID, "process is stopped");
+ return -1;
+ }
+
+ if (waitpid(process->pid, &state, 0) < 0) {
+ git_error_set(GIT_ERROR_OS, "could not wait for child");
+ return -1;
+ }
+
+ process->pid = 0;
+
+ if (result) {
+ if (WIFEXITED(state)) {
+ result->status = GIT_PROCESS_STATUS_NORMAL;
+ result->exitcode = WEXITSTATUS(state);
+ } else if (WIFSIGNALED(state)) {
+ result->status = GIT_PROCESS_STATUS_ERROR;
+ result->signal = WTERMSIG(state);
+ } else {
+ result->status = GIT_PROCESS_STATUS_ERROR;
+ }
+ }
+
+ return 0;
+}
+
+int git_process_result_msg(git_str *out, git_process_result *result)
+{
+ if (result->status == GIT_PROCESS_STATUS_NONE) {
+ return git_str_puts(out, "process not started");
+ } else if (result->status == GIT_PROCESS_STATUS_NORMAL) {
+ return git_str_printf(out, "process exited with code %d",
+ result->exitcode);
+ } else if (result->signal) {
+ return git_str_printf(out, "process exited on signal %d",
+ result->signal);
+ }
+
+ return git_str_puts(out, "unknown error");
+}
+
+void git_process_free(git_process *process)
+{
+ if (!process)
+ return;
+
+ if (process->pid)
+ git_process_close(process);
+
+ git__free(process->cwd);
+ git_strlist_free_with_null(process->args);
+ git_strlist_free_with_null(process->env);
+ git__free(process);
+}
diff --git a/src/util/unix/realpath.c b/src/util/unix/realpath.c
index 9e31a63b9f4..2565e2e83bc 100644
--- a/src/util/unix/realpath.c
+++ b/src/util/unix/realpath.c
@@ -16,17 +16,35 @@
char *p_realpath(const char *pathname, char *resolved)
{
- char *ret;
- if ((ret = realpath(pathname, resolved)) == NULL)
+ char *result;
+
+ if ((result = realpath(pathname, resolved)) == NULL)
return NULL;
#ifdef __OpenBSD__
/* The OpenBSD realpath function behaves differently,
* figure out if the file exists */
- if (access(ret, F_OK) < 0)
- ret = NULL;
+ if (access(result, F_OK) < 0) {
+ if (!resolved)
+ free(result);
+
+ return NULL;
+ }
#endif
- return ret;
+
+ /*
+ * If resolved == NULL, the system has allocated the result
+ * string. We need to strdup this into _our_ allocator pool
+ * so that callers can free it with git__free.
+ */
+ if (!resolved) {
+ char *dup = git__strdup(result);
+ free(result);
+
+ result = dup;
+ }
+
+ return result;
}
#endif
diff --git a/src/util/util.c b/src/util/util.c
index aee95fddfb5..e86bceeb5a8 100644
--- a/src/util/util.c
+++ b/src/util/util.c
@@ -18,7 +18,7 @@
# endif
# include
-# ifdef GIT_QSORT_S
+# ifdef GIT_QSORT_MSC
# include
# endif
#endif
@@ -623,12 +623,12 @@ int git__bsearch_r(
*/
int git__strcmp_cb(const void *a, const void *b)
{
- return strcmp((const char *)a, (const char *)b);
+ return git__strcmp((const char *)a, (const char *)b);
}
int git__strcasecmp_cb(const void *a, const void *b)
{
- return strcasecmp((const char *)a, (const char *)b);
+ return git__strcasecmp((const char *)a, (const char *)b);
}
int git__parse_bool(int *out, const char *value)
@@ -673,7 +673,7 @@ size_t git__unescape(char *str)
return (pos - str);
}
-#if defined(GIT_QSORT_S) || defined(GIT_QSORT_R_BSD)
+#if defined(GIT_QSORT_MSC) || defined(GIT_QSORT_BSD)
typedef struct {
git__sort_r_cmp cmp;
void *payload;
@@ -688,9 +688,11 @@ static int GIT_LIBGIT2_CALL git__qsort_r_glue_cmp(
#endif
-#if !defined(GIT_QSORT_R_BSD) && \
- !defined(GIT_QSORT_R_GNU) && \
- !defined(GIT_QSORT_S)
+#if !defined(GIT_QSORT_BSD) && \
+ !defined(GIT_QSORT_GNU) && \
+ !defined(GIT_QSORT_C11) && \
+ !defined(GIT_QSORT_MSC)
+
static void swap(uint8_t *a, uint8_t *b, size_t elsize)
{
char tmp[256];
@@ -716,17 +718,20 @@ static void insertsort(
for (j = i; j > base && cmp(j, j - elsize, payload) < 0; j -= elsize)
swap(j, j - elsize, elsize);
}
+
#endif
void git__qsort_r(
void *els, size_t nel, size_t elsize, git__sort_r_cmp cmp, void *payload)
{
-#if defined(GIT_QSORT_R_BSD)
+#if defined(GIT_QSORT_GNU)
+ qsort_r(els, nel, elsize, cmp, payload);
+#elif defined(GIT_QSORT_C11)
+ qsort_s(els, nel, elsize, cmp, payload);
+#elif defined(GIT_QSORT_BSD)
git__qsort_r_glue glue = { cmp, payload };
qsort_r(els, nel, elsize, &glue, git__qsort_r_glue_cmp);
-#elif defined(GIT_QSORT_R_GNU)
- qsort_r(els, nel, elsize, cmp, payload);
-#elif defined(GIT_QSORT_S)
+#elif defined(GIT_QSORT_MSC)
git__qsort_r_glue glue = { cmp, payload };
qsort_s(els, nel, elsize, git__qsort_r_glue_cmp, &glue);
#else
@@ -743,7 +748,7 @@ int git__getenv(git_str *out, const char *name)
git_str_clear(out);
- if (git__utf8_to_16_alloc(&wide_name, name) < 0)
+ if (git_utf8_to_16_alloc(&wide_name, name) < 0)
return -1;
if ((value_len = GetEnvironmentVariableW(wide_name, NULL, 0)) > 0) {
diff --git a/src/util/util.h b/src/util/util.h
index 63d6080f730..7053a9d494a 100644
--- a/src/util/util.h
+++ b/src/util/util.h
@@ -7,15 +7,15 @@
#ifndef INCLUDE_util_h__
#define INCLUDE_util_h__
-#ifndef GIT_WIN32
-# include
-#endif
-
#include "str.h"
#include "git2_util.h"
#include "strnlen.h"
#include "thread.h"
+#ifndef GIT_WIN32
+# include
+#endif
+
#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
#define bitsizeof(x) (CHAR_BIT * sizeof(x))
#define MSB(x, bits) ((x) & (~UINT64_C(0) << (bitsizeof(x) - (bits))))
@@ -83,15 +83,6 @@ extern char *git__strsep(char **end, const char *sep);
extern void git__strntolower(char *str, size_t len);
extern void git__strtolower(char *str);
-#ifdef GIT_WIN32
-GIT_INLINE(int) git__tolower(int c)
-{
- return (c >= 'A' && c <= 'Z') ? (c + 32) : c;
-}
-#else
-# define git__tolower(a) tolower(a)
-#endif
-
extern size_t git__linenlen(const char *buffer, size_t buffer_len);
GIT_INLINE(const char *) git__next_line(const char *s)
@@ -249,26 +240,6 @@ GIT_INLINE(size_t) git__size_t_powerof2(size_t v)
return git__size_t_bitmask(v) + 1;
}
-GIT_INLINE(bool) git__isupper(int c)
-{
- return (c >= 'A' && c <= 'Z');
-}
-
-GIT_INLINE(bool) git__isalpha(int c)
-{
- return ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'));
-}
-
-GIT_INLINE(bool) git__isdigit(int c)
-{
- return (c >= '0' && c <= '9');
-}
-
-GIT_INLINE(bool) git__isspace(int c)
-{
- return (c == ' ' || c == '\t' || c == '\n' || c == '\f' || c == '\r' || c == '\v');
-}
-
GIT_INLINE(bool) git__isspace_nonlf(int c)
{
return (c == ' ' || c == '\t' || c == '\f' || c == '\r' || c == '\v');
@@ -279,11 +250,6 @@ GIT_INLINE(bool) git__iswildcard(int c)
return (c == '*' || c == '?' || c == '[');
}
-GIT_INLINE(bool) git__isxdigit(int c)
-{
- return ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'));
-}
-
/*
* Parse a string value as a boolean, just like Core Git does.
*
@@ -319,59 +285,67 @@ GIT_INLINE(void) git__memzero(void *data, size_t size)
#ifdef GIT_WIN32
-GIT_INLINE(double) git__timer(void)
+GIT_INLINE(uint64_t) git_time_monotonic(void)
{
/* GetTickCount64 returns the number of milliseconds that have
* elapsed since the system was started. */
- return (double) GetTickCount64() / (double) 1000;
+ return GetTickCount64();
}
#elif __APPLE__
#include
+#include
-GIT_INLINE(double) git__timer(void)
+GIT_INLINE(uint64_t) git_time_monotonic(void)
{
- uint64_t time = mach_absolute_time();
- static double scaling_factor = 0;
+ static double scaling_factor = 0;
+
+ if (scaling_factor == 0) {
+ mach_timebase_info_data_t info;
- if (scaling_factor == 0) {
- mach_timebase_info_data_t info;
- (void)mach_timebase_info(&info);
- scaling_factor = (double)info.numer / (double)info.denom;
- }
+ scaling_factor = mach_timebase_info(&info) == KERN_SUCCESS ?
+ ((double)info.numer / (double)info.denom) / 1.0E6 :
+ -1;
+ } else if (scaling_factor < 0) {
+ struct timeval tv;
+
+ /* mach_timebase_info failed; fall back to gettimeofday */
+ gettimeofday(&tv, NULL);
+ return (tv.tv_sec * 1000) + (tv.tv_usec / 1000);
+ }
- return (double)time * scaling_factor / 1.0E9;
+ return (uint64_t)(mach_absolute_time() * scaling_factor);
}
#elif defined(__amigaos4__)
#include
-GIT_INLINE(double) git__timer(void)
+GIT_INLINE(uint64_t) git_time_monotonic(void)
{
struct TimeVal tv;
ITimer->GetUpTime(&tv);
- return (double)tv.Seconds + (double)tv.Microseconds / 1.0E6;
+ return (tv.Seconds * 1000) + (tv.Microseconds / 1000);
}
#else
#include
-GIT_INLINE(double) git__timer(void)
+GIT_INLINE(uint64_t) git_time_monotonic(void)
{
struct timeval tv;
#ifdef CLOCK_MONOTONIC
struct timespec tp;
if (clock_gettime(CLOCK_MONOTONIC, &tp) == 0)
- return (double) tp.tv_sec + (double) tp.tv_nsec / 1.0E9;
+ return (tp.tv_sec * 1000) + (tp.tv_nsec / 1.0E6);
#endif
/* Fall back to using gettimeofday */
gettimeofday(&tv, NULL);
- return (double)tv.tv_sec + (double)tv.tv_usec / 1.0E6;
+ return (tv.tv_sec * 1000) + (tv.tv_usec / 1000);
}
#endif
diff --git a/src/util/vector.c b/src/util/vector.c
index 4a4bc8c0e44..34ac3bb9c5b 100644
--- a/src/util/vector.c
+++ b/src/util/vector.c
@@ -76,7 +76,7 @@ int git_vector_dup(git_vector *v, const git_vector *src, git_vector_cmp cmp)
return 0;
}
-void git_vector_free(git_vector *v)
+void git_vector_dispose(git_vector *v)
{
if (!v)
return;
@@ -88,7 +88,7 @@ void git_vector_free(git_vector *v)
v->_alloc_size = 0;
}
-void git_vector_free_deep(git_vector *v)
+void git_vector_dispose_deep(git_vector *v)
{
size_t i;
@@ -100,7 +100,7 @@ void git_vector_free_deep(git_vector *v)
v->contents[i] = NULL;
}
- git_vector_free(v);
+ git_vector_dispose(v);
}
int git_vector_init(git_vector *v, size_t initial_size, git_vector_cmp cmp)
diff --git a/src/util/vector.h b/src/util/vector.h
index e50cdfefcbd..02f82b30d03 100644
--- a/src/util/vector.h
+++ b/src/util/vector.h
@@ -28,8 +28,8 @@ typedef struct git_vector {
GIT_WARN_UNUSED_RESULT int git_vector_init(
git_vector *v, size_t initial_size, git_vector_cmp cmp);
-void git_vector_free(git_vector *v);
-void git_vector_free_deep(git_vector *v); /* free each entry and self */
+void git_vector_dispose(git_vector *v);
+void git_vector_dispose_deep(git_vector *v); /* free each entry and self */
void git_vector_clear(git_vector *v);
GIT_WARN_UNUSED_RESULT int git_vector_dup(
git_vector *v, const git_vector *src, git_vector_cmp cmp);
diff --git a/src/util/win32/error.c b/src/util/win32/error.c
index 3a52fb5a90a..141b1ad4cef 100644
--- a/src/util/win32/error.c
+++ b/src/util/win32/error.c
@@ -9,7 +9,7 @@
#include "utf-conv.h"
-#ifdef GIT_WINHTTP
+#ifdef GIT_HTTPS_WINHTTP
# include
#endif
@@ -24,7 +24,7 @@ char *git_win32_get_error_message(DWORD error_code)
if (!error_code)
return NULL;
-#ifdef GIT_WINHTTP
+#ifdef GIT_HTTPS_WINHTTP
/* Errors raised by WinHTTP are not in the system resource table */
if (error_code >= WINHTTP_ERROR_BASE &&
error_code <= WINHTTP_ERROR_LAST)
@@ -43,7 +43,7 @@ char *git_win32_get_error_message(DWORD error_code)
(LPWSTR)&lpMsgBuf, 0, NULL)) {
/* Convert the message to UTF-8. If this fails, we will
* return NULL, which is a condition expected by the caller */
- if (git__utf16_to_8_alloc(&utf8_msg, lpMsgBuf) < 0)
+ if (git_utf8_from_16_alloc(&utf8_msg, lpMsgBuf) < 0)
utf8_msg = NULL;
LocalFree(lpMsgBuf);
diff --git a/src/util/win32/path_w32.c b/src/util/win32/path_w32.c
index d9fc8292b0c..7a559e45c58 100644
--- a/src/util/win32/path_w32.c
+++ b/src/util/win32/path_w32.c
@@ -336,13 +336,13 @@ int git_win32_path_from_utf8(git_win32_path out, const char *src)
/* See if this is an absolute path (beginning with a drive letter) */
if (git_fs_path_is_absolute(src)) {
- if (git__utf8_to_16(dest, GIT_WIN_PATH_MAX, src) < 0)
+ if (git_utf8_to_16(dest, GIT_WIN_PATH_MAX, src) < 0)
goto on_error;
}
/* File-prefixed NT-style paths beginning with \\?\ */
else if (path__is_nt_namespace(src)) {
/* Skip the NT prefix, the destination already contains it */
- if (git__utf8_to_16(dest, GIT_WIN_PATH_MAX, src + PATH__NT_NAMESPACE_LEN) < 0)
+ if (git_utf8_to_16(dest, GIT_WIN_PATH_MAX, src + PATH__NT_NAMESPACE_LEN) < 0)
goto on_error;
}
/* UNC paths */
@@ -351,7 +351,7 @@ int git_win32_path_from_utf8(git_win32_path out, const char *src)
dest += 4;
/* Skip the leading "\\" */
- if (git__utf8_to_16(dest, GIT_WIN_PATH_MAX - 2, src + 2) < 0)
+ if (git_utf8_to_16(dest, GIT_WIN_PATH_MAX - 2, src + 2) < 0)
goto on_error;
}
/* Absolute paths omitting the drive letter */
@@ -365,7 +365,7 @@ int git_win32_path_from_utf8(git_win32_path out, const char *src)
}
/* Skip the drive letter specification ("C:") */
- if (git__utf8_to_16(dest + 2, GIT_WIN_PATH_MAX - 2, src) < 0)
+ if (git_utf8_to_16(dest + 2, GIT_WIN_PATH_MAX - 2, src) < 0)
goto on_error;
}
/* Relative paths */
@@ -377,7 +377,7 @@ int git_win32_path_from_utf8(git_win32_path out, const char *src)
dest[cwd_len++] = L'\\';
- if (git__utf8_to_16(dest + cwd_len, GIT_WIN_PATH_MAX - cwd_len, src) < 0)
+ if (git_utf8_to_16(dest + cwd_len, GIT_WIN_PATH_MAX - cwd_len, src) < 0)
goto on_error;
}
@@ -404,7 +404,7 @@ int git_win32_path_relative_from_utf8(git_win32_path out, const char *src)
return git_win32_path_from_utf8(out, src);
}
- if ((len = git__utf8_to_16(dest, GIT_WIN_PATH_MAX, src)) < 0)
+ if ((len = git_utf8_to_16(dest, GIT_WIN_PATH_MAX, src)) < 0)
return -1;
for (p = dest; p < (dest + len); p++) {
@@ -433,7 +433,7 @@ int git_win32_path_to_utf8(git_win32_utf8_path dest, const wchar_t *src)
}
}
- if ((len = git__utf16_to_8(out, GIT_WIN_PATH_UTF8, src)) < 0)
+ if ((len = git_utf8_from_16(out, GIT_WIN_PATH_UTF8, src)) < 0)
return len;
git_fs_path_mkposix(dest);
@@ -471,7 +471,7 @@ char *git_win32_path_8dot3_name(const char *path)
if (namelen > 12 || (shortname = git__malloc(namelen + 1)) == NULL)
return NULL;
- if ((len = git__utf16_to_8(shortname, namelen + 1, start)) < 0)
+ if ((len = git_utf8_from_16(shortname, namelen + 1, start)) < 0)
return NULL;
return shortname;
diff --git a/src/util/win32/posix_w32.c b/src/util/win32/posix_w32.c
index 5862e5c9ad6..7ace3b1e1f8 100644
--- a/src/util/win32/posix_w32.c
+++ b/src/util/win32/posix_w32.c
@@ -649,7 +649,7 @@ int p_getcwd(char *buffer_out, size_t size)
git_win32_path_remove_namespace(cwd, wcslen(cwd));
/* Convert the working directory back to UTF-8 */
- if (git__utf16_to_8(buffer_out, size, cwd) < 0) {
+ if (git_utf8_from_16(buffer_out, size, cwd) < 0) {
DWORD code = GetLastError();
if (code == ERROR_INSUFFICIENT_BUFFER)
@@ -770,6 +770,7 @@ int p_rmdir(const char *path)
* handle to the directory." This sounds like what everybody else calls
* EBUSY. Let's convert appropriate error codes.
*/
+ case ERROR_ACCESS_DENIED:
case ERROR_SHARING_VIOLATION:
errno = EBUSY;
break;
@@ -787,13 +788,19 @@ int p_rmdir(const char *path)
char *p_realpath(const char *orig_path, char *buffer)
{
git_win32_path orig_path_w, buffer_w;
+ DWORD long_len;
if (git_win32_path_from_utf8(orig_path_w, orig_path) < 0)
return NULL;
- /* Note that if the path provided is a relative path, then the current directory
+ /*
+ * POSIX realpath performs two functions: first, it turns relative
+ * paths into absolute paths. For this, we need GetFullPathName.
+ *
+ * Note that if the path provided is a relative path, then the current directory
* is used to resolve the path -- which is a concurrency issue because the current
- * directory is a process-wide variable. */
+ * directory is a process-wide variable.
+ */
if (!GetFullPathNameW(orig_path_w, GIT_WIN_PATH_UTF16, buffer_w, NULL)) {
if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
errno = ENAMETOOLONG;
@@ -803,9 +810,26 @@ char *p_realpath(const char *orig_path, char *buffer)
return NULL;
}
- /* The path must exist. */
- if (GetFileAttributesW(buffer_w) == INVALID_FILE_ATTRIBUTES) {
- errno = ENOENT;
+ /*
+ * Then, the path is canonicalized. eg, on macOS,
+ * "/TMP" -> "/private/tmp". For this, we need GetLongPathName.
+ */
+ if ((long_len = GetLongPathNameW(buffer_w, buffer_w, GIT_WIN_PATH_UTF16)) == 0) {
+ DWORD error = GetLastError();
+
+ if (error == ERROR_FILE_NOT_FOUND ||
+ error == ERROR_PATH_NOT_FOUND)
+ errno = ENOENT;
+ else if (error == ERROR_ACCESS_DENIED)
+ errno = EPERM;
+ else
+ errno = EINVAL;
+
+ return NULL;
+ }
+
+ if (long_len > GIT_WIN_PATH_UTF16) {
+ errno = ENAMETOOLONG;
return NULL;
}
@@ -821,7 +845,6 @@ char *p_realpath(const char *orig_path, char *buffer)
return NULL;
git_fs_path_mkposix(buffer);
-
return buffer;
}
diff --git a/src/util/win32/process.c b/src/util/win32/process.c
new file mode 100644
index 00000000000..bb522459711
--- /dev/null
+++ b/src/util/win32/process.c
@@ -0,0 +1,506 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include
+#include
+
+#include "git2_util.h"
+#include "process.h"
+#include "strlist.h"
+
+#ifndef DWORD_MAX
+# define DWORD_MAX INT32_MAX
+#endif
+
+#define ENV_MAX 32767
+
+struct git_process {
+ wchar_t *appname;
+ wchar_t *cmdline;
+ wchar_t *env;
+
+ wchar_t *cwd;
+
+ unsigned int capture_in : 1,
+ capture_out : 1,
+ capture_err : 1;
+
+ PROCESS_INFORMATION process_info;
+
+ HANDLE child_in;
+ HANDLE child_out;
+ HANDLE child_err;
+
+ git_process_result_status status;
+};
+
+/*
+ * Windows processes have a single command-line that is split by the
+ * invoked application into arguments (instead of an array of
+ * command-line arguments). This command-line is split by space or
+ * tab delimiters, unless that whitespace is within a double quote.
+ * Literal double-quotes themselves can be escaped by a backslash,
+ * but only when not within double quotes. Literal backslashes can
+ * be escaped by a backslash.
+ *
+ * Effectively, this means that instead of thinking about quoting
+ * individual strings, think about double quotes as an escaping
+ * mechanism for whitespace.
+ *
+ * In other words (using ` as a string boundary):
+ * [ `foo`, `bar` ] => `foo bar`
+ * [ `foo bar` ] => `foo" "bar`
+ * [ `foo bar`, `foo bar` ] => `foo" "bar foo" "bar`
+ * [ `foo "bar" foo` ] => `foo" "\"bar\"" "foo`
+ */
+int git_process__cmdline(
+ git_str *out,
+ const char **in,
+ size_t in_len)
+{
+ bool quoted = false;
+ const char *c;
+ size_t i;
+
+ for (i = 0; i < in_len; i++) {
+ /* Arguments are delimited by an unquoted space */
+ if (i)
+ git_str_putc(out, ' ');
+
+ for (c = in[i]; *c; c++) {
+ /* Start or stop quoting spaces within an argument */
+ if ((*c == ' ' || *c == '\t') && !quoted) {
+ git_str_putc(out, '"');
+ quoted = true;
+ } else if (*c != ' ' && *c != '\t' && quoted) {
+ git_str_putc(out, '"');
+ quoted = false;
+ }
+
+ /* Escape double-quotes and backslashes */
+ if (*c == '"' || *c == '\\')
+ git_str_putc(out, '\\');
+
+ git_str_putc(out, *c);
+ }
+ }
+
+ return git_str_oom(out) ? -1 : 0;
+}
+
+GIT_INLINE(bool) is_delete_env(const char *env)
+{
+ char *c = strchr(env, '=');
+
+ if (c == NULL)
+ return false;
+
+ return *(c+1) == '\0';
+}
+
+static int merge_env(wchar_t **out, const char **in, size_t in_len, bool exclude_env)
+{
+ git_str merged = GIT_STR_INIT;
+ wchar_t *in16 = NULL, *env = NULL, *e;
+ char *e8 = NULL;
+ size_t e_len;
+ int ret = 0;
+ size_t i;
+
+ *out = NULL;
+
+ in16 = git__malloc(ENV_MAX * sizeof(wchar_t));
+ GIT_ERROR_CHECK_ALLOC(in16);
+
+ e8 = git__malloc(ENV_MAX);
+ GIT_ERROR_CHECK_ALLOC(e8);
+
+ for (i = 0; in && i < in_len; i++) {
+ if (is_delete_env(in[i]))
+ continue;
+
+ if ((ret = git_utf8_to_16(in16, ENV_MAX, in[i])) < 0)
+ goto done;
+
+ git_str_put(&merged, (const char *)in16, ret * 2);
+ git_str_put(&merged, "\0\0", 2);
+ }
+
+ if (!exclude_env) {
+ env = GetEnvironmentStringsW();
+
+ for (e = env; *e; e += (e_len + 1)) {
+ e_len = wcslen(e);
+
+ if ((ret = git_utf8_from_16(e8, ENV_MAX, e)) < 0)
+ goto done;
+
+ if (git_strlist_contains_key(in, in_len, e8, '='))
+ continue;
+
+ git_str_put(&merged, (const char *)e, e_len * 2);
+ git_str_put(&merged, "\0\0", 2);
+ }
+ }
+
+ git_str_put(&merged, "\0\0", 2);
+
+ *out = (wchar_t *)git_str_detach(&merged);
+
+done:
+ if (env)
+ FreeEnvironmentStringsW(env);
+
+ git_str_dispose(&merged);
+ git__free(e8);
+ git__free(in16);
+
+ return ret < 0 ? -1 : 0;
+}
+
+static int process_new(
+ git_process **out,
+ const char *appname,
+ const char *cmdline,
+ const char **env,
+ size_t env_len,
+ git_process_options *opts)
+{
+ git_process *process;
+ int error = 0;
+
+ *out = NULL;
+
+ process = git__calloc(1, sizeof(git_process));
+ GIT_ERROR_CHECK_ALLOC(process);
+
+ if (appname &&
+ git_utf8_to_16_alloc(&process->appname, appname) < 0) {
+ error = -1;
+ goto done;
+ }
+
+ if (git_utf8_to_16_alloc(&process->cmdline, cmdline) < 0) {
+ error = -1;
+ goto done;
+ }
+
+ if (opts && opts->cwd &&
+ git_utf8_to_16_alloc(&process->cwd, opts->cwd) < 0) {
+ error = -1;
+ goto done;
+ }
+
+ if (env && (error = merge_env(&process->env, env, env_len, opts && opts->exclude_env) < 0))
+ goto done;
+
+ if (opts) {
+ process->capture_in = opts->capture_in;
+ process->capture_out = opts->capture_out;
+ process->capture_err = opts->capture_err;
+ }
+
+done:
+ if (error)
+ git_process_free(process);
+ else
+ *out = process;
+
+ return error;
+}
+
+int git_process_new_from_cmdline(
+ git_process **out,
+ const char *cmdline,
+ const char **env,
+ size_t env_len,
+ git_process_options *opts)
+{
+ GIT_ASSERT_ARG(out && cmdline);
+
+ return process_new(out, NULL, cmdline, env, env_len, opts);
+}
+
+int git_process_new(
+ git_process **out,
+ const char **args,
+ size_t args_len,
+ const char **env,
+ size_t env_len,
+ git_process_options *opts)
+{
+ git_str cmdline = GIT_STR_INIT;
+ int error;
+
+ GIT_ASSERT_ARG(out && args && args_len > 0);
+
+ if ((error = git_process__cmdline(&cmdline, args, args_len)) < 0)
+ goto done;
+
+ error = process_new(out, args[0], cmdline.ptr, env, env_len, opts);
+
+done:
+ git_str_dispose(&cmdline);
+ return error;
+}
+
+#define CLOSE_HANDLE(h) do { if ((h) != NULL) CloseHandle(h); } while(0)
+
+int git_process_start(git_process *process)
+{
+ STARTUPINFOW startup_info;
+ SECURITY_ATTRIBUTES security_attrs;
+ DWORD flags = CREATE_UNICODE_ENVIRONMENT;
+ HANDLE in[2] = { NULL, NULL },
+ out[2] = { NULL, NULL },
+ err[2] = { NULL, NULL };
+
+ memset(&security_attrs, 0, sizeof(SECURITY_ATTRIBUTES));
+ security_attrs.bInheritHandle = TRUE;
+
+ memset(&startup_info, 0, sizeof(STARTUPINFOW));
+ startup_info.cb = sizeof(STARTUPINFOW);
+ startup_info.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
+ startup_info.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
+ startup_info.hStdError = GetStdHandle(STD_ERROR_HANDLE);
+
+ if (process->capture_in) {
+ if (!CreatePipe(&in[0], &in[1], &security_attrs, 0) ||
+ !SetHandleInformation(in[1], HANDLE_FLAG_INHERIT, 0)) {
+ git_error_set(GIT_ERROR_OS, "could not create pipe");
+ goto on_error;
+ }
+
+ startup_info.hStdInput = in[0];
+ startup_info.dwFlags |= STARTF_USESTDHANDLES;
+ }
+
+ if (process->capture_out) {
+ if (!CreatePipe(&out[0], &out[1], &security_attrs, 0) ||
+ !SetHandleInformation(out[0], HANDLE_FLAG_INHERIT, 0)) {
+ git_error_set(GIT_ERROR_OS, "could not create pipe");
+ goto on_error;
+ }
+
+ startup_info.hStdOutput = out[1];
+ startup_info.dwFlags |= STARTF_USESTDHANDLES;
+ }
+
+ if (process->capture_err) {
+ if (!CreatePipe(&err[0], &err[1], &security_attrs, 0) ||
+ !SetHandleInformation(err[0], HANDLE_FLAG_INHERIT, 0)) {
+ git_error_set(GIT_ERROR_OS, "could not create pipe");
+ goto on_error;
+ }
+
+ startup_info.hStdError = err[1];
+ startup_info.dwFlags |= STARTF_USESTDHANDLES;
+ }
+
+ memset(&process->process_info, 0, sizeof(PROCESS_INFORMATION));
+
+ if (!CreateProcessW(process->appname, process->cmdline,
+ NULL, NULL, TRUE, flags, process->env,
+ process->cwd,
+ &startup_info,
+ &process->process_info)) {
+ git_error_set(GIT_ERROR_OS, "could not create process");
+ goto on_error;
+ }
+
+ CLOSE_HANDLE(in[0]); process->child_in = in[1];
+ CLOSE_HANDLE(out[1]); process->child_out = out[0];
+ CLOSE_HANDLE(err[1]); process->child_err = err[0];
+
+ return 0;
+
+on_error:
+ CLOSE_HANDLE(in[0]); CLOSE_HANDLE(in[1]);
+ CLOSE_HANDLE(out[0]); CLOSE_HANDLE(out[1]);
+ CLOSE_HANDLE(err[0]); CLOSE_HANDLE(err[1]);
+ return -1;
+}
+
+int git_process_id(p_pid_t *out, git_process *process)
+{
+ GIT_ASSERT(out && process);
+
+ if (!process->process_info.dwProcessId) {
+ git_error_set(GIT_ERROR_INVALID, "process not running");
+ return -1;
+ }
+
+ *out = process->process_info.dwProcessId;
+ return 0;
+}
+
+ssize_t git_process_read(git_process *process, void *buf, size_t count)
+{
+ DWORD ret;
+
+ if (count > DWORD_MAX)
+ count = DWORD_MAX;
+ if (count > SSIZE_MAX)
+ count = SSIZE_MAX;
+
+ if (!ReadFile(process->child_out, buf, (DWORD)count, &ret, NULL)) {
+ if (GetLastError() == ERROR_BROKEN_PIPE)
+ return 0;
+
+ git_error_set(GIT_ERROR_OS, "could not read");
+ return -1;
+ }
+
+ return ret;
+}
+
+ssize_t git_process_write(git_process *process, const void *buf, size_t count)
+{
+ DWORD ret;
+
+ if (count > DWORD_MAX)
+ count = DWORD_MAX;
+ if (count > SSIZE_MAX)
+ count = SSIZE_MAX;
+
+ if (!WriteFile(process->child_in, buf, (DWORD)count, &ret, NULL)) {
+ git_error_set(GIT_ERROR_OS, "could not write");
+ return -1;
+ }
+
+ return ret;
+}
+
+int git_process_close_in(git_process *process)
+{
+ if (!process->capture_in) {
+ git_error_set(GIT_ERROR_INVALID, "input is not open");
+ return -1;
+ }
+
+ if (process->child_in) {
+ CloseHandle(process->child_in);
+ process->child_in = NULL;
+ }
+
+ return 0;
+}
+
+int git_process_close_out(git_process *process)
+{
+ if (!process->capture_out) {
+ git_error_set(GIT_ERROR_INVALID, "output is not open");
+ return -1;
+ }
+
+ if (process->child_out) {
+ CloseHandle(process->child_out);
+ process->child_out = NULL;
+ }
+
+ return 0;
+}
+
+int git_process_close_err(git_process *process)
+{
+ if (!process->capture_err) {
+ git_error_set(GIT_ERROR_INVALID, "error is not open");
+ return -1;
+ }
+
+ if (process->child_err) {
+ CloseHandle(process->child_err);
+ process->child_err = NULL;
+ }
+
+ return 0;
+}
+
+int git_process_close(git_process *process)
+{
+ if (process->child_in) {
+ CloseHandle(process->child_in);
+ process->child_in = NULL;
+ }
+
+ if (process->child_out) {
+ CloseHandle(process->child_out);
+ process->child_out = NULL;
+ }
+
+ if (process->child_err) {
+ CloseHandle(process->child_err);
+ process->child_err = NULL;
+ }
+
+ CloseHandle(process->process_info.hProcess);
+ process->process_info.hProcess = NULL;
+
+ CloseHandle(process->process_info.hThread);
+ process->process_info.hThread = NULL;
+
+ return 0;
+}
+
+int git_process_wait(git_process_result *result, git_process *process)
+{
+ DWORD exitcode;
+
+ if (result)
+ memset(result, 0, sizeof(git_process_result));
+
+ if (!process->process_info.dwProcessId) {
+ git_error_set(GIT_ERROR_INVALID, "process is stopped");
+ return -1;
+ }
+
+ if (WaitForSingleObject(process->process_info.hProcess, INFINITE) == WAIT_FAILED) {
+ git_error_set(GIT_ERROR_OS, "could not wait for process");
+ return -1;
+ }
+
+ if (!GetExitCodeProcess(process->process_info.hProcess, &exitcode)) {
+ git_error_set(GIT_ERROR_OS, "could not get process exit code");
+ return -1;
+ }
+
+ result->status = GIT_PROCESS_STATUS_NORMAL;
+ result->exitcode = exitcode;
+
+ memset(&process->process_info, 0, sizeof(PROCESS_INFORMATION));
+ return 0;
+}
+
+int git_process_result_msg(git_str *out, git_process_result *result)
+{
+ if (result->status == GIT_PROCESS_STATUS_NONE) {
+ return git_str_puts(out, "process not started");
+ } else if (result->status == GIT_PROCESS_STATUS_NORMAL) {
+ return git_str_printf(out, "process exited with code %d",
+ result->exitcode);
+ } else if (result->signal) {
+ return git_str_printf(out, "process exited on signal %d",
+ result->signal);
+ }
+
+ return git_str_puts(out, "unknown error");
+}
+
+void git_process_free(git_process *process)
+{
+ if (!process)
+ return;
+
+ if (process->process_info.hProcess)
+ git_process_close(process);
+
+ git__free(process->env);
+ git__free(process->cwd);
+ git__free(process->cmdline);
+ git__free(process->appname);
+ git__free(process);
+}
diff --git a/src/util/win32/utf-conv.c b/src/util/win32/utf-conv.c
index 4bde3023ab6..ad35c0c35ff 100644
--- a/src/util/win32/utf-conv.c
+++ b/src/util/win32/utf-conv.c
@@ -15,108 +15,114 @@ GIT_INLINE(void) git__set_errno(void)
errno = EINVAL;
}
-/**
- * Converts a UTF-8 string to wide characters.
- *
- * @param dest The buffer to receive the wide string.
- * @param dest_size The size of the buffer, in characters.
- * @param src The UTF-8 string to convert.
- * @return The length of the wide string, in characters (not counting the NULL terminator), or < 0 for failure
- */
-int git__utf8_to_16(wchar_t *dest, size_t dest_size, const char *src)
+int git_utf8_to_16(wchar_t *dest, size_t dest_size, const char *src)
+{
+ /* Length of -1 indicates NULL termination of the input string. */
+ return git_utf8_to_16_with_len(dest, dest_size, src, -1);
+}
+
+int git_utf8_to_16_with_len(
+ wchar_t *dest,
+ size_t _dest_size,
+ const char *src,
+ int src_len)
{
+ int dest_size = (int)min(_dest_size, INT_MAX);
int len;
- /* Length of -1 indicates NULL termination of the input string. Subtract 1 from the result to
- * turn 0 into -1 (an error code) and to not count the NULL terminator as part of the string's
- * length. MultiByteToWideChar never returns int's minvalue, so underflow is not possible */
- if ((len = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, src, -1, dest, (int)dest_size) - 1) < 0)
+ /*
+ * Subtract 1 from the result to turn 0 into -1 (an error code) and
+ * to not count the NULL terminator as part of the string's length.
+ * MultiByteToWideChar never returns int's minvalue, so underflow
+ * is not possible.
+ */
+ len = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS,
+ src, src_len, dest, dest_size) - 1;
+
+ if (len < 0)
git__set_errno();
return len;
}
-/**
- * Converts a wide string to UTF-8.
- *
- * @param dest The buffer to receive the UTF-8 string.
- * @param dest_size The size of the buffer, in bytes.
- * @param src The wide string to convert.
- * @return The length of the UTF-8 string, in bytes (not counting the NULL terminator), or < 0 for failure
- */
-int git__utf16_to_8(char *dest, size_t dest_size, const wchar_t *src)
+int git_utf8_from_16(char *dest, size_t dest_size, const wchar_t *src)
{
+ /* Length of -1 indicates NULL termination of the input string. */
+ return git_utf8_from_16_with_len(dest, dest_size, src, -1);
+}
+
+int git_utf8_from_16_with_len(
+ char *dest,
+ size_t _dest_size,
+ const wchar_t *src,
+ int src_len)
+{
+ int dest_size = (int)min(_dest_size, INT_MAX);
int len;
- /* Length of -1 indicates NULL termination of the input string. Subtract 1 from the result to
- * turn 0 into -1 (an error code) and to not count the NULL terminator as part of the string's
- * length. WideCharToMultiByte never returns int's minvalue, so underflow is not possible */
- if ((len = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, src, -1, dest, (int)dest_size, NULL, NULL) - 1) < 0)
+ /*
+ * Subtract 1 from the result to turn 0 into -1 (an error code) and
+ * to not count the NULL terminator as part of the string's length.
+ * WideCharToMultiByte never returns int's minvalue, so underflow
+ * is not possible.
+ */
+ len = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS,
+ src, src_len, dest, dest_size, NULL, NULL) - 1;
+
+ if (len < 0)
git__set_errno();
return len;
}
-/**
- * Converts a UTF-8 string to wide characters.
- * Memory is allocated to hold the converted string.
- * The caller is responsible for freeing the string with git__free.
- *
- * @param dest Receives a pointer to the wide string.
- * @param src The UTF-8 string to convert.
- * @return The length of the wide string, in characters (not counting the NULL terminator), or < 0 for failure
- */
-int git__utf8_to_16_alloc(wchar_t **dest, const char *src)
+int git_utf8_to_16_alloc(wchar_t **dest, const char *src)
+{
+ /* Length of -1 indicates NULL termination of the input string. */
+ return git_utf8_to_16_alloc_with_len(dest, src, -1);
+}
+
+int git_utf8_to_16_alloc_with_len(wchar_t **dest, const char *src, int src_len)
{
int utf16_size;
*dest = NULL;
- /* Length of -1 indicates NULL termination of the input string */
- utf16_size = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, src, -1, NULL, 0);
+ utf16_size = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS,
+ src, src_len, NULL, 0);
if (!utf16_size) {
git__set_errno();
return -1;
}
- if (!(*dest = git__mallocarray(utf16_size, sizeof(wchar_t)))) {
- errno = ENOMEM;
- return -1;
- }
+ *dest = git__mallocarray(utf16_size, sizeof(wchar_t));
+ GIT_ERROR_CHECK_ALLOC(*dest);
- utf16_size = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, src, -1, *dest, utf16_size);
-
- if (!utf16_size) {
- git__set_errno();
+ utf16_size = git_utf8_to_16_with_len(*dest, (size_t)utf16_size,
+ src, src_len);
+ if (utf16_size < 0) {
git__free(*dest);
*dest = NULL;
}
- /* Subtract 1 from the result to turn 0 into -1 (an error code) and to not count the NULL
- * terminator as part of the string's length. MultiByteToWideChar never returns int's minvalue,
- * so underflow is not possible */
- return utf16_size - 1;
+ return utf16_size;
}
-/**
- * Converts a wide string to UTF-8.
- * Memory is allocated to hold the converted string.
- * The caller is responsible for freeing the string with git__free.
- *
- * @param dest Receives a pointer to the UTF-8 string.
- * @param src The wide string to convert.
- * @return The length of the UTF-8 string, in bytes (not counting the NULL terminator), or < 0 for failure
- */
-int git__utf16_to_8_alloc(char **dest, const wchar_t *src)
+int git_utf8_from_16_alloc(char **dest, const wchar_t *src)
+{
+ /* Length of -1 indicates NULL termination of the input string. */
+ return git_utf8_from_16_alloc_with_len(dest, src, -1);
+}
+
+int git_utf8_from_16_alloc_with_len(char **dest, const wchar_t *src, int src_len)
{
int utf8_size;
*dest = NULL;
- /* Length of -1 indicates NULL termination of the input string */
- utf8_size = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, src, -1, NULL, 0, NULL, NULL);
+ utf8_size = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS,
+ src, src_len, NULL, 0, NULL, NULL);
if (!utf8_size) {
git__set_errno();
@@ -124,23 +130,15 @@ int git__utf16_to_8_alloc(char **dest, const wchar_t *src)
}
*dest = git__malloc(utf8_size);
+ GIT_ERROR_CHECK_ALLOC(*dest);
- if (!*dest) {
- errno = ENOMEM;
- return -1;
- }
-
- utf8_size = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, src, -1, *dest, utf8_size, NULL, NULL);
-
- if (!utf8_size) {
- git__set_errno();
+ utf8_size = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS,
+ src, src_len, *dest, utf8_size, NULL, NULL);
+ if (utf8_size < 0) {
git__free(*dest);
*dest = NULL;
}
- /* Subtract 1 from the result to turn 0 into -1 (an error code) and to not count the NULL
- * terminator as part of the string's length. MultiByteToWideChar never returns int's minvalue,
- * so underflow is not possible */
- return utf8_size - 1;
+ return utf8_size;
}
diff --git a/src/util/win32/utf-conv.h b/src/util/win32/utf-conv.h
index 120d647efdf..301f5a6d36c 100644
--- a/src/util/win32/utf-conv.h
+++ b/src/util/win32/utf-conv.h
@@ -15,15 +15,46 @@
# define WC_ERR_INVALID_CHARS 0x80
#endif
+/**
+ * Converts a NUL-terminated UTF-8 string to wide characters. This is a
+ * convenience function for `git_utf8_to_16_with_len`.
+ *
+ * @param dest The buffer to receive the wide string.
+ * @param dest_size The size of the buffer, in characters.
+ * @param src The UTF-8 string to convert.
+ * @return The length of the wide string, in characters
+ * (not counting the NULL terminator), or < 0 for failure
+ */
+int git_utf8_to_16(wchar_t *dest, size_t dest_size, const char *src);
+
/**
* Converts a UTF-8 string to wide characters.
*
* @param dest The buffer to receive the wide string.
* @param dest_size The size of the buffer, in characters.
* @param src The UTF-8 string to convert.
- * @return The length of the wide string, in characters (not counting the NULL terminator), or < 0 for failure
+ * @param src_len The length of the string to convert.
+ * @return The length of the wide string, in characters
+ * (not counting the NULL terminator), or < 0 for failure
+ */
+int git_utf8_to_16_with_len(
+ wchar_t *dest,
+ size_t dest_size,
+ const char *src,
+ int src_len);
+
+/**
+ * Converts a NUL-terminated wide string to UTF-8. This is a convenience
+ * function for `git_utf8_from_16_with_len`.
+ *
+ * @param dest The buffer to receive the UTF-8 string.
+ * @param dest_size The size of the buffer, in bytes.
+ * @param src The wide string to convert.
+ * @param src_len The length of the string to convert.
+ * @return The length of the UTF-8 string, in bytes
+ * (not counting the NULL terminator), or < 0 for failure
*/
-int git__utf8_to_16(wchar_t *dest, size_t dest_size, const char *src);
+int git_utf8_from_16(char *dest, size_t dest_size, const wchar_t *src);
/**
* Converts a wide string to UTF-8.
@@ -31,30 +62,66 @@ int git__utf8_to_16(wchar_t *dest, size_t dest_size, const char *src);
* @param dest The buffer to receive the UTF-8 string.
* @param dest_size The size of the buffer, in bytes.
* @param src The wide string to convert.
- * @return The length of the UTF-8 string, in bytes (not counting the NULL terminator), or < 0 for failure
+ * @param src_len The length of the string to convert.
+ * @return The length of the UTF-8 string, in bytes
+ * (not counting the NULL terminator), or < 0 for failure
*/
-int git__utf16_to_8(char *dest, size_t dest_size, const wchar_t *src);
+int git_utf8_from_16_with_len(char *dest, size_t dest_size, const wchar_t *src, int src_len);
/**
- * Converts a UTF-8 string to wide characters.
- * Memory is allocated to hold the converted string.
- * The caller is responsible for freeing the string with git__free.
+ * Converts a UTF-8 string to wide characters. Memory is allocated to hold
+ * the converted string. The caller is responsible for freeing the string
+ * with git__free.
*
* @param dest Receives a pointer to the wide string.
* @param src The UTF-8 string to convert.
- * @return The length of the wide string, in characters (not counting the NULL terminator), or < 0 for failure
+ * @return The length of the wide string, in characters
+ * (not counting the NULL terminator), or < 0 for failure
*/
-int git__utf8_to_16_alloc(wchar_t **dest, const char *src);
+int git_utf8_to_16_alloc(wchar_t **dest, const char *src);
/**
- * Converts a wide string to UTF-8.
- * Memory is allocated to hold the converted string.
- * The caller is responsible for freeing the string with git__free.
+ * Converts a UTF-8 string to wide characters. Memory is allocated to hold
+ * the converted string. The caller is responsible for freeing the string
+ * with git__free.
+ *
+ * @param dest Receives a pointer to the wide string.
+ * @param src The UTF-8 string to convert.
+ * @param src_len The length of the string.
+ * @return The length of the wide string, in characters
+ * (not counting the NULL terminator), or < 0 for failure
+ */
+int git_utf8_to_16_alloc_with_len(
+ wchar_t **dest,
+ const char *src,
+ int src_len);
+
+/**
+ * Converts a wide string to UTF-8. Memory is allocated to hold the
+ * converted string. The caller is responsible for freeing the string
+ * with git__free.
+ *
+ * @param dest Receives a pointer to the UTF-8 string.
+ * @param src The wide string to convert.
+ * @return The length of the UTF-8 string, in bytes
+ * (not counting the NULL terminator), or < 0 for failure
+ */
+int git_utf8_from_16_alloc(char **dest, const wchar_t *src);
+
+/**
+ * Converts a wide string to UTF-8. Memory is allocated to hold the
+ * converted string. The caller is responsible for freeing the string
+ * with git__free.
*
* @param dest Receives a pointer to the UTF-8 string.
* @param src The wide string to convert.
- * @return The length of the UTF-8 string, in bytes (not counting the NULL terminator), or < 0 for failure
+ * @param src_len The length of the wide string.
+ * @return The length of the UTF-8 string, in bytes
+ * (not counting the NULL terminator), or < 0 for failure
*/
-int git__utf16_to_8_alloc(char **dest, const wchar_t *src);
+int git_utf8_from_16_alloc_with_len(
+ char **dest,
+ const wchar_t *src,
+ int src_len);
#endif
diff --git a/src/util/win32/w32_leakcheck.c b/src/util/win32/w32_leakcheck.c
index 0f095de12d2..26c20918ce3 100644
--- a/src/util/win32/w32_leakcheck.c
+++ b/src/util/win32/w32_leakcheck.c
@@ -7,7 +7,7 @@
#include "w32_leakcheck.h"
-#if defined(GIT_WIN32_LEAKCHECK)
+#if defined(GIT_DEBUG_LEAKCHECK_WIN32)
#include "Windows.h"
#include "Dbghelp.h"
diff --git a/src/util/win32/w32_leakcheck.h b/src/util/win32/w32_leakcheck.h
index 82d863851ee..52ff10a777a 100644
--- a/src/util/win32/w32_leakcheck.h
+++ b/src/util/win32/w32_leakcheck.h
@@ -13,7 +13,7 @@
/* Initialize the win32 leak checking system. */
int git_win32_leakcheck_global_init(void);
-#if defined(GIT_WIN32_LEAKCHECK)
+#if defined(GIT_DEBUG_LEAKCHECK_WIN32)
#include
#include
diff --git a/src/util/win32/w32_util.c b/src/util/win32/w32_util.c
index fe4b75baefd..f5b006a1974 100644
--- a/src/util/win32/w32_util.c
+++ b/src/util/win32/w32_util.c
@@ -115,7 +115,7 @@ int git_win32__file_attribute_to_stat(
/* st_size gets the UTF-8 length of the target name, in bytes,
* not counting the NULL terminator */
- if ((st->st_size = git__utf16_to_8(NULL, 0, target)) < 0) {
+ if ((st->st_size = git_utf8_from_16(NULL, 0, target)) < 0) {
git_error_set(GIT_ERROR_OS, "could not convert reparse point name for '%ls'", path);
return -1;
}
diff --git a/src/util/win32/w32_util.h b/src/util/win32/w32_util.h
index 519663720d5..dfdf69cd0db 100644
--- a/src/util/win32/w32_util.h
+++ b/src/util/win32/w32_util.h
@@ -77,8 +77,10 @@ GIT_INLINE(void) git_win32__filetime_to_timespec(
int64_t winTime = ((int64_t)ft->dwHighDateTime << 32) + ft->dwLowDateTime;
winTime -= INT64_C(116444736000000000); /* Windows to Unix Epoch conversion */
ts->tv_sec = (time_t)(winTime / 10000000);
-#ifdef GIT_USE_NSEC
+#ifdef GIT_NSEC_WIN32
ts->tv_nsec = (winTime % 10000000) * 100;
+#elif GIT_NSEC
+# error GIT_NSEC defined but GIT_NSEC_WIN32 not defined
#else
ts->tv_nsec = 0;
#endif
diff --git a/tests/benchmarks/_script/flamegraph/README.md b/tests/benchmarks/_script/flamegraph/README.md
new file mode 100644
index 00000000000..ee1b3eee429
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/README.md
@@ -0,0 +1,226 @@
+# Flame Graphs visualize profiled code
+
+Main Website: http://www.brendangregg.com/flamegraphs.html
+
+Example (click to zoom):
+
+[](http://www.brendangregg.com/FlameGraphs/cpu-bash-flamegraph.svg)
+
+Click a box to zoom the Flame Graph to this stack frame only.
+To search and highlight all stack frames matching a regular expression, click the _search_ button in the upper right corner or press Ctrl-F.
+By default, search is case sensitive, but this can be toggled by pressing Ctrl-I or by clicking the _ic_ button in the upper right corner.
+
+Other sites:
+- The Flame Graph article in ACMQ and CACM: http://queue.acm.org/detail.cfm?id=2927301 http://cacm.acm.org/magazines/2016/6/202665-the-flame-graph/abstract
+- CPU profiling using Linux perf\_events, DTrace, SystemTap, or ktap: http://www.brendangregg.com/FlameGraphs/cpuflamegraphs.html
+- CPU profiling using XCode Instruments: http://schani.wordpress.com/2012/11/16/flame-graphs-for-instruments/
+- CPU profiling using Xperf.exe: http://randomascii.wordpress.com/2013/03/26/summarizing-xperf-cpu-usage-with-flame-graphs/
+- Memory profiling: http://www.brendangregg.com/FlameGraphs/memoryflamegraphs.html
+- Other examples, updates, and news: http://www.brendangregg.com/flamegraphs.html#Updates
+
+Flame graphs can be created in three steps:
+
+1. Capture stacks
+2. Fold stacks
+3. flamegraph.pl
+
+1\. Capture stacks
+=================
+Stack samples can be captured using Linux perf\_events, FreeBSD pmcstat (hwpmc), DTrace, SystemTap, and many other profilers. See the stackcollapse-\* converters.
+
+### Linux perf\_events
+
+Using Linux perf\_events (aka "perf") to capture 60 seconds of 99 Hertz stack samples, both user- and kernel-level stacks, all processes:
+
+```
+# perf record -F 99 -a -g -- sleep 60
+# perf script > out.perf
+```
+
+Now only capturing PID 181:
+
+```
+# perf record -F 99 -p 181 -g -- sleep 60
+# perf script > out.perf
+```
+
+### DTrace
+
+Using DTrace to capture 60 seconds of kernel stacks at 997 Hertz:
+
+```
+# dtrace -x stackframes=100 -n 'profile-997 /arg0/ { @[stack()] = count(); } tick-60s { exit(0); }' -o out.kern_stacks
+```
+
+Using DTrace to capture 60 seconds of user-level stacks for PID 12345 at 97 Hertz:
+
+```
+# dtrace -x ustackframes=100 -n 'profile-97 /pid == 12345 && arg1/ { @[ustack()] = count(); } tick-60s { exit(0); }' -o out.user_stacks
+```
+
+60 seconds of user-level stacks, including time spent in-kernel, for PID 12345 at 97 Hertz:
+
+```
+# dtrace -x ustackframes=100 -n 'profile-97 /pid == 12345/ { @[ustack()] = count(); } tick-60s { exit(0); }' -o out.user_stacks
+```
+
+Switch `ustack()` for `jstack()` if the application has a ustack helper to include translated frames (eg, node.js frames; see: http://dtrace.org/blogs/dap/2012/01/05/where-does-your-node-program-spend-its-time/). The rate for user-level stack collection is deliberately slower than kernel, which is especially important when using `jstack()` as it performs additional work to translate frames.
+
+2\. Fold stacks
+==============
+Use the stackcollapse programs to fold stack samples into single lines. The programs provided are:
+
+- `stackcollapse.pl`: for DTrace stacks
+- `stackcollapse-perf.pl`: for Linux perf_events "perf script" output
+- `stackcollapse-pmc.pl`: for FreeBSD pmcstat -G stacks
+- `stackcollapse-stap.pl`: for SystemTap stacks
+- `stackcollapse-instruments.pl`: for XCode Instruments
+- `stackcollapse-vtune.pl`: for Intel VTune profiles
+- `stackcollapse-ljp.awk`: for Lightweight Java Profiler
+- `stackcollapse-jstack.pl`: for Java jstack(1) output
+- `stackcollapse-gdb.pl`: for gdb(1) stacks
+- `stackcollapse-go.pl`: for Golang pprof stacks
+- `stackcollapse-vsprof.pl`: for Microsoft Visual Studio profiles
+- `stackcollapse-wcp.pl`: for wallClockProfiler output
+
+Usage example:
+
+```
+For perf_events:
+$ ./stackcollapse-perf.pl out.perf > out.folded
+
+For DTrace:
+$ ./stackcollapse.pl out.kern_stacks > out.kern_folded
+```
+
+The output looks like this:
+
+```
+unix`_sys_sysenter_post_swapgs 1401
+unix`_sys_sysenter_post_swapgs;genunix`close 5
+unix`_sys_sysenter_post_swapgs;genunix`close;genunix`closeandsetf 85
+unix`_sys_sysenter_post_swapgs;genunix`close;genunix`closeandsetf;c2audit`audit_closef 26
+unix`_sys_sysenter_post_swapgs;genunix`close;genunix`closeandsetf;c2audit`audit_setf 5
+unix`_sys_sysenter_post_swapgs;genunix`close;genunix`closeandsetf;genunix`audit_getstate 6
+unix`_sys_sysenter_post_swapgs;genunix`close;genunix`closeandsetf;genunix`audit_unfalloc 2
+unix`_sys_sysenter_post_swapgs;genunix`close;genunix`closeandsetf;genunix`closef 48
+[...]
+```
+
+3\. flamegraph.pl
+================
+Use flamegraph.pl to render a SVG.
+
+```
+$ ./flamegraph.pl out.kern_folded > kernel.svg
+```
+
+An advantage of having the folded input file (and why this is separate to flamegraph.pl) is that you can use grep for functions of interest. Eg:
+
+```
+$ grep cpuid out.kern_folded | ./flamegraph.pl > cpuid.svg
+```
+
+Provided Examples
+=================
+
+### Linux perf\_events
+
+An example output from Linux "perf script" is included, gzip'd, as example-perf-stacks.txt.gz. The resulting flame graph is example-perf.svg:
+
+[](http://www.brendangregg.com/FlameGraphs/example-perf.svg)
+
+You can create this using:
+
+```
+$ gunzip -c example-perf-stacks.txt.gz | ./stackcollapse-perf.pl --all | ./flamegraph.pl --color=java --hash > example-perf.svg
+```
+
+This shows my typical workflow: I'll gzip profiles on the target, then copy them to my laptop for analysis. Since I have hundreds of profiles, I leave them gzip'd!
+
+Since this profile included Java, I used the flamegraph.pl --color=java palette. I've also used stackcollapse-perf.pl --all, which includes all annotations that help flamegraph.pl use separate colors for kernel and user level code. The resulting flame graph uses: green == Java, yellow == C++, red == user-mode native, orange == kernel.
+
+This profile was from an analysis of vert.x performance. The benchmark client, wrk, is also visible in the flame graph.
+
+### DTrace
+
+An example output from DTrace is also included, example-dtrace-stacks.txt, and the resulting flame graph, example-dtrace.svg:
+
+[](http://www.brendangregg.com/FlameGraphs/example-dtrace.svg)
+
+You can generate this using:
+
+```
+$ ./stackcollapse.pl example-stacks.txt | ./flamegraph.pl > example.svg
+```
+
+This was from a particular performance investigation: the Flame Graph identified that CPU time was spent in the lofs module, and quantified that time.
+
+
+Options
+=======
+See the USAGE message (--help) for options:
+
+USAGE: ./flamegraph.pl [options] infile > outfile.svg
+
+ --title TEXT # change title text
+ --subtitle TEXT # second level title (optional)
+ --width NUM # width of image (default 1200)
+ --height NUM # height of each frame (default 16)
+ --minwidth NUM # omit smaller functions. In pixels or use "%" for
+ # percentage of time (default 0.1 pixels)
+ --fonttype FONT # font type (default "Verdana")
+ --fontsize NUM # font size (default 12)
+ --countname TEXT # count type label (default "samples")
+ --nametype TEXT # name type label (default "Function:")
+ --colors PALETTE # set color palette. choices are: hot (default), mem,
+ # io, wakeup, chain, java, js, perl, red, green, blue,
+ # aqua, yellow, purple, orange
+ --bgcolors COLOR # set background colors. gradient choices are yellow
+ # (default), blue, green, grey; flat colors use "#rrggbb"
+ --hash # colors are keyed by function name hash
+ --cp # use consistent palette (palette.map)
+ --reverse # generate stack-reversed flame graph
+ --inverted # icicle graph
+ --flamechart # produce a flame chart (sort by time, do not merge stacks)
+ --negate # switch differential hues (blue<->red)
+ --notes TEXT # add notes comment in SVG (for debugging)
+ --help # this message
+
+ eg,
+ ./flamegraph.pl --title="Flame Graph: malloc()" trace.txt > graph.svg
+
+As suggested in the example, flame graphs can process traces of any event,
+such as malloc()s, provided stack traces are gathered.
+
+
+Consistent Palette
+==================
+If you use the `--cp` option, it will use the $colors selection and randomly
+generate the palette like normal. Any future flamegraphs created using the `--cp`
+option will use the same palette map. Any new symbols from future flamegraphs
+will have their colors randomly generated using the $colors selection.
+
+If you don't like the palette, just delete the palette.map file.
+
+This allows your to change your colorscheme between flamegraphs to make the
+differences REALLY stand out.
+
+Example:
+
+Say we have 2 captures, one with a problem, and one when it was working
+(whatever "it" is):
+
+```
+cat working.folded | ./flamegraph.pl --cp > working.svg
+# this generates a palette.map, as per the normal random generated look.
+
+cat broken.folded | ./flamegraph.pl --cp --colors mem > broken.svg
+# this svg will use the same palette.map for the same events, but a very
+# different colorscheme for any new events.
+```
+
+Take a look at the demo directory for an example:
+
+palette-example-working.svg
+palette-example-broken.svg
diff --git a/tests/benchmarks/_script/flamegraph/aix-perf.pl b/tests/benchmarks/_script/flamegraph/aix-perf.pl
new file mode 100755
index 00000000000..1edd082ecfc
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/aix-perf.pl
@@ -0,0 +1,31 @@
+#!/usr/bin/perl
+
+use Getopt::Std;
+
+getopt('urt');
+
+unless ($opt_r && $opt_t){
+ print "Usage: $0 [ -u user] -r sample_count -t sleep_time\n";
+ exit(0);
+}
+
+my $i;
+my @proc = "";
+for ($i = 0; $i < $opt_r ; $i++){
+ if ($opt_u){
+ $proc = `/usr/sysv/bin/ps -u $opt_u `;
+ $proc =~ s/^.*\n//;
+ $proc =~ s/\s*(\d+).*\n/\1 /g;
+ @proc = split(/\s+/,$proc);
+ } else {
+ opendir(my $dh, '/proc') || die "Cant't open /proc: $!";
+ @proc = grep { /^[\d]+$/ } readdir($dh);
+ closedir ($dh);
+ }
+
+ foreach my $pid (@proc){
+ my $command = "/usr/bin/procstack $pid";
+ print `$command 2>/dev/null`;
+ }
+ select(undef, undef, undef, $opt_t);
+}
diff --git a/tests/benchmarks/_script/flamegraph/difffolded.pl b/tests/benchmarks/_script/flamegraph/difffolded.pl
new file mode 100755
index 00000000000..4c76c2ecf30
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/difffolded.pl
@@ -0,0 +1,115 @@
+#!/usr/bin/perl -w
+#
+# difffolded.pl diff two folded stack files. Use this for generating
+# flame graph differentials.
+#
+# USAGE: ./difffolded.pl [-hns] folded1 folded2 | ./flamegraph.pl > diff2.svg
+#
+# Options are described in the usage message (-h).
+#
+# The flamegraph will be colored based on higher samples (red) and smaller
+# samples (blue). The frame widths will be based on the 2nd folded file.
+# This might be confusing if stack frames disappear entirely; it will make
+# the most sense to ALSO create a differential based on the 1st file widths,
+# while switching the hues; eg:
+#
+# ./difffolded.pl folded2 folded1 | ./flamegraph.pl --negate > diff1.svg
+#
+# Here's what they mean when comparing a before and after profile:
+#
+# diff1.svg: widths show the before profile, colored by what WILL happen
+# diff2.svg: widths show the after profile, colored by what DID happen
+#
+# INPUT: See stackcollapse* programs.
+#
+# OUTPUT: The full list of stacks, with two columns, one from each file.
+# If a stack wasn't present in a file, the column value is zero.
+#
+# folded_stack_trace count_from_folded1 count_from_folded2
+#
+# eg:
+#
+# funca;funcb;funcc 31 33
+# ...
+#
+# COPYRIGHT: Copyright (c) 2014 Brendan Gregg.
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+#
+# (http://www.gnu.org/copyleft/gpl.html)
+#
+# 28-Oct-2014 Brendan Gregg Created this.
+
+use strict;
+use Getopt::Std;
+
+# defaults
+my $normalize = 0; # make sample counts equal
+my $striphex = 0; # strip hex numbers
+
+sub usage {
+ print STDERR < diff2.svg
+ -h # help message
+ -n # normalize sample counts
+ -s # strip hex numbers (addresses)
+See stackcollapse scripts for generating folded files.
+Also consider flipping the files and hues to highlight reduced paths:
+$0 folded2 folded1 | ./flamegraph.pl --negate > diff1.svg
+USAGE_END
+ exit 2;
+}
+
+usage() if @ARGV < 2;
+our($opt_h, $opt_n, $opt_s);
+getopts('ns') or usage();
+usage() if $opt_h;
+$normalize = 1 if defined $opt_n;
+$striphex = 1 if defined $opt_s;
+
+my ($total1, $total2) = (0, 0);
+my %Folded;
+
+my $file1 = $ARGV[0];
+my $file2 = $ARGV[1];
+
+open FILE, $file1 or die "ERROR: Can't read $file1\n";
+while () {
+ chomp;
+ my ($stack, $count) = (/^(.*)\s+?(\d+(?:\.\d*)?)$/);
+ $stack =~ s/0x[0-9a-fA-F]+/0x.../g if $striphex;
+ $Folded{$stack}{1} += $count;
+ $total1 += $count;
+}
+close FILE;
+
+open FILE, $file2 or die "ERROR: Can't read $file2\n";
+while () {
+ chomp;
+ my ($stack, $count) = (/^(.*)\s+?(\d+(?:\.\d*)?)$/);
+ $stack =~ s/0x[0-9a-fA-F]+/0x.../g if $striphex;
+ $Folded{$stack}{2} += $count;
+ $total2 += $count;
+}
+close FILE;
+
+foreach my $stack (keys %Folded) {
+ $Folded{$stack}{1} = 0 unless defined $Folded{$stack}{1};
+ $Folded{$stack}{2} = 0 unless defined $Folded{$stack}{2};
+ if ($normalize && $total1 != $total2) {
+ $Folded{$stack}{1} = int($Folded{$stack}{1} * $total2 / $total1);
+ }
+ print "$stack $Folded{$stack}{1} $Folded{$stack}{2}\n";
+}
diff --git a/tests/benchmarks/_script/flamegraph/example-dtrace-stacks.txt b/tests/benchmarks/_script/flamegraph/example-dtrace-stacks.txt
new file mode 100644
index 00000000000..04d84424719
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/example-dtrace-stacks.txt
@@ -0,0 +1,41913 @@
+CPU ID FUNCTION:NAME
+ 0 64091 :tick-60s
+
+
+ genunix`kmem_cpu_reload+0x20
+ genunix`kmem_cache_free+0xce
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`cv_broadcast+0x1
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`tsc_gethrtimeunscaled+0x21
+ genunix`gethrtime_unscaled+0xa
+ genunix`syscall_mstate+0x5d
+ unix`sys_syscall+0x10e
+ 1
+
+ unix`mutex_exit+0x12
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`mutex_exit+0x12
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`mutex_init+0x32
+ genunix`rwst_init+0x38
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`tsc_read+0x3
+ unix`mutex_vector_enter+0xcc
+ genunix`lookuppnatcred+0x89
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ zfs`zfs_lookup+0xa5
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`lookupnameatcred+0x76
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`fop_lookup+0x16
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_alloc+0x46
+ lofs`makelonode+0xa9
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`crfree+0x76
+ genunix`unfalloc+0x4a
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_rele+0x27
+ genunix`lookuppnvp+0x39f
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`fop_lookup+0x118
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`dispatch_hilevel+0x18
+ unix`do_interrupt+0x120
+ unix`_interrupt+0xba
+ unix`strlen+0x10
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cpu_reload+0x28
+ genunix`kmem_cache_free+0xce
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cpu_reload+0x28
+ genunix`kmem_cache_free+0xce
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ ufs`ufs_lookup+0x48
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`lookuppnvp+0x1f9
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_alloc+0x49
+ genunix`vn_alloc+0x1a
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_alloc+0x49
+ lofs`makelonode+0xa9
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`mutex_exit+0x19
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`mutex_init+0x39
+ genunix`rwst_init+0x38
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`ufalloc_file+0x4b
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`setf+0xfb
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_free+0xb
+ genunix`audit_unfalloc+0x44
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_rele+0x2c
+ genunix`lookuppnvp+0x39f
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`fop_lookup+0x1d
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cpu_reload+0x2d
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cpu_reload+0x2d
+ lofs`makelonode+0xa9
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_alloc+0x4e
+ genunix`kmem_zalloc+0x47
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`dnlc_lookup+0xef
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`sigcheck+0x20
+ genunix`post_syscall+0x3d3
+ unix`0xfffffffffb800c91
+ 1
+
+ ufs`ufs_getpage+0x1
+ genunix`segvn_fault+0xdfa
+ genunix`as_fault+0x36a
+ unix`pagefault+0x96
+ unix`trap+0x2c7
+ unix`0xfffffffffb8001d6
+ 1
+
+ genunix`dnlc_lookup+0xf2
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`pn_get_buf+0x13
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ zfs`specvp_check+0x24
+ zfs`zfs_lookup+0xf4
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`openat+0x25
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_alloc+0x56
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`post_syscall+0x1b7
+ unix`0xfffffffffb800c91
+ 1
+
+ genunix`cv_broadcast+0x17
+ genunix`rwst_exit+0x8f
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ zfs`zfs_fastaccesschk_execute+0x47
+ zfs`zfs_lookup+0xc2
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ lofs`table_lock_enter+0x8
+ lofs`freelonode+0x47
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_recycle+0x98
+ genunix`vn_reinit+0x7b
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ zfs`specvp_check+0x29
+ zfs`zfs_lookup+0xf4
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`fop_lookup+0x129
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_alloc+0x5a
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ lofs`table_lock_enter+0xc
+ lofs`makelonode+0x36
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_rele+0x3d
+ genunix`lookuppnvp+0x39f
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`mtype_func+0x8e
+ unix`page_get_mnode_freelist+0x4f
+ unix`page_get_freelist+0x16d
+ unix`page_create_va+0x2ad
+ genunix`pvn_read_kluster+0x10c
+ ufs`ufs_getpage_ra+0x11c
+ ufs`ufs_getpage+0x866
+ genunix`fop_getpage+0x7e
+ genunix`segvn_faulta+0x12b
+ genunix`as_faulta+0x143
+ genunix`memcntl+0x53d
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`post_syscall+0x1bf
+ unix`0xfffffffffb800c91
+ 1
+
+ genunix`lookuppnvp+0xf
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`dnlc_lookup+0x100
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`dnlc_lookup+0x104
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`copen+0x1a6
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ zfs`zfs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`setbackdq+0x258
+ FSS`fss_preempt+0x241
+ unix`preempt+0xd6
+ genunix`post_syscall+0x4cd
+ unix`0xfffffffffb800c91
+ 1
+
+ genunix`kmem_cache_alloc+0x6a
+ lofs`makelonode+0xa9
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`fd_find+0x9c
+ genunix`ufalloc_file+0x91
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`thread_lock+0x3f
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 1
+
+ genunix`disp_lock_exit+0x20
+ genunix`post_syscall+0x318
+ unix`0xfffffffffb800c91
+ 1
+
+ genunix`segvn_fault
+ unix`pagefault+0x96
+ unix`trap+0x2c7
+ unix`0xfffffffffb8001d6
+ 1
+
+ lofs`lo_root+0x22
+ genunix`fsop_root+0x2d
+ genunix`traverse+0x87
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_alloc+0x73
+ lofs`makelonode+0xa9
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ lofs`lo_lookup+0x54
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`open+0x14
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`htable_lookup+0x44
+ unix`htable_walk+0x17e
+ unix`hat_unload_callback+0x138
+ genunix`segvn_unmap+0x5b7
+ genunix`as_unmap+0x19c
+ unix`mmapobj_map_elf+0x147
+ unix`mmapobj_map_interpret+0x22c
+ unix`mmapobj+0x71
+ genunix`mmapobjsys+0x1d0
+ unix`sys_syscall+0x17a
+ 1
+
+ lofs`freelonode+0x1f9
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_free+0x3a
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_free+0x3a
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_vfslocks_getlock+0xc
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`dnlc_lookup+0x11e
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_rele+0x60
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`lookuppnvp+0x330
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_free+0xb0
+ genunix`unfalloc+0x61
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_mountedvfs+0x1
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_vfslocks_getlock+0x13
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`pn_getcomponent+0x84
+ genunix`lookuppnvp+0x16d
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`bcopy+0x244
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_alloc+0x84
+ genunix`kmem_alloc+0x4b
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_free+0xb4
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ ufs`ufs_lookup+0x84
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`audit_falloc+0x6
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`bcopy+0x248
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`lookuppnvp+0x138
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_alloc+0x89
+ lofs`makelonode+0xa9
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`lookuppnvp+0x23a
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`disp_lock_exit+0x3b
+ genunix`post_syscall+0x318
+ unix`0xfffffffffb800c91
+ 1
+
+ genunix`vn_vfslocks_getlock+0x1b
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`fd_reserve+0xb
+ genunix`ufalloc_file+0x103
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ lofs`table_lock_enter+0x3c
+ lofs`makelonode+0x36
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ lofs`table_lock_enter+0x3c
+ lofs`freelonode+0x47
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_alloc+0x8d
+ genunix`vn_alloc+0x1a
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_alloc+0x8d
+ genunix`kmem_alloc+0x4b
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_free+0xbd
+ genunix`audit_unfalloc+0x44
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_vfslocks_getlock+0x1f
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_reinit+0xf
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`syscall_mstate+0xff
+ unix`0xfffffffffb800c86
+ 1
+
+ unix`page_numtopp_nolock+0x130
+ unix`hat_pte_unmap+0xb8
+ unix`hat_unload_callback+0x259
+ genunix`segvn_unmap+0x5b7
+ genunix`as_free+0xdc
+ genunix`relvm+0x220
+ genunix`proc_exit+0x444
+ genunix`exit+0x15
+ genunix`rexit+0x18
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_mountedvfs+0x10
+ genunix`lookuppnvp+0x217
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`rwst_exit
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`rwst_exit+0x1
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_free+0x52
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_openat+0x83
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ lofs`table_lock_enter+0x45
+ lofs`makelonode+0x36
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_exists+0x15
+ lofs`makelonode+0x1e7
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`setbackdq+0x286
+ FSS`fss_preempt+0x241
+ unix`preempt+0xd6
+ genunix`post_syscall+0x4cd
+ unix`0xfffffffffb800c91
+ 1
+
+ genunix`vn_openat+0x486
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_openat+0x87
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_free+0x57
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`mutex_destroy+0x78
+ genunix`rwst_destroy+0x1c
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_vfslocks_getlock+0x29
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_openat+0x48a
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`lookuppnatcred+0x13a
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`rwst_init+0x1b
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`mutex_destroy+0x7b
+ genunix`rwst_destroy+0x1c
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`cv_init+0xd
+ genunix`rwst_init+0x47
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`cv_init+0xd
+ genunix`rwst_init+0x56
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_vfslocks_getlock+0x2d
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_free+0xce
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`lwp_getdatamodel+0xf
+ genunix`post_syscall+0x2f5
+ unix`0xfffffffffb800c91
+ 1
+
+ unix`prunstop
+ unix`0xfffffffffb800c91
+ 1
+
+ unix`hment_compare+0x10
+ genunix`avl_find+0x72
+ genunix`avl_add+0x27
+ unix`hment_insert+0x8b
+ unix`hment_assign+0x3a
+ unix`hati_pte_map+0x343
+ unix`hati_load_common+0x139
+ unix`hat_memload+0x75
+ unix`hat_memload_region+0x25
+ genunix`segvn_fault+0x1079
+ genunix`as_fault+0x36a
+ unix`pagefault+0x96
+ unix`trap+0x2c7
+ unix`0xfffffffffb8001d6
+ 1
+
+ unix`bcopy+0x260
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`syscall_mstate+0x10
+ unix`sys_syscall+0x1a1
+ 1
+
+ genunix`cv_init+0x11
+ genunix`rwst_init+0x47
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`cv_init+0x11
+ genunix`rwst_init+0x56
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`rwst_init+0x21
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`rwst_init+0x21
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`copen+0x1e2
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`membar_enter+0x3
+ unix`disp+0x11e
+ unix`swtch+0xba
+ unix`preempt+0xec
+ genunix`post_syscall+0x4cd
+ unix`0xfffffffffb800c91
+ 1
+
+ lofs`table_lock_enter+0x54
+ lofs`makelonode+0x36
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_openat+0x94
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`pn_getcomponent+0xa5
+ genunix`lookuppnvp+0x16d
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_vfslocks_getlock+0x35
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`cpucaps_charge+0x75
+ FSS`fss_preempt+0x12f
+ unix`preempt+0xd6
+ genunix`post_syscall+0x4cd
+ unix`0xfffffffffb800c91
+ 1
+
+ unix`bcopy+0x268
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`lookuppnvp+0x58
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`rwst_enter_common+0x1e8
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_vfslocks_getlock+0x39
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_alloc+0xd9
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`lwp_getdatamodel+0x19
+ genunix`post_syscall+0x2f5
+ unix`0xfffffffffb800c91
+ 1
+
+ unix`lwp_getdatamodel+0x1a
+ unix`0xfffffffffb800c91
+ 1
+
+ genunix`fop_lookup+0x7b
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`fop_lookup+0x7b
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_free+0xdb
+ genunix`unfalloc+0x61
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`crgetuid+0xb
+ ufs`ufs_iaccess+0xe5
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_vfslocks_getlock+0x3c
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`copen+0xed
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`cv_init+0x1d
+ genunix`rwst_init+0x56
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ lofs`freelonode+0x2f
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`pn_getcomponent+0xb0
+ genunix`lookuppnvp+0x16d
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`ufalloc_file+0xb0
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`syscall_mstate+0x22
+ unix`0xfffffffffb800c86
+ 1
+
+ genunix`audit_falloc+0x34
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`cv_broadcast+0x76
+ genunix`rwst_exit+0x8f
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`lock_try+0x6
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 1
+
+ genunix`set_errno+0x17
+ genunix`copen+0x4fa
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`copen+0x1f8
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`pn_getcomponent+0xba
+ genunix`lookuppnvp+0x16d
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`syscall_mstate+0x2a
+ unix`0xfffffffffb800c86
+ 1
+
+ genunix`post_syscall+0x21b
+ unix`0xfffffffffb800c91
+ 1
+
+ genunix`lookuppnatcred+0x5b
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`post_syscall+0x1b
+ unix`0xfffffffffb800c91
+ 1
+
+ unix`prunstop+0x1c
+ unix`0xfffffffffb800c91
+ 1
+
+ genunix`dnlc_lookup+0x5c
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookuppn+0x38
+ genunix`resolvepath+0x86
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_free+0xed
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_free+0xed
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_free+0xed
+ genunix`kmem_free+0x4e
+ genunix`removectx+0xf5
+ genunix`schedctl_lwp_cleanup+0x8e
+ genunix`exitlwps+0x73
+ genunix`proc_exit+0x59
+ genunix`exit+0x15
+ genunix`rexit+0x18
+ unix`sys_syscall+0x17a
+ 1
+
+ lofs`freelonode+0x23f
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`dnlc_lookup+0x160
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`copen+0x1
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_invalid+0x1
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_invalid+0x1
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`rwst_enter_common+0x1
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`do_splx+0x1
+ unix`preempt+0xec
+ genunix`post_syscall+0x4cd
+ unix`0xfffffffffb800c91
+ 1
+
+ genunix`crhold+0x11
+ genunix`falloc+0xbc
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`dnlc_lookup+0x65
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ zfs`zfs_lookup+0x25
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`lookuppnatcred+0x66
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`cv_destroy+0x8
+ genunix`rwst_destroy+0x25
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_setpath+0xc9
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`lookuppnatcred+0x6a
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_free+0xfa
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`cv_destroy+0xc
+ genunix`rwst_destroy+0x25
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_recycle+0xc
+ genunix`vn_reinit+0x7b
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`fop_lookup+0x9c
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_vfslocks_getlock+0x5d
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`lookuppnvp+0x7d
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`syscall_mstate+0x13d
+ unix`0xfffffffffb800c86
+ 1
+
+ genunix`syscall_mstate+0x13d
+ unix`sys_syscall+0x1a1
+ 1
+
+ genunix`lookuppnatcred+0x6e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_reinit+0x4f
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`pn_fixslash+0x40
+ genunix`lookuppnvp+0x105
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`do_splx+0x10
+ genunix`disp_lock_exit+0x47
+ genunix`post_syscall+0x318
+ unix`0xfffffffffb800c91
+ 1
+
+ genunix`kmem_cache_free
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_free
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`thread_lock+0xa1
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 1
+
+ genunix`memcmp+0x1
+ genunix`dnlc_lookup+0x10d
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`rwst_exit+0x41
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ doorfs`door_close+0x1
+ namefs`nm_close+0xac
+ genunix`fop_close+0x61
+ genunix`closef+0x5e
+ genunix`close_exec+0xfd
+ genunix`exec_common+0x7e4
+ genunix`exece+0x1b
+ unix`_sys_sysenter_post_swapgs+0x149
+ 1
+
+ unix`cpucaps_charge+0xa2
+ FSS`fss_preempt+0x12f
+ unix`preempt+0xd6
+ genunix`post_syscall+0x4cd
+ unix`0xfffffffffb800c91
+ 1
+
+ genunix`vn_vfslocks_rele+0x23
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`setf+0x83
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`dotoprocs+0xc4
+ genunix`doprio+0x77
+ genunix`priocntl_common+0x616
+ genunix`priocntlsys+0x24
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_alloc+0x4
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`syscall_mstate+0x45
+ unix`sys_syscall+0x10e
+ 1
+
+ genunix`setf+0x87
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`lock_clear_splx+0x7
+ genunix`post_syscall+0x318
+ unix`0xfffffffffb800c91
+ 1
+
+ genunix`fop_lookup+0xaa
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`fd_find+0xb
+ genunix`ufalloc_file+0x91
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`pn_fixslash+0x4c
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_free+0xc
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_vfslocks_getlock+0x6e
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_zalloc+0x1e
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`post_syscall+0x13e
+ unix`0xfffffffffb800c91
+ 1
+
+ genunix`copen+0x20
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`traverse+0x10
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_free+0x10
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_free+0x10
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_free+0x10
+ genunix`kmem_free+0x4e
+ genunix`audit_unfalloc+0x44
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ FSS`fss_preempt
+ genunix`post_syscall+0x4cd
+ unix`0xfffffffffb800c91
+ 1
+
+ genunix`vn_recycle+0x21
+ genunix`vn_reinit+0x7b
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`crfree+0x11
+ genunix`unfalloc+0x4a
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`rwst_enter_common+0x22
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`memcmp+0x13
+ unix`bcmp+0x9
+ genunix`dnlc_lookup+0x10d
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ zfs`zfs_lookup+0x43
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`syscall_mstate+0x153
+ unix`sys_syscall+0x1a1
+ 1
+
+ genunix`lookuppnatcred+0x84
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`crfree+0x15
+ genunix`unfalloc+0x4a
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`bitset_in_set+0x6
+ unix`cpu_wakeup_mwait+0x40
+ unix`setbackdq+0x200
+ FSS`fss_preempt+0x241
+ unix`preempt+0xd6
+ genunix`post_syscall+0x4cd
+ unix`0xfffffffffb800c91
+ 1
+
+ genunix`dnlc_lookup+0x186
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_zalloc+0x26
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`hment_insert+0x37
+ unix`hment_assign+0x3a
+ unix`hati_pte_map+0x343
+ unix`hati_load_common+0x139
+ unix`hat_memload+0x75
+ unix`hat_memload_region+0x25
+ genunix`segvn_fault+0x1079
+ genunix`as_fault+0x36a
+ unix`pagefault+0x96
+ unix`trap+0x2c7
+ unix`0xfffffffffb8001d6
+ 1
+
+ genunix`kmem_cache_free+0x17
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`setf+0x98
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`post_syscall+0x34b
+ unix`0xfffffffffb800c91
+ 1
+
+ genunix`traverse+0x1c
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`rwst_enter_common+0x2d
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_zalloc+0x2d
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`setbackdq+0x3de
+ FSS`fss_preempt+0x241
+ unix`preempt+0xd6
+ genunix`post_syscall+0x4cd
+ unix`0xfffffffffb800c91
+ 1
+
+ lofs`lo_inactive+0x1e
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_free+0x9e
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`lookupnameatcred+0x1e
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`lookuppnvp+0x39f
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`falloc+0xaf
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`fd_find+0x21
+ genunix`ufalloc_file+0x91
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`dnlc_lookup+0x92
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_free+0x22
+ genunix`kmem_free+0x4e
+ genunix`audit_unfalloc+0x44
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_free+0x22
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`secpolicy_vnode_access2+0x222
+ ufs`ufs_iaccess+0x128
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_free+0xa3
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`cmt_balance+0xc3
+ unix`setbackdq+0x3a3
+ FSS`fss_preempt+0x241
+ unix`preempt+0xd6
+ genunix`post_syscall+0x4cd
+ unix`0xfffffffffb800c91
+ 1
+
+ genunix`rwst_enter_common+0x335
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_recycle+0x36
+ genunix`vn_reinit+0x7b
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`lookuppnvp+0x3a7
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`syscall_mstate+0x167
+ unix`sys_syscall+0x1a1
+ 1
+
+ ufs`ufs_lookup+0xf7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`mutex_delay_default+0x7
+ unix`mutex_vector_enter+0xcc
+ genunix`lookuppnatcred+0x89
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`page_create_va+0x218
+ genunix`pvn_read_kluster+0x10c
+ ufs`ufs_getpage_ra+0x11c
+ ufs`ufs_getpage+0x866
+ genunix`fop_getpage+0x7e
+ genunix`segvn_faulta+0x12b
+ genunix`as_faulta+0x143
+ genunix`memcntl+0x53d
+ unix`sys_syscall+0x17a
+ 1
+
+ lofs`makelonode+0x6a
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`unfalloc+0x1a
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`fop_lookup+0x1cb
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`fop_lookup+0x1cb
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_free+0x2b
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vmem_free+0x2b
+ genunix`segkp_release_internal+0x1ab
+ genunix`segkp_release+0xa0
+ genunix`schedctl_freepage+0x34
+ genunix`schedctl_proc_cleanup+0x68
+ genunix`proc_exit+0x1ab
+ genunix`exit+0x15
+ genunix`rexit+0x18
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`crgetmapped+0xb
+ genunix`fop_lookup+0x1dc
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`copystr+0x2e
+ genunix`pn_get_buf+0x43
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_free+0x2f
+ genunix`unfalloc+0x61
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_free+0x2f
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`crgetmapped+0xf
+ genunix`fop_lookup+0x1dc
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_alloc+0x100
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_alloc+0x100
+ lofs`makelonode+0xa9
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ ufs`ufs_lookup+0x100
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ lofs`makelonode+0x71
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_openat+0xf1
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_vfsrlock+0x31
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`ufalloc_file+0x1
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`swtch+0x14
+ unix`preempt+0xec
+ unix`kpreempt+0x98
+ unix`sys_rtt_common+0x1ba
+ unix`_sys_rtt_ints_disabled+0x8
+ genunix`audit_getstate
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_recycle+0x45
+ genunix`vn_reinit+0x7b
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_vfslocks_rele+0x57
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_free+0x37
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ zfs`zfs_lookup+0x68
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`lookupnameatcred+0x3a
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_free+0x3a
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`schedctl_save+0x1b
+ genunix`savectx+0x35
+ unix`resume+0x5b
+ unix`swtch+0x141
+ unix`preempt+0xec
+ genunix`post_syscall+0x4cd
+ unix`0xfffffffffb800c91
+ 1
+
+ genunix`dnlc_lookup+0xac
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vsd_free+0xdc
+ genunix`vn_recycle+0xb5
+ genunix`vn_reinit+0x7b
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vsd_free+0xdc
+ genunix`vn_free+0x8b
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`thread_lock+0xdd
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 1
+
+ lofs`freelonode+0x18e
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ ufs`ufs_lookup+0xf
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ ufs`ufs_lookup+0x10f
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`pn_getcomponent+0x10
+ genunix`lookuppnvp+0x16d
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_alloc+0x110
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`mutex_enter
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`mutex_enter
+ genunix`kmem_zalloc+0x47
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`lgrp_mem_choose+0x1
+ genunix`swap_getapage+0x113
+ genunix`swap_getpage+0x90
+ genunix`fop_getpage+0x7e
+ genunix`anon_zero+0xb6
+ genunix`segvn_faultpage+0x6d2
+ genunix`segvn_fault+0x8e6
+ genunix`as_fault+0x36a
+ unix`pagefault+0x96
+ unix`trap+0x2c7
+ unix`0xfffffffffb8001d6
+ 1
+
+ genunix`audit_getstate+0x1
+ unix`0xfffffffffb800c91
+ 1
+
+ genunix`rwst_destroy+0x32
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`disp_lock_exit_high+0x33
+ unix`swtch+0xba
+ unix`preempt+0xec
+ genunix`post_syscall+0x4cd
+ unix`0xfffffffffb800c91
+ 1
+
+ genunix`lookuppnvp+0x3c3
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ ufs`ufs_lookup+0x13
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`syscall_mstate+0x84
+ unix`sys_syscall+0x1a1
+ 1
+
+ zfs`zfs_lookup+0x76
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`unfalloc+0x37
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_alloc+0x118
+ genunix`vn_alloc+0x1a
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ lofs`lo_lookup+0x2f9
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vsd_free+0xe9
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`mutex_enter+0x9
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`mutex_enter+0x9
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`mutex_enter+0x9
+ lofs`freelonode+0x47
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`mutex_enter+0x9
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`rwst_exit+0x8a
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_zalloc+0x5a
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_alloc+0x1b
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`copen+0x15c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`unfalloc+0x3c
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ zfs`zfs_fastaccesschk_execute+0xc
+ zfs`zfs_lookup+0xc2
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`audit_getstate+0xd
+ genunix`setf+0x3f
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`audit_getstate+0xd
+ genunix`lookuppnvp+0x82
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ zfs`zfs_lookup+0x7e
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`traverse+0x4e
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_alloc+0x1e
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`hwblkclr+0x3f
+ unix`pfnzero+0x78
+ unix`pagezero+0x2d
+ genunix`anon_zero+0xd2
+ genunix`segvn_faultpage+0x6d2
+ genunix`segvn_fault+0x8e6
+ genunix`as_fault+0x36a
+ unix`pagefault+0x96
+ unix`trap+0x2c7
+ unix`0xfffffffffb8001d6
+ 1
+
+ unix`tsc_gethrtimeunscaled
+ genunix`mstate_thread_onproc_time+0x59
+ unix`caps_charge_adjust+0x32
+ unix`cpucaps_charge+0x58
+ FSS`fss_preempt+0x12f
+ unix`preempt+0xd6
+ genunix`post_syscall+0x4cd
+ unix`0xfffffffffb800c91
+ 1
+
+ unix`page_lookup_create+0xf0
+ unix`page_lookup+0x21
+ genunix`swap_getapage+0xea
+ genunix`swap_getpage+0x90
+ genunix`fop_getpage+0x7e
+ genunix`anon_zero+0xb6
+ genunix`segvn_faultpage+0x6d2
+ genunix`segvn_fault+0x8e6
+ genunix`as_fault+0x36a
+ unix`pagefault+0x96
+ unix`trap+0x2c7
+ unix`0xfffffffffb8001d6
+ 1
+
+ unix`page_lookup_create+0xf0
+ unix`page_lookup+0x21
+ ufs`ufs_getpage+0x762
+ genunix`fop_getpage+0x7e
+ genunix`segvn_fault+0xdfa
+ genunix`as_fault+0x36a
+ unix`pagefault+0x96
+ unix`trap+0x2c7
+ unix`0xfffffffffb8001d6
+ 1
+
+ unix`mutex_enter+0x10
+ unix`page_get_mnode_freelist+0x32c
+ unix`page_get_freelist+0x16d
+ unix`page_create_va+0x2ad
+ genunix`swap_getapage+0x113
+ genunix`swap_getpage+0x90
+ genunix`fop_getpage+0x7e
+ genunix`anon_zero+0xb6
+ genunix`segvn_faultpage+0x6d2
+ genunix`segvn_fault+0x8e6
+ genunix`as_fault+0x36a
+ unix`pagefault+0x96
+ unix`trap+0x2c7
+ unix`0xfffffffffb8001d6
+ 1
+
+ unix`mutex_enter+0x10
+ unix`page_get_mnode_freelist+0x32c
+ unix`page_get_freelist+0x16d
+ unix`page_create_va+0x2ad
+ genunix`pvn_read_kluster+0x10c
+ ufs`ufs_getpage_ra+0x11c
+ ufs`ufs_getpage+0x866
+ genunix`fop_getpage+0x7e
+ genunix`segvn_faulta+0x12b
+ genunix`as_faulta+0x143
+ genunix`memcntl+0x53d
+ unix`sys_syscall+0x17a
+ 1
+
+ ufs`ufs_iaccess+0x91
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_rele+0x1
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`fop_lookup+0xf1
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`mutex_destroy+0x1
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`mutex_destroy+0x1
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`rwst_enter_common+0x162
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`pvn_plist_init+0x42
+ genunix`swap_getapage+0x323
+ genunix`swap_getpage+0x90
+ genunix`fop_getpage+0x7e
+ genunix`anon_zero+0xb6
+ genunix`segvn_faultpage+0x6d2
+ genunix`segvn_fault+0x8e6
+ genunix`as_fault+0x36a
+ unix`pagefault+0x96
+ unix`trap+0x2c7
+ unix`0xfffffffffb8001d6
+ 1
+
+ genunix`kmem_cache_alloc+0x22
+ genunix`vn_alloc+0x1a
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_alloc+0x22
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`copen+0x63
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`do_splx+0x65
+ unix`swtch+0x17c
+ unix`preempt+0xec
+ genunix`post_syscall+0x4cd
+ unix`0xfffffffffb800c91
+ 1
+
+ unix`do_splx+0x65
+ genunix`disp_lock_exit_nopreempt+0x42
+ unix`preempt+0xe7
+ unix`kpreempt+0x98
+ genunix`disp_lock_exit+0x6f
+ genunix`post_syscall+0x318
+ unix`0xfffffffffb800c91
+ 1
+
+ unix`mutex_enter+0x16
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`cpu_decay+0x27
+ genunix`cpu_grow+0x24
+ genunix`cpu_update_pct+0x86
+ genunix`new_mstate+0x73
+ unix`trap+0x63e
+ unix`sys_rtt_common+0x55
+ unix`_sys_rtt_ints_disabled+0x8
+ 1
+
+ unix`tsc_gethrtimeunscaled+0x8
+ genunix`gethrtime_unscaled+0xa
+ genunix`syscall_mstate+0x5d
+ unix`sys_syscall+0x10e
+ 1
+
+ unix`do_splx+0x68
+ genunix`disp_lock_exit+0x47
+ genunix`post_syscall+0x318
+ unix`0xfffffffffb800c91
+ 1
+
+ genunix`traverse+0x5a
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_alloc+0x2a
+ genunix`kmem_zalloc+0x47
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`mutex_init+0x1b
+ genunix`rwst_init+0x38
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_rele+0xc
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`mutex_destroy+0xc
+ genunix`rwst_destroy+0x1c
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`mutex_destroy+0xc
+ genunix`rwst_destroy+0x1c
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ lofs`lo_lookup+0xf
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ lofs`freelonode+0x1b0
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_rele+0x10
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`openat+0x1
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`as_fault+0x381
+ unix`pagefault+0x96
+ unix`trap+0x2c7
+ unix`0xfffffffffb8001d6
+ 1
+
+ genunix`vn_vfsunlock+0x1
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`audit_getstate+0x21
+ genunix`copen+0x59
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`hwblkclr+0x52
+ unix`pfnzero+0x78
+ unix`pagezero+0x2d
+ genunix`anon_zero+0xd2
+ genunix`segvn_faultpage+0x6d2
+ genunix`segvn_fault+0x8e6
+ genunix`as_fault+0x36a
+ unix`pagefault+0x96
+ unix`trap+0x2c7
+ unix`0xfffffffffb8001d6
+ 1
+
+ genunix`fop_lookup+0x103
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_alloc+0x33
+ lofs`makelonode+0xa9
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`savectx+0x24
+ unix`resume+0x5b
+ unix`swtch+0x141
+ unix`preempt+0xec
+ genunix`post_syscall+0x4cd
+ unix`0xfffffffffb800c91
+ 1
+
+ genunix`kmem_cache_alloc+0x37
+ genunix`falloc+0x63
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`kmem_cache_alloc+0x37
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`thread_lock+0x8
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 1
+
+ genunix`lookuppnvp+0xe9
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`mutex_exit+0x9
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`mutex_exit+0x9
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`mutex_exit+0x9
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ unix`hwblkclr+0x5b
+ unix`pfnzero+0x78
+ unix`pagezero+0x2d
+ genunix`anon_zero+0xd2
+ genunix`segvn_faultpage+0x6d2
+ genunix`segvn_fault+0x8e6
+ genunix`as_fault+0x36a
+ unix`pagefault+0x96
+ unix`trap+0x2c7
+ unix`0xfffffffffb8001d6
+ 1
+
+ genunix`vn_vfsunlock+0xc
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`audit_getstate+0x2d
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ lofs`lo_lookup+0x1e
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`syscall_mstate+0x1ae
+ unix`sys_syscall+0x1a1
+ 1
+
+ genunix`kmem_cache_alloc+0x3e
+ genunix`vn_alloc+0x1a
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_rele+0x1f
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1
+
+ genunix`vn_vfsunlock+0x10
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`vn_vfsunlock+0x10
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`audit_getstate+0x30
+ unix`0xfffffffffb800c91
+ 2
+
+ genunix`kmem_cache_free+0x70
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`pn_get_buf+0x1
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`mutex_exit+0x12
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`mutex_exit+0x12
+ lofs`freelonode+0x1fe
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`fd_find+0x73
+ genunix`ufalloc_file+0x91
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`audit_getstate+0x33
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`audit_getstate+0x33
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`vn_rele+0x24
+ genunix`traverse+0x9f
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`vn_setpath+0x144
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`syscall_mstate+0xb4
+ unix`sys_syscall+0x10e
+ 2
+
+ genunix`lookuppnvp+0xf5
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ zfs`zfs_fastaccesschk_execute+0x35
+ zfs`zfs_lookup+0xc2
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`vn_setpath+0x46
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`tsc_read+0x7
+ genunix`gethrtime_unscaled+0xa
+ genunix`syscall_mstate+0x5d
+ unix`0xfffffffffb800c86
+ 2
+
+ genunix`cv_broadcast+0x8
+ genunix`rwst_exit+0x8f
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`cv_broadcast+0x8
+ genunix`rwst_exit+0x8f
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`mutex_exit+0x19
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`mutex_init+0x39
+ genunix`rwst_init+0x38
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`bcopy+0xa
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`post_syscall+0x1ab
+ unix`0xfffffffffb800c91
+ 2
+
+ genunix`kmem_free+0xb
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`copen+0x8d
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`lookupnameatcred+0x7e
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`sys_syscall+0x104
+ 2
+
+ genunix`kmem_free+0xf
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`vn_free
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`disp_lock_exit+0x1
+ unix`0xfffffffffb800c91
+ 2
+
+ genunix`vn_rele+0x31
+ genunix`traverse+0x9f
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`vn_rele+0x31
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ lofs`lo_lookup+0x132
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`lookupnameatcred+0x82
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`traverse+0x82
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_cache_free+0x82
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`falloc+0x13
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`tsc_gethrtimeunscaled+0x34
+ genunix`syscall_mstate+0x5d
+ unix`0xfffffffffb800ca0
+ 2
+
+ unix`tsc_gethrtimeunscaled+0x34
+ genunix`syscall_mstate+0x5d
+ unix`sys_syscall+0x1a1
+ 2
+
+ genunix`falloc+0x15
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`dnlc_lookup+0xf6
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_cache_alloc+0x56
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`cv_broadcast+0x17
+ genunix`rwst_exit+0x8f
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ lofs`lo_root+0x8
+ genunix`fsop_root+0x2d
+ genunix`traverse+0x87
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`disp_lock_exit+0x8
+ genunix`post_syscall+0x318
+ unix`0xfffffffffb800c91
+ 2
+
+ genunix`setf+0x8
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`lookuppnvp+0x209
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`pn_get_buf+0x1b
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`vn_openat+0x4b
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`cv_broadcast+0x1b
+ genunix`setf+0x8c
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_free+0x1b
+ genunix`audit_unfalloc+0x44
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`disp_lock_exit+0xc
+ genunix`post_syscall+0x318
+ unix`0xfffffffffb800c91
+ 2
+
+ lofs`freelonode+0x1de
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`vn_rele+0x3e
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`copen+0x19f
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`setf+0x10
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`fop_lookup+0x131
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`copen+0x1a2
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ lofs`table_lock_enter+0x13
+ lofs`freelonode+0x47
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_free+0x26
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_free+0x26
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_free+0x26
+ genunix`audit_unfalloc+0x44
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`fop_lookup+0x139
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`lookuppnvp+0x1a
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ lofs`table_lock_enter+0x1b
+ lofs`freelonode+0x47
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ lofs`lo_root+0x1b
+ genunix`fsop_root+0x2d
+ genunix`traverse+0x87
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`fsop_root+0x3b
+ genunix`traverse+0x87
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`setf+0x1b
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`lookuppnatcred+0xf
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ zfs`zfs_fastaccesschk_execute+0x5f
+ zfs`zfs_lookup+0xc2
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`vn_vfslocks_getlock+0x1
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`open+0x12
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`dnlc_lookup+0x113
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`setf+0x123
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`copen+0x1b4
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`ufalloc+0x6
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_cache_alloc+0x77
+ genunix`kmem_zalloc+0x47
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_cache_alloc+0x77
+ genunix`vn_alloc+0x1a
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_cache_alloc+0x77
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`bzero+0x188
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ lofs`freelonode+0x1fe
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`ufalloc+0xe
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ lofs`freelonode
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`bcopy+0x240
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`vn_free+0x32
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`vn_rele+0x63
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`vn_vfslocks_getlock+0x13
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_free+0x43
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 2
+
+ genunix`fsop_root+0x56
+ genunix`traverse+0x87
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`rw_enter+0x26
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`copen+0x1c7
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`vn_vfslocks_getlock+0x17
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ zfs`zfs_lookup+0xe8
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`lookuppnatcred+0x29
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`lookuppnatcred+0x129
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_cache_alloc+0x89
+ genunix`kmem_zalloc+0x47
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`vn_vfslocks_getlock+0x1b
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ zfs`zfs_lookup+0xec
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_cache_free+0xbd
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`audit_falloc+0xe
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_cache_free+0xc0
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`lwp_getdatamodel
+ unix`0xfffffffffb800c91
+ 2
+
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`rwst_enter_common+0x2d3
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`syscall_mstate+0x203
+ unix`0xfffffffffb800ca0
+ 2
+
+ unix`mutex_destroy+0x74
+ genunix`rwst_destroy+0x1c
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`fd_reserve+0x17
+ genunix`ufalloc_file+0x103
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_free+0x57
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_free+0x57
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`bcopy+0x258
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`syscall_mstate+0x108
+ unix`0xfffffffffb800c86
+ 2
+
+ genunix`rwst_exit+0x8
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ lofs`freelonode+0x1b
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`rwst_enter_common+0x2db
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`mutex_destroy+0x7b
+ genunix`rwst_destroy+0x1c
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`vn_vfslocks_getlock+0x2d
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`vn_exists+0x1f
+ lofs`makelonode+0x1e7
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`hment_compare+0x10
+ genunix`avl_find+0x72
+ unix`hment_remove+0xac
+ unix`hat_pte_unmap+0x159
+ unix`hat_unload_callback+0xe8
+ genunix`segvn_unmap+0x5b7
+ genunix`as_free+0xdc
+ genunix`relvm+0x220
+ genunix`proc_exit+0x444
+ genunix`exit+0x15
+ genunix`rexit+0x18
+ unix`sys_syscall+0x17a
+ 2
+
+ lofs`lo_lookup+0x80
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`set_errno+0x1
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`cv_init+0x11
+ genunix`rwst_init+0x47
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ ufs`ufs_iaccess+0x12
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`rwst_enter_common+0x1e2
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`mutex_destroy+0x84
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`cv_init+0x15
+ genunix`rwst_init+0x56
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`set_errno+0x6
+ genunix`copen+0x4fa
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`lookuppnatcred+0x46
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ lofs`lo_root+0x58
+ genunix`fsop_root+0x2d
+ genunix`traverse+0x87
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`copen+0x1e8
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`crgetuid+0x8
+ zfs`zfs_fastaccesschk_execute+0x2e
+ zfs`zfs_lookup+0xc2
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`vn_vfslocks_getlock+0x39
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`vn_vfslocks_getlock+0x39
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`vn_vfslocks_getlock+0x39
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`gethrtime_unscaled+0xa
+ genunix`syscall_mstate+0x5d
+ unix`sys_syscall+0x10e
+ 2
+
+ lofs`freelonode+0x2b
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`syscall_mstate+0x1b
+ unix`0xfffffffffb800c86
+ 2
+
+ genunix`kmem_cache_free+0xdb
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`post_syscall+0xb
+ unix`0xfffffffffb800c91
+ 2
+
+ genunix`vn_vfslocks_getlock+0x3c
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ lofs`lsave+0x4e
+ lofs`makelonode+0x1df
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`copen+0x1ef
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`vn_vfslocks_getlock+0x41
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`copen+0xf2
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`bcopy+0x272
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`syscall_mstate+0x22
+ unix`sys_syscall+0x1a1
+ 2
+
+ genunix`fd_reserve+0x33
+ genunix`ufalloc_file+0x103
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`post_syscall+0x13
+ unix`0xfffffffffb800c91
+ 2
+
+ genunix`dnlc_lookup+0x154
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`fop_lookup+0x85
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`dnlc_lookup+0x56
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`cv_broadcast+0x76
+ genunix`setf+0x8c
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`syscall_mstate+0x26
+ unix`sys_syscall+0x10e
+ 2
+
+ lofs`lsave+0x57
+ lofs`makelonode+0x1df
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ lofs`freelonode+0x37
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`post_syscall+0x17
+ unix`0xfffffffffb800c91
+ 2
+
+ genunix`vn_vfslocks_rele+0x8
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_cache_free+0xe8
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`copen+0x4fa
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`cv_broadcast+0x7a
+ genunix`setf+0x8c
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_cache_free+0xed
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_cache_free+0xed
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`copen
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`0xfffffffffb800c81
+ 2
+
+ genunix`cv_destroy+0x1
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_cache_free+0xf1
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_cache_free+0xf1
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`lookuppnatcred+0x62
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`syscall_mstate+0x33
+ unix`0xfffffffffb800ca0
+ 2
+
+ genunix`copen+0x204
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`fop_lookup+0x97
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`cv_destroy+0x8
+ genunix`rwst_destroy+0x2e
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`lookuppnatcred+0x168
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`do_splx+0x8
+ genunix`disp_lock_exit+0x47
+ genunix`post_syscall+0x318
+ unix`0xfffffffffb800c91
+ 2
+
+ genunix`vn_vfslocks_getlock+0x59
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`set_errno+0x2e
+ genunix`copen+0x4fa
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`dnlc_lookup+0x6e
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`setf+0x7f
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_zalloc+0x10
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`fd_find+0x1
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`dnlc_lookup+0x75
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`dnlc_lookup+0x175
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`syscall_mstate+0x45
+ unix`0xfffffffffb800c86
+ 2
+
+ zfs`zfs_lookup+0x37
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`memcmp+0x8
+ unix`bcmp+0x9
+ genunix`dnlc_lookup+0x10d
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_cache_free+0x8
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`copen+0x19
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`dnlc_lookup+0x79
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`bcopy+0x399
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`vn_vfslocks_rele+0x29
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`memcmp+0xb
+ unix`bcmp+0x9
+ genunix`dnlc_lookup+0x10d
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`do_splx+0x1b
+ genunix`disp_lock_exit+0x47
+ genunix`post_syscall+0x318
+ unix`0xfffffffffb800c91
+ 2
+
+ genunix`dnlc_lookup+0x17f
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ zfs`zfs_lookup+0x3f
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`secpolicy_vnode_access2+0xf
+ ufs`ufs_iaccess+0x128
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ lofs`lo_inactive+0x14
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`rwst_exit+0x54
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_cache_alloc+0xe4
+ genunix`falloc+0x63
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`syscall_mstate+0x55
+ unix`0xfffffffffb800c86
+ 2
+
+ unix`strlen+0x16
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`fd_find+0x17
+ genunix`ufalloc_file+0x91
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`crfree+0x18
+ genunix`unfalloc+0x4a
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`vn_recycle+0x2b
+ genunix`vn_reinit+0x7b
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ zfs`zfs_lookup+0x4b
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`fop_lookup+0xbb
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_cache_free+0x1b
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`setf+0x9c
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`copystr+0x1d
+ genunix`pn_get_buf+0x43
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`rwst_exit+0x5d
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ ufs`ufs_lookup+0xed
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`post_syscall+0x14d
+ unix`0xfffffffffb800c91
+ 2
+
+ genunix`dnlc_lookup+0x8f
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`post_syscall+0x4f
+ unix`0xfffffffffb800c91
+ 2
+
+ genunix`unfalloc+0x10
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`secpolicy_vnode_access2+0x22
+ ufs`ufs_iaccess+0x128
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`traverse+0x23
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`syscall_mstate+0x163
+ unix`sys_syscall+0x1a1
+ 2
+
+ genunix`syscall_mstate+0x167
+ unix`0xfffffffffb800c86
+ 2
+
+ genunix`traverse+0x28
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`ufalloc_file+0xf8
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`unfalloc+0x18
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`setf+0xa9
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`lookuppnvp+0xaa
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`secpolicy_vnode_access2+0x22a
+ ufs`ufs_iaccess+0x128
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ lofs`lo_lookup+0x1db
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`copystr+0x2b
+ genunix`pn_get_buf+0x43
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_cache_free+0x2b
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_cache_alloc+0xfc
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`lookupnameatcred+0x2d
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_cache_alloc+0x100
+ genunix`vn_alloc+0x1a
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_cache_alloc+0x1
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`post_syscall+0x64
+ unix`0xfffffffffb800c91
+ 2
+
+ genunix`memcmp+0x35
+ unix`bcmp+0x9
+ genunix`dnlc_lookup+0x10d
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`fop_inactive+0x35
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`copen+0x46
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ ufs`ufs_lookup+0x106
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`copystr+0x37
+ genunix`pn_get_buf+0x43
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`vn_openat+0xf7
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_zalloc+0x47
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`dnlc_lookup+0x1a8
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`memcmp+0x38
+ genunix`dnlc_lookup+0x10d
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ lofs`freelonode+0x189
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_cache_free+0x3a
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`vn_vfslocks_rele+0x5c
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`falloc+0xcc
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`syscall_mstate+0x17c
+ unix`sys_syscall+0x1a1
+ 2
+
+ genunix`fd_find+0x40
+ genunix`ufalloc_file+0x91
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`fop_lookup+0xe0
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`mutex_enter
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`mutex_enter
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`mutex_enter
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`mutex_enter
+ genunix`kmem_free+0x4e
+ genunix`audit_unfalloc+0x44
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`mutex_enter
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`mutex_enter
+ genunix`lookuppnvp+0x39f
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`lookuppnvp+0xc1
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`post_syscall+0x173
+ unix`0xfffffffffb800c91
+ 2
+
+ genunix`fop_lookup+0xe4
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`vn_openat+0x106
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`lookuppnvp+0x3c7
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_cache_alloc+0x17
+ genunix`falloc+0x63
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ lofs`freelonode+0x98
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ ufs`ufs_lookup+0x118
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`mutex_enter+0x9
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`mutex_enter+0x9
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`mutex_enter+0x9
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`lookupnameatcred+0x4b
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_cache_alloc+0x1b
+ genunix`kmem_zalloc+0x47
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`dnlc_lookup+0xbe
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ ufs`ufs_lookup+0x11e
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`fd_find+0x4f
+ genunix`ufalloc_file+0x91
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`lookuppnvp+0x3cf
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_cache_alloc+0x22
+ genunix`kmem_zalloc+0x47
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`fd_find+0x53
+ genunix`ufalloc_file+0x91
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`rwst_enter_common+0x165
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`vn_openat+0x16
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`lookupnameatcred+0x56
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`vn_alloc+0x27
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`vn_rele+0x8
+ ufs`ufs_lookup+0x36d
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`audit_getstate+0x18
+ genunix`lookuppnvp+0x82
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_cache_alloc+0x2a
+ genunix`vn_alloc+0x1a
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`copen+0x16c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`vn_rele+0xc
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`vn_openat+0x1c
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`fop_lookup+0xfc
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`falloc+0xed
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ zfs`zfs_fastaccesschk_execute+0x11f
+ zfs`zfs_lookup+0xc2
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`fop_inactive+0x60
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_cpu_reload+0x10
+ genunix`kmem_cache_free+0xce
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`mutex_exit
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`mutex_exit
+ zfs`zfs_lookup+0xc2
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`mutex_exit
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`mutex_exit
+ genunix`lookuppnvp+0x39f
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ lofs`lo_lookup+0x13
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`vn_openat+0x24
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`vn_rele+0x17
+ ufs`ufs_lookup+0x36d
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`vn_rele+0x17
+ genunix`lookuppnvp+0x39f
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_cache_alloc+0x37
+ lofs`makelonode+0xa9
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`mutex_destroy+0x17
+ genunix`rwst_destroy+0x1c
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`audit_getstate+0x28
+ genunix`setf+0x3f
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_cpu_reload+0x18
+ genunix`kmem_cache_alloc+0x118
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`ufalloc_file+0x3a
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ unix`tsc_gethrtimeunscaled+0x1b
+ genunix`gethrtime_unscaled+0xa
+ genunix`syscall_mstate+0x5d
+ unix`0xfffffffffb800ca0
+ 2
+
+ unix`mutex_exit+0xc
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`copen+0x17d
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`vn_openat+0x2e
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`kmem_cache_alloc+0x3e
+ genunix`kmem_zalloc+0x47
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ zfs`zfs_lookup+0x9f
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 2
+
+ genunix`cv_broadcast
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`audit_getstate+0x30
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`audit_getstate+0x30
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`kmem_cache_free+0x70
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`kmem_free
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`lookuppnatcred+0xe1
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`lookupnameatcred+0x72
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ unix`mutex_exit+0x12
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ unix`mutex_exit+0x12
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ unix`mutex_exit+0x12
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`vn_rele+0x24
+ ufs`ufs_lookup+0x36d
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`vn_rele+0x24
+ lofs`freelonode+0x1fe
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ lofs`freelonode+0x1c5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ lofs`lo_lookup+0x25
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`openat+0x16
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`vn_openat+0x36
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ lofs`freelonode+0xc7
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`ufalloc_file+0x48
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`fop_lookup+0x118
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ unix`mutex_exit+0x19
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ lofs`lo_lookup+0x12a
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`copen+0x18b
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ unix`copyinstr+0xc
+ genunix`pn_get_buf+0x43
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`cv_broadcast+0xc
+ genunix`setf+0x8c
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`lookuppnvp+0xfd
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`kmem_cache_alloc+0x4e
+ genunix`falloc+0x63
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ lofs`freelonode+0x1cf
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`copen+0x90
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`pn_get_buf+0x10
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`fop_lookup+0x120
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`setf+0x103
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ unix`tsc_gethrtimeunscaled+0x34
+ genunix`syscall_mstate+0x5d
+ unix`0xfffffffffb800c86
+ 3
+
+ genunix`fd_find+0x85
+ genunix`ufalloc_file+0x91
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`vsd_free+0x26
+ genunix`vn_recycle+0xb5
+ genunix`vn_reinit+0x7b
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`pn_get_buf+0x17
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`kmem_free+0x17
+ genunix`audit_unfalloc+0x44
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`vn_free+0x8
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`lookupnameatcred+0x88
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`syscall_mstate+0x1c8
+ unix`0xfffffffffb800c86
+ 3
+
+ unix`sys_syscall+0x10e
+ 3
+
+ genunix`falloc+0x19
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`kmem_free+0x1b
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`fop_lookup+0x12d
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`post_syscall+0x2bf
+ unix`0xfffffffffb800c91
+ 3
+
+ lofs`lo_root+0x10
+ genunix`fsop_root+0x2d
+ genunix`traverse+0x87
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`dnlc_lookup+0x1
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`fd_find+0x91
+ genunix`ufalloc_file+0x91
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`lookuppnvp+0x111
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`falloc+0x24
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`vn_openat+0x55
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`thread_lock+0x36
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 3
+
+ genunix`vn_free+0x17
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`fd_find+0x98
+ genunix`ufalloc_file+0x91
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`falloc+0x28
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`fop_lookup+0x139
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`pn_get_buf+0x2a
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`kmem_cache_alloc+0x6a
+ genunix`vn_alloc+0x1a
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`kmem_free+0x2a
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`kmem_free+0x2a
+ genunix`audit_unfalloc+0x44
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`lookuppnatcred+0xb
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`clear_stale_fd+0xd
+ genunix`post_syscall+0x1fe
+ unix`0xfffffffffb800c91
+ 3
+
+ genunix`fop_lookup+0x13d
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`falloc+0x2f
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`lookuppnatcred+0x110
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`ufalloc+0x1
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ lofs`table_lock_enter+0x22
+ lofs`freelonode+0x47
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`lookuppnatcred+0x13
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`lookuppnvp+0x124
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`pn_get_buf+0x35
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ unix`rw_enter+0x1c
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`copen+0x2be
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`vn_vfslocks_rele+0xce
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ zfs`zfs_fastaccesschk_execute+0x6e
+ zfs`zfs_lookup+0xc2
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`fd_reserve
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`kmem_cache_free+0xb0
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`thread_lock+0x53
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 3
+
+ genunix`pn_get_buf+0x43
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`vn_vfslocks_getlock+0x13
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`setf+0x33
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`kmem_free+0x43
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`kmem_cache_alloc+0x84
+ genunix`kmem_zalloc+0x47
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`dnlc_lookup+0x26
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`syscall_mstate+0x1f7
+ unix`0xfffffffffb800ca0
+ 3
+
+ lofs`freelonode+0x8
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`syscall_mstate+0xf8
+ unix`sys_syscall+0x10e
+ 3
+
+ genunix`kmem_cache_alloc+0x89
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`copen+0x2ca
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`vn_exists+0xc
+ lofs`makelonode+0x1e7
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`lookuppnvp+0x43c
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`kmem_cache_free+0xbd
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`copen+0x2ce
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`kmem_free+0x4e
+ genunix`audit_unfalloc+0x44
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`vn_openat+0x47f
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`vn_vfslocks_getlock+0x1f
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`vn_vfslocks_getlock+0x1f
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`copen+0x1d0
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`rwst_exit
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`ufalloc_file+0x91
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`disp_lock_exit+0x42
+ genunix`post_syscall+0x318
+ unix`0xfffffffffb800c91
+ 3
+
+ genunix`kmem_cache_alloc+0x92
+ genunix`falloc+0x63
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`copen+0x1d3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`syscall_mstate+0x203
+ unix`sys_syscall+0x1a1
+ 3
+
+ genunix`lookuppnatcred+0x34
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`lookuppnvp+0x444
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`audit_falloc+0x15
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ lofs`freelonode+0x17
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`syscall_mstate+0x8
+ unix`0xfffffffffb800c86
+ 3
+
+ genunix`syscall_mstate+0x108
+ unix`sys_syscall+0x10e
+ 3
+
+ genunix`rwst_exit+0x8
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ unix`sys_syscall+0x14e
+ 3
+
+ genunix`fop_inactive+0xcb
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`fop_inactive+0xcb
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`vn_vfslocks_getlock+0x2d
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`vn_openat+0x8e
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ lofs`freelonode+0x1f
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ unix`splr+0x1f
+ genunix`thread_lock+0x24
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 3
+
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ lofs`table_lock_enter+0x50
+ lofs`freelonode+0x47
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`copen+0x4e0
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`syscall_mstate+0x10
+ unix`0xfffffffffb800c86
+ 3
+
+ genunix`crgetuid
+ zfs`zfs_lookup+0xc2
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ unix`sys_syscall+0x156
+ 3
+
+ genunix`rwst_enter_common+0x1e2
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`falloc+0x63
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`lookuppnatcred+0x147
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`syscall_mstate+0x17
+ unix`0xfffffffffb800c86
+ 3
+
+ genunix`dnlc_lookup+0x149
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`syscall_mstate+0x119
+ unix`0xfffffffffb800ca0
+ 3
+
+ genunix`syscall_mstate+0x1b
+ unix`0xfffffffffb800ca0
+ 3
+
+ genunix`post_syscall+0x30c
+ unix`0xfffffffffb800c91
+ 3
+
+ unix`sys_syscall+0x162
+ 3
+
+ genunix`falloc+0x6f
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`crgetuid+0x10
+ zfs`zfs_lookup+0xc2
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ unix`lock_try
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 3
+
+ genunix`lookuppnatcred+0x151
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`cv_broadcast+0x72
+ genunix`setf+0x8c
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ zfs`zfs_lookup+0x12
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`syscall_mstate+0x123
+ unix`sys_syscall+0x10e
+ 3
+
+ zfs`zfs_lookup+0x16
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`pn_fixslash+0x28
+ genunix`lookuppnvp+0x105
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`kmem_cache_free+0xe8
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`lookuppnvp+0x36b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ lofs`table_lock_enter+0x6d
+ lofs`freelonode+0x47
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`set_errno+0x1e
+ genunix`copen+0x4fa
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`cv_broadcast+0x7f
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`cv_broadcast+0x7f
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`cv_broadcast+0x7f
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ unix`atomic_add_32_nv
+ genunix`unfalloc+0x4a
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`pn_fixslash+0x32
+ genunix`lookuppnvp+0x105
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`syscall_mstate+0x33
+ unix`sys_syscall+0x1a1
+ 3
+
+ genunix`syscall_mstate+0x135
+ unix`0xfffffffffb800c86
+ 3
+
+ genunix`syscall_mstate+0x135
+ unix`0xfffffffffb800ca0
+ 3
+
+ genunix`rwst_exit+0x35
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`kmem_zalloc+0x5
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ unix`0xfffffffffb800c86
+ 3
+
+ lofs`freelonode+0x47
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`copen+0x207
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`vn_vfslocks_rele+0x17
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`fop_lookup+0x97
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`vn_openat+0x2b8
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`vn_free+0x78
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`dnlc_lookup+0x16c
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`fop_lookup+0x9c
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ unix`do_splx+0xc
+ genunix`disp_lock_exit+0x47
+ genunix`post_syscall+0x318
+ unix`0xfffffffffb800c91
+ 3
+
+ genunix`post_syscall+0x32d
+ unix`0xfffffffffb800c91
+ 3
+
+ genunix`syscall_mstate+0x13d
+ unix`sys_syscall+0x10e
+ 3
+
+ genunix`memcmp
+ genunix`dnlc_lookup+0x10d
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ zfs`zfs_lookup+0x30
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`kmem_cache_free
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`kmem_cache_free
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`kmem_cache_free
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ unix`bcopy+0x391
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`syscall_mstate+0x41
+ unix`0xfffffffffb800c86
+ 3
+
+ genunix`lookuppnatcred+0x72
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`set_errno+0x35
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`syscall_mstate+0x45
+ unix`sys_syscall+0x1a1
+ 3
+
+ genunix`vn_vfslocks_getlock+0x66
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`lookuppnatcred+0x77
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ unix`do_splx+0x17
+ genunix`disp_lock_exit+0x47
+ genunix`post_syscall+0x318
+ unix`0xfffffffffb800c91
+ 3
+
+ genunix`audit_unfalloc+0x17
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`vn_openat+0xc8
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`fop_inactive+0x8
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`vn_vfslocks_rele+0x29
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`crfree+0x9
+ genunix`unfalloc+0x4a
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`rwst_init+0x5a
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`fop_inactive+0xc
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`copen+0x1d
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`fd_find+0xf
+ genunix`ufalloc_file+0x91
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ unix`0xfffffffffb800ca0
+ 3
+
+ genunix`rwst_destroy
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`kmem_cache_free+0x10
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`syscall_mstate+0x157
+ unix`0xfffffffffb800c86
+ 3
+
+ genunix`kmem_cache_free+0x17
+ genunix`unfalloc+0x61
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`kmem_cache_free+0x17
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`secpolicy_vnode_access2+0x17
+ ufs`ufs_iaccess+0x128
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`vn_vfslocks_rele+0x38
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`traverse+0x18
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`unfalloc+0x8
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`lookuppnvp+0x39a
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`dnlc_lookup+0x8b
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`kmem_cache_free+0x1b
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`vn_vfslocks_getlock+0x7d
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`secpolicy_vnode_access2+0x21e
+ ufs`ufs_iaccess+0x128
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`syscall_mstate+0x15f
+ unix`0xfffffffffb800c86
+ 3
+
+ unix`bzero
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`dnlc_lookup+0x92
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`fop_inactive+0x22
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ unix`copystr+0x24
+ genunix`pn_get_buf+0x43
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`fd_find+0x24
+ genunix`ufalloc_file+0x91
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`rwst_enter_common+0x35
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`fop_lookup+0xc7
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`syscall_mstate+0x167
+ unix`0xfffffffffb800ca0
+ 3
+
+ genunix`rwst_destroy+0x17
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`dnlc_lookup+0x99
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`syscall_mstate+0x69
+ unix`0xfffffffffb800c86
+ 3
+
+ genunix`syscall_mstate+0x69
+ unix`sys_syscall+0x1a1
+ 3
+
+ genunix`kmem_cache_free+0x2b
+ genunix`kmem_free+0x4e
+ genunix`audit_unfalloc+0x44
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`post_syscall+0x35c
+ 3
+
+ genunix`copen+0x3d
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`dnlc_lookup+0x9d
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`kmem_cache_free+0x2f
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ ufs`ufs_lookup+0x1
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`fop_lookup+0xd2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`ufalloc_file+0x103
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`lookuppnvp+0x3b5
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`crgetmapped+0x15
+ genunix`fop_inactive+0x60
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ unix`bzero+0x16
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`kmem_cache_free+0x37
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`vsd_free+0xd8
+ genunix`vn_free+0x8b
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`kmem_cache_alloc+0x8
+ genunix`kmem_zalloc+0x47
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`post_syscall+0x6b
+ unix`0xfffffffffb800c91
+ 3
+
+ genunix`vn_vfsrlock+0x3c
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`fd_find+0x3c
+ genunix`ufalloc_file+0x91
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`lookuppnatcred+0xad
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`setf+0xbd
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ unix`bcopy+0x3d0
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ unix`mutex_enter
+ genunix`fsop_root+0x2d
+ genunix`traverse+0x87
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ unix`mutex_enter
+ lofs`freelonode+0x1fe
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ unix`mutex_enter
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`syscall_mstate+0x84
+ unix`0xfffffffffb800ca0
+ 3
+
+ genunix`post_syscall+0x75
+ unix`0xfffffffffb800c91
+ 3
+
+ genunix`ufalloc_file+0x17
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`fop_lookup+0x1e7
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ unix`bcopy+0x3d8
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`fd_find+0x48
+ genunix`ufalloc_file+0x91
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`vn_openat+0x9
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`vn_vfslocks_rele+0x6b
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`ufalloc_file+0x1b
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`vn_setpath+0x11c
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ lofs`makelonode+0x8d
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`lookuppnatcred+0xbe
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ zfs`zfs_lookup+0x7f
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ unix`bcopy+0x3e0
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`lookuppnvp+0x3d0
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ unix`mutex_destroy
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`lookupnameatcred+0x52
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`syscall_mstate+0x193
+ unix`sys_syscall+0x1a1
+ 3
+
+ genunix`vn_openat+0x115
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`falloc+0xe5
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`copen+0x166
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`ufalloc_file+0x126
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`kmem_cache_alloc+0x26
+ genunix`kmem_zalloc+0x47
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`vn_rele+0x8
+ lofs`freelonode+0x1fe
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ unix`tsc_gethrtimeunscaled+0x8
+ genunix`gethrtime_unscaled+0xa
+ genunix`syscall_mstate+0x5d
+ unix`0xfffffffffb800c86
+ 3
+
+ genunix`audit_getstate+0x18
+ genunix`post_syscall+0xbe
+ unix`0xfffffffffb800c91
+ 3
+
+ genunix`audit_getstate+0x18
+ genunix`setf+0x3f
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`vn_openat+0x11b
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`traverse+0x5b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`vn_vfslocks_getlock+0xbc
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ unix`tsc_gethrtimeunscaled+0xc
+ genunix`gethrtime_unscaled+0xa
+ genunix`syscall_mstate+0x5d
+ unix`0xfffffffffb800ca0
+ 3
+
+ genunix`syscall_mstate+0x19d
+ unix`sys_syscall+0x1a1
+ 3
+
+ unix`mutex_exit
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ unix`mutex_exit
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`syscall_mstate+0x1a1
+ unix`0xfffffffffb800ca0
+ 3
+
+ genunix`syscall_mstate+0xa2
+ unix`sys_syscall+0x1a1
+ 3
+
+ genunix`vn_rele+0x17
+ lofs`freelonode+0x1fe
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`vn_rele+0x17
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`kmem_cache_alloc+0x37
+ genunix`vn_alloc+0x1a
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`openat+0x8
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`vn_vfsunlock+0x8
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`kmem_cache_free+0x68
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ unix`mutex_exit+0x9
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ unix`mutex_exit+0x9
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`kmem_cache_alloc+0x3a
+ genunix`falloc+0x63
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ unix`tsc_gethrtimeunscaled+0x1b
+ genunix`gethrtime_unscaled+0xa
+ genunix`syscall_mstate+0x5d
+ unix`0xfffffffffb800c86
+ 3
+
+ genunix`vn_vfsunlock+0xc
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`falloc+0xfc
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ unix`mutex_exit+0xc
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`fop_inactive+0x6d
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`vn_rele+0x1f
+ ufs`ufs_lookup+0x36d
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 3
+
+ genunix`post_syscall+0x19f
+ unix`0xfffffffffb800c91
+ 3
+
+ genunix`pn_get_buf
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`cv_broadcast
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_cache_free+0x70
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ lofs`freelonode+0x1c1
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`unfalloc+0x61
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`fop_lookup+0x12
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`mutex_exit+0x12
+ genunix`unfalloc+0x61
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`mutex_exit+0x12
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`mutex_exit+0x12
+ ufs`ufs_lookup+0x36d
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`mutex_exit+0x12
+ genunix`traverse+0x9f
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`mutex_exit+0x12
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`mutex_exit+0x12
+ genunix`kmem_zalloc+0x47
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`mutex_exit+0x12
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_free+0x5
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`pn_get_buf+0x6
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`bcopy+0x308
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`copyinstr+0x8
+ genunix`pn_get_buf+0x43
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`mutex_exit+0x19
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`fop_lookup+0x1a
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`tsc_read+0xa
+ genunix`gethrtime_unscaled+0xa
+ genunix`syscall_mstate+0x5d
+ unix`0xfffffffffb800c86
+ 4
+
+ genunix`fsop_root+0x1b
+ genunix`traverse+0x87
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`crfree+0x7b
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`vn_vfslocks_rele+0x9e
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`ufalloc_file+0x50
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`syscall_mstate+0x1c0
+ unix`0xfffffffffb800c86
+ 4
+
+ zfs`zfs_fastaccesschk_execute+0x140
+ zfs`zfs_lookup+0xc2
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`vn_rele+0x31
+ lofs`freelonode+0x1fe
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`vn_rele+0x31
+ genunix`lookuppnvp+0x39f
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`sys_syscall+0x109
+ 4
+
+ genunix`lookuppnvp+0x105
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`vn_vfslocks_rele+0xa6
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`vn_vfslocks_rele+0xa6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`fop_inactive+0x86
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`fop_inactive+0x86
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`lookupnameatcred+0x87
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_free+0x17
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`syscall_mstate+0x1c8
+ unix`sys_syscall+0x10e
+ 4
+
+ genunix`vn_rele+0x39
+ ufs`ufs_lookup+0x36d
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`vn_rele+0x39
+ lofs`freelonode+0x1fe
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`syscall_mstate+0xc9
+ unix`0xfffffffffb800c86
+ 4
+
+ genunix`post_syscall+0xb9
+ unix`0xfffffffffb800c91
+ 4
+
+ genunix`fsop_root+0x2a
+ genunix`traverse+0x87
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_free+0x1b
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_free+0x1b
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ zfs`zfs_lookup+0xbd
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`post_syscall+0xbe
+ unix`0xfffffffffb800c91
+ 4
+
+ genunix`clear_stale_fd+0x1
+ unix`0xfffffffffb800c91
+ 4
+
+ genunix`dnlc_lookup+0x104
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`open+0x6
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`pn_get_buf+0x26
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`setf+0x116
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_cache_alloc+0x66
+ genunix`falloc+0x63
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ lofs`lo_root+0x17
+ genunix`fsop_root+0x2d
+ genunix`traverse+0x87
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`lookuppnatcred+0x109
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ zfs`specvp_check+0x3a
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_free+0x2a
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ ufs`ufs_lookup+0x36d
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`traverse+0x9f
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`fop_inactive+0x9f
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`post_syscall+0x2d0
+ unix`0xfffffffffb800c91
+ 4
+
+ genunix`pn_get_buf+0x31
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`setf+0x22
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`fop_inactive+0xa3
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ zfs`zfs_lookup+0xd4
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`vn_vfslocks_rele+0xc6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`setf+0x26
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`dnlc_lookup+0x118
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_cache_alloc+0x79
+ genunix`falloc+0x63
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_cache_alloc+0x79
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`copen+0x1bd
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`vn_vfslocks_rele+0xce
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`lookuppnatcred+0x1e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`vn_free+0x2f
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`syscall_mstate+0x1ef
+ unix`0xfffffffffb800ca0
+ 4
+
+ genunix`fd_reserve
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_cache_free+0xb0
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_free+0x43
+ genunix`audit_unfalloc+0x44
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ lofs`lo_lookup+0x64
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ lofs`lo_lookup+0x67
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`vn_vfslocks_getlock+0x17
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_cache_alloc+0x89
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`fd_reserve+0xb
+ genunix`setf+0x123
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`fop_inactive+0xbb
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_cache_free+0xbd
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`dnlc_lookup+0x2e
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`copen+0x2cf
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`post_syscall+0x1f0
+ unix`0xfffffffffb800c91
+ 4
+
+ ufs`ufs_lookup+0x93
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`lwp_getdatamodel+0x8
+ genunix`post_syscall+0x2f5
+ unix`0xfffffffffb800c91
+ 4
+
+ genunix`vn_vfslocks_getlock+0x29
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`splr+0x1b
+ genunix`thread_lock+0x24
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 4
+
+ genunix`pn_fixslash+0xc
+ genunix`lookuppnvp+0x105
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`clear_stale_fd+0x3c
+ genunix`post_syscall+0x1fe
+ unix`0xfffffffffb800c91
+ 4
+
+ genunix`vn_rele+0x7d
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`vn_openat+0x48e
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`set_errno
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ ufs`ufs_iaccess+0x110
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`vn_setpath+0xa0
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`gethrtime_unscaled
+ unix`0xfffffffffb800c86
+ 4
+
+ genunix`cv_init+0x11
+ genunix`rwst_init+0x56
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`lookuppnvp+0x51
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`rwst_enter_common+0x1e4
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`cv_init+0x15
+ genunix`rwst_init+0x56
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ lofs`freelonode+0x27
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`vn_openat+0x497
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`fop_lookup+0x77
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`syscall_mstate+0x17
+ unix`sys_syscall+0x1a1
+ 4
+
+ genunix`copen+0xe8
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`rwst_exit+0x18
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`vn_openat+0x9a
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_cache_free+0xdb
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_cache_free+0xdb
+ genunix`kmem_free+0x4e
+ genunix`audit_unfalloc+0x44
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`post_syscall+0x20c
+ unix`0xfffffffffb800c91
+ 4
+
+ genunix`cv_init+0x1d
+ genunix`rwst_init+0x56
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`bcmp
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`syscall_mstate+0x22
+ unix`0xfffffffffb800ca0
+ 4
+
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`prunstop+0x14
+ genunix`post_syscall+0x2d0
+ unix`0xfffffffffb800c91
+ 4
+
+ genunix`vn_vfslocks_rele+0x105
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`vn_openat+0xa7
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`fd_reserve+0x37
+ genunix`ufalloc_file+0x103
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ lofs`lo_root+0x68
+ genunix`fsop_root+0x2d
+ genunix`traverse+0x87
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`vn_vfslocks_rele+0x8
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_cache_free+0xe8
+ genunix`kmem_free+0x4e
+ genunix`audit_unfalloc+0x44
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ zfs`zfs_lookup+0x1a
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`syscall_mstate+0x2a
+ unix`sys_syscall+0x10e
+ 4
+
+ lofs`lo_root+0x70
+ genunix`fsop_root+0x2d
+ genunix`traverse+0x87
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_zalloc
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`membar_consumer
+ lofs`freelonode+0x47
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`membar_consumer
+ lofs`freelonode+0x47
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_cache_free+0xf1
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_cache_free+0xf1
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_cache_free+0xf1
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`fop_lookup+0x93
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`syscall_mstate+0x135
+ unix`sys_syscall+0x1a1
+ 4
+
+ genunix`lookuppnvp+0x76
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`set_errno+0x27
+ genunix`copen+0x4fa
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`vn_vfslocks_rele+0x17
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`fd_reserve+0x48
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`syscall_mstate+0x139
+ unix`0xfffffffffb800c86
+ 4
+
+ genunix`kmem_cache_free+0xfa
+ genunix`unfalloc+0x61
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_cache_free+0xfa
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_cache_free+0xfa
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`sys_syscall+0x180
+ 4
+
+ genunix`copen+0xb
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`vn_openat+0xbc
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ lofs`table_lock_enter+0x7d
+ lofs`freelonode+0x47
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`syscall_mstate+0x13d
+ unix`0xfffffffffb800ca0
+ 4
+
+ genunix`lookuppnvp+0x37f
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`lookupnameatcred
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`fop_inactive
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`audit_unfalloc+0x10
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_cache_free
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_cache_free
+ genunix`audit_unfalloc+0x44
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ lofs`lo_inactive+0x1
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`copen+0x13
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`rwst_exit+0x44
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`ufalloc_file+0xd7
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`fd_find+0x8
+ genunix`ufalloc_file+0x91
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_cache_free+0x8
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_zalloc+0x1a
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`rwst_exit+0x4c
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`do_splx+0x1f
+ genunix`disp_lock_exit+0x47
+ genunix`post_syscall+0x318
+ unix`0xfffffffffb800c91
+ 4
+
+ genunix`kmem_cache_free+0x10
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`strlen+0x10
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`strlen+0x13
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`copen+0x24
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`vn_vfsrlock+0x14
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`setf+0x94
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`rwst_exit+0x54
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_cache_alloc+0xe4
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`fop_lookup+0xb6
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`post_syscall+0x347
+ unix`0xfffffffffb800c91
+ 4
+
+ genunix`syscall_mstate+0x157
+ unix`sys_syscall+0x10e
+ 4
+
+ genunix`kmem_cache_free+0x17
+ genunix`kmem_free+0x4e
+ genunix`audit_unfalloc+0x44
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`copen+0x28
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`vn_vfslocks_rele+0x38
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`syscall_mstate+0x58
+ unix`sys_syscall+0x1a1
+ 4
+
+ genunix`rwst_destroy+0x8
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`vn_openat+0x2d9
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_zalloc+0x29
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`fop_inactive+0x1b
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`sys_syscall+0x1a1
+ 4
+
+ genunix`dnlc_lookup+0x18e
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`audit_unfalloc+0x2e
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`copen+0x2f
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`setf+0xa0
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`crgetmapped
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_cache_free+0x22
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_cache_free+0x22
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`post_syscall+0x353
+ unix`0xfffffffffb800c91
+ 4
+
+ genunix`falloc+0xb3
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`setf+0xa4
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`vn_vfslocks_getlock+0x86
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`vn_vfslocks_getlock+0x86
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`syscall_mstate+0x67
+ unix`sys_syscall+0x1a1
+ 4
+
+ genunix`syscall_mstate+0x167
+ unix`sys_syscall+0x10e
+ 4
+
+ genunix`setf+0xa8
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`vn_invalid+0x39
+ lofs`freelonode+0x115
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`syscall_mstate+0x69
+ unix`0xfffffffffb800ca0
+ 4
+
+ unix`splr+0x79
+ genunix`thread_lock+0x24
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 4
+
+ genunix`lookuppnatcred+0x9b
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`rwst_destroy+0x1c
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_cache_alloc+0xfc
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`fop_inactive+0x2d
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`splr+0x7e
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 4
+
+ genunix`syscall_mstate+0x170
+ unix`0xfffffffffb800ca0
+ 4
+
+ genunix`rwst_destroy+0x20
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`syscall_mstate+0x71
+ unix`0xfffffffffb800ca0
+ 4
+
+ unix`clear_int_flag+0x1
+ genunix`thread_lock+0x24
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 4
+
+ genunix`lookuppnvp+0xb4
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`fop_lookup+0xd4
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`audit_unfalloc+0x44
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`rwst_destroy+0x25
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`fop_inactive+0x35
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`memcmp+0x37
+ unix`bcmp+0x9
+ genunix`dnlc_lookup+0x10d
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ lofs`freelonode+0x88
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`ufalloc_file+0x8
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`vsd_free+0xd8
+ genunix`vn_free+0x8b
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`copystr+0x3c
+ genunix`pn_get_buf+0x43
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_cache_free+0x3f
+ genunix`kmem_free+0x4e
+ genunix`audit_unfalloc+0x44
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`ufalloc_file+0x10
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`unfalloc+0x30
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`audit_getstate
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_cache_alloc+0x10
+ genunix`kmem_zalloc+0x47
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`mutex_enter
+ ufs`ufs_lookup+0x36d
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`mutex_enter
+ genunix`traverse+0x9f
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`mutex_enter
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ zfs`zfs_fastaccesschk_execute
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`rwst_destroy+0x32
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`traverse+0x43
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`syscall_mstate+0x84
+ unix`0xfffffffffb800c86
+ 4
+
+ genunix`rwst_exit+0x86
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`ufalloc_file+0x117
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`copen+0x59
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`mutex_enter+0x9
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`bcopy+0x2db
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`fd_find+0x4c
+ genunix`ufalloc_file+0x91
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ lofs`freelonode+0x9d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`fop_inactive+0x4e
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ ufs`ufs_lookup+0x1e
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`rwst_exit+0x8f
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ zfs`zfs_fastaccesschk_execute+0x10f
+ zfs`zfs_lookup+0xc2
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ lofs`freelonode+0xa0
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`copen+0x160
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_cpu_reload
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`i_ddi_splhigh
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 4
+
+ lofs`makelonode+0x91
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ lofs`lo_lookup+0x1
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ lofs`lsave+0xc4
+ lofs`makelonode+0x1df
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`lookuppnatcred+0xc5
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`bcopy+0x3e8
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`vn_rele+0x8
+ genunix`traverse+0x9f
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`vn_rele+0x8
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`vn_openat+0x18
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`vfs_matchops+0x8
+ lofs`lo_lookup+0x1e6
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`copen+0x169
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`copystr+0x5a
+ genunix`pn_get_buf+0x43
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`ufalloc_file+0x2a
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`falloc+0xee
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`post_syscall+0x18f
+ unix`0xfffffffffb800c91
+ 4
+
+ unix`mutex_exit
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`mutex_exit
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`mutex_exit
+ genunix`kmem_free+0x4e
+ genunix`audit_unfalloc+0x44
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`mutex_exit
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`mutex_exit
+ genunix`kmem_zalloc+0x47
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`lookupnameatcred+0x61
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`unfalloc+0x52
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`lookuppnvp+0x1e4
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`fop_lookup+0x107
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ zfs`specvp_check+0x8
+ zfs`zfs_lookup+0xf4
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`audit_getstate+0x28
+ genunix`post_syscall+0xbe
+ unix`0xfffffffffb800c91
+ 4
+
+ genunix`vsd_free+0x8
+ genunix`vn_free+0x8b
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`vsd_free+0x8
+ genunix`vn_free+0x8b
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_cache_free+0x68
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`kmem_cache_free+0x68
+ genunix`kmem_free+0x4e
+ genunix`audit_unfalloc+0x44
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ lofs`lo_lookup+0x11b
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ unix`tsc_gethrtimeunscaled+0x1b
+ genunix`gethrtime_unscaled+0xa
+ genunix`syscall_mstate+0x5d
+ unix`sys_syscall+0x10e
+ 4
+
+ genunix`fd_find+0x6f
+ genunix`ufalloc_file+0x91
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 4
+
+ genunix`fsop_root+0x10
+ genunix`traverse+0x87
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`audit_getstate+0x30
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ lofs`lo_lookup+0x122
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`syscall_mstate+0x1b2
+ unix`0xfffffffffb800ca0
+ 5
+
+ unix`mutex_exit+0x12
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ unix`mutex_exit+0x12
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ unix`mutex_exit+0x12
+ lofs`freelonode+0x1fe
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`audit_getstate+0x33
+ unix`0xfffffffffb800c91
+ 5
+
+ genunix`vn_rele+0x24
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`syscall_mstate+0xb4
+ unix`sys_syscall+0x1a1
+ 5
+
+ genunix`fsop_root+0x17
+ genunix`traverse+0x87
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`traverse+0x77
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ unix`tsc_read+0x7
+ genunix`gethrtime_unscaled+0xa
+ genunix`syscall_mstate+0x5d
+ unix`sys_syscall+0x1a1
+ 5
+
+ unix`tsc_gethrtimeunscaled+0x28
+ genunix`gethrtime_unscaled+0xa
+ genunix`syscall_mstate+0x5d
+ unix`0xfffffffffb800c86
+ 5
+
+ unix`mutex_exit+0x19
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`syscall_mstate+0x1bb
+ unix`sys_syscall+0x1a1
+ 5
+
+ genunix`kmem_free+0xb
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`kmem_free+0xf
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`kmem_free+0xf
+ genunix`audit_unfalloc+0x44
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`dnlc_lookup+0xf0
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_rele+0x31
+ ufs`ufs_lookup+0x36d
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ unix`copyinstr+0x11
+ genunix`pn_get_buf+0x43
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`setf+0x1
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ unix`mutex_init+0x41
+ genunix`rwst_init+0x38
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`fsop_root+0x22
+ genunix`traverse+0x87
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`fd_find+0x82
+ genunix`ufalloc_file+0x91
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_openat+0x47
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ unix`bcopy+0x318
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`lookuppnvp+0xb
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`kmem_free+0x1b
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ lofs`lo_root+0xc
+ genunix`fsop_root+0x2d
+ genunix`traverse+0x87
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`lookupnameatcred+0x8c
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`fd_find+0x8d
+ genunix`ufalloc_file+0x91
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_rele+0x3e
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_rele+0x3e
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`lookupnameatcred+0x93
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`syscall_mstate+0x1d4
+ unix`0xfffffffffb800c86
+ 5
+
+ genunix`kmem_free+0x26
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ lofs`table_lock_enter+0x17
+ lofs`freelonode+0x47
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_openat+0x59
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`kmem_free+0x2a
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`dnlc_lookup+0x10d
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`pn_get_buf+0x2d
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_openat+0x60
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`falloc+0x33
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_openat+0x64
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`dnlc_lookup+0x15
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ lofs`lo_root+0x28
+ genunix`fsop_root+0x2d
+ genunix`traverse+0x87
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`open+0x18
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_vfslocks_getlock+0x8
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`kmem_cache_alloc+0x79
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_openat+0x6a
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`falloc+0x3a
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`thread_lock+0x4b
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 5
+
+ genunix`dnlc_lookup+0x11c
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ lofs`freelonode+0x1fe
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`kmem_cache_free+0xb0
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`kmem_cache_free+0xb0
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_mountedvfs+0x1
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`dnlc_lookup+0x22
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_vfslocks_getlock+0x13
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`kmem_cache_alloc+0x84
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_vfslocks_getlock+0x17
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`lookuppnvp+0x39
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`dnlc_lookup+0x2a
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`setf+0x3a
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_vfslocks_getlock+0x1b
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ unix`mutex_destroy+0x6b
+ genunix`rwst_destroy+0x1c
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`kmem_cache_alloc+0x8d
+ genunix`kmem_zalloc+0x47
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_vfslocks_getlock+0x1f
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`rwst_enter_common+0x2cf
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ lofs`freelonode+0x10
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`pn_fixslash+0x1
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`cv_init+0x8
+ genunix`rwst_init+0x56
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`syscall_mstate+0x8
+ unix`sys_syscall+0x10e
+ 5
+
+ genunix`syscall_mstate+0x108
+ unix`sys_syscall+0x1a1
+ 5
+
+ genunix`vn_vfslocks_getlock+0x29
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ ufs`ufs_iaccess+0xa
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`syscall_mstate+0xc
+ unix`0xfffffffffb800c86
+ 5
+
+ genunix`cv_init+0xd
+ genunix`rwst_init+0x56
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_vfslocks_getlock+0x2d
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`fop_lookup+0x6d
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`kmem_zalloc+0xdf
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`gethrtime_unscaled
+ unix`sys_syscall+0x1a1
+ 5
+
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ lofs`freelonode+0x23
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ unix`mutex_destroy+0x84
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ unix`sys_syscall+0x15a
+ 5
+
+ genunix`fd_reserve+0x26
+ genunix`setf+0x123
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ lofs`table_lock_enter+0x57
+ lofs`freelonode+0x47
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`syscall_mstate+0x17
+ unix`0xfffffffffb800ca0
+ 5
+
+ genunix`gethrtime_unscaled+0xa
+ genunix`syscall_mstate+0x5d
+ unix`0xfffffffffb800ca0
+ 5
+
+ genunix`kmem_cache_free+0xdb
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`kmem_cache_free+0xdb
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`kmem_cache_free+0xdb
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ lofs`table_lock_enter+0x5c
+ lofs`freelonode+0x47
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`pn_getcomponent+0xad
+ genunix`lookuppnvp+0x16d
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`lookuppnvp+0x35e
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`kmem_alloc+0xdf
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`crhold
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`cv_broadcast+0x72
+ genunix`rwst_exit+0x8f
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`syscall_mstate+0x22
+ unix`sys_syscall+0x10e
+ 5
+
+ genunix`syscall_mstate+0x123
+ unix`0xfffffffffb800c86
+ 5
+
+ genunix`rwst_exit+0x23
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`audit_falloc+0x33
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_vfslocks_rele+0x105
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`fop_lookup+0x85
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_free+0x66
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`syscall_mstate+0x26
+ unix`sys_syscall+0x1a1
+ 5
+
+ genunix`copen+0xf8
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`kmem_cache_free+0xe8
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`kmem_cache_free+0xe8
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`dnlc_lookup+0x159
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`crhold+0x9
+ genunix`falloc+0xbc
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`fop_lookup+0x8e
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`lookuppnvp+0x6f
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ lofs`lo_lookup+0x1a0
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`lookuppnatcred+0x60
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`audit_unfalloc
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ lofs`freelonode+0x42
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`post_syscall+0x23
+ unix`0xfffffffffb800c91
+ 5
+
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`crhold+0x16
+ genunix`falloc+0xbc
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`cv_destroy+0x8
+ genunix`rwst_destroy+0x25
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`ufalloc_file+0xc8
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`dnlc_lookup+0x69
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_vfslocks_getlock+0x59
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`syscall_mstate+0x3a
+ unix`0xfffffffffb800ca0
+ 5
+
+ genunix`post_syscall+0x2e
+ unix`0xfffffffffb800c91
+ 5
+
+ lofs`freelonode+0x4f
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`fd_find
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`crfree
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ lofs`table_lock_enter+0x82
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`lookuppnvp+0x82
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`syscall_mstate+0x45
+ unix`0xfffffffffb800ca0
+ 5
+
+ unix`lock_clear_splx+0x5
+ genunix`post_syscall+0x318
+ unix`0xfffffffffb800c91
+ 5
+
+ genunix`post_syscall+0x338
+ unix`0xfffffffffb800c91
+ 5
+
+ genunix`lookuppnatcred+0x78
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`traverse+0x8
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`kmem_cache_free+0x8
+ genunix`kmem_free+0x4e
+ genunix`audit_unfalloc+0x44
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_vfslocks_rele+0x29
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_vfslocks_rele+0x29
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`rwst_init+0x5b
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`fop_lookup+0xad
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`kmem_cache_alloc+0xe4
+ genunix`kmem_zalloc+0x47
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ lofs`lo_lookup+0x1c5
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`lookupnameatcred+0x17
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ zfs`zfs_lookup+0x47
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_vfslocks_rele+0x38
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`syscall_mstate+0x58
+ unix`0xfffffffffb800c86
+ 5
+
+ unix`rw_exit+0x8
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`lookuppnatcred+0x89
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`rwst_enter_common+0x29
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`dnlc_lookup+0x8b
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`kmem_cache_free+0x1b
+ genunix`kmem_free+0x4e
+ genunix`audit_unfalloc+0x44
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`syscall_mstate+0x5d
+ unix`0xfffffffffb800c86
+ 5
+
+ genunix`crfree+0x1d
+ genunix`unfalloc+0x4a
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`lookupnameat+0x10
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`kmem_zalloc+0x31
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_openat+0xe2
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`kmem_cache_free+0x22
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`kmem_cache_free+0x22
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_vfslocks_rele+0x46
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_vfslocks_rele+0x46
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_vfslocks_rele+0x46
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`post_syscall+0x357
+ unix`0xfffffffffb800c91
+ 5
+
+ genunix`rwst_destroy+0x17
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`dnlc_lookup+0x198
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`lookupnameat+0x18
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`syscall_mstate+0x168
+ 5
+
+ genunix`crgetmapped+0x8
+ genunix`fop_inactive+0x60
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_invalid+0x39
+ lofs`freelonode+0x115
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`lookupnameatcred+0x29
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ zfs`zfs_lookup+0x59
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`post_syscall+0x35b
+ unix`0xfffffffffb800c91
+ 5
+
+ genunix`kmem_cache_free+0x2b
+ genunix`unfalloc+0x61
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`kmem_cache_free+0x2b
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`unfalloc+0x1d
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ unix`atomic_add_32
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ unix`atomic_add_32
+ genunix`falloc+0xbc
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`kmem_cache_alloc
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ unix`clear_int_flag
+ genunix`disp_lock_exit+0x47
+ genunix`post_syscall+0x318
+ unix`0xfffffffffb800c91
+ 5
+
+ genunix`syscall_mstate+0x71
+ unix`sys_syscall+0x10e
+ 5
+
+ genunix`syscall_mstate+0x71
+ unix`sys_syscall+0x1a1
+ 5
+
+ genunix`fop_inactive+0x31
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`fop_lookup+0xd2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`rwst_destroy+0x25
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ unix`bcopy+0x3c8
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ zfs`zfs_lookup+0x6a
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_vfsrlock+0x3c
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`fop_lookup+0xdd
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`rwst_destroy+0x2e
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`kmem_cache_free+0x3f
+ genunix`unfalloc+0x61
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`kmem_cache_free+0x3f
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ unix`atomic_add_64
+ unix`sys_syscall+0x10e
+ 5
+
+ unix`atomic_add_64
+ unix`0xfffffffffb800ca0
+ 5
+
+ unix`atomic_add_64
+ unix`sys_syscall+0x1a1
+ 5
+
+ genunix`vn_openat
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_setpath+0x10
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ unix`mutex_enter
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ unix`mutex_enter
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ unix`mutex_enter
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ unix`mutex_enter
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ unix`mutex_enter
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ unix`mutex_enter
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ lofs`makelonode+0x81
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_openat+0x1
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ unix`bcopy+0x2d2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`rwst_destroy+0x33
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`copen+0x54
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`lookupnameat+0x34
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ ufs`ufs_iaccess+0x86
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`lookupnameatcred+0x47
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`fop_lookup+0x1e7
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ lofs`freelonode+0x98
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vsd_free+0xe8
+ genunix`vn_free+0x8b
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`falloc+0xd9
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`fop_lookup+0xe9
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ unix`mutex_enter+0x9
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`lookupnameat+0x3a
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`fop_inactive+0x4a
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`crgetmapped+0x2a
+ genunix`fop_inactive+0x60
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_vfslocks_rele+0x6b
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`kmem_cache_alloc+0x1b
+ lofs`makelonode+0xa9
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`syscall_mstate+0x18c
+ unix`sys_syscall+0x1a1
+ 5
+
+ genunix`audit_getstate+0xd
+ genunix`copen+0x59
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_rele
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`ufalloc_file+0x22
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ zfs`zfs_fastaccesschk_execute+0x16
+ zfs`zfs_lookup+0xc2
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ lofs`freelonode+0xa8
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_rele+0x8
+ genunix`lookuppnvp+0x39f
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`falloc+0xe9
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`unfalloc+0x4a
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ unix`copystr+0x5d
+ genunix`pn_get_buf+0x43
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_setpath+0x2d
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`falloc+0xf0
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ unix`mutex_exit
+ genunix`unfalloc+0x61
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ unix`mutex_exit
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ unix`mutex_exit
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ unix`mutex_exit
+ ufs`ufs_lookup+0x36d
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ unix`mutex_exit
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ unix`mutex_exit
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ unix`mutex_exit
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`post_syscall+0x291
+ unix`0xfffffffffb800c91
+ 5
+
+ genunix`lookuppnatcred+0xd1
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`syscall_mstate+0xa2
+ unix`sys_syscall+0x10e
+ 5
+
+ genunix`syscall_mstate+0xa2
+ unix`0xfffffffffb800c86
+ 5
+
+ genunix`lookuppnvp+0xe3
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`vn_rele+0x17
+ genunix`traverse+0x9f
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ zfs`zfs_lookup+0x97
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ unix`mutex_destroy+0x17
+ genunix`rwst_destroy+0x1c
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`setf+0xe8
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`fop_lookup+0x208
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`audit_getstate+0x28
+ genunix`lookuppnvp+0x82
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`audit_getstate+0x28
+ genunix`copen+0x59
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`kmem_cache_free+0x68
+ genunix`unfalloc+0x61
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`kmem_cache_free+0x68
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ unix`tsc_gethrtimeunscaled+0x1b
+ genunix`gethrtime_unscaled+0xa
+ genunix`syscall_mstate+0x5d
+ unix`sys_syscall+0x1a1
+ 5
+
+ genunix`thread_lock+0xc
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 5
+
+ genunix`dnlc_lookup+0xdc
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`audit_getstate+0x2d
+ unix`0xfffffffffb800c91
+ 5
+
+ genunix`kmem_cache_alloc+0x3e
+ lofs`makelonode+0xa9
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ zfs`zfs_fastaccesschk_execute+0x2e
+ zfs`zfs_lookup+0xc2
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`dnlc_lookup+0xdf
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 5
+
+ genunix`cv_broadcast
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`kmem_cache_free+0x70
+ genunix`kmem_free+0x4e
+ genunix`audit_unfalloc+0x44
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`kmem_free
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`kmem_free
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ unix`tsc_read
+ genunix`gethrtime_unscaled+0xa
+ genunix`syscall_mstate+0x5d
+ unix`sys_syscall+0x1a1
+ 6
+
+ unix`splx
+ genunix`post_syscall+0x318
+ unix`0xfffffffffb800c91
+ 6
+
+ genunix`post_syscall+0x2a1
+ unix`0xfffffffffb800c91
+ 6
+
+ unix`copyinstr+0x1
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`lookuppnvp+0x1f1
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`ufalloc_file+0x41
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ unix`mutex_exit+0x12
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ unix`mutex_exit+0x12
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ unix`mutex_exit+0x12
+ genunix`lookuppnvp+0x39f
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`syscall_mstate+0xb4
+ unix`0xfffffffffb800c86
+ 6
+
+ genunix`syscall_mstate+0xb4
+ unix`0xfffffffffb800ca0
+ 6
+
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`kmem_free+0x5
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ lofs`freelonode+0xc7
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`vsd_free+0x17
+ genunix`vn_free+0x8b
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ unix`tsc_read+0x7
+ genunix`gethrtime_unscaled+0xa
+ genunix`syscall_mstate+0x5d
+ unix`sys_syscall+0x10e
+ 6
+
+ unix`tsc_read+0x7
+ genunix`gethrtime_unscaled+0xa
+ genunix`syscall_mstate+0x5d
+ unix`0xfffffffffb800ca0
+ 6
+
+ genunix`cv_broadcast+0x8
+ genunix`setf+0x8c
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ unix`tsc_gethrtimeunscaled+0x28
+ genunix`gethrtime_unscaled+0xa
+ genunix`syscall_mstate+0x5d
+ unix`sys_syscall+0x10e
+ 6
+
+ unix`tsc_gethrtimeunscaled+0x28
+ genunix`gethrtime_unscaled+0xa
+ genunix`syscall_mstate+0x5d
+ unix`0xfffffffffb800ca0
+ 6
+
+ genunix`fd_find+0x78
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ unix`mutex_exit+0x19
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`openat+0x1a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`kmem_free+0xb
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`vn_vfslocks_rele+0x9e
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`thread_lock+0x1f
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 6
+
+ genunix`syscall_mstate+0x1c0
+ unix`sys_syscall+0x10e
+ 6
+
+ genunix`post_syscall+0x1b3
+ unix`0xfffffffffb800c91
+ 6
+
+ genunix`fsop_root+0x26
+ genunix`traverse+0x87
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ unix`copyinstr+0x16
+ genunix`pn_get_buf+0x43
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`vn_vfslocks_rele+0xa6
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`vn_rele+0x39
+ genunix`traverse+0x9f
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`setf+0xc
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`fsop_root+0x2d
+ genunix`traverse+0x87
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`falloc+0x1d
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`openat+0x2f
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`pn_get_buf+0x1f
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ unix`bcopy+0x320
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ zfs`specvp_check+0x30
+ zfs`zfs_lookup+0xf4
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`clear_stale_fd
+ unix`0xfffffffffb800c91
+ 6
+
+ genunix`dnlc_lookup+0x1
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`lookuppnatcred+0x104
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`kmem_cache_alloc+0x66
+ genunix`kmem_zalloc+0x47
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`kmem_cache_alloc+0x66
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ lofs`table_lock_enter+0x17
+ lofs`freelonode+0x47
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`vn_free+0x17
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`thread_lock+0x39
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 6
+
+ genunix`fop_inactive+0x9f
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`vn_vfslocks_getlock
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`vn_vfslocks_getlock+0x1
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`syscall_mstate+0xe3
+ unix`sys_syscall+0x10e
+ 6
+
+ lofs`table_lock_enter+0x26
+ lofs`freelonode+0x47
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`vn_vfslocks_rele+0xc6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`vn_vfslocks_getlock+0x8
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`traverse+0xa8
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`lookuppnatcred+0x1a
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`kmem_free+0x3a
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ lofs`freelonode+0xfb
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`vn_vfslocks_getlock+0xc
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`lookuppnatcred+0x11c
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ unix`_sys_rtt
+ 6
+
+ genunix`ufalloc_file+0x7e
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`kmem_cache_free+0xb0
+ genunix`kmem_free+0x4e
+ genunix`audit_unfalloc+0x44
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`kmem_cache_free+0xb0
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`kmem_free+0x43
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`vn_mountedvfs+0x8
+ genunix`traverse+0x77
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`kmem_zalloc+0xc8
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ lofs`freelonode+0x109
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`kmem_cache_alloc+0x89
+ genunix`falloc+0x63
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`kmem_cache_alloc+0x8d
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`kmem_cache_free+0xbd
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`kmem_cache_free+0xbd
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ unix`splr+0x10
+ genunix`thread_lock+0x24
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 6
+
+ genunix`fsop_root+0x61
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`vn_rele+0x71
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`dnlc_lookup+0x32
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`kmem_cache_alloc+0x92
+ genunix`kmem_zalloc+0x47
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`kmem_zalloc+0xd3
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`post_syscall+0x2f5
+ unix`0xfffffffffb800c91
+ 6
+
+ genunix`fd_reserve+0x17
+ genunix`setf+0x123
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`rwst_init+0x17
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ unix`splr+0x17
+ genunix`thread_lock+0x24
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 6
+
+ genunix`kmem_free+0x57
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`copen+0x1d8
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`lookuppnatcred+0x138
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`falloc+0x5c
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`vn_rele+0x7d
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ ufs`ufs_iaccess+0xe
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`syscall_mstate+0x10
+ unix`sys_syscall+0x10e
+ 6
+
+ genunix`gethrtime_unscaled
+ unix`sys_syscall+0x10e
+ 6
+
+ genunix`dnlc_lookup+0x43
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`kmem_alloc+0xd4
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`fd_reserve+0x26
+ genunix`ufalloc_file+0x103
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ lofs`freelonode+0x27
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ unix`sys_syscall+0x15e
+ 6
+
+ ufs`ufs_iaccess+0x19
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`kmem_zalloc+0xea
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`gethrtime_unscaled+0xa
+ genunix`syscall_mstate+0x5d
+ unix`0xfffffffffb800c86
+ 6
+
+ genunix`syscall_mstate+0x1b
+ unix`sys_syscall+0x1a1
+ 6
+
+ lofs`table_lock_enter+0x5c
+ lofs`freelonode+0x47
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`vn_vfslocks_getlock+0x3c
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ unix`prunstop+0xd
+ genunix`post_syscall+0x2d0
+ unix`0xfffffffffb800c91
+ 6
+
+ ufs`ufs_iaccess+0x1d
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`vn_vfslocks_rele
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`vn_openat+0xa1
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ lofs`lo_root+0x62
+ genunix`fsop_root+0x2d
+ genunix`traverse+0x87
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`cv_broadcast+0x72
+ genunix`rwst_exit+0x8f
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`fd_reserve+0x33
+ genunix`setf+0x123
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`rwst_exit+0x23
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ lofs`freelonode+0x37
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`vn_vfslocks_rele+0x8
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`vn_vfslocks_rele+0x8
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`kmem_cache_free+0xe8
+ genunix`unfalloc+0x61
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`syscall_mstate+0x2a
+ unix`0xfffffffffb800ca0
+ 6
+
+ genunix`post_syscall+0x31b
+ unix`0xfffffffffb800c91
+ 6
+
+ genunix`post_syscall+0x1f
+ unix`0xfffffffffb800c91
+ 6
+
+ genunix`vn_invalid
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ zfs`zfs_lookup+0x21
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`kmem_cache_free+0xf1
+ genunix`unfalloc+0x61
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`kmem_cache_free+0xf1
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`dnlc_lookup+0x62
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`post_syscall+0x324
+ unix`0xfffffffffb800c91
+ 6
+
+ genunix`falloc+0x84
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`vn_vfslocks_rele+0x17
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`rwst_init+0x47
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`post_syscall+0x27
+ unix`0xfffffffffb800c91
+ 6
+
+ genunix`cv_destroy+0x8
+ genunix`rwst_destroy+0x2e
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`fd_reserve+0x48
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`syscall_mstate+0x139
+ unix`sys_syscall+0x10e
+ 6
+
+ genunix`syscall_mstate+0x3a
+ unix`sys_syscall+0x1a1
+ 6
+
+ genunix`kmem_cache_free+0xfa
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`cv_destroy+0xc
+ genunix`rwst_destroy+0x25
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`pn_fixslash+0x3d
+ genunix`lookuppnvp+0x105
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`lookuppnatcred+0x16f
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ lofs`lo_inactive
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`kmem_cache_free
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`kmem_alloc
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`post_syscall+0x134
+ unix`0xfffffffffb800c91
+ 6
+
+ genunix`fop_lookup+0xa5
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ lofs`lo_inactive+0x8
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`kmem_cache_free+0x8
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ lofs`lsave+0x7a
+ lofs`makelonode+0x1df
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`pn_fixslash+0x4b
+ genunix`lookuppnvp+0x105
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ unix`sys_syscall+0x192
+ 6
+
+ genunix`dnlc_lookup+0x7d
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`vn_vfslocks_getlock+0x6e
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`unfalloc
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`rwst_destroy
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`ufalloc_file+0xe3
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`memcmp+0x17
+ unix`bcmp+0x9
+ genunix`dnlc_lookup+0x10d
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`fop_inactive+0x17
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`kmem_cache_free+0x17
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`kmem_cache_free+0x17
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`fop_lookup+0xbb
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`vn_vfslocks_getlock+0x7d
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`syscall_mstate+0x5d
+ unix`sys_syscall+0x1a1
+ 6
+
+ genunix`rwst_exit+0x5d
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`copen+0x33
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`vn_vfslocks_rele+0x46
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`traverse+0x26
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`kmem_cache_free+0x2b
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`kmem_cache_alloc+0xfc
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ ufs`ufs_lookup+0xfd
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ unix`rw_exit+0x1e
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`copen+0x13f
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ unix`bcopy+0x3c0
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`lookupnameat+0x20
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`lookuppnvp+0x1b7
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`syscall_mstate+0x177
+ unix`sys_syscall+0x1a1
+ 6
+
+ genunix`kmem_cache_alloc+0x8
+ genunix`falloc+0x63
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`kmem_cache_free+0x3a
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`dnlc_lookup+0x1ad
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`rwst_destroy+0x2e
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`fd_find+0x3f
+ genunix`ufalloc_file+0x91
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`ufalloc_file+0x10f
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`audit_getstate
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ unix`mutex_enter
+ genunix`unfalloc+0x61
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ unix`mutex_enter
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ unix`mutex_enter
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ unix`mutex_enter
+ zfs`zfs_lookup+0xc2
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ unix`mutex_enter
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ unix`mutex_enter
+ genunix`falloc+0x63
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`audit_getstate+0x1
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`lookuppnvp+0xc3
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`rwst_destroy+0x33
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`vn_vfslocks_getlock+0xa6
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`rwst_exit+0x86
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ ufs`ufs_lookup+0x17
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ zfs`zfs_fastaccesschk_execute+0x8
+ zfs`zfs_lookup+0xc2
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ zfs`zfs_lookup+0x7a
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`audit_getstate+0xa
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`setf+0xcc
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`crgetmapped+0x2e
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`post_syscall+0x7f
+ unix`0xfffffffffb800c91
+ 6
+
+ genunix`vn_rele
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ unix`mutex_destroy
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`traverse+0x52
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`rwst_enter_common+0x162
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`ufalloc_file+0x26
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ unix`tsc_gethrtimeunscaled+0x8
+ genunix`gethrtime_unscaled+0xa
+ genunix`syscall_mstate+0x5d
+ unix`0xfffffffffb800ca0
+ 6
+
+ unix`mutex_destroy+0x8
+ genunix`rwst_destroy+0x1c
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`thread_lock
+ unix`0xfffffffffb800c91
+ 6
+
+ genunix`vn_rele+0x10
+ ufs`ufs_lookup+0x36d
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ zfs`specvp_check
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`vsd_free
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ unix`mutex_exit
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ unix`mutex_exit
+ genunix`fsop_root+0x2d
+ genunix`traverse+0x87
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ unix`mutex_exit
+ lofs`freelonode+0x1fe
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ unix`mutex_exit
+ genunix`falloc+0x63
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`syscall_mstate+0xa2
+ unix`0xfffffffffb800ca0
+ 6
+
+ unix`do_splx+0x74
+ genunix`disp_lock_exit+0x47
+ genunix`post_syscall+0x318
+ unix`0xfffffffffb800c91
+ 6
+
+ zfs`zfs_fastaccesschk_execute+0x26
+ zfs`zfs_lookup+0xc2
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`vn_vfsunlock+0x8
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`kmem_cache_free+0x68
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ lofs`freelonode+0xb9
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ lofs`freelonode+0xb9
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`lookuppnvp+0x1e9
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ unix`do_splx+0x79
+ genunix`post_syscall+0x318
+ unix`0xfffffffffb800c91
+ 6
+
+ unix`bcopy+0x3fa
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`syscall_mstate+0x1ab
+ unix`sys_syscall+0x1a1
+ 6
+
+ genunix`traverse+0x6f
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 6
+
+ genunix`thread_lock+0x10
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 7
+
+ genunix`kmem_cache_free+0x70
+ genunix`unfalloc+0x61
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`kmem_cache_free+0x70
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ unix`tsc_read
+ genunix`gethrtime_unscaled+0xa
+ genunix`syscall_mstate+0x5d
+ unix`sys_syscall+0x10e
+ 7
+
+ genunix`cv_broadcast+0x1
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ unix`mutex_exit+0x12
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`thread_lock+0x17
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 7
+
+ unix`tsc_gethrtimeunscaled+0x28
+ genunix`gethrtime_unscaled+0xa
+ genunix`syscall_mstate+0x5d
+ unix`sys_syscall+0x1a1
+ 7
+
+ zfs`zfs_fastaccesschk_execute+0x138
+ zfs`zfs_lookup+0xc2
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`vn_openat+0x3d
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`dnlc_lookup+0xef
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`falloc+0xf
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ unix`bcopy+0x310
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`lookuppnvp
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ lofs`lo_root+0x1
+ genunix`traverse+0x87
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ lofs`makelonode+0x1c4
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ unix`tsc_gethrtimeunscaled+0x34
+ genunix`syscall_mstate+0x5d
+ unix`sys_syscall+0x10e
+ 7
+
+ genunix`lookuppnatcred+0xf5
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`cv_broadcast+0x17
+ genunix`setf+0x8c
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`traverse+0x87
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`vn_free+0x8
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`vn_rele+0x39
+ lofs`freelonode+0x1fe
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ unix`copyinstr+0x1b
+ genunix`pn_get_buf+0x43
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`fop_inactive+0x8b
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`dnlc_lookup+0xfc
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`fop_lookup+0x12d
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ ufs`ufs_lookup+0x365
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`kmem_cache_alloc+0x66
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`vn_vfslocks_getlock
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`ufalloc
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`clear_stale_fd+0x13
+ genunix`post_syscall+0x1fe
+ unix`0xfffffffffb800c91
+ 7
+
+ genunix`lookuppnvp+0x29
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`copen+0x2ba
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ lofs`freelonode+0xfb
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`vn_free+0x2b
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`setf+0x12b
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`fop_inactive+0xab
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ unix`sys_syscall+0x132
+ 7
+
+ genunix`audit_falloc
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ lofs`freelonode+0x1
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`disp_lock_exit+0x32
+ genunix`post_syscall+0x318
+ unix`0xfffffffffb800c91
+ 7
+
+ genunix`open+0x26
+ 7
+
+ genunix`thread_lock+0x57
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 7
+
+ genunix`syscall_mstate+0x1f7
+ unix`sys_syscall+0x1a1
+ 7
+
+ lofs`freelonode+0x8
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`rwst_enter_common+0x2cb
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ unix`mutex_destroy+0x6b
+ genunix`rwst_destroy+0x1c
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`vn_mountedvfs+0xc
+ genunix`traverse+0x77
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`kmem_cache_alloc+0x8d
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`pn_get_buf+0x4f
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`setf+0x3f
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`pn_get_buf+0x50
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`lookuppnatcred+0x30
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`vn_mountedvfs+0x10
+ genunix`traverse+0x77
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ zfs`zfs_lookup+0xf4
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ lofs`freelonode+0x115
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ lofs`lo_lookup+0x275
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`cv_init+0x8
+ genunix`rwst_init+0x47
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ lofs`freelonode+0x21e
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`lookuppnatcred+0x3f
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`gethrtime_unscaled
+ unix`0xfffffffffb800ca0
+ 7
+
+ genunix`fop_lookup+0x73
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`kmem_alloc+0xd4
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`lookuppnvp+0x458
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`rwst_exit+0x18
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`rwst_init+0x28
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`syscall_mstate+0x119
+ unix`0xfffffffffb800c86
+ 7
+
+ genunix`syscall_mstate+0x1b
+ unix`sys_syscall+0x10e
+ 7
+
+ genunix`kmem_cache_free+0xdb
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`syscall_mstate+0x11c
+ unix`sys_syscall+0x1a1
+ 7
+
+ lofs`freelonode+0x2f
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`vn_free+0x66
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`syscall_mstate+0x26
+ unix`0xfffffffffb800c86
+ 7
+
+ genunix`syscall_mstate+0x26
+ unix`0xfffffffffb800ca0
+ 7
+
+ genunix`fd_reserve+0x37
+ genunix`setf+0x123
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ ufs`ufs_iaccess+0x28
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`vn_vfslocks_rele+0x8
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`rwst_init+0x38
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ unix`bcmp+0x9
+ genunix`dnlc_lookup+0x10d
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`syscall_mstate+0x2a
+ unix`sys_syscall+0x1a1
+ 7
+
+ genunix`dnlc_lookup+0x5f
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ unix`bcmp+0xf
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`fd_reserve+0x40
+ genunix`setf+0x123
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ unix`do_splx+0x1
+ genunix`post_syscall+0x318
+ unix`0xfffffffffb800c91
+ 7
+
+ genunix`rwst_exit+0x35
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ lofs`lo_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`vn_vfslocks_rele+0x17
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`vn_invalid+0x8
+ lofs`freelonode+0x115
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`kmem_cache_free+0xfa
+ genunix`kmem_free+0x4e
+ genunix`audit_unfalloc+0x44
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`kmem_cache_free+0xfa
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`rwst_enter_common+0xb
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`cv_destroy+0xc
+ genunix`rwst_destroy+0x2e
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ zfs`zfs_lookup+0x2c
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`vn_vfsrlock
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ unix`lock_clear_splx
+ genunix`post_syscall+0x318
+ unix`0xfffffffffb800c91
+ 7
+
+ unix`strlen+0x3
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`rwst_exit+0x44
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`vn_vfslocks_getlock+0x66
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`falloc+0x97
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`kmem_cache_free+0x8
+ genunix`unfalloc+0x61
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`kmem_cache_free+0x8
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`vn_free+0x8b
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`kmem_alloc+0xb
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`lookuppnatcred+0x7c
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`setf+0x8c
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`vn_invalid+0x1d
+ lofs`freelonode+0x115
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`vn_vfslocks_getlock+0x6e
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`ufalloc_file+0xde
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ lofs`lo_inactive+0x10
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ unix`copystr+0x14
+ genunix`pn_get_buf+0x43
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ lofs`makelfsnode+0x17
+ lofs`makelonode+0x192
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`kmem_cache_free+0x17
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ lofs`lo_inactive+0x18
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ lofs`lo_inactive+0x18
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`vn_vfsrlock+0x18
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`syscall_mstate+0x58
+ unix`0xfffffffffb800ca0
+ 7
+
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`secpolicy_vnode_access2+0x1e
+ ufs`ufs_iaccess+0x128
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`rwst_enter_common+0x331
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`dnlc_lookup+0x195
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`memcmp+0x26
+ unix`bcmp+0x9
+ genunix`dnlc_lookup+0x10d
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`fop_inactive+0x26
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`syscall_mstate+0x69
+ unix`sys_syscall+0x10e
+ 7
+
+ genunix`falloc+0xbc
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`rwst_destroy+0x1c
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`syscall_mstate+0x170
+ unix`sys_syscall+0x1a1
+ 7
+
+ genunix`syscall_mstate+0x71
+ unix`0xfffffffffb800c86
+ 7
+
+ zfs`zfs_lookup+0x63
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`crgetmapped+0x15
+ genunix`fop_inactive+0x60
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`kmem_cache_free+0x3a
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`vn_vfslocks_rele+0x5c
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`fop_lookup+0x1e0
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`audit_getstate
+ unix`0xfffffffffb800c91
+ 7
+
+ genunix`kmem_cache_alloc+0x10
+ lofs`makelonode+0xa9
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ unix`mutex_enter
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ unix`mutex_enter
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ unix`mutex_enter
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`audit_getstate+0x1
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`pn_getcomponent+0x14
+ genunix`lookuppnvp+0x16d
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`vn_openat+0x307
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`kmem_cache_alloc+0x17
+ genunix`kmem_zalloc+0x47
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ lofs`makelonode+0x89
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`audit_getstate+0xa
+ unix`0xfffffffffb800c91
+ 7
+
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`fop_lookup+0xed
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`crgetmapped+0x2e
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ lofs`freelonode+0x1a0
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ zfs`zfs_lookup+0x80
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`kmem_cache_alloc+0x22
+ lofs`makelonode+0xa9
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`fop_inactive+0x53
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`fop_inactive+0x53
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`post_syscall+0x85
+ unix`0xfffffffffb800c91
+ 7
+
+ genunix`vn_setpath+0x26
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`kmem_cache_alloc+0x26
+ genunix`falloc+0x63
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ unix`mutex_destroy+0x8
+ genunix`rwst_destroy+0x1c
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`kmem_cache_alloc+0x2a
+ lofs`makelonode+0xa9
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`fop_lookup+0xfc
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ lofs`makelonode+0x1a0
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ unix`mutex_exit
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ unix`mutex_exit
+ lofs`freelonode+0x1fe
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`vn_rele+0x17
+ lofs`freelonode+0x1fe
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ unix`copystr+0x67
+ genunix`pn_get_buf+0x43
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ unix`mutex_init+0x27
+ genunix`rwst_init+0x38
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`kmem_cache_free+0x68
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`fop_lookup+0x20b
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`fop_lookup+0x10c
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`fop_inactive+0x6d
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 7
+
+ genunix`falloc
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`kmem_cache_free+0x70
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ unix`mutex_exit+0x12
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ unix`mutex_exit+0x12
+ genunix`kmem_free+0x4e
+ genunix`audit_unfalloc+0x44
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ unix`mutex_exit+0x12
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`kmem_free+0x5
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`copen+0x86
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`unfalloc+0x66
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`kmem_cache_alloc+0x46
+ genunix`kmem_alloc+0x4b
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ zfs`specvp_check+0x17
+ zfs`zfs_lookup+0xf4
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`kmem_cache_alloc+0x49
+ genunix`kmem_alloc+0x4b
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ unix`mutex_exit+0x19
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ unix`mutex_exit+0x19
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ unix`mutex_exit+0x19
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`thread_lock+0x1b
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 8
+
+ unix`mutex_init+0x3d
+ genunix`rwst_init+0x38
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`kmem_cache_alloc+0x4e
+ lofs`makelonode+0xa9
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ lofs`lo_lookup+0x30
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`copen+0x195
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`vn_vfslocks_rele+0xa6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ lofs`freelonode+0xdd
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ lofs`freelonode+0xdd
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`vn_rele+0x3e
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`fop_inactive+0x90
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`vn_vfslocks_getlock+0xf2
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ zfs`zfs_lookup+0xc2
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`vn_vfslocks_rele+0xb3
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`syscall_mstate+0x1d4
+ unix`sys_syscall+0x10e
+ 8
+
+ lofs`lsave+0x8
+ lofs`makelonode+0x1df
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`fop_lookup+0x13d
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`disp_lock_exit+0x1e
+ genunix`post_syscall+0x318
+ unix`0xfffffffffb800c91
+ 8
+
+ genunix`syscall_mstate+0xe3
+ unix`0xfffffffffb800c86
+ 8
+
+ lofs`lo_root+0x25
+ genunix`fsop_root+0x2d
+ genunix`traverse+0x87
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`disp_lock_exit+0x30
+ genunix`post_syscall+0x318
+ unix`0xfffffffffb800c91
+ 8
+
+ genunix`rwst_init
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`kmem_free+0x43
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`vn_setpath+0x85
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ lofs`table_lock_enter+0x38
+ lofs`freelonode+0x47
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`vn_rele+0x68
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`rwst_enter_common+0x1c8
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`syscall_mstate+0xf8
+ unix`0xfffffffffb800c86
+ 8
+
+ genunix`kmem_cache_free+0xbd
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`kmem_cache_free+0xbd
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ lofs`lo_lookup+0x26f
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`pn_fixslash
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`lookuppnvp+0x240
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`vn_mountedvfs+0x11
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`rwst_enter_common+0x2d7
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`kmem_free+0x57
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`syscall_mstate+0x108
+ unix`0xfffffffffb800ca0
+ 8
+
+ genunix`vn_vfslocks_getlock+0x29
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`vn_vfslocks_getlock+0x29
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`rwst_enter_common+0x2db
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`fop_lookup+0x6d
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ unix`mutex_destroy+0x7f
+ genunix`rwst_destroy+0x1c
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`syscall_mstate+0x10
+ unix`0xfffffffffb800ca0
+ 8
+
+ genunix`kmem_alloc+0xd4
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ lofs`table_lock_enter+0x57
+ lofs`freelonode+0x47
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`syscall_mstate+0x17
+ unix`sys_syscall+0x10e
+ 8
+
+ genunix`rwst_exit+0x18
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`gethrtime_unscaled+0xa
+ genunix`syscall_mstate+0x5d
+ unix`sys_syscall+0x1a1
+ 8
+
+ lofs`makelonode+0x1b
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`rwst_enter_common+0x1ec
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`copen+0x4ee
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`post_syscall+0xf
+ unix`0xfffffffffb800c91
+ 8
+
+ genunix`post_syscall+0x318
+ unix`0xfffffffffb800c91
+ 8
+
+ genunix`kmem_cache_free+0xe8
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ lofs`freelonode+0x23a
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`fop_lookup+0x8a
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`kmem_cache_free+0xf1
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`kmem_cache_free+0xf1
+ genunix`kmem_free+0x4e
+ genunix`audit_unfalloc+0x44
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`syscall_mstate+0x132
+ unix`sys_syscall+0x1a1
+ 8
+
+ genunix`syscall_mstate+0x135
+ unix`sys_syscall+0x10e
+ 8
+
+ genunix`vn_free+0x78
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`kmem_cache_free+0xfa
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`kmem_cache_free+0xfa
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`cv_destroy+0xc
+ genunix`rwst_destroy+0x2e
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`kmem_zalloc+0xc
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ lofs`freelonode+0x4f
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ lofs`lo_inactive+0x8
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`kmem_cache_free+0x8
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`secpolicy_vnode_access2+0x8
+ ufs`ufs_iaccess+0x128
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`copen+0x21b
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ zfs`zfs_lookup+0x3b
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ lofs`lo_inactive+0xc
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`rwst_exit+0x4c
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ unix`strlen+0x10
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`secpolicy_vnode_access2+0x13
+ ufs`ufs_iaccess+0x128
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`kmem_cache_alloc+0xe4
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`syscall_mstate+0x157
+ unix`0xfffffffffb800ca0
+ 8
+
+ genunix`kmem_cache_free+0x1b
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`vn_vfslocks_getlock+0x7d
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`syscall_mstate+0x5d
+ unix`sys_syscall+0x10e
+ 8
+
+ genunix`rwst_exit+0x5d
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`lookuppnvp+0xa2
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ zfs`zfs_lookup+0x52
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`memcmp+0x23
+ unix`bcmp+0x9
+ genunix`dnlc_lookup+0x10d
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`kmem_cache_alloc+0xf3
+ genunix`falloc+0x63
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ lofs`lfind+0x16
+ lofs`makelonode+0x47
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`vn_vfslocks_getlock+0x86
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`copen+0x37
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`rwst_destroy+0x17
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`fop_lookup+0x1c8
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`rwst_enter_common+0x38
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`kmem_alloc+0x2a
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`fop_lookup+0xcb
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`memcmp+0x2c
+ unix`bcmp+0x9
+ genunix`dnlc_lookup+0x10d
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`dnlc_lookup+0xa0
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ unix`atomic_add_32
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`vn_alloc
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`secpolicy_vnode_access2+0x34
+ ufs`ufs_iaccess+0x128
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`vsd_free+0xd8
+ genunix`vn_recycle+0xb5
+ genunix`vn_reinit+0x7b
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ lofs`freelonode+0x189
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`fd_find+0x3a
+ genunix`ufalloc_file+0x91
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`kmem_cache_free+0x3a
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`kmem_cache_alloc+0xc
+ lofs`makelonode+0xa9
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`audit_unfalloc+0x4d
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`kmem_cache_free+0x3f
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`fop_lookup+0xe0
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ unix`mutex_enter
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ unix`mutex_enter
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ unix`mutex_enter
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ ufs`ufs_lookup+0x111
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`syscall_mstate+0x84
+ unix`sys_syscall+0x10e
+ 8
+
+ genunix`kmem_cache_alloc+0x17
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ unix`mutex_enter+0x9
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ lofs`freelonode+0x9d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`rwst_enter_common+0x15f
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`vn_rele
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ ufs`ufs_lookup+0x22
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ unix`mutex_init+0x17
+ genunix`rwst_init+0x38
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`audit_getstate+0x18
+ genunix`copen+0x59
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`kmem_cache_alloc+0x2a
+ genunix`kmem_alloc+0x4b
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`ufalloc_file+0x12f
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`vn_vfsunlock
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ unix`mutex_exit
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ unix`mutex_exit
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`fd_find+0x62
+ genunix`ufalloc_file+0x91
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`post_syscall+0x93
+ unix`0xfffffffffb800c91
+ 8
+
+ genunix`vn_vfslocks_getlock+0xc4
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ unix`bcopy+0x3f5
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`kmem_cache_alloc+0x3a
+ lofs`makelonode+0xa9
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`audit_getstate+0x2c
+ genunix`post_syscall+0xbe
+ unix`0xfffffffffb800c91
+ 8
+
+ genunix`kmem_cache_alloc+0x3e
+ genunix`kmem_alloc+0x4b
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 8
+
+ genunix`kmem_cache_free+0x70
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`kmem_cache_free+0x70
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ unix`tsc_read
+ genunix`gethrtime_unscaled+0xa
+ genunix`syscall_mstate+0x5d
+ unix`0xfffffffffb800ca0
+ 9
+
+ unix`mutex_exit+0x12
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ unix`mutex_exit+0x12
+ zfs`zfs_lookup+0xc2
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ unix`mutex_exit+0x12
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ unix`mutex_exit+0x12
+ genunix`falloc+0x63
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`audit_getstate+0x33
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`vsd_free+0x17
+ genunix`vn_recycle+0xb5
+ genunix`vn_reinit+0x7b
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ unix`mutex_exit+0x19
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`openat+0x1e
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`vn_recycle+0x90
+ genunix`vn_reinit+0x7b
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`fd_find+0x80
+ genunix`ufalloc_file+0x91
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`setf
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`thread_lock+0x24
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 9
+
+ genunix`kmem_free+0x17
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ lofs`table_lock_enter+0x8
+ lofs`makelonode+0x36
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`vn_rele+0x39
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`lookuppnatcred
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`lookuppnvp+0x217
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`kmem_free+0x2a
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`vn_vfslocks_getlock+0x106
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`kmem_cache_alloc+0x77
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`vn_vfslocks_getlock+0x8
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`rwst_enter_common+0x1b8
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`post_syscall+0xda
+ unix`0xfffffffffb800c91
+ 9
+
+ genunix`fsop_root+0x4b
+ genunix`traverse+0x87
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`vn_setops+0x30
+ lofs`makelonode+0x1c4
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`kmem_cache_free+0xb0
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`lookuppnvp+0x132
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ lofs`table_lock_enter+0x38
+ lofs`freelonode+0x47
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`rwst_init+0x8
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`kmem_cache_free+0xbd
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`rwst_exit
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`disp_lock_exit+0x47
+ genunix`post_syscall+0x318
+ unix`0xfffffffffb800c91
+ 9
+
+ genunix`rwst_enter_common+0x1d8
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`rwst_enter_common+0x2dc
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`rwst_enter_common+0x2dc
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ lofs`freelonode+0x21e
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ unix`mutex_destroy+0x7f
+ genunix`rwst_destroy+0x1c
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ lofs`table_lock_enter+0x50
+ lofs`makelonode+0x36
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ lofs`makelonode+0x10
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ zfs`zfs_lookup+0x1
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`post_syscall+0x1
+ 9
+
+ genunix`copen+0x4e3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ ufs`ufs_iaccess+0x15
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`rwst_enter_common+0x1e8
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`cv_init+0x19
+ genunix`rwst_init+0x47
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`cv_init+0x19
+ genunix`rwst_init+0x56
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`kmem_cache_free+0xdb
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`kmem_cache_free+0xdb
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`vn_vfslocks_getlock+0x3c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ lofs`freelonode+0x22e
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`vn_vfslocks_getlock+0x41
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`vn_vfslocks_getlock+0x41
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ lofs`freelonode+0x33
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`kmem_cache_free+0xe8
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`cv_broadcast+0x7f
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`cv_destroy+0x1
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`rwst_init+0x42
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`fop_lookup+0x93
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ lofs`freelonode+0x47
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ lofs`lo_root+0x77
+ genunix`traverse+0x87
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`vn_vfslocks_getlock+0x59
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`kmem_cache_free+0xfa
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`cv_destroy+0xc
+ genunix`rwst_destroy+0x25
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`kmem_cache_free
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`kmem_cache_free
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`kmem_cache_free
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ unix`strlen
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`lookuppnvp+0x182
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`kmem_alloc+0x5
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`post_syscall+0x35
+ unix`0xfffffffffb800c91
+ 9
+
+ lofs`makelfsnode+0x8
+ lofs`makelonode+0x192
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`kmem_cache_free+0x8
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`vn_vfslocks_rele+0x29
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`vn_vfsrlock+0x9
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`rwst_enter_common+0x1b
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`rwst_enter_common+0x1b
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`kmem_cache_free+0xc
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`syscall_mstate+0x14d
+ unix`0xfffffffffb800c86
+ 9
+
+ genunix`vn_openat+0xd1
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`rwst_exit+0x54
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`kmem_cache_alloc+0xe4
+ genunix`vn_alloc+0x1a
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ lofs`lo_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`fop_inactive+0x17
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`kmem_cache_free+0x17
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`kmem_cache_free+0x17
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`kmem_alloc+0x17
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`vn_setpath+0xea
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`kmem_cache_alloc+0xf3
+ genunix`vn_alloc+0x1a
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`kmem_cache_alloc+0xf3
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`vn_vfslocks_getlock+0x88
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`kmem_cache_free+0x2b
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`vn_openat+0x2ef
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`kmem_cache_alloc
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`fd_find+0x36
+ genunix`ufalloc_file+0x91
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`vfs_getops+0x3b
+ lofs`lo_lookup+0x1e6
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`kmem_alloc+0x3b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`fop_lookup+0x1dc
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`kmem_cache_free+0x3f
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`secpolicy_vnode_access2+0x3f
+ ufs`ufs_iaccess+0x128
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ unix`mutex_enter
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`copen+0x156
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`secpolicy_vnode_access2+0x46
+ ufs`ufs_iaccess+0x128
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ unix`mutex_enter+0x9
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`rwst_exit+0x8f
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ lofs`freelonode+0x1a0
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`vn_rele
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`traverse+0x52
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`lookuppnvp+0xd6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ lofs`freelonode+0xa8
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ unix`mutex_exit
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`vn_setpath+0x35
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`kmem_cache_free+0x68
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`kmem_cache_free+0x68
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`kmem_cache_alloc+0x3a
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`vn_setpath+0x13b
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ unix`mutex_exit+0xc
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ lofs`freelonode+0x1bd
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 9
+
+ genunix`kmem_cache_free+0x70
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ unix`mutex_exit+0x12
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ unix`mutex_exit+0x12
+ genunix`vn_alloc+0x1a
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`vsd_free+0x17
+ genunix`vn_free+0x8b
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ unix`mutex_exit+0x19
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ lofs`table_lock_enter
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`disp_lock_exit
+ unix`0xfffffffffb800c91
+ 10
+
+ genunix`dnlc_lookup+0xf2
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`vn_openat+0x43
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`cv_broadcast+0x17
+ genunix`rwst_exit+0x8f
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ lofs`lsave
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`open
+ 10
+
+ genunix`vn_vfslocks_rele+0xb3
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`vn_setpath+0x66
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ lofs`table_lock_enter+0x17
+ lofs`makelonode+0x36
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ unix`sys_syscall+0x121
+ 10
+
+ genunix`fop_inactive+0xa3
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ lofs`table_lock_enter+0x26
+ lofs`freelonode+0x47
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`kmem_cache_alloc+0x77
+ lofs`makelonode+0xa9
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`syscall_mstate+0x1ef
+ unix`sys_syscall+0x1a1
+ 10
+
+ genunix`vn_reinit
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`kmem_cache_free+0xb0
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`lookuppnatcred+0x25
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`vn_vfslocks_getlock+0x17
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`vn_rele+0x68
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ lofs`freelonode+0x109
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`cv_init+0x1
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`kmem_cache_alloc+0x92
+ genunix`vn_alloc+0x1a
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`thread_lock+0x167
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 10
+
+ genunix`rwst_enter_common+0x2d7
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`kmem_alloc+0xc8
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`lookuppnatcred+0x3b
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ zfs`zfs_lookup
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`pn_fixslash+0x14
+ genunix`lookuppnvp+0x105
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ lofs`table_lock_enter+0x57
+ lofs`makelonode+0x36
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`vn_vfslocks_getlock+0x3c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`rwst_enter_common+0x1ec
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`lookuppnvp+0x45f
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`vn_vfslocks_rele
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`syscall_mstate+0x123
+ unix`sys_syscall+0x1a1
+ 10
+
+ genunix`vn_setpath+0xb8
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ lofs`freelonode+0x23a
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`dnlc_lookup+0x5c
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ lofs`table_lock_enter+0x6d
+ lofs`freelonode+0x47
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`vn_openat+0xb1
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`kmem_cache_free+0xf1
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`cv_destroy+0xd
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ lofs`lo_inactive
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`vn_vfsrlock
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ unix`strlen
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`syscall_mstate+0x41
+ unix`0xfffffffffb800ca0
+ 10
+
+ genunix`rwst_init+0x51
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`lookupnameatcred+0xf
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ lofs`lfind
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`vn_setpath+0xe2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`kmem_cache_alloc+0xe4
+ lofs`makelonode+0xa9
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`vfs_getops+0x17
+ genunix`vfs_matchops+0x1c
+ lofs`lo_lookup+0x1e6
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`kmem_cache_free+0x17
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`kmem_alloc+0x1b
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`dnlc_lookup+0x8f
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`memcmp+0x20
+ unix`bcmp+0x9
+ genunix`dnlc_lookup+0x10d
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`lookupnameat+0x14
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`vn_vfslocks_getlock+0x88
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`crgetmapped+0x8
+ genunix`fop_inactive+0x60
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`fop_lookup+0xcd
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`secpolicy_vnode_access2+0x2d
+ ufs`ufs_iaccess+0x128
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`kmem_alloc+0x2e
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`vn_vfslocks_getlock+0x90
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`kmem_cache_alloc
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`lookupnameatcred+0x31
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ lofs`makelonode+0x17d
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ unix`atomic_add_64
+ unix`0xfffffffffb800c86
+ 10
+
+ genunix`vfs_getops+0x40
+ genunix`vfs_matchops+0x1c
+ lofs`lo_lookup+0x1e6
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`audit_getstate
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ unix`mutex_enter
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ unix`mutex_enter
+ lofs`freelonode+0x1fe
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`secpolicy_vnode_access2+0x43
+ ufs`ufs_iaccess+0x128
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`kmem_cache_alloc+0x17
+ genunix`kmem_alloc+0x4b
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`vsd_free+0xe8
+ genunix`vn_recycle+0xb5
+ genunix`vn_reinit+0x7b
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ unix`mutex_init+0x8
+ genunix`rwst_init+0x38
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`vn_alloc+0x1a
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`thread_lock+0xed
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 10
+
+ genunix`fop_inactive+0x4e
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ lofs`freelonode+0xa0
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ unix`tsc_gethrtimeunscaled
+ genunix`syscall_mstate+0x5d
+ unix`0xfffffffffb800c86
+ 10
+
+ unix`tsc_gethrtimeunscaled
+ genunix`syscall_mstate+0x5d
+ unix`0xfffffffffb800ca0
+ 10
+
+ unix`tsc_gethrtimeunscaled
+ genunix`syscall_mstate+0x5d
+ unix`sys_syscall+0x1a1
+ 10
+
+ genunix`vn_rele+0x8
+ lofs`freelonode+0x1fe
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`openat
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`vsd_free
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ unix`mutex_exit
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ unix`mutex_exit
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ unix`mutex_exit
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`vn_vfslocks_getlock+0xc4
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ genunix`fd_find+0x67
+ genunix`ufalloc_file+0x91
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ unix`mutex_init+0x27
+ genunix`rwst_init+0x38
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 10
+
+ unix`bcopy+0x300
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ unix`tsc_read
+ genunix`gethrtime_unscaled+0xa
+ genunix`syscall_mstate+0x5d
+ unix`0xfffffffffb800c86
+ 11
+
+ lofs`freelonode+0x1c1
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`vn_rele+0x24
+ lofs`freelonode+0x1fe
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`post_syscall+0x1a5
+ unix`0xfffffffffb800c91
+ 11
+
+ genunix`kmem_cache_alloc+0x4e
+ genunix`kmem_alloc+0x4b
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`vn_free
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`fop_lookup+0x126
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ lofs`table_lock_enter+0x8
+ lofs`freelonode+0x47
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`vn_setops+0x8
+ lofs`makelonode+0x1c4
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`vn_rele+0x3e
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`kmem_free+0x26
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`vn_vfslocks_getlock+0x106
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`kmem_cache_alloc+0x79
+ genunix`vn_alloc+0x1a
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`vn_free+0x2b
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`vn_free+0x2f
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`vn_rele+0x60
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`vn_mountedvfs
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`kmem_cache_free+0xb0
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`syscall_mstate+0x1f3
+ unix`sys_syscall+0x1a1
+ 11
+
+ genunix`kmem_free+0x43
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ lofs`lsave+0x26
+ lofs`makelonode+0x1df
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`ufalloc_file+0x86
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`vn_vfslocks_getlock+0x17
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`rwst_enter_common+0x2c7
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`vn_mountedvfs+0x8
+ genunix`traverse+0x77
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`kmem_cache_free+0xbd
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`post_syscall+0x5f0
+ unix`0xfffffffffb800c91
+ 11
+
+ genunix`kmem_cache_alloc+0x92
+ lofs`makelonode+0xa9
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ lofs`makelonode+0x8
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`vn_rele+0x78
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`syscall_mstate+0xc
+ unix`sys_syscall+0x10e
+ 11
+
+ genunix`post_syscall+0x1fe
+ unix`0xfffffffffb800c91
+ 11
+
+ lofs`lsave+0x42
+ lofs`makelonode+0x1df
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ lofs`makelonode+0x26
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`kmem_cache_free+0xe8
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`pn_fixslash+0x2c
+ genunix`lookuppnvp+0x105
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`cv_destroy
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ lofs`makelonode+0x36
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ lofs`lo_lookup+0x1a8
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`vn_setpath+0xce
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ lofs`makelonode+0x42
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`rwst_init+0x56
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`vn_vfsrlock+0x9
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`rwst_init+0x5a
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`vn_invalid+0x1d
+ lofs`freelonode+0x115
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`fop_lookup+0xb2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`kmem_alloc+0x17
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`secpolicy_vnode_access2+0x218
+ ufs`ufs_iaccess+0x128
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`kmem_cache_free+0x1b
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`unfalloc+0xc
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`syscall_mstate+0x5d
+ unix`0xfffffffffb800ca0
+ 11
+
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`rwst_enter_common+0x331
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`kmem_cache_alloc+0xf3
+ genunix`kmem_alloc+0x4b
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`ufalloc_file
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`kmem_cache_alloc
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`rwst_enter_common+0x341
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ lofs`lfind+0x24
+ lofs`makelonode+0x47
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ lofs`freelonode+0x88
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`vn_setpath+0x8
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`kmem_cache_free+0x3a
+ genunix`kmem_free+0x4e
+ genunix`audit_unfalloc+0x44
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`fop_lookup+0xdd
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ unix`mutex_enter
+ genunix`kmem_alloc+0x4b
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`rwst_destroy+0x33
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ lofs`lfind+0x35
+ lofs`makelonode+0x47
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`vn_vfslocks_getlock+0xa6
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`kmem_alloc+0x46
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ unix`bcopy+0x2d7
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`vn_setpath+0x17
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`vsd_free+0xe8
+ genunix`vn_free+0x8b
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ unix`mutex_enter+0x9
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ unix`mutex_enter+0x9
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`fop_lookup+0xea
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`crgetmapped+0x2a
+ genunix`fop_inactive+0x60
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`syscall_mstate+0x18c
+ unix`0xfffffffffb800ca0
+ 11
+
+ genunix`rwst_exit+0x8f
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ unix`tsc_gethrtimeunscaled
+ genunix`syscall_mstate+0x5d
+ unix`sys_syscall+0x10e
+ 11
+
+ genunix`vn_vfslocks_getlock+0xb4
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ ufs`ufs_lookup+0x2d
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`rwst_tryenter+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`fop_inactive+0x60
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`vn_setpath+0x31
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ genunix`vn_openat+0x124
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ ufs`ufs_lookup+0x34
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 11
+
+ unix`copyinstr
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`vn_alloc+0x43
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`kmem_cache_alloc+0x4e
+ genunix`vn_alloc+0x1a
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`vn_rele+0x31
+ lofs`freelonode+0x1fe
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ unix`mutex_init+0x42
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`vn_vfslocks_rele+0xa6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`vn_rele+0x39
+ genunix`lookuppnvp+0x39f
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`fop_inactive+0x90
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`vn_vfsunlock+0x35
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`fop_lookup+0x135
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`vn_setops+0x17
+ lofs`makelonode+0x1c4
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`vn_vfslocks_getlock
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`dnlc_lookup+0x11
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ lofs`lsave+0x17
+ lofs`makelonode+0x1df
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ unix`rw_enter+0x17
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`kmem_cache_alloc+0x79
+ genunix`kmem_alloc+0x4b
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`dnlc_lookup+0x22
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ lofs`table_lock_enter+0x38
+ lofs`makelonode+0x36
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`vn_reinit+0x8
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`rwst_enter_common+0x1c8
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ lofs`lsave+0x32
+ lofs`makelonode+0x1df
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ lofs`freelonode+0x115
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ lofs`table_lock_enter+0x50
+ lofs`freelonode+0x47
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`fop_lookup+0x77
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`cv_init+0x19
+ genunix`rwst_init+0x47
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`kmem_cache_free+0xdb
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`dnlc_lookup+0x59
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ ufs`ufs_iaccess+0x2f
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`vn_invalid
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ unix`membar_consumer
+ lofs`makelonode+0x36
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`vn_setpath+0x1c7
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`kmem_cache_free+0xfa
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`dnlc_lookup+0x16c
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`vfs_getops
+ lofs`lo_lookup+0x1e6
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`kmem_alloc
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`ufalloc_file+0xd3
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`set_errno+0x34
+ genunix`copen+0x4fa
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ lofs`makelonode+0x47
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`dnlc_lookup+0x17f
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`kmem_alloc+0xf
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`kmem_cache_free+0x1b
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`vn_vfslocks_getlock+0x7d
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`vn_free+0xa3
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`kmem_cache_alloc+0xf3
+ genunix`kmem_zalloc+0x47
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`vn_vfslocks_getlock+0x86
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`vn_vfslocks_getlock+0x86
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ lofs`makelonode+0x168
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`kmem_cache_free+0x2b
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`kmem_cache_free+0x2b
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`rwst_enter_common+0x341
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`kmem_alloc+0x32
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`kmem_cache_alloc+0x8
+ lofs`makelonode+0xa9
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`vn_vfslocks_rele+0x5c
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`rwst_destroy+0x2e
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`kmem_cache_free+0x3f
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ unix`mutex_enter
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`fop_inactive+0x41
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`rwst_enter_common+0x157
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`rwst_enter_common+0x157
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`kmem_cache_alloc+0x17
+ genunix`vn_alloc+0x1a
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`kmem_cache_alloc+0x17
+ lofs`makelonode+0xa9
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ lofs`lfind+0x3b
+ lofs`makelonode+0x47
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`vn_setpath+0x1b
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`kmem_alloc+0x4b
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`fop_lookup+0x1f0
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`fop_lookup+0xf1
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`kmem_cache_alloc+0x26
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ unix`mutex_init+0x17
+ genunix`rwst_init+0x38
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ lofs`freelonode+0x1b0
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ unix`mutex_exit
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`dnlc_lookup+0xd3
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`vn_vfsunlock+0x8
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ ufs`ufs_lookup+0x138
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`vn_setpath+0x3d
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 12
+
+ genunix`kmem_cache_free+0x70
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`traverse+0x77
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ unix`mutex_init+0x3d
+ genunix`rwst_init+0x38
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`fop_lookup+0x25
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`kmem_free+0x17
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ lofs`freelonode+0x1de
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`fop_lookup+0x30
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`vn_vfslocks_getlock+0xf2
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`fop_lookup+0x37
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ lofs`table_lock_enter+0x1b
+ lofs`makelonode+0x36
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ lofs`lo_lookup+0x250
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ lofs`table_lock_enter+0x26
+ lofs`makelonode+0x36
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`fop_lookup+0x47
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`vn_mountedvfs
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`fop_lookup+0x55
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`dnlc_lookup+0x26
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`vn_setops+0x3d
+ lofs`makelonode+0x1c4
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`kmem_cache_free+0xbd
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`dnlc_lookup+0x2e
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`cv_init
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ lofs`freelonode+0x17
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`rwst_init+0x17
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`cv_init+0x8
+ genunix`rwst_init+0x56
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ lofs`lo_lookup+0x283
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`rwst_enter_common+0x1e4
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`rwst_init+0x28
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ lofs`table_lock_enter+0x5c
+ lofs`makelonode+0x36
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`vn_setpath+0xb0
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ lofs`lsave+0x52
+ lofs`makelonode+0x1df
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`rwst_exit+0x23
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ ufs`ufs_iaccess+0x24
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`vn_exists+0x36
+ lofs`makelonode+0x1e7
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`vn_vfslocks_rele+0x8
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`kmem_cache_free+0xe8
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`kmem_cache_free+0xe8
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ lofs`makelonode+0x2a
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ lofs`table_lock_enter+0x6d
+ lofs`makelonode+0x36
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`vn_recycle
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`post_syscall+0x221
+ unix`0xfffffffffb800c91
+ 13
+
+ genunix`cv_destroy+0x8
+ genunix`rwst_destroy+0x25
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`vn_invalid+0x8
+ lofs`freelonode+0x115
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ ufs`ufs_iaccess+0x3c
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`audit_unfalloc+0xc
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ lofs`table_lock_enter+0x7d
+ lofs`makelonode+0x36
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ lofs`lsave+0x6f
+ lofs`makelonode+0x1df
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`fop_lookup+0x9f
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ lofs`makelfsnode
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ unix`sys_syscall+0x186
+ 13
+
+ lofs`table_lock_enter+0x82
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`rwst_exit+0x44
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`rwst_init+0x56
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`traverse+0x8
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`kmem_cache_free+0x8
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`kmem_alloc+0xb
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ unix`strlen+0xb
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`vn_vfslocks_getlock+0x6e
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`vn_vfslocks_rele+0x38
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`traverse+0x18
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`vn_vfslocks_getlock+0x7d
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`kmem_cache_alloc+0xf3
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`vn_vfslocks_rele+0x46
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`traverse+0x26
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`unfalloc+0x16
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`kmem_alloc+0x26
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`fop_lookup+0xc7
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`kmem_cache_alloc+0xfc
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`kmem_cache_alloc
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`vn_vfsrlock+0x3b
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`vn_setpath+0x118
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ unix`mutex_init+0x8
+ genunix`rwst_init+0x38
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ ufs`ufs_lookup+0x1a
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`vn_vfslocks_rele+0x6b
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`vn_setpath+0x22
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ lofs`makelonode+0x98
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ lofs`lo_lookup+0xb
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ ufs`ufs_iaccess+0x9d
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ lofs`makelfsnode+0x5f
+ lofs`makelonode+0x192
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ unix`mutex_exit
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`vn_setpath+0x133
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`vn_rele+0x17
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`kmem_cache_alloc+0x37
+ genunix`kmem_alloc+0x4b
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`kmem_cache_alloc+0x3a
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`fd_find+0x6b
+ genunix`ufalloc_file+0x91
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`fop_lookup+0xb
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`audit_getstate+0x2c
+ genunix`lookuppnvp+0x82
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ lofs`freelonode+0x1bd
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 13
+
+ genunix`vn_setpath+0x140
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ unix`mutex_exit+0x12
+ genunix`kmem_alloc+0x4b
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ unix`mutex_exit+0x12
+ lofs`makelonode+0xa9
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`dnlc_lookup+0xe5
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`vfs_matchops+0x27
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`cv_broadcast+0x8
+ genunix`rwst_exit+0x8f
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`fop_lookup+0x1a
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`fop_lookup+0x21
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`fop_lookup+0x21
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`vn_setpath+0x155
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`vn_vfslocks_rele+0xa6
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`fop_inactive+0x8b
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`fop_lookup+0x2c
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ lofs`makelonode+0x1d2
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`vn_recycle+0xa2
+ genunix`vn_reinit+0x7b
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ lofs`table_lock_enter+0x13
+ lofs`makelonode+0x36
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`vn_setpath+0x163
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`kmem_cache_alloc+0x66
+ genunix`kmem_alloc+0x4b
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`fop_lookup+0x3b
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`fop_lookup+0x43
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`fd_find+0xa6
+ genunix`ufalloc_file+0x91
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`vn_vfslocks_getlock+0x8
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`vn_vfslocks_getlock+0x8
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`fop_lookup+0x4b
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`vn_recycle+0xbd
+ genunix`vn_reinit+0x7b
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ lofs`table_lock_enter+0x2e
+ lofs`makelonode+0x36
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ lofs`freelonode
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`rwst_init
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`kmem_cache_free+0xb0
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`kmem_cache_alloc+0x84
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`vn_exists+0x8
+ lofs`makelonode+0x1e7
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ ufs`ufs_lookup+0x9b
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ unix`mutex_destroy+0x84
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ lofs`lsave+0x45
+ lofs`makelonode+0x1df
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`vn_reinit+0x29
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`vn_setpath+0xb5
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`dnlc_lookup+0x56
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ lofs`makelonode+0x2e
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ ufs`ufs_iaccess+0x130
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`syscall_mstate+0x130
+ unix`sys_syscall+0x1a1
+ 14
+
+ genunix`rwst_init+0x42
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`vn_vfslocks_rele+0x17
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`vn_vfslocks_rele+0x17
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`rwst_init+0x47
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`rwst_enter_common+0xb
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ lofs`lo_lookup+0x1ae
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`traverse
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`fop_inactive
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ unix`0xfffffffffb800c91
+ 14
+
+ genunix`lookupnameatcred+0x1
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ unix`bcopy+0x395
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`vfs_getops+0x8
+ genunix`vfs_matchops+0x1c
+ lofs`lo_lookup+0x1e6
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`fop_inactive+0x8
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`kmem_cache_free+0x8
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`rwst_init+0x5b
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`fop_lookup+0xb0
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`kmem_cache_free+0x17
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`vn_vfsrlock+0x18
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`secpolicy_vnode_access2+0x1a
+ ufs`ufs_iaccess+0x128
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`crgetmapped
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`kmem_cache_alloc+0xf3
+ lofs`makelonode+0xa9
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ ufs`ufs_lookup+0xf4
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`fop_inactive+0x26
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`rwst_enter_common+0x38
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`kmem_alloc+0x2a
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`kmem_cache_alloc+0xfc
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ lofs`makelonode+0x6d
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`post_syscall+0x5e
+ unix`0xfffffffffb800c91
+ 14
+
+ genunix`secpolicy_vnode_access2+0x22f
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`vfs_getops+0x32
+ genunix`vfs_matchops+0x1c
+ lofs`lo_lookup+0x1e6
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`kmem_cache_free+0x3a
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`lookupnameat+0x30
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ unix`mutex_enter
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ unix`mutex_enter
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ unix`mutex_enter
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ unix`mutex_enter
+ lofs`freelonode+0x47
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`fop_lookup+0xed
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ ufs`ufs_iaccess+0x8e
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`vfs_matchops
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ unix`mutex_destroy+0x8
+ genunix`rwst_destroy+0x1c
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`vn_rele+0xc
+ ufs`ufs_lookup+0x36d
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`vsd_free
+ genunix`vn_reinit+0x7b
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ unix`mutex_exit
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ unix`mutex_exit
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ unix`mutex_exit
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ unix`mutex_exit
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`kmem_cache_alloc+0x3a
+ genunix`vn_alloc+0x1a
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ genunix`fop_lookup+0x10c
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ ufs`ufs_lookup+0x3c
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 14
+
+ unix`mutex_exit+0x12
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ unix`mutex_exit+0x12
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ lofs`makelfsnode+0x77
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ lofs`makelfsnode+0x78
+ lofs`makelonode+0x192
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`dnlc_lookup+0xeb
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`vsd_free+0x1b
+ genunix`vn_recycle+0xb5
+ genunix`vn_reinit+0x7b
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`vn_vfslocks_rele+0x9e
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ lofs`lo_root
+ genunix`traverse+0x87
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ lofs`makelonode+0xc2
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ unix`mutex_init+0x42
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`kmem_cache_alloc+0x66
+ genunix`vn_alloc+0x1a
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`kmem_cache_alloc+0x66
+ lofs`makelonode+0xa9
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`kmem_free+0x2a
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ lofs`table_lock_enter+0x22
+ lofs`makelonode+0x36
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ ufs`ufs_iaccess+0xe5
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`vn_setops+0x26
+ lofs`makelonode+0x1c4
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`lookupnameatcred+0xa8
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`rwst_enter_common+0x1b8
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`kmem_cache_alloc+0x84
+ lofs`makelonode+0xa9
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`lookuppnvp+0x235
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`rwst_enter_common+0x2c7
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ ufs`ufs_lookup+0x88
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`kmem_cache_alloc+0x89
+ genunix`kmem_alloc+0x4b
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`fop_lookup+0x5a
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ unix`mutex_destroy+0x6b
+ genunix`rwst_destroy+0x1c
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`kmem_cache_alloc+0x92
+ genunix`kmem_alloc+0x4b
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`kmem_cache_alloc+0x92
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`kmem_free+0x57
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`disp_lock_exit+0x48
+ unix`0xfffffffffb800c91
+ 15
+
+ genunix`kmem_alloc+0xc8
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`syscall_mstate+0xc
+ unix`sys_syscall+0x1a1
+ 15
+
+ genunix`syscall_mstate+0x10f
+ unix`sys_syscall+0x1a1
+ 15
+
+ genunix`vn_setops+0x50
+ lofs`makelonode+0x1c4
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`crgetuid
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`dnlc_lookup+0x43
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`post_syscall+0x205
+ unix`0xfffffffffb800c91
+ 15
+
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`vn_rele+0x87
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`cv_init+0x19
+ genunix`rwst_init+0x56
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`crgetuid+0x10
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ lofs`makelonode+0x22
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`cv_destroy
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`rwst_exit+0x35
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`cv_destroy+0x8
+ genunix`rwst_destroy+0x2e
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`vn_recycle+0x8
+ genunix`vn_reinit+0x7b
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`syscall_mstate+0x139
+ unix`0xfffffffffb800ca0
+ 15
+
+ lofs`table_lock_enter+0x7d
+ lofs`freelonode+0x47
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ lofs`lo_lookup+0xaf
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`traverse
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ unix`lock_clear_splx+0x3
+ genunix`post_syscall+0x318
+ unix`0xfffffffffb800c91
+ 15
+
+ lofs`lo_lookup+0xb7
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ lofs`lfind+0xb
+ lofs`makelonode+0x47
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ lofs`makelonode+0x5e
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`rwst_destroy+0x25
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`vn_alloc+0x6
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`memcmp+0x37
+ unix`bcmp+0x9
+ genunix`dnlc_lookup+0x10d
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`pn_getcomponent+0x8
+ genunix`lookuppnvp+0x16d
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`kmem_cache_alloc+0x8
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`kmem_cache_alloc+0x8
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ lofs`makelonode+0x79
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ ufs`ufs_lookup+0xb
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ unix`mutex_enter
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`syscall_mstate+0x183
+ unix`sys_syscall+0x1a1
+ 15
+
+ lofs`makelonode+0x186
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`rwst_exit+0x86
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`kmem_cache_alloc+0x1b
+ genunix`kmem_alloc+0x4b
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`crgetmapped+0x2e
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ unix`copystr+0x54
+ genunix`pn_get_buf+0x43
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`kmem_cache_alloc+0x26
+ genunix`kmem_alloc+0x4b
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`vn_rele+0x8
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`traverse+0x5b
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`vn_vfsunlock
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ unix`mutex_exit
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ unix`mutex_exit
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`kmem_cache_free+0x68
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`kmem_cache_free+0x68
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`vn_setpath+0x39
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`fsop_root+0xc
+ genunix`traverse+0x87
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ unix`mutex_exit+0xc
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 15
+
+ genunix`cv_broadcast
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ genunix`vsd_free+0x10
+ genunix`vn_recycle+0xb5
+ genunix`vn_reinit+0x7b
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ genunix`vn_rele+0x24
+ genunix`lookuppnvp+0x39f
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ lofs`lfind+0x67
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ genunix`kmem_cache_alloc+0x4e
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ lofs`table_lock_enter
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ lofs`lo_lookup+0x34
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ genunix`dnlc_lookup+0x100
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ lofs`lo_lookup+0x48
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ lofs`makelonode+0x1df
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ genunix`post_syscall+0x1d0
+ unix`0xfffffffffb800c91
+ 16
+
+ unix`bcopy+0x330
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ genunix`vn_vfslocks_getlock
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ unix`bcopy+0x238
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ genunix`vn_mountedvfs+0x8
+ genunix`lookuppnvp+0x217
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ genunix`pn_get_buf+0x4b
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ unix`splr+0xc
+ genunix`thread_lock+0x24
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 16
+
+ genunix`kmem_cache_alloc+0x8d
+ lofs`makelonode+0xa9
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ genunix`kmem_cache_alloc+0x92
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ genunix`fop_lookup+0x64
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ genunix`vn_setpath+0x97
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ genunix`kmem_alloc+0xc8
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ genunix`syscall_mstate+0xc
+ unix`0xfffffffffb800ca0
+ 16
+
+ genunix`vn_setops+0x5f
+ lofs`makelonode+0x1c4
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ unix`bcmp
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ genunix`vn_vfslocks_getlock+0x41
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ genunix`cv_broadcast+0x72
+ genunix`rwst_exit+0x8f
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ genunix`fop_lookup+0x82
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ ufs`ufs_iaccess+0x128
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ lofs`lo_lookup+0x198
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ lofs`lsave+0x61
+ lofs`makelonode+0x1df
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ genunix`vn_setpath+0x1c2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ ufs`ufs_iaccess+0x137
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ unix`sys_syscall+0x17d
+ 16
+
+ genunix`rwst_init+0x51
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ genunix`lookuppnvp+0x185
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ genunix`vn_vfslocks_getlock+0x66
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ genunix`kmem_cache_free+0x8
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ genunix`kmem_cache_alloc+0xe4
+ genunix`kmem_alloc+0x4b
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ genunix`memcmp+0x17
+ unix`bcmp+0x9
+ genunix`dnlc_lookup+0x10d
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ genunix`kmem_cache_alloc+0xfc
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ unix`atomic_add_32
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ genunix`kmem_cache_alloc+0x8
+ genunix`vn_alloc+0x1a
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ genunix`kmem_cache_alloc+0x8
+ genunix`kmem_alloc+0x4b
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ unix`mutex_enter
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ genunix`vfs_getops+0x49
+ genunix`vfs_matchops+0x1c
+ lofs`lo_lookup+0x1e6
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ genunix`lookuppnvp+0xcb
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ lofs`lsave+0xc0
+ lofs`makelonode+0x1df
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ unix`mutex_destroy
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ genunix`kmem_cache_alloc+0x22
+ genunix`kmem_alloc+0x4b
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ genunix`kmem_cache_alloc+0x26
+ lofs`makelonode+0xa9
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ ufs`ufs_iaccess+0xa2
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ genunix`fop_lookup+0x107
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ genunix`vsd_free+0x8
+ genunix`vn_recycle+0xb5
+ genunix`vn_reinit+0x7b
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ lofs`lfind+0x5f
+ lofs`makelonode+0x47
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 16
+
+ unix`mutex_exit+0x12
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`fop_lookup+0x16
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`vn_setpath+0x14d
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`kmem_cache_alloc+0x4e
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ lofs`makelonode+0x1bf
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`kmem_free+0x17
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ lofs`lo_lookup+0x138
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`dnlc_lookup
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`vn_vfslocks_rele+0xc6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`lookuppnvp+0x327
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`fop_lookup+0x47
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`fop_inactive+0xab
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`lookuppnvp+0x32e
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ lofs`lo_lookup+0x60
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`vn_exists
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`rwst_init+0x8
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`rwst_enter_common+0x1d8
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`vn_exists+0x1d
+ lofs`makelonode+0x1e7
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ lofs`makelonode+0x17
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`dnlc_lookup+0x50
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`vn_vfslocks_getlock+0x41
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`cv_init+0x22
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ unix`membar_consumer
+ genunix`vfs_matchops+0x1c
+ lofs`lo_lookup+0x1e6
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ lofs`makelonode+0x31
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`vn_reinit+0x47
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`syscall_mstate+0x41
+ unix`sys_syscall+0x1a1
+ 17
+
+ lofs`table_lock_enter+0x82
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`vn_recycle+0x17
+ genunix`vn_reinit+0x7b
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`memcmp+0x8
+ unix`bcmp+0x9
+ genunix`dnlc_lookup+0x10d
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`secpolicy_vnode_access2+0x108
+ ufs`ufs_iaccess+0x128
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`vn_vfslocks_rele+0x29
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`rwst_exit+0x4c
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`rwst_destroy+0x8
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`lookuppnvp+0x1ac
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`fop_lookup+0xcd
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ lofs`lo_lookup+0x2e0
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ unix`mutex_enter
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ unix`mutex_enter
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`traverse+0x43
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`fop_lookup+0xe9
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`crgetmapped+0x2a
+ genunix`fop_lookup+0x1dc
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`vn_recycle+0x65
+ genunix`vn_reinit+0x7b
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`kmem_cache_alloc+0x26
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ lofs`lsave+0xca
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ lofs`makelonode+0x9f
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`rwst_tryenter+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ unix`mutex_exit
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`kmem_cache_alloc+0x33
+ genunix`vn_alloc+0x1a
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`vfs_matchops+0x17
+ lofs`lo_lookup+0x1e6
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ genunix`vfs_matchops+0x1c
+ lofs`lo_lookup+0x1e6
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ unix`mutex_exit+0xc
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ lofs`makelfsnode+0x6e
+ lofs`makelonode+0x192
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 17
+
+ unix`mutex_exit+0x12
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ genunix`vfs_matchops+0x23
+ lofs`lo_lookup+0x1e6
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ genunix`vsd_free+0x1f
+ genunix`vn_recycle+0xb5
+ genunix`vn_reinit+0x7b
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ genunix`lookuppnvp+0x205
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ unix`bcopy+0x1f
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ genunix`fop_lookup+0x135
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ genunix`fop_lookup+0x3f
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ lofs`lo_lookup+0x50
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ ufs`ufs_lookup+0x70
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ genunix`kmem_cache_alloc+0x89
+ genunix`vn_alloc+0x1a
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ genunix`dnlc_lookup+0x2a
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ lofs`lo_lookup+0x26b
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ genunix`cv_init+0x1
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ genunix`vn_mountedvfs+0x11
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ genunix`dnlc_lookup+0x32
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ genunix`fop_lookup+0x64
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ genunix`cv_init+0x8
+ genunix`rwst_init+0x47
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ lofs`lo_lookup+0x79
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ ufs`ufs_iaccess+0x10c
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ genunix`lookuppnvp+0x15e
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ genunix`kmem_alloc+0xdf
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ genunix`post_syscall+0x211
+ unix`0xfffffffffb800c91
+ 18
+
+ genunix`fop_lookup+0x82
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ unix`bcmp+0x9
+ genunix`dnlc_lookup+0x10d
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ genunix`fop_lookup+0x8e
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ genunix`rwst_enter_common
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ unix`do_splx
+ genunix`post_syscall+0x318
+ unix`0xfffffffffb800c91
+ 18
+
+ unix`strlen
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ genunix`dnlc_lookup+0x7d
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ genunix`fop_lookup+0xb0
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ genunix`fop_lookup+0xb6
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ genunix`rwst_enter_common+0x29
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ genunix`lookupnameat+0xc
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ genunix`vn_vfslocks_rele+0x46
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ genunix`rwst_destroy+0x1c
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ genunix`pn_getcomponent
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ genunix`vn_vfslocks_getlock+0x90
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ genunix`vn_vfsrlock+0x3b
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ genunix`kmem_alloc+0x3b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ genunix`rwst_destroy+0x32
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ genunix`rwst_tryenter+0x9
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ genunix`crgetmapped+0x2a
+ genunix`fop_lookup+0x1dc
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ lofs`makelonode+0x192
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ genunix`vn_alloc+0x35
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ lofs`makelonode+0xa9
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ genunix`audit_getstate+0x2c
+ genunix`copen+0x59
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ unix`mutex_exit+0xc
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ lofs`makelonode+0x1af
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 18
+
+ unix`mutex_exit+0x12
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 19
+
+ genunix`vn_rele+0x24
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 19
+
+ genunix`dnlc_lookup+0x9
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 19
+
+ genunix`fop_lookup+0x3f
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 19
+
+ genunix`fop_lookup+0x43
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 19
+
+ genunix`dnlc_lookup+0x15
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 19
+
+ lofs`lo_lookup+0x25d
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 19
+
+ genunix`vn_vfslocks_rele+0xce
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 19
+
+ unix`rw_enter+0x22
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 19
+
+ genunix`fop_lookup+0x55
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 19
+
+ lofs`makelonode
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 19
+
+ genunix`vn_mountedvfs+0x11
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 19
+
+ genunix`vn_vfslocks_rele+0x105
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 19
+
+ genunix`dnlc_lookup+0x160
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 19
+
+ unix`membar_consumer
+ lofs`makelonode+0x1c4
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 19
+
+ genunix`audit_unfalloc+0x1
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 19
+
+ genunix`fop_lookup+0x9f
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 19
+
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 19
+
+ genunix`audit_unfalloc+0x24
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 19
+
+ genunix`vn_reinit+0x67
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 19
+
+ lofs`lo_lookup+0x1d4
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 19
+
+ genunix`fop_lookup+0x1c8
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 19
+
+ genunix`crgetmapped+0x8
+ genunix`fop_lookup+0x1dc
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 19
+
+ genunix`memcmp+0x30
+ unix`bcmp+0x9
+ genunix`dnlc_lookup+0x10d
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 19
+
+ unix`clear_int_flag
+ genunix`thread_lock+0x24
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 19
+
+ genunix`crgetmapped+0x15
+ genunix`fop_lookup+0x1dc
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 19
+
+ ufs`ufs_iaccess+0x7f
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 19
+
+ unix`mutex_enter
+ lofs`freelonode+0x47
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 19
+
+ unix`mutex_init
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 19
+
+ genunix`rwst_tryenter+0x9
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 19
+
+ unix`i_ddi_splhigh+0x5
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 19
+
+ genunix`kmem_cache_alloc+0x26
+ genunix`vn_alloc+0x1a
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 19
+
+ unix`tsc_gethrtimeunscaled+0xc
+ genunix`gethrtime_unscaled+0xa
+ genunix`syscall_mstate+0x5d
+ unix`sys_syscall+0x1a1
+ 19
+
+ unix`copystr+0x60
+ genunix`pn_get_buf+0x43
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 19
+
+ unix`mutex_exit
+ lofs`makelonode+0xa9
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 19
+
+ ufs`ufs_lookup+0x38
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 19
+
+ lofs`lo_lookup+0x1a
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 19
+
+ genunix`traverse+0x6f
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 19
+
+ genunix`kmem_free
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 20
+
+ genunix`traverse+0x7c
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 20
+
+ genunix`vn_setpath+0x4e
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 20
+
+ genunix`vn_setops
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 20
+
+ genunix`fop_lookup+0x25
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 20
+
+ lofs`lo_lookup+0x3c
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 20
+
+ genunix`vn_vfslocks_rele+0xb3
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 20
+
+ genunix`vn_vfslocks_getlock
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 20
+
+ genunix`traverse+0xa8
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 20
+
+ genunix`vn_recycle+0xbe
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 20
+
+ genunix`vn_setpath+0x190
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 20
+
+ lofs`table_lock_enter+0x41
+ lofs`freelonode+0x47
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 20
+
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 20
+
+ unix`mutex_destroy+0x7f
+ genunix`rwst_destroy+0x1c
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 20
+
+ ufs`ufs_iaccess+0x11c
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 20
+
+ genunix`kmem_alloc+0xdf
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 20
+
+ genunix`vn_setpath+0x1b0
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 20
+
+ genunix`dnlc_lookup+0x159
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 20
+
+ genunix`kmem_cache_free+0xf1
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 20
+
+ genunix`dnlc_lookup+0x65
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 20
+
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 20
+
+ genunix`cv_destroy+0xd
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 20
+
+ genunix`vn_vfslocks_rele+0x38
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 20
+
+ genunix`dnlc_lookup+0x198
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 20
+
+ genunix`crgetmapped+0x8
+ genunix`fop_lookup+0x1dc
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 20
+
+ genunix`kmem_alloc+0x2a
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 20
+
+ genunix`crgetmapped+0x15
+ genunix`fop_lookup+0x1dc
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 20
+
+ genunix`fop_lookup+0x1d7
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 20
+
+ genunix`rwst_tryenter
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 20
+
+ lofs`makelonode+0x92
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 20
+
+ unix`mutex_exit
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 20
+
+ genunix`dnlc_lookup+0xdf
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 20
+
+ ufs`ufs_lookup+0x40
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 21
+
+ lofs`lo_lookup+0x29
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 21
+
+ genunix`kmem_free+0xb
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 21
+
+ genunix`fop_lookup+0x126
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 21
+
+ genunix`kmem_free+0x17
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 21
+
+ genunix`fop_lookup+0x13e
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 21
+
+ lofs`makelonode+0x1e7
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 21
+
+ genunix`vn_recycle+0xb9
+ genunix`vn_reinit+0x7b
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 21
+
+ ufs`ufs_lookup+0x80
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 21
+
+ genunix`vn_free+0x32
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 21
+
+ ufs`ufs_lookup+0x85
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 21
+
+ genunix`vn_setops+0x4a
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 21
+
+ genunix`crgetuid+0x8
+ ufs`ufs_iaccess+0xe5
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 21
+
+ ufs`ufs_iaccess+0x33
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 21
+
+ genunix`dnlc_lookup+0x79
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 21
+
+ unix`strlen+0xb
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 21
+
+ genunix`vn_vfslocks_getlock+0x6e
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 21
+
+ genunix`rwst_destroy
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 21
+
+ unix`strlen+0x13
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 21
+
+ unix`strlen+0x13
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 21
+
+ genunix`crgetmapped
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 21
+
+ lofs`makelfsnode+0x26
+ lofs`makelonode+0x192
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 21
+
+ unix`bcopy+0x3b8
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 21
+
+ genunix`vfs_getops+0x28
+ genunix`vfs_matchops+0x1c
+ lofs`lo_lookup+0x1e6
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 21
+
+ genunix`dnlc_lookup+0x9d
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 21
+
+ genunix`vn_recycle+0x41
+ genunix`vn_reinit+0x7b
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 21
+
+ genunix`rwst_enter_common+0x44
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 21
+
+ genunix`secpolicy_vnode_access2+0x38
+ ufs`ufs_iaccess+0x128
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 21
+
+ genunix`kmem_cache_free+0x3a
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 21
+
+ lofs`lo_lookup+0x1ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 21
+
+ genunix`rwst_tryenter
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 21
+
+ unix`mutex_enter
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 21
+
+ genunix`fop_lookup+0x1f8
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 21
+
+ unix`mutex_destroy+0x17
+ genunix`rwst_destroy+0x1c
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 21
+
+ genunix`syscall_mstate+0x1b2
+ unix`sys_syscall+0x1a1
+ 22
+
+ unix`mutex_exit+0x12
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 22
+
+ lofs`lo_lookup+0x40
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 22
+
+ genunix`fop_lookup+0x30
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 22
+
+ genunix`lookuppnvp+0x31a
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 22
+
+ genunix`disp_lock_exit+0x1b
+ genunix`post_syscall+0x318
+ unix`0xfffffffffb800c91
+ 22
+
+ genunix`dnlc_lookup+0x11
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 22
+
+ genunix`vn_setpath+0x83
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 22
+
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 22
+
+ genunix`pn_getcomponent+0x90
+ genunix`lookuppnvp+0x16d
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 22
+
+ ufs`ufs_iaccess+0x8
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 22
+
+ lofs`lsave+0x3a
+ lofs`makelonode+0x1df
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 22
+
+ genunix`rwst_init+0x38
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 22
+
+ genunix`secpolicy_vnode_access2+0x1
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 22
+
+ genunix`kmem_cache_alloc+0xfc
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 22
+
+ genunix`dnlc_lookup+0xa0
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 22
+
+ ufs`ufs_lookup
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 22
+
+ genunix`fop_lookup+0x1d7
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 22
+
+ genunix`dnlc_lookup+0xa9
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 22
+
+ ufs`ufs_iaccess+0x7a
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 22
+
+ unix`mutex_enter
+ lofs`makelonode+0x36
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 22
+
+ unix`mutex_enter
+ lofs`makelonode+0xa9
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 22
+
+ genunix`rwst_enter_common+0x15f
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 22
+
+ ufs`ufs_lookup+0x29
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 22
+
+ unix`mutex_exit
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 22
+
+ unix`mutex_exit+0x12
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 23
+
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 23
+
+ unix`mutex_exit+0x19
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 23
+
+ genunix`lookuppnvp+0x308
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 23
+
+ genunix`dnlc_lookup+0x10d
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 23
+
+ genunix`dnlc_lookup+0x11c
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 23
+
+ genunix`pn_getcomponent+0x89
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 23
+
+ genunix`lookuppnvp+0x13e
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 23
+
+ genunix`pn_getcomponent+0xab
+ genunix`lookuppnvp+0x16d
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 23
+
+ genunix`rwst_enter_common
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 23
+
+ genunix`cv_destroy+0x1
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 23
+
+ lofs`lo_lookup+0x1bf
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 23
+
+ unix`rw_exit+0x3
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 23
+
+ genunix`secpolicy_vnode_access2+0x29
+ ufs`ufs_iaccess+0x128
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 23
+
+ genunix`kmem_cache_alloc
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 23
+
+ genunix`dnlc_lookup+0x1ad
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 23
+
+ genunix`kmem_cache_alloc+0x17
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 23
+
+ genunix`pn_getcomponent+0x18
+ genunix`lookuppnvp+0x16d
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 23
+
+ genunix`fop_lookup+0x1eb
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 23
+
+ genunix`crgetmapped+0x2e
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 23
+
+ genunix`fsop_root
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 23
+
+ unix`mutex_exit
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 23
+
+ unix`mutex_exit+0x9
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 23
+
+ genunix`falloc+0x1
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 24
+
+ genunix`vn_alloc+0x42
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 24
+
+ lofs`lo_lookup+0x126
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 24
+
+ genunix`traverse+0x7f
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 24
+
+ unix`bcopy+0x1b
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 24
+
+ genunix`vn_vfsunlock+0x35
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 24
+
+ ufs`ufs_iaccess+0xd8
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 24
+
+ ufs`ufs_iaccess+0x1
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 24
+
+ genunix`fop_lookup+0x73
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 24
+
+ ufs`ufs_lookup+0xb7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 24
+
+ lofs`lo_lookup+0x9d
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 24
+
+ genunix`pn_getcomponent+0xc1
+ genunix`lookuppnvp+0x16d
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 24
+
+ genunix`syscall_mstate+0x139
+ unix`sys_syscall+0x1a1
+ 24
+
+ genunix`dnlc_lookup+0x175
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 24
+
+ genunix`fop_lookup+0xc2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 24
+
+ genunix`secpolicy_vnode_access2+0x226
+ ufs`ufs_iaccess+0x128
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 24
+
+ genunix`fop_lookup+0xcb
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 24
+
+ genunix`dnlc_lookup+0x1a8
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 24
+
+ unix`copystr+0x45
+ genunix`pn_get_buf+0x43
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 24
+
+ zfs`zfs_lookup+0x88
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 24
+
+ genunix`fop_lookup+0xb
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 24
+
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 24
+
+ genunix`dnlc_lookup+0xeb
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 25
+
+ genunix`fop_lookup+0x1d
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 25
+
+ genunix`fop_lookup+0x2c
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 25
+
+ genunix`secpolicy_vnode_access2+0xa0
+ ufs`ufs_iaccess+0x128
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 25
+
+ genunix`fop_lookup+0x5a
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 25
+
+ genunix`cv_init+0x22
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 25
+
+ lofs`lo_lookup+0x1a4
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 25
+
+ genunix`post_syscall+0x22d
+ unix`0xfffffffffb800c91
+ 25
+
+ genunix`lookupnameat
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 25
+
+ genunix`unfalloc+0x1
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 25
+
+ unix`strlen+0x16
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 25
+
+ ufs`ufs_lookup+0xe9
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 25
+
+ unix`mutex_enter
+ genunix`vn_alloc+0x1a
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 25
+
+ genunix`lookuppnvp+0x1c5
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 25
+
+ genunix`fop_lookup+0x1eb
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 25
+
+ genunix`vn_setpath+0x12b
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 25
+
+ unix`mutex_exit
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 25
+
+ unix`mutex_exit
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 25
+
+ genunix`vn_setpath+0x137
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 25
+
+ genunix`audit_getstate+0x2c
+ genunix`setf+0x3f
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 25
+
+ lofs`table_lock_enter
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 26
+
+ genunix`fop_lookup+0x3b
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 26
+
+ genunix`fop_lookup+0x13e
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 26
+
+ genunix`kmem_free+0x3a
+ genunix`audit_unfalloc+0x44
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 26
+
+ genunix`cv_init
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 26
+
+ genunix`fop_inactive+0xc2
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 26
+
+ genunix`rwst_exit+0x8
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 26
+
+ lofs`lo_lookup+0x8f
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 26
+
+ unix`prunstop+0x1b
+ genunix`post_syscall+0x2d0
+ unix`0xfffffffffb800c91
+ 26
+
+ unix`bcmp+0xf
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 26
+
+ lofs`lo_lookup+0xa1
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 26
+
+ genunix`cv_destroy+0xd
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 26
+
+ ufs`ufs_iaccess+0x59
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 26
+
+ genunix`kmem_cache_alloc
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 26
+
+ lofs`lo_lookup+0x1e6
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 26
+
+ genunix`dnlc_lookup+0xbe
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 26
+
+ unix`mutex_exit
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 26
+
+ unix`mutex_exit
+ genunix`vn_alloc+0x1a
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 26
+
+ lofs`lo_lookup+0x118
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 26
+
+ genunix`dnlc_lookup+0x149
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 27
+
+ genunix`lookuppnvp+0x16d
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 27
+
+ ufs`ufs_iaccess+0x141
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 27
+
+ unix`bcopy+0x3b4
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 27
+
+ genunix`vn_reinit+0x7b
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 27
+
+ unix`rw_exit+0x24
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 27
+
+ genunix`thread_lock+0x1
+ unix`0xfffffffffb800c91
+ 27
+
+ unix`mutex_exit+0xc
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 27
+
+ genunix`lookuppnvp+0x1ed
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 27
+
+ unix`strlen
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 28
+
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 28
+
+ unix`strlen+0xb
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 28
+
+ genunix`vn_setpath+0xc
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 28
+
+ genunix`kmem_cache_alloc+0x10
+ genunix`kmem_alloc+0x4b
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 28
+
+ genunix`fd_find+0x58
+ genunix`ufalloc_file+0x91
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 28
+
+ genunix`fop_lookup+0x1
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 28
+
+ unix`mutex_exit+0xc
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 28
+
+ unix`mutex_exit+0xc
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 28
+
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 29
+
+ genunix`fop_lookup+0x37
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 29
+
+ unix`bcopy+0x234
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 29
+
+ genunix`vn_recycle+0xb5
+ genunix`vn_reinit+0x7b
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 29
+
+ genunix`fop_lookup+0x5e
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 29
+
+ genunix`rwst_enter_common+0x44
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 29
+
+ unix`tsc_gethrtimeunscaled+0x1
+ genunix`syscall_mstate+0x5d
+ unix`sys_syscall+0x1a1
+ 29
+
+ genunix`syscall_mstate+0x1a1
+ unix`sys_syscall+0x1a1
+ 29
+
+ unix`mutex_exit+0xc
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 29
+
+ lofs`lo_lookup+0x133
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 30
+
+ unix`bcopy+0x32c
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 30
+
+ genunix`fop_inactive+0xc2
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 30
+
+ genunix`clear_stale_fd+0x46
+ genunix`post_syscall+0x1fe
+ unix`0xfffffffffb800c91
+ 30
+
+ genunix`vn_vfslocks_rele
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 30
+
+ genunix`syscall_mstate+0x14d
+ unix`0xfffffffffb800ca0
+ 30
+
+ unix`rw_exit
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 30
+
+ genunix`rwst_enter_common+0x40
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 30
+
+ unix`mutex_enter
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 30
+
+ unix`mutex_exit
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 30
+
+ genunix`post_syscall+0x29a
+ unix`0xfffffffffb800c91
+ 30
+
+ lofs`lo_lookup+0x38
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 31
+
+ unix`rw_enter+0x9
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 31
+
+ unix`splr
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 31
+
+ genunix`fop_lookup+0xc2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 31
+
+ genunix`memcmp+0x23
+ unix`bcmp+0x9
+ genunix`dnlc_lookup+0x10d
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 31
+
+ unix`mutex_init
+ genunix`vn_vfslocks_getlock+0xb0
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 31
+
+ lofs`lo_lookup
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 31
+
+ genunix`fop_lookup
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 31
+
+ unix`bcopy+0x17
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 32
+
+ genunix`pn_getcomponent+0x73
+ genunix`lookuppnvp+0x16d
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 32
+
+ genunix`pn_getcomponent+0x81
+ genunix`lookuppnvp+0x16d
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 32
+
+ unix`bcopy+0x38c
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 32
+
+ genunix`crgetmapped
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 32
+
+ ufs`ufs_lookup+0xfa
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 32
+
+ genunix`dnlc_lookup+0xd0
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 32
+
+ ufs`ufs_lookup+0x44
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 33
+
+ genunix`post_syscall+0x2b9
+ unix`0xfffffffffb800c91
+ 33
+
+ genunix`dnlc_lookup+0x75
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 33
+
+ ufs`ufs_iaccess+0x89
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 33
+
+ genunix`fsop_root+0x1
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 33
+
+ genunix`kmem_free
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 34
+
+ genunix`fop_lookup+0x113
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 34
+
+ lofs`lo_root+0x1f
+ genunix`fsop_root+0x2d
+ genunix`traverse+0x87
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 34
+
+ genunix`fop_lookup+0x5e
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 34
+
+ lofs`table_lock_enter+0x41
+ lofs`freelonode+0x47
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 34
+
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 34
+
+ genunix`dnlc_lookup+0x99
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 34
+
+ unix`clear_int_flag+0x2
+ genunix`disp_lock_exit+0x47
+ genunix`post_syscall+0x318
+ unix`0xfffffffffb800c91
+ 34
+
+ lofs`lfind+0x40
+ lofs`makelonode+0x47
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 34
+
+ genunix`lookuppnvp+0x1db
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 34
+
+ genunix`fop_lookup
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 34
+
+ lofs`lo_lookup+0x58
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 35
+
+ genunix`memcmp
+ genunix`dnlc_lookup+0x10d
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 35
+
+ unix`strlen+0xe
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 35
+
+ unix`mutex_enter
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 35
+
+ genunix`fop_lookup+0x1ff
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 35
+
+ unix`mutex_exit+0xc
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 35
+
+ genunix`vn_setpath+0x6b
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 36
+
+ genunix`vn_setpath+0x9e
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 36
+
+ unix`membar_consumer+0x3
+ lofs`freelonode+0x47
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 36
+
+ genunix`secpolicy_vnode_access2
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 36
+
+ unix`copystr+0x39
+ genunix`pn_get_buf+0x43
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 36
+
+ unix`mutex_exit
+ genunix`kmem_alloc+0x4b
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 36
+
+ genunix`vn_mountedvfs
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 37
+
+ unix`mutex_enter+0x9
+ genunix`kmem_alloc+0x4b
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 37
+
+ genunix`vn_reinit+0x7c
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 38
+
+ unix`mutex_exit+0xc
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 38
+
+ unix`mutex_exit+0xc
+ genunix`kmem_zalloc+0x47
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 38
+
+ genunix`lookupnameat+0x1
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 39
+
+ unix`mutex_exit
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 39
+
+ genunix`pn_getcomponent+0x9e
+ genunix`lookuppnvp+0x16d
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 40
+
+ unix`mutex_exit+0xc
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 40
+
+ unix`bcopy
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 41
+
+ unix`mutex_exit+0x12
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 41
+
+ unix`mutex_exit+0x12
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 41
+
+ genunix`dnlc_lookup
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 41
+
+ genunix`syscall_mstate+0x1
+ 41
+
+ unix`bcopy+0x2cd
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 41
+
+ unix`bcopy+0x2fc
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 41
+
+ unix`0xfffffffffb800c7c
+ 42
+
+ genunix`dnlc_lookup+0x5f
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 42
+
+ genunix`cv_destroy
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 42
+
+ genunix`audit_getstate+0x1
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 42
+
+ unix`copystr+0x52
+ genunix`pn_get_buf+0x43
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 42
+
+ unix`mutex_exit+0xc
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 42
+
+ unix`mutex_exit+0x12
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 43
+
+ genunix`syscall_mstate
+ 43
+
+ genunix`vn_setpath+0xe7
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 43
+
+ unix`mutex_exit+0xc
+ genunix`kmem_free+0x4e
+ genunix`audit_unfalloc+0x44
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 43
+
+ unix`mutex_exit+0xc
+ genunix`falloc+0x63
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 43
+
+ genunix`vn_setpath
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 44
+
+ unix`mutex_exit+0xc
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 44
+
+ genunix`dnlc_lookup+0x6b
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 45
+
+ genunix`kmem_alloc
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 45
+
+ genunix`fop_lookup+0x1dc
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 46
+
+ unix`mutex_enter
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 46
+
+ genunix`dnlc_lookup+0x53
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 47
+
+ genunix`vn_rele
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 47
+
+ unix`mutex_exit+0xc
+ genunix`unfalloc+0x61
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 47
+
+ unix`mutex_exit+0xc
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 47
+
+ unix`mutex_exit+0xc
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 47
+
+ unix`mutex_exit+0x12
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 48
+
+ unix`rw_enter+0x14
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 48
+
+ unix`mutex_exit+0x12
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 49
+
+ unix`mutex_exit+0xc
+ genunix`lookuppnvp+0x39f
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 49
+
+ unix`atomic_cas_64
+ lofs`makelonode+0x1c4
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 50
+
+ unix`mutex_exit+0xc
+ lofs`freelonode+0x1fe
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 50
+
+ ufs`ufs_iaccess
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 51
+
+ unix`strlen+0x8
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 51
+
+ unix`strlen+0xb
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 52
+
+ genunix`vn_setpath+0xee
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 52
+
+ unix`mutex_enter
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 52
+
+ unix`mutex_exit+0xc
+ genunix`traverse+0x9f
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 52
+
+ unix`mutex_exit+0x12
+ genunix`fsop_root+0x2d
+ genunix`traverse+0x87
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 53
+
+ genunix`vn_setpath+0x6f
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 53
+
+ unix`mutex_exit+0xc
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 53
+
+ unix`rw_enter
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 55
+
+ unix`mutex_exit+0xc
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 55
+
+ genunix`vn_setpath+0x126
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 56
+
+ genunix`kmem_free
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 57
+
+ unix`splr+0x1
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 57
+
+ genunix`dnlc_lookup+0x62
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 57
+
+ lofs`table_lock_enter+0x41
+ lofs`makelonode+0x36
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 58
+
+ genunix`syscall_mstate+0x14d
+ unix`sys_syscall+0x10e
+ 58
+
+ unix`mutex_exit+0x12
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 59
+
+ unix`mutex_exit+0x12
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 59
+
+ genunix`vsd_free+0xc
+ genunix`vn_recycle+0xb5
+ genunix`vn_reinit+0x7b
+ genunix`vn_alloc+0x3e
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 59
+
+ unix`bcopy+0x388
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 60
+
+ genunix`kmem_alloc+0x17
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 60
+
+ unix`bcopy+0x3b0
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 60
+
+ unix`mutex_exit+0xc
+ zfs`zfs_lookup+0xc2
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 61
+
+ unix`mutex_exit+0xc
+ ufs`ufs_lookup+0x36d
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 61
+
+ unix`membar_consumer+0x3
+ lofs`freelonode+0x47
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 62
+
+ unix`mutex_enter
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 62
+
+ unix`mutex_exit+0x12
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 64
+
+ unix`strlen+0x10
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 64
+
+ unix`bcopy+0x328
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 66
+
+ genunix`dnlc_lookup+0x6e
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 66
+
+ lofs`lo_lookup+0x279
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 67
+
+ genunix`vn_setpath+0x76
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 69
+
+ genunix`vn_setops+0x2b
+ lofs`makelonode+0x1c4
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 69
+
+ genunix`vn_openat+0x7b
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 69
+
+ genunix`dnlc_lookup+0x69
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 69
+
+ unix`mutex_exit+0xc
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 69
+
+ unix`strlen+0xe
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 71
+
+ unix`mutex_exit+0xc
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 71
+
+ genunix`vfs_getops+0x20
+ genunix`vfs_matchops+0x1c
+ lofs`lo_lookup+0x1e6
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 72
+
+ unix`bcopy+0x2c8
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 72
+
+ unix`mutex_exit+0x12
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 74
+
+ unix`bcopy+0x230
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 74
+
+ unix`bcopy+0x2f8
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 74
+
+ unix`mutex_enter+0x10
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 75
+
+ genunix`vn_setpath+0x15a
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 76
+
+ unix`mutex_exit+0xc
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 77
+
+ unix`mutex_exit+0xc
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 77
+
+ genunix`vn_setpath+0x199
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 78
+
+ genunix`fop_lookup+0xf8
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 78
+
+ unix`mutex_enter+0x10
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 79
+
+ genunix`memcmp+0x20
+ unix`bcmp+0x9
+ genunix`dnlc_lookup+0x10d
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 80
+
+ unix`mutex_enter+0x10
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 82
+
+ genunix`memcmp+0x2c
+ unix`bcmp+0x9
+ genunix`dnlc_lookup+0x10d
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 87
+
+ unix`mutex_enter+0x10
+ genunix`lookuppnvp+0x39f
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 87
+
+ unix`atomic_add_64+0x4
+ unix`0xfffffffffb800ca0
+ 90
+
+ unix`mutex_enter+0x10
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 90
+
+ unix`mutex_enter+0x10
+ genunix`unfalloc+0x61
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 91
+
+ unix`mutex_enter+0x10
+ genunix`traverse+0x9f
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 91
+
+ unix`mutex_enter+0x10
+ genunix`fsop_root+0x2d
+ genunix`traverse+0x87
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 92
+
+ unix`mutex_enter+0x10
+ zfs`zfs_lookup+0xc2
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 92
+
+ unix`mutex_exit
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 92
+
+ unix`mutex_enter+0x10
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 93
+
+ unix`mutex_enter+0x10
+ genunix`falloc+0x63
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 93
+
+ unix`mutex_enter+0x10
+ lofs`freelonode+0x47
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 93
+
+ unix`mutex_enter+0x10
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 93
+
+ unix`mutex_enter+0x10
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 94
+
+ unix`mutex_enter+0x10
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 94
+
+ unix`mutex_exit+0x12
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 95
+
+ unix`mutex_enter+0x10
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 95
+
+ unix`mutex_enter+0x10
+ lofs`freelonode+0x1fe
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 95
+
+ unix`mutex_enter+0x10
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 96
+
+ unix`atomic_add_32_nv+0x6
+ genunix`unfalloc+0x4a
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 97
+
+ unix`atomic_add_64+0x4
+ unix`sys_syscall+0x1a1
+ 97
+
+ unix`mutex_exit+0xc
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 97
+
+ unix`atomic_add_64+0x4
+ unix`sys_syscall+0x10e
+ 98
+
+ unix`mutex_exit+0xc
+ genunix`kmem_alloc+0x4b
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 99
+
+ unix`mutex_exit+0x12
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 100
+
+ unix`membar_consumer+0x3
+ lofs`makelonode+0x1c4
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 100
+
+ unix`atomic_add_64+0x4
+ unix`0xfffffffffb800c86
+ 100
+
+ unix`mutex_enter+0x10
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 101
+
+ unix`mutex_destroy+0x74
+ genunix`rwst_destroy+0x1c
+ genunix`vn_vfslocks_rele+0xd6
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 102
+
+ unix`mutex_enter+0x10
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 102
+
+ unix`atomic_add_32+0x3
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 105
+
+ unix`mutex_enter+0x10
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 105
+
+ unix`mutex_exit+0xc
+ lofs`makelonode+0xa9
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 105
+
+ unix`membar_consumer+0x3
+ lofs`makelonode+0x36
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 106
+
+ unix`membar_consumer+0x3
+ genunix`vfs_matchops+0x1c
+ lofs`lo_lookup+0x1e6
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 106
+
+ unix`mutex_exit+0xc
+ genunix`vn_alloc+0x1a
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 106
+
+ unix`mutex_exit+0xc
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 107
+
+ unix`mutex_enter+0x10
+ ufs`ufs_lookup+0x36d
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 108
+
+ unix`mutex_exit+0xc
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 108
+
+ unix`mutex_enter+0x10
+ genunix`kmem_free+0x4e
+ genunix`audit_unfalloc+0x44
+ genunix`unfalloc+0x41
+ genunix`copen+0x4f3
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 109
+
+ genunix`pn_getcomponent+0xa8
+ genunix`lookuppnvp+0x16d
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 110
+
+ unix`mutex_enter+0x10
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 111
+
+ genunix`dnlc_lookup+0x5c
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 114
+
+ unix`mutex_enter+0x10
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0x92
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 114
+
+ unix`mutex_enter+0x10
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 114
+
+ unix`mutex_exit+0xc
+ lofs`freelonode+0x1fe
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 114
+
+ genunix`dnlc_lookup+0xe5
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 115
+
+ genunix`pn_getcomponent+0xb3
+ genunix`lookuppnvp+0x16d
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 116
+
+ genunix`rwst_enter_common+0x40
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 116
+
+ unix`mutex_enter+0x10
+ genunix`kmem_zalloc+0x47
+ genunix`audit_falloc+0x1f
+ genunix`falloc+0xf8
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 121
+
+ unix`mutex_exit+0xc
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 123
+
+ unix`mutex_exit+0x12
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 124
+
+ unix`mutex_exit+0xc
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 126
+
+ unix`atomic_add_32+0x3
+ genunix`falloc+0xbc
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 129
+
+ unix`tsc_read+0x3
+ genunix`gethrtime_unscaled+0xa
+ genunix`syscall_mstate+0x5d
+ unix`0xfffffffffb800ca0
+ 145
+
+ unix`strlen+0x13
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 146
+
+ genunix`fop_lookup+0x113
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 154
+
+ unix`clear_int_flag+0x2
+ genunix`thread_lock+0x24
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 157
+
+ unix`tsc_read+0x3
+ genunix`gethrtime_unscaled+0xa
+ genunix`syscall_mstate+0x5d
+ unix`sys_syscall+0x1a1
+ 163
+
+ unix`copystr+0x34
+ genunix`pn_get_buf+0x43
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 164
+
+ unix`mutex_exit+0xc
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 168
+
+ unix`tsc_read+0x3
+ genunix`gethrtime_unscaled+0xa
+ genunix`syscall_mstate+0x5d
+ unix`0xfffffffffb800c86
+ 169
+
+ unix`mutex_enter+0x10
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 169
+
+ lofs`lfind+0x38
+ lofs`makelonode+0x47
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 171
+
+ unix`mutex_exit+0xc
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 172
+
+ unix`atomic_add_32+0x3
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 174
+
+ unix`mutex_enter+0x10
+ lofs`freelonode+0x47
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 174
+
+ unix`mutex_exit+0xc
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 178
+
+ unix`tsc_read+0x3
+ genunix`gethrtime_unscaled+0xa
+ genunix`syscall_mstate+0x5d
+ unix`sys_syscall+0x10e
+ 180
+
+ unix`mutex_enter+0x10
+ lofs`freelonode+0x1fe
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 186
+
+ genunix`fop_lookup+0xf8
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 188
+
+ genunix`dnlc_lookup+0x50
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 190
+
+ unix`mutex_enter+0x10
+ genunix`vn_free+0x9a
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 190
+
+ unix`mutex_enter+0x10
+ genunix`ufalloc+0x13
+ genunix`falloc+0x43
+ genunix`copen+0x1ab
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 191
+
+ unix`mutex_enter+0x10
+ genunix`kmem_free+0x4e
+ genunix`vn_free+0x37
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 193
+
+ unix`mutex_enter+0x10
+ lofs`freelonode+0x1ed
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 196
+
+ unix`mutex_enter+0x10
+ genunix`copen+0x4ea
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 196
+
+ unix`mutex_enter+0x10
+ zfs`zfs_lookup+0xaa
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 201
+
+ unix`mutex_exit+0xc
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 210
+
+ unix`mutex_enter+0x10
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 233
+
+ unix`mutex_enter+0x10
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 237
+
+ unix`mutex_exit+0xc
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 258
+
+ unix`copystr+0x3e
+ genunix`pn_get_buf+0x43
+ genunix`lookupnameatcred+0x69
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 261
+
+ unix`atomic_cas_64+0x8
+ lofs`makelonode+0x1c4
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 268
+
+ unix`mutex_enter+0x10
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 279
+
+ unix`mutex_enter+0x10
+ genunix`vn_vfsunlock+0x28
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 280
+
+ unix`mutex_enter+0x10
+ genunix`vn_vfsunlock+0x20
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 286
+
+ unix`mutex_enter+0x10
+ genunix`vn_vfsunlock+0x15
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 290
+
+ unix`mutex_enter+0x10
+ genunix`vn_alloc+0x1a
+ lofs`makelonode+0xb6
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 293
+
+ unix`mutex_enter+0x10
+ lofs`makelonode+0x36
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 298
+
+ unix`mutex_enter+0x10
+ lofs`makelonode+0xa9
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 298
+
+ unix`mutex_enter+0x10
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 301
+
+ unix`mutex_enter+0x10
+ genunix`rwst_tryenter+0x1a
+ genunix`vn_vfsrlock+0x2f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 305
+
+ unix`mutex_enter+0x10
+ genunix`kmem_free+0x4e
+ genunix`vn_vfslocks_rele+0xe3
+ genunix`vn_vfsunlock+0x30
+ genunix`traverse+0xb3
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 308
+
+ unix`atomic_add_32+0x3
+ lofs`lo_lookup+0x268
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 309
+
+ unix`mutex_enter+0x10
+ genunix`kmem_alloc+0x4b
+ genunix`vn_setpath+0xc2
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 318
+
+ unix`strlen+0x10
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 327
+
+ genunix`syscall_mstate+0x14d
+ unix`sys_syscall+0x1a1
+ 330
+
+ unix`rw_exit+0xf
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 348
+
+ unix`mutex_enter+0x10
+ genunix`kmem_alloc+0x4b
+ genunix`vn_vfslocks_getlock+0x9c
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 349
+
+ unix`rw_enter+0x2b
+ ufs`ufs_lookup+0xc7
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 355
+
+ unix`splr+0x6a
+ genunix`thread_lock+0x24
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 361
+
+ unix`mutex_enter+0x10
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 372
+
+ unix`strlen+0x8
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x387
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 407
+
+ unix`mutex_enter+0x10
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ genunix`lookuppnvp+0x229
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 420
+
+ unix`strlen+0x8
+ lofs`freelonode+0x1f5
+ lofs`lo_inactive+0x1d
+ genunix`fop_inactive+0x76
+ genunix`vn_rele+0x82
+ genunix`lookuppnvp+0x33b
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 534
+
+ unix`strlen+0xe
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 562
+
+ unix`sys_syscall+0xff
+ 565
+
+ unix`mutex_enter+0x10
+ genunix`vn_vfsrlock+0x1f
+ genunix`traverse+0x30
+ lofs`lo_lookup+0x2ee
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 673
+
+ unix`lock_try+0x8
+ genunix`post_syscall+0x2e4
+ unix`0xfffffffffb800c91
+ 774
+
+ unix`mutex_enter+0x10
+ ufs`ufs_lookup+0xa6
+ genunix`fop_lookup+0xa2
+ lofs`lo_lookup+0xbc
+ genunix`fop_lookup+0xa2
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 816
+
+ unix`mutex_enter+0x10
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 884
+
+ unix`strlen+0x8
+ genunix`fop_lookup+0x210
+ genunix`lookuppnvp+0x1f6
+ genunix`lookuppnatcred+0x15e
+ genunix`lookupnameatcred+0xad
+ genunix`lookupnameat+0x39
+ genunix`vn_openat+0x315
+ genunix`copen+0x20c
+ genunix`openat+0x2a
+ genunix`open+0x25
+ unix`sys_syscall+0x17a
+ 1535
+
+ unix`do_splx+0x65
+ genunix`disp_lock_exit+0x47
+ genunix`post_syscall+0x318
+ unix`0xfffffffffb800c91
+ 1971
diff --git a/tests/benchmarks/_script/flamegraph/example-dtrace.svg b/tests/benchmarks/_script/flamegraph/example-dtrace.svg
new file mode 100644
index 00000000000..6702dc8b38f
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/example-dtrace.svg
@@ -0,0 +1,1842 @@
+
+
+
+
+
+
+
+
+
+
+Flame Graph
+
+Reset Zoom
+Search
+
+unix`mutex_enter (195 samples, 0.34%)
+
+genunix`as_fault (12 samples, 0.02%)
+
+genunix`disp_lock_exit (27 samples, 0.05%)
+
+genunix`vsd_free (17 samples, 0.03%)
+
+genunix`pn_fixslash (44 samples, 0.08%)
+
+unix`mutex_exit (105 samples, 0.18%)
+
+genunix`falloc (1,363 samples, 2.37%) g..
+
+
+genunix`traverse (30 samples, 0.05%)
+
+genunix`fop_lookup (55 samples, 0.10%)
+
+genunix`kmem_cache_free (29 samples, 0.05%)
+
+lofs`makelonode (39 samples, 0.07%)
+
+genunix`vsd_free (155 samples, 0.27%)
+
+unix`strlen (2,659 samples, 4.63%) unix`..
+
+
+unix`clear_int_flag (180 samples, 0.31%)
+
+unix`mutex_exit (38 samples, 0.07%)
+
+genunix`kmem_cpu_reload (5 samples, 0.01%)
+
+unix`mutex_exit (26 samples, 0.05%)
+
+genunix`vn_vfslocks_getlock (47 samples, 0.08%)
+
+unix`bzero (8 samples, 0.01%)
+
+genunix`vn_exists (50 samples, 0.09%)
+
+unix`mutex_enter (727 samples, 1.27%)
+
+genunix`kmem_cache_alloc (179 samples, 0.31%)
+
+unix`mutex_enter (905 samples, 1.58%)
+
+genunix`ufalloc (10 samples, 0.02%)
+
+genunix`vn_rele (25 samples, 0.04%)
+
+genunix`vn_exists (17 samples, 0.03%)
+
+unix`lock_try (778 samples, 1.35%)
+
+genunix`rwst_enter_common (314 samples, 0.55%)
+
+genunix`fsop_root (62 samples, 0.11%)
+
+lofs`table_lock_enter (44 samples, 0.08%)
+
+unix`mutex_exit (138 samples, 0.24%)
+
+unix`mutex_enter (316 samples, 0.55%)
+
+genunix`kmem_cache_free (5 samples, 0.01%)
+
+unix`preempt (14 samples, 0.02%)
+
+genunix`vn_alloc (1,189 samples, 2.07%) g..
+
+
+genunix`kmem_cache_alloc (126 samples, 0.22%)
+
+genunix`vfs_getops (157 samples, 0.27%)
+
+lofs`lsave (27 samples, 0.05%)
+
+unix`tsc_read (160 samples, 0.28%)
+
+lofs`lfind (26 samples, 0.05%)
+
+unix`atomic_add_64 (205 samples, 0.36%)
+
+unix`mutex_enter (320 samples, 0.56%)
+
+genunix`traverse (17 samples, 0.03%)
+
+unix`mutex_enter (197 samples, 0.34%)
+
+genunix`vn_mountedvfs (20 samples, 0.03%)
+
+genunix`audit_unfalloc (340 samples, 0.59%)
+
+genunix`kmem_cache_free (209 samples, 0.36%)
+
+genunix`kmem_zalloc (13 samples, 0.02%)
+
+genunix`thread_lock (33 samples, 0.06%)
+
+unix`tsc_read (186 samples, 0.32%)
+
+genunix`vn_vfsrlock (12 samples, 0.02%)
+
+lofs`lo_inactive (21 samples, 0.04%)
+
+genunix`rwst_destroy (20 samples, 0.03%)
+
+unix`mutex_enter (379 samples, 0.66%)
+
+genunix`vn_setops (41 samples, 0.07%)
+
+genunix`vn_recycle (33 samples, 0.06%)
+
+lofs`lo_inactive (6,307 samples, 10.98%) lofs`lo_inactive
+
+
+lofs`table_lock_enter (220 samples, 0.38%)
+
+genunix`cv_broadcast (25 samples, 0.04%)
+
+unix`mutex_exit (358 samples, 0.62%)
+
+genunix`kmem_cache_alloc (234 samples, 0.41%)
+
+unix`rw_enter (525 samples, 0.91%)
+
+unix`membar_consumer (237 samples, 0.41%)
+
+unix`swtch (5 samples, 0.01%)
+
+genunix`rwst_enter_common (32 samples, 0.06%)
+
+lofs`freelonode (5,313 samples, 9.25%) lofs`freelonode
+
+
+genunix`vn_openat (46,342 samples, 80.68%) genunix`vn_openat
+
+
+genunix`vn_rele (19 samples, 0.03%)
+
+genunix`proc_exit (5 samples, 0.01%)
+
+unix`mutex_exit (512 samples, 0.89%)
+
+genunix`kmem_free (35 samples, 0.06%)
+
+unix`mutex_enter (252 samples, 0.44%)
+
+genunix`rwst_exit (12 samples, 0.02%)
+
+genunix`crgetuid (22 samples, 0.04%)
+
+genunix`kmem_free (17 samples, 0.03%)
+
+unix`mutex_init (53 samples, 0.09%)
+
+ufs`ufs_iaccess (648 samples, 1.13%)
+
+all (57,441 samples, 100%)
+
+genunix`fop_inactive (6,689 samples, 11.64%) genunix`fop_inact..
+
+
+genunix`kmem_cache_alloc (9 samples, 0.02%)
+
+genunix`kmem_cache_free (184 samples, 0.32%)
+
+genunix`pn_get_buf (13 samples, 0.02%)
+
+unix`strlen (107 samples, 0.19%)
+
+unix`mutex_exit (46 samples, 0.08%)
+
+genunix`post_syscall (12 samples, 0.02%)
+
+unix`mutex_init (38 samples, 0.07%)
+
+unix`rw_exit (439 samples, 0.76%)
+
+lofs`lo_lookup (65 samples, 0.11%)
+
+genunix`clear_stale_fd (44 samples, 0.08%)
+
+unix`mutex_enter (238 samples, 0.41%)
+
+genunix`pn_get_buf (687 samples, 1.20%)
+
+genunix`vn_free (1,663 samples, 2.90%) ge..
+
+
+unix`mutex_enter (980 samples, 1.71%)
+
+genunix`crhold (5 samples, 0.01%)
+
+unix`mutex_exit (59 samples, 0.10%)
+
+genunix`vn_reinit (48 samples, 0.08%)
+
+genunix`vfs_getops (21 samples, 0.04%)
+
+genunix`open (49,669 samples, 86.47%) genunix`open
+
+
+genunix`kmem_cache_alloc (39 samples, 0.07%)
+
+genunix`vn_vfslocks_getlock (79 samples, 0.14%)
+
+unix`clear_int_flag (39 samples, 0.07%)
+
+genunix`kmem_cache_free (215 samples, 0.37%)
+
+unix`mutex_destroy (53 samples, 0.09%)
+
+genunix`vn_vfsunlock (3,578 samples, 6.23%) genunix`..
+
+
+genunix`dnlc_lookup (1,843 samples, 3.21%) gen..
+
+
+genunix`lookupnameatcred (45,978 samples, 80.04%) genunix`lookupnameatcred
+
+
+genunix`crgetmapped (41 samples, 0.07%)
+
+genunix`anon_zero (7 samples, 0.01%)
+
+genunix`rwst_tryenter (628 samples, 1.09%)
+
+unix`mutex_enter (309 samples, 0.54%)
+
+genunix`vn_rele (14 samples, 0.02%)
+
+genunix`vn_setpath (1,969 samples, 3.43%) gen..
+
+
+unix`mutex_enter (111 samples, 0.19%)
+
+genunix`cv_broadcast (40 samples, 0.07%)
+
+genunix`kmem_cache_alloc (66 samples, 0.11%)
+
+genunix`audit_getstate (21 samples, 0.04%)
+
+genunix`vn_setpath (58 samples, 0.10%)
+
+genunix`open (17 samples, 0.03%)
+
+unix`bcopy (896 samples, 1.56%)
+
+unix`mutex_enter (99 samples, 0.17%)
+
+genunix`traverse (5,557 samples, 9.67%) genunix`traverse
+
+
+genunix`pn_getcomponent (41 samples, 0.07%)
+
+unix`mutex_enter (640 samples, 1.11%)
+
+unix`mutex_destroy (176 samples, 0.31%)
+
+unix`lwp_getdatamodel (6 samples, 0.01%)
+
+genunix`unfalloc (39 samples, 0.07%)
+
+genunix`syscall_mstate (355 samples, 0.62%)
+
+genunix`cv_init (65 samples, 0.11%)
+
+unix`mutex_enter (95 samples, 0.17%)
+
+unix`bcmp (42 samples, 0.07%)
+
+unix`mutex_exit (350 samples, 0.61%)
+
+genunix`kmem_free (288 samples, 0.50%)
+
+unix`mutex_exit (58 samples, 0.10%)
+
+genunix`kmem_alloc (32 samples, 0.06%)
+
+unix`mutex_exit (356 samples, 0.62%)
+
+unix`mutex_init (46 samples, 0.08%)
+
+genunix`rwst_init (173 samples, 0.30%)
+
+genunix`rwst_enter_common (28 samples, 0.05%)
+
+genunix`openat (49,647 samples, 86.43%) genunix`openat
+
+
+unix`mutex_enter (303 samples, 0.53%)
+
+lofs`lfind (278 samples, 0.48%)
+
+unix`mutex_exit (90 samples, 0.16%)
+
+genunix`cv_init (49 samples, 0.09%)
+
+unix`tsc_gethrtimeunscaled (43 samples, 0.07%)
+
+genunix`rwst_tryenter (32 samples, 0.06%)
+
+genunix`pn_fixslash (14 samples, 0.02%)
+
+genunix`gethrtime_unscaled (420 samples, 0.73%)
+
+genunix`post_syscall (4,245 samples, 7.39%) genunix`po..
+
+
+genunix`kmem_zalloc (280 samples, 0.49%)
+
+genunix`vn_alloc (20 samples, 0.03%)
+
+genunix`vn_mountedvfs (43 samples, 0.07%)
+
+genunix`audit_getstate (15 samples, 0.03%)
+
+zfs`zfs_lookup (22 samples, 0.04%)
+
+genunix`crgetuid (6 samples, 0.01%)
+
+unix`copystr (598 samples, 1.04%)
+
+unix`i_ddi_splhigh (23 samples, 0.04%)
+
+unix`trap (13 samples, 0.02%)
+
+genunix`audit_getstate (27 samples, 0.05%)
+
+genunix`vn_mountedvfs (56 samples, 0.10%)
+
+unix`mutex_destroy (17 samples, 0.03%)
+
+genunix`cv_broadcast (14 samples, 0.02%)
+
+genunix`segvn_fault (11 samples, 0.02%)
+
+genunix`vn_rele (39 samples, 0.07%)
+
+genunix`kmem_free (457 samples, 0.80%)
+
+genunix`vn_vfsunlock (20 samples, 0.03%)
+
+genunix`vn_vfslocks_rele (34 samples, 0.06%)
+
+unix`atomic_cas_64 (318 samples, 0.55%)
+
+unix`mutex_enter (337 samples, 0.59%)
+
+unix`do_splx (31 samples, 0.05%)
+
+genunix`ufalloc_file (20 samples, 0.03%)
+
+genunix`fd_reserve (35 samples, 0.06%)
+
+genunix`copen (49,444 samples, 86.08%) genunix`copen
+
+
+unix`mutex_enter (279 samples, 0.49%)
+
+unix`0xfffffffffb800c91 (4,361 samples, 7.59%) unix`0xfff..
+
+
+genunix`crgetmapped (55 samples, 0.10%)
+
+genunix`cv_init (56 samples, 0.10%)
+
+genunix`dnlc_lookup (26 samples, 0.05%)
+
+genunix`kmem_alloc (11 samples, 0.02%)
+
+genunix`cv_init (53 samples, 0.09%)
+
+unix`copyinstr (25 samples, 0.04%)
+
+genunix`gethrtime_unscaled (203 samples, 0.35%)
+
+genunix`kmem_cache_alloc (11 samples, 0.02%)
+
+genunix`vn_free (26 samples, 0.05%)
+
+unix`mutex_exit (149 samples, 0.26%)
+
+genunix`vn_recycle (319 samples, 0.56%)
+
+genunix`vn_rele (64 samples, 0.11%)
+
+unix`bcmp (11 samples, 0.02%)
+
+genunix`kmem_cache_free (154 samples, 0.27%)
+
+unix`lock_clear_splx (28 samples, 0.05%)
+
+genunix`unfalloc (729 samples, 1.27%)
+
+genunix`fop_lookup (85 samples, 0.15%)
+
+zfs`specvp_check (10 samples, 0.02%)
+
+genunix`lookupnameatcred (22 samples, 0.04%)
+
+unix`tsc_read (367 samples, 0.64%)
+
+genunix`memcmp (38 samples, 0.07%)
+
+unix`splx (6 samples, 0.01%)
+
+unix`mutex_exit (95 samples, 0.17%)
+
+genunix`gethrtime_unscaled (7 samples, 0.01%)
+
+genunix`rwst_init (13 samples, 0.02%)
+
+genunix`audit_getstate (31 samples, 0.05%)
+
+genunix`kmem_cache_alloc (32 samples, 0.06%)
+
+genunix`disp_lock_exit (2,096 samples, 3.65%) genu..
+
+
+unix`mutex_exit (49 samples, 0.09%)
+
+unix`copyinstr (18 samples, 0.03%)
+
+ufs`ufs_lookup (46 samples, 0.08%)
+
+genunix`clear_stale_fd (10 samples, 0.02%)
+
+genunix`rwst_destroy (296 samples, 0.52%)
+
+genunix`syscall_mstate (1,336 samples, 2.33%) g..
+
+
+genunix`kmem_alloc (934 samples, 1.63%)
+
+unix`atomic_add_32 (325 samples, 0.57%)
+
+unix`mutex_enter (947 samples, 1.65%)
+
+unix`mutex_exit (56 samples, 0.10%)
+
+unix`mutex_enter (318 samples, 0.55%)
+
+lofs`lo_root (80 samples, 0.14%)
+
+genunix`lookuppnvp (44,242 samples, 77.02%) genunix`lookuppnvp
+
+
+genunix`lookupnameat (46,075 samples, 80.21%) genunix`lookupnameat
+
+
+unix`setbackdq (5 samples, 0.01%)
+
+lofs`lo_root (31 samples, 0.05%)
+
+genunix`kmem_cache_alloc (17 samples, 0.03%)
+
+unix`mutex_exit (212 samples, 0.37%)
+
+genunix`vn_vfsrlock (2,414 samples, 4.20%) genun..
+
+
+genunix`vfs_matchops (28 samples, 0.05%)
+
+unix`prunstop (36 samples, 0.06%)
+
+unix`mutex_exit (155 samples, 0.27%)
+
+unix`mutex_init (31 samples, 0.05%)
+
+unix`atomic_add_32_nv (100 samples, 0.17%)
+
+genunix`lookupnameat (69 samples, 0.12%)
+
+unix`_sys_rtt (6 samples, 0.01%)
+
+genunix`kmem_cache_alloc (49 samples, 0.09%)
+
+unix`tsc_gethrtimeunscaled (17 samples, 0.03%)
+
+genunix`fop_lookup (29,216 samples, 50.86%) genunix`fop_lookup
+
+
+unix`mutex_exit (142 samples, 0.25%)
+
+genunix`crgetmapped (31 samples, 0.05%)
+
+unix`do_splx (1,993 samples, 3.47%) uni..
+
+
+genunix`kmem_cache_free (22 samples, 0.04%)
+
+unix`mutex_enter (95 samples, 0.17%)
+
+genunix`crhold (11 samples, 0.02%)
+
+unix`mutex_enter (823 samples, 1.43%)
+
+unix`mutex_exit (29 samples, 0.05%)
+
+genunix`vn_vfsrlock (3,342 samples, 5.82%) genunix..
+
+
+unix`tsc_gethrtimeunscaled (13 samples, 0.02%)
+
+genunix`vn_rele (73 samples, 0.13%)
+
+unix`mutex_exit (337 samples, 0.59%)
+
+genunix`vn_vfslocks_getlock (973 samples, 1.69%)
+
+zfs`specvp_check (20 samples, 0.03%)
+
+genunix`vsd_free (14 samples, 0.02%)
+
+unix`mutex_enter (314 samples, 0.55%)
+
+genunix`cv_destroy (81 samples, 0.14%)
+
+genunix`cv_broadcast (25 samples, 0.04%)
+
+unix`mutex_enter (122 samples, 0.21%)
+
+unix`mutex_exit (55 samples, 0.10%)
+
+genunix`set_errno (24 samples, 0.04%)
+
+genunix`cv_destroy (42 samples, 0.07%)
+
+genunix`fd_find (13 samples, 0.02%)
+
+genunix`vn_invalid (47 samples, 0.08%)
+
+genunix`vfs_matchops (336 samples, 0.58%)
+
+unix`tsc_gethrtimeunscaled (59 samples, 0.10%)
+
+genunix`fop_inactive (39 samples, 0.07%)
+
+genunix`kmem_free (693 samples, 1.21%)
+
+genunix`syscall_mstate (412 samples, 0.72%)
+
+genunix`thread_lock (670 samples, 1.17%)
+
+lofs`lsave (162 samples, 0.28%)
+
+unix`atomic_add_64 (95 samples, 0.17%)
+
+genunix`audit_getstate (66 samples, 0.11%)
+
+genunix`dnlc_lookup (70 samples, 0.12%)
+
+genunix`vn_mountedvfs (30 samples, 0.05%)
+
+genunix`cv_broadcast (19 samples, 0.03%)
+
+genunix`kmem_alloc (533 samples, 0.93%)
+
+unix`mutex_exit (160 samples, 0.28%)
+
+genunix`memcmp (38 samples, 0.07%)
+
+unix`strlen (1,238 samples, 2.16%) u..
+
+
+genunix`lookuppnatcred (12 samples, 0.02%)
+
+genunix`crfree (13 samples, 0.02%)
+
+lofs`table_lock_enter (43 samples, 0.07%)
+
+genunix`rwst_exit (18 samples, 0.03%)
+
+genunix`cv_destroy (31 samples, 0.05%)
+
+genunix`rwst_init (236 samples, 0.41%)
+
+genunix`vn_vfslocks_rele (1,420 samples, 2.47%) ge..
+
+
+genunix`falloc (36 samples, 0.06%)
+
+genunix`setf (187 samples, 0.33%)
+
+zfs`zfs_fastaccesschk_execute (50 samples, 0.09%)
+
+genunix`vn_vfslocks_getlock (120 samples, 0.21%)
+
+genunix`fd_reserve (9 samples, 0.02%)
+
+genunix`vn_setops (160 samples, 0.28%)
+
+unix`sys_syscall (51,908 samples, 90.37%) unix`sys_syscall
+
+
+genunix`kmem_free (115 samples, 0.20%)
+
+genunix`vsd_free (48 samples, 0.08%)
+
+genunix`rexit (5 samples, 0.01%)
+
+genunix`vn_mountedvfs (11 samples, 0.02%)
+
+genunix`lookuppnatcred (44,681 samples, 77.79%) genunix`lookuppnatcred
+
+
+unix`splr (92 samples, 0.16%)
+
+genunix`vn_vfsrlock (13 samples, 0.02%)
+
+unix`mutex_exit (371 samples, 0.65%)
+
+genunix`kmem_cache_free (5 samples, 0.01%)
+
+genunix`dnlc_lookup (263 samples, 0.46%)
+
+genunix`audit_unfalloc (32 samples, 0.06%)
+
+unix`0xfffffffffb8001d6 (13 samples, 0.02%)
+
+genunix`rwst_destroy (146 samples, 0.25%)
+
+genunix`gethrtime_unscaled (182 samples, 0.32%)
+
+unix`mutex_enter (575 samples, 1.00%)
+
+unix`mutex_exit (148 samples, 0.26%)
+
+genunix`ufalloc_file (294 samples, 0.51%)
+
+unix`mutex_exit (163 samples, 0.28%)
+
+unix`membar_consumer (106 samples, 0.18%)
+
+genunix`crgetmapped (36 samples, 0.06%)
+
+genunix`memcmp (277 samples, 0.48%)
+
+genunix`cv_destroy (77 samples, 0.13%)
+
+genunix`kmem_cache_free (116 samples, 0.20%)
+
+genunix`kmem_cache_alloc (29 samples, 0.05%)
+
+genunix`fd_reserve (8 samples, 0.01%)
+
+zfs`zfs_lookup (946 samples, 1.65%)
+
+genunix`kmem_alloc (795 samples, 1.38%)
+
+unix`tsc_gethrtimeunscaled (11 samples, 0.02%)
+
+genunix`segvn_faultpage (7 samples, 0.01%)
+
+genunix`set_errno (9 samples, 0.02%)
+
+unix`splr (400 samples, 0.70%)
+
+genunix`rwst_destroy (32 samples, 0.06%)
+
+genunix`rwst_init (28 samples, 0.05%)
+
+unix`atomic_add_32 (292 samples, 0.51%)
+
+unix`0xfffffffffb800ca0 (517 samples, 0.90%)
+
+genunix`syscall_mstate (89 samples, 0.15%)
+
+genunix`kmem_alloc (73 samples, 0.13%)
+
+genunix`vn_vfsunlock (40 samples, 0.07%)
+
+unix`mutex_enter (1,202 samples, 2.09%) u..
+
+
+lofs`makelfsnode (28 samples, 0.05%)
+
+unix`0xfffffffffb800c86 (472 samples, 0.82%)
+
+genunix`vn_rele (6,943 samples, 12.09%) genunix`vn_rele
+
+
+unix`mutex_exit (56 samples, 0.10%)
+
+genunix`kmem_cache_free (51 samples, 0.09%)
+
+genunix`gethrtime_unscaled (11 samples, 0.02%)
+
+unix`pagefault (13 samples, 0.02%)
+
+genunix`secpolicy_vnode_access2 (217 samples, 0.38%)
+
+genunix`vn_vfslocks_getlock (1,357 samples, 2.36%) g..
+
+
+unix`bcmp (295 samples, 0.51%)
+
+unix`mutex_enter (97 samples, 0.17%)
+
+unix`membar_consumer (123 samples, 0.21%)
+
+genunix`audit_getstate (16 samples, 0.03%)
+
+unix`mutex_enter (455 samples, 0.79%)
+
+lofs`makelonode (4,212 samples, 7.33%) lofs`makel..
+
+
+genunix`kmem_cache_alloc (168 samples, 0.29%)
+
+genunix`vn_vfslocks_getlock (62 samples, 0.11%)
+
+genunix`secpolicy_vnode_access2 (72 samples, 0.13%)
+
+genunix`kmem_cache_free (73 samples, 0.13%)
+
+genunix`vn_reinit (424 samples, 0.74%)
+
+genunix`pn_getcomponent (454 samples, 0.79%)
+
+genunix`fsop_root (297 samples, 0.52%)
+
+genunix`crgetuid (30 samples, 0.05%)
+
+genunix`kmem_free (785 samples, 1.37%)
+
+unix`mutex_exit (171 samples, 0.30%)
+
+genunix`crgetmapped (58 samples, 0.10%)
+
+unix`mutex_enter (299 samples, 0.52%)
+
+genunix`rwst_exit (167 samples, 0.29%)
+
+genunix`audit_falloc (8 samples, 0.01%)
+
+genunix`rwst_exit (110 samples, 0.19%)
+
+genunix`exit (5 samples, 0.01%)
+
+unix`mutex_exit (250 samples, 0.44%)
+
+lofs`freelonode (35 samples, 0.06%)
+
+genunix`rwst_tryenter (37 samples, 0.06%)
+
+ufs`ufs_iaccess (91 samples, 0.16%)
+
+unix`tsc_gethrtimeunscaled (12 samples, 0.02%)
+
+genunix`kmem_cache_alloc (241 samples, 0.42%)
+
+FSS`fss_preempt (8 samples, 0.01%)
+
+genunix`fd_reserve (15 samples, 0.03%)
+
+genunix`cv_broadcast (16 samples, 0.03%)
+
+genunix`crgetmapped (57 samples, 0.10%)
+
+unix`mutex_exit (379 samples, 0.66%)
+
+unix`mutex_destroy (31 samples, 0.05%)
+
+lofs`table_lock_enter (189 samples, 0.33%)
+
+genunix`rwst_enter_common (264 samples, 0.46%)
+
+genunix`kmem_free (11 samples, 0.02%)
+
+unix`atomic_add_32 (134 samples, 0.23%)
+
+genunix`ufalloc (551 samples, 0.96%)
+
+genunix`audit_falloc (313 samples, 0.54%)
+
+lofs`lo_lookup (19,887 samples, 34.62%) lofs`lo_lookup
+
+
+unix`atomic_add_64 (110 samples, 0.19%)
+
+genunix`vn_vfsunlock (2,372 samples, 4.13%) genu..
+
+
+genunix`openat (17 samples, 0.03%)
+
+unix`bcmp (45 samples, 0.08%)
+
+genunix`audit_getstate (62 samples, 0.11%)
+
+genunix`crfree (9 samples, 0.02%)
+
+genunix`kmem_cache_free (18 samples, 0.03%)
+
+genunix`vn_vfslocks_rele (903 samples, 1.57%)
+
+genunix`vn_invalid (20 samples, 0.03%)
+
+genunix`vn_vfslocks_rele (50 samples, 0.09%)
+
+genunix`lookuppnvp (10 samples, 0.02%)
+
+genunix`fd_find (161 samples, 0.28%)
+
+ufs`ufs_lookup (5,399 samples, 9.40%) ufs`ufs_lookup
+
+
+unix`0xfffffffffb800c7c (42 samples, 0.07%)
+
+genunix`vn_openat (14 samples, 0.02%)
+
+genunix`setf (16 samples, 0.03%)
+
+genunix`traverse (7,243 samples, 12.61%) genunix`traverse
+
+
+genunix`rwst_tryenter (734 samples, 1.28%)
+
+unix`mutex_enter (366 samples, 0.64%)
+
+genunix`fop_lookup (6,470 samples, 11.26%) genunix`fop_lookup
+
+
+unix`mutex_exit (135 samples, 0.24%)
+
+lofs`makelfsnode (82 samples, 0.14%)
+
+genunix`copen (7 samples, 0.01%)
+
diff --git a/tests/benchmarks/_script/flamegraph/example-perf-stacks.txt.gz b/tests/benchmarks/_script/flamegraph/example-perf-stacks.txt.gz
new file mode 100644
index 00000000000..e7b762b88bb
Binary files /dev/null and b/tests/benchmarks/_script/flamegraph/example-perf-stacks.txt.gz differ
diff --git a/tests/benchmarks/_script/flamegraph/example-perf.svg b/tests/benchmarks/_script/flamegraph/example-perf.svg
new file mode 100644
index 00000000000..d4896fc3503
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/example-perf.svg
@@ -0,0 +1,4895 @@
+
+
+
+
+
+
+
+
+
+
+Flame Graph
+
+Reset Zoom
+Search
+
+
+rw_verify_area (9 samples, 0.68%)
+
+_raw_spin_lock_irqsave (2 samples, 0.15%)
+
+sun/nio/ch/FileDispatcherImpl:.read0 (31 samples, 2.36%) s..
+
+
+do_sync_read (22 samples, 1.67%)
+
+sun/nio/ch/SocketChannelImpl:.write (209 samples, 15.89%) sun/nio/ch/SocketChannel..
+
+
+timerqueue_del (1 samples, 0.08%)
+
+io/netty/channel/AdaptiveRecvByteBufAllocator$HandleImpl:.record (2 samples, 0.15%)
+
+org/mozilla/javascript/ScriptRuntime:.setObjectProp (86 samples, 6.54%) org/mozi..
+
+
+read_tsc (1 samples, 0.08%)
+
+org/mozilla/javascript/gen/file__root_vert_x_2_1_5_sys_mods_io_vertx_lang_js_1_1_0_vertx_http_js_2 (14 samples, 1.06%)
+
+org/mozilla/javascript/ScriptableObject:.putImpl (45 samples, 3.42%) org..
+
+
+netdev_pick_tx (1 samples, 0.08%)
+
+io/netty/channel/AbstractChannelHandlerContext:.write (33 samples, 2.51%) io..
+
+
+java/lang/String:.equals (1 samples, 0.08%)
+
+system_call_fastpath (7 samples, 0.53%)
+
+GCTaskManager::get_task (1 samples, 0.08%)
+
+security_file_free (1 samples, 0.08%)
+
+apparmor_socket_recvmsg (5 samples, 0.38%)
+
+itable stub (1 samples, 0.08%)
+
+skb_release_data (3 samples, 0.23%)
+
+hrtimer_try_to_cancel (3 samples, 0.23%)
+
+default_wake_function (25 samples, 1.90%) d..
+
+
+__remove_hrtimer (3 samples, 0.23%)
+
+epoll_ctl (1 samples, 0.08%)
+
+fsnotify (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptRuntime:.nameOrFunction (4 samples, 0.30%)
+
+tcp_clean_rtx_queue (1 samples, 0.08%)
+
+tcp_send_delayed_ack (5 samples, 0.38%)
+
+org/mozilla/javascript/ScriptRuntime:.nameOrFunction (1 samples, 0.08%)
+
+java/lang/String:.hashCode (1 samples, 0.08%)
+
+tcp_v4_rcv (87 samples, 6.62%) tcp_v4_rcv
+
+
+aeProcessEvents (1 samples, 0.08%)
+
+org/mozilla/javascript/NativeJavaObject:.initMembers (1 samples, 0.08%)
+
+schedule_preempt_disabled (2 samples, 0.15%)
+
+kfree (1 samples, 0.08%)
+
+sun/nio/ch/SocketChannelImpl:.write (1 samples, 0.08%)
+
+sk_reset_timer (2 samples, 0.15%)
+
+org/mozilla/javascript/ScriptableObject:.putImpl (6 samples, 0.46%)
+
+remote_function (4 samples, 0.30%)
+
+io/netty/handler/codec/http/HttpObjectDecoder:.skipControlCharacters (1 samples, 0.08%)
+
+intel_pmu_enable_all (4 samples, 0.30%)
+
+mod_timer (5 samples, 0.38%)
+
+io/netty/handler/codec/MessageToMessageEncoder:.write (31 samples, 2.36%) i..
+
+
+io/netty/buffer/UnpooledHeapByteBuf:.init (1 samples, 0.08%)
+
+intel_pmu_enable_all (4 samples, 0.30%)
+
+io/netty/channel/AbstractChannelHandlerContext:.write (2 samples, 0.15%)
+
+enqueue_hrtimer (1 samples, 0.08%)
+
+itable stub (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject$Slot:.setAttributes (12 samples, 0.91%)
+
+cpuidle_idle_call (6 samples, 0.46%)
+
+system_call (1 samples, 0.08%)
+
+org/mozilla/javascript/IdScriptableObject:.get (2 samples, 0.15%)
+
+[unknown] (6 samples, 0.46%)
+
+Monitor::IWait (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptRuntime:.bind (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject:.getSlot (40 samples, 3.04%) org..
+
+
+__wake_up_sync_key (3 samples, 0.23%)
+
+system_call_fastpath (1 samples, 0.08%)
+
+vfs_write (85 samples, 6.46%) vfs_write
+
+
+mod_timer (2 samples, 0.15%)
+
+rcu_sysidle_enter (1 samples, 0.08%)
+
+oopDesc* PSPromotionManager::copy_to_survivor_spacefalse (1 samples, 0.08%)
+
+__wake_up_common (2 samples, 0.15%)
+
+io/netty/channel/AbstractChannelHandlerContext:.fireChannelRead (637 samples, 48.44%) io/netty/channel/AbstractChannelHandlerContext:.fireChannelRead
+
+
+_raw_spin_lock_irqsave (2 samples, 0.15%)
+
+ScavengeRootsTask::do_it (1 samples, 0.08%)
+
+tcp_urg (1 samples, 0.08%)
+
+aa_file_perm (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptRuntime:.setObjectProp (21 samples, 1.60%)
+
+__remove_hrtimer (1 samples, 0.08%)
+
+put_filp (1 samples, 0.08%)
+
+skb_free_head (1 samples, 0.08%)
+
+apparmor_file_permission (1 samples, 0.08%)
+
+ktime_get (1 samples, 0.08%)
+
+JavaCalls::call_virtual (956 samples, 72.70%) JavaCalls::call_virtual
+
+
+__copy_skb_header (1 samples, 0.08%)
+
+__slab_alloc (1 samples, 0.08%)
+
+cpuidle_idle_call (1 samples, 0.08%)
+
+org/mozilla/javascript/IdScriptableObject:.has (30 samples, 2.28%) o..
+
+
+ip_queue_xmit (51 samples, 3.88%) ip_q..
+
+
+org/mozilla/javascript/NativeCall:.init (15 samples, 1.14%)
+
+tcp_ack (9 samples, 0.68%)
+
+sys_ioctl (5 samples, 0.38%)
+
+fsnotify (2 samples, 0.15%)
+
+sk_reset_timer (2 samples, 0.15%)
+
+org/mozilla/javascript/ScriptableObject:.addKnownAbsentSlot (1 samples, 0.08%)
+
+lapic_next_deadline (2 samples, 0.15%)
+
+org/mozilla/javascript/gen/file__root_vert_x_2_1_5_Server2_js_1:.call (79 samples, 6.01%) org/mozi..
+
+
+sys_execve (1 samples, 0.08%)
+
+perf_event_enable (5 samples, 0.38%)
+
+sys_futex (1 samples, 0.08%)
+
+java/lang/String:.init (1 samples, 0.08%)
+
+inet_recvmsg (7 samples, 0.53%)
+
+org/mozilla/javascript/gen/file__root_vert_x_2_1_5_sys_mods_io_vertx_lang_js_1_1_0_vertx_http_js_2 (2 samples, 0.15%)
+
+io/netty/util/internal/AppendableCharSequence:.substring (4 samples, 0.30%)
+
+_raw_spin_lock_irqsave (1 samples, 0.08%)
+
+x86_pmu_enable (4 samples, 0.30%)
+
+__libc_read (1 samples, 0.08%)
+
+tcp_sendmsg (77 samples, 5.86%) tcp_sen..
+
+
+cpuidle_enter_state (12 samples, 0.91%)
+
+flush_tlb_mm_range (1 samples, 0.08%)
+
+ksize (1 samples, 0.08%)
+
+cpu_startup_entry (44 samples, 3.35%) cpu..
+
+
+pthread_self (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject:.getSlot (1 samples, 0.08%)
+
+_raw_spin_lock_bh (1 samples, 0.08%)
+
+io/netty/channel/DefaultChannelPipeline$HeadContext:.flush (2 samples, 0.15%)
+
+tcp_rcv_established (23 samples, 1.75%)
+
+org/mozilla/javascript/BaseFunction:.execIdCall (48 samples, 3.65%) org/..
+
+
+lapic_next_deadline (1 samples, 0.08%)
+
+[unknown] (197 samples, 14.98%) [unknown]
+
+
+io/netty/channel/AbstractChannelHandlerContext:.fireChannelReadComplete (242 samples, 18.40%) io/netty/channel/AbstractCha..
+
+
+bictcp_cong_avoid (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptRuntime:.nameOrFunction (5 samples, 0.38%)
+
+JavaCalls::call_virtual (956 samples, 72.70%) JavaCalls::call_virtual
+
+
+resched_task (2 samples, 0.15%)
+
+sock_wfree (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject:.getSlot (4 samples, 0.30%)
+
+io/netty/buffer/AbstractByteBuf:.getByte (1 samples, 0.08%)
+
+check_preempt_curr (2 samples, 0.15%)
+
+io/netty/channel/ChannelOutboundBuffer:.progress (1 samples, 0.08%)
+
+tcp_current_mss (1 samples, 0.08%)
+
+__execve (1 samples, 0.08%)
+
+hrtimer_force_reprogram (1 samples, 0.08%)
+
+__GI___mprotect (1 samples, 0.08%)
+
+ep_send_events_proc (9 samples, 0.68%)
+
+schedule (11 samples, 0.84%)
+
+org/mozilla/javascript/IdScriptableObject:.put (3 samples, 0.23%)
+
+org/mozilla/javascript/IdScriptableObject:.get (1 samples, 0.08%)
+
+org/mozilla/javascript/gen/file__root_vert_x_2_1_5_sys_mods_io_vertx_lang_js_1_1_0_vertx_http_js_2 (409 samples, 31.10%) org/mozilla/javascript/gen/file__root_vert_x_2_1_..
+
+
+io/netty/channel/ChannelOutboundBuffer:.decrementPendingOutboundBytes (2 samples, 0.15%)
+
+ktime_get_real (1 samples, 0.08%)
+
+aa_revalidate_sk (2 samples, 0.15%)
+
+stats_record (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject:.getSlot (1 samples, 0.08%)
+
+__perf_event_enable (4 samples, 0.30%)
+
+__alloc_skb (9 samples, 0.68%)
+
+org/mozilla/javascript/gen/file__root_vert_x_2_1_5_sys_mods_io_vertx_lang_js_1_1_0_vertx_http_js_2 (17 samples, 1.29%)
+
+socket_readable (2 samples, 0.15%)
+
+ns_to_timeval (1 samples, 0.08%)
+
+ip_rcv (33 samples, 2.51%) ip..
+
+
+SafepointSynchronize::begin (1 samples, 0.08%)
+
+java/nio/DirectByteBuffer:.duplicate (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject:.getSlot (2 samples, 0.15%)
+
+org/mozilla/javascript/IdScriptableObject:.get (1 samples, 0.08%)
+
+org/mozilla/javascript/gen/file__root_vert_x_2_1_5_sys_mods_io_vertx_lang_js_1_1_0_vertx_http_js_2 (20 samples, 1.52%)
+
+io/netty/channel/nio/AbstractNioByteChannel$NioByteUnsafe:.read (939 samples, 71.41%) io/netty/channel/nio/AbstractNioByteChannel$NioByteUnsafe:.read
+
+
+raw_local_deliver (1 samples, 0.08%)
+
+__dev_queue_xmit (4 samples, 0.30%)
+
+skb_copy_datagram_iovec (3 samples, 0.23%)
+
+apic_timer_interrupt (1 samples, 0.08%)
+
+do_vfs_ioctl (5 samples, 0.38%)
+
+do_sync_read (8 samples, 0.61%)
+
+system_call_after_swapgs (1 samples, 0.08%)
+
+_raw_spin_lock_irqsave (1 samples, 0.08%)
+
+call_function_single_interrupt (4 samples, 0.30%)
+
+io/netty/handler/codec/http/HttpHeaders:.hash (4 samples, 0.30%)
+
+io/netty/handler/codec/http/DefaultHttpMessage:.init (2 samples, 0.15%)
+
+rcu_sysidle_enter (1 samples, 0.08%)
+
+java/nio/channels/spi/AbstractInterruptibleChannel:.end (3 samples, 0.23%)
+
+clockevents_program_event (2 samples, 0.15%)
+
+org/mozilla/javascript/gen/file__root_vert_x_2_1_5_sys_mods_io_vertx_lang_js_1_1_0_vertx_http_js_2 (9 samples, 0.68%)
+
+tcp_try_rmem_schedule (2 samples, 0.15%)
+
+__schedule (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject:.putImpl (10 samples, 0.76%)
+
+tcp_v4_md5_lookup (1 samples, 0.08%)
+
+CardTableExtension::scavenge_contents_parallel (20 samples, 1.52%)
+
+aa_revalidate_sk (1 samples, 0.08%)
+
+__fsnotify_parent (1 samples, 0.08%)
+
+org/mozilla/javascript/IdScriptableObject:.get (7 samples, 0.53%)
+
+sk_reset_timer (5 samples, 0.38%)
+
+__schedule (2 samples, 0.15%)
+
+io/netty/handler/codec/http/DefaultHttpHeaders:.init (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject:.getSlot (1 samples, 0.08%)
+
+io/netty/channel/nio/AbstractNioByteChannel:.doWrite (225 samples, 17.11%) io/netty/channel/nio/Abstr..
+
+
+timerqueue_add (1 samples, 0.08%)
+
+_raw_spin_unlock_irqrestore (2 samples, 0.15%)
+
+try_to_wake_up (24 samples, 1.83%) t..
+
+
+org/mozilla/javascript/IdScriptableObject:.setAttributes (4 samples, 0.30%)
+
+io/netty/handler/codec/http/HttpResponseEncoder:.acceptOutboundMessage (1 samples, 0.08%)
+
+rw_verify_area (2 samples, 0.15%)
+
+x86_pmu_commit_txn (4 samples, 0.30%)
+
+alloc_pages_current (1 samples, 0.08%)
+
+org/mozilla/javascript/gen/file__root_vert_x_2_1_5_sys_mods_io_vertx_lang_js_1_1_0_vertx_streams_j (1 samples, 0.08%)
+
+org/mozilla/javascript/IdScriptableObject:.setAttributes (7 samples, 0.53%)
+
+org/mozilla/javascript/IdScriptableObject:.get (1 samples, 0.08%)
+
+tcp_transmit_skb (1 samples, 0.08%)
+
+sock_aio_read.part.8 (7 samples, 0.53%)
+
+sys_read (28 samples, 2.13%) s..
+
+
+org/mozilla/javascript/ScriptRuntime:.setObjectProp (28 samples, 2.13%) o..
+
+
+JavaCalls::call_helper (956 samples, 72.70%) JavaCalls::call_helper
+
+
+ttwu_do_wakeup (1 samples, 0.08%)
+
+generic_smp_call_function_single_interrupt (4 samples, 0.30%)
+
+mutex_unlock (1 samples, 0.08%)
+
+io/netty/handler/codec/http/HttpHeaders:.hash (2 samples, 0.15%)
+
+http_parser_execute (1 samples, 0.08%)
+
+mod_timer (5 samples, 0.38%)
+
+system_call_fastpath (1 samples, 0.08%)
+
+tcp_recvmsg (13 samples, 0.99%)
+
+__slab_alloc (1 samples, 0.08%)
+
+__alloc_skb (7 samples, 0.53%)
+
+clockevents_program_event (1 samples, 0.08%)
+
+vfs_read (18 samples, 1.37%)
+
+__internal_add_timer (1 samples, 0.08%)
+
+epoll_wait (1 samples, 0.08%)
+
+lock_sock_nested (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject:.getSlot (1 samples, 0.08%)
+
+native_write_msr_safe (4 samples, 0.30%)
+
+Interpreter (956 samples, 72.70%) Interpreter
+
+
+org/mozilla/javascript/ScriptableObject:.getBase (4 samples, 0.30%)
+
+dev_hard_start_xmit (9 samples, 0.68%)
+
+java/lang/String:.hashCode (1 samples, 0.08%)
+
+ip_output (46 samples, 3.50%) ip_..
+
+
+account_entity_enqueue (1 samples, 0.08%)
+
+itable stub (1 samples, 0.08%)
+
+ip_rcv (1 samples, 0.08%)
+
+io/netty/buffer/AbstractByteBuf:.writeBytes (5 samples, 0.38%)
+
+tcp_clean_rtx_queue (14 samples, 1.06%)
+
+io/netty/channel/AbstractChannelHandlerContext:.flush (1 samples, 0.08%)
+
+sys_read (21 samples, 1.60%)
+
+[unknown] (10 samples, 0.76%)
+
+java/util/concurrent/ConcurrentHashMap:.get (1 samples, 0.08%)
+
+io/netty/channel/AbstractChannel:.hashCode (4 samples, 0.30%)
+
+rcu_idle_enter (1 samples, 0.08%)
+
+gettimeofday@plt (1 samples, 0.08%)
+
+__do_softirq (103 samples, 7.83%) __do_softirq
+
+
+org/mozilla/javascript/ScriptRuntime:.nameOrFunction (8 samples, 0.61%)
+
+io/netty/buffer/AbstractByteBuf:.writeBytes (3 samples, 0.23%)
+
+inotify_add_watch (1 samples, 0.08%)
+
+fdval (1 samples, 0.08%)
+
+io/netty/handler/codec/http/HttpHeaders:.encode (7 samples, 0.53%)
+
+unsafe_arraycopy (1 samples, 0.08%)
+
+sk_stream_alloc_skb (10 samples, 0.76%)
+
+lock_timer_base.isra.35 (1 samples, 0.08%)
+
+ip_local_out (121 samples, 9.20%) ip_local_out
+
+
+java/lang/String:.hashCode (1 samples, 0.08%)
+
+io/netty/util/internal/AppendableCharSequence:.substring (2 samples, 0.15%)
+
+org/mozilla/javascript/ScriptRuntime:.bind (1 samples, 0.08%)
+
+ep_poll (53 samples, 4.03%) ep_p..
+
+
+lock_hrtimer_base.isra.19 (1 samples, 0.08%)
+
+InstanceKlass::oop_push_contents (1 samples, 0.08%)
+
+cpuacct_charge (1 samples, 0.08%)
+
+harmonize_features.isra.92.part.93 (1 samples, 0.08%)
+
+update_rq_clock.part.63 (1 samples, 0.08%)
+
+native_write_msr_safe (1 samples, 0.08%)
+
+io/netty/handler/codec/http/HttpObjectDecoder:.findNonWhitespace (1 samples, 0.08%)
+
+org/mozilla/javascript/gen/file__root_vert_x_2_1_5_sys_mods_io_vertx_lang_js_1_1_0_vertx_streams_j (1 samples, 0.08%)
+
+org/mozilla/javascript/BaseFunction:.construct (156 samples, 11.86%) org/mozilla/javas..
+
+
+_raw_spin_lock (2 samples, 0.15%)
+
+cpu_function_call (5 samples, 0.38%)
+
+fget_light (2 samples, 0.15%)
+
+start_kernel (24 samples, 1.83%) s..
+
+
+native_write_msr_safe (2 samples, 0.15%)
+
+org/mozilla/javascript/gen/file__root_vert_x_2_1_5_sys_mods_io_vertx_lang_js_1_1_0_vertx_http_js_2 (511 samples, 38.86%) org/mozilla/javascript/gen/file__root_vert_x_2_1_5_sys_mods_io..
+
+
+ipv4_mtu (1 samples, 0.08%)
+
+__schedule (11 samples, 0.84%)
+
+system_call_fastpath (88 samples, 6.69%) system_ca..
+
+
+io/netty/channel/nio/NioEventLoop:.select (7 samples, 0.53%)
+
+org/mozilla/javascript/IdScriptableObject:.get (3 samples, 0.23%)
+
+org/mozilla/javascript/TopLevel:.getBuiltinPrototype (7 samples, 0.53%)
+
+sun/nio/ch/IOUtil:.readIntoNativeBuffer (31 samples, 2.36%) s..
+
+
+itable stub (1 samples, 0.08%)
+
+io/netty/channel/AbstractChannelHandlerContext:.write (6 samples, 0.46%)
+
+timerqueue_del (1 samples, 0.08%)
+
+__tcp_v4_send_check (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptRuntime:.nameOrFunction (3 samples, 0.23%)
+
+io/netty/buffer/AbstractByteBuf:.writeBytes (4 samples, 0.30%)
+
+org/mozilla/javascript/WrapFactory:.wrapAsJavaObject (1 samples, 0.08%)
+
+io/netty/handler/codec/http/DefaultHttpMessage:.init (2 samples, 0.15%)
+
+_raw_spin_lock_irqsave (2 samples, 0.15%)
+
+org/mozilla/javascript/IdScriptableObject:.put (7 samples, 0.53%)
+
+io/netty/handler/codec/http/DefaultHttpHeaders:.add0 (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject:.getSlot (8 samples, 0.61%)
+
+java/util/ArrayList:.ensureCapacityInternal (1 samples, 0.08%)
+
+__wake_up_locked (25 samples, 1.90%) _..
+
+
+java/util/HashMap:.getNode (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptRuntime:.toObjectOrNull (1 samples, 0.08%)
+
+__tcp_push_pending_frames (1 samples, 0.08%)
+
+[unknown] (61 samples, 4.64%) [unkn..
+
+
+__slab_free (1 samples, 0.08%)
+
+org/mozilla/javascript/IdScriptableObject:.put (11 samples, 0.84%)
+
+sock_def_readable (5 samples, 0.38%)
+
+gmain (1 samples, 0.08%)
+
+_raw_spin_lock_irqsave (1 samples, 0.08%)
+
+__kmalloc_reserve.isra.26 (3 samples, 0.23%)
+
+org/mozilla/javascript/ScriptableObject:.putImpl (5 samples, 0.38%)
+
+org/mozilla/javascript/NativeCall:.init (20 samples, 1.52%)
+
+org/mozilla/javascript/WrapFactory:.wrap (1 samples, 0.08%)
+
+_raw_spin_lock_bh (1 samples, 0.08%)
+
+aeProcessEvents (3 samples, 0.23%)
+
+java/lang/String:.hashCode (1 samples, 0.08%)
+
+io/netty/channel/AbstractChannelHandlerContext:.executor (1 samples, 0.08%)
+
+fget_light (2 samples, 0.15%)
+
+io/netty/buffer/PooledByteBufAllocator:.newDirectBuffer (2 samples, 0.15%)
+
+menu_select (1 samples, 0.08%)
+
+generic_smp_call_function_single_interrupt (4 samples, 0.30%)
+
+org/mozilla/javascript/TopLevel:.getBuiltinPrototype (1 samples, 0.08%)
+
+org/mozilla/javascript/IdScriptableObject:.setAttributes (1 samples, 0.08%)
+
+schedule_hrtimeout_range_clock (20 samples, 1.52%)
+
+io/netty/buffer/UnreleasableByteBuf:.duplicate (1 samples, 0.08%)
+
+tick_program_event (2 samples, 0.15%)
+
+__netif_receive_skb_core (33 samples, 2.51%) __..
+
+
+java/util/HashMap:.getNode (1 samples, 0.08%)
+
+io/netty/buffer/AbstractByteBuf:.forEachByteAsc0 (2 samples, 0.15%)
+
+get_next_timer_interrupt (2 samples, 0.15%)
+
+vtable stub (1 samples, 0.08%)
+
+start_secondary (44 samples, 3.35%) sta..
+
+
+skb_release_all (3 samples, 0.23%)
+
+update_cfs_rq_blocked_load (1 samples, 0.08%)
+
+org/mozilla/javascript/IdScriptableObject:.get (1 samples, 0.08%)
+
+call_function_single_interrupt (4 samples, 0.30%)
+
+sun/nio/ch/SocketChannelImpl:.read (40 samples, 3.04%) sun..
+
+
+sys_epoll_wait (1 samples, 0.08%)
+
+tcp_check_space (1 samples, 0.08%)
+
+__wake_up_common (25 samples, 1.90%) _..
+
+
+native_sched_clock (1 samples, 0.08%)
+
+fget_light (3 samples, 0.23%)
+
+sys_inotify_add_watch (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject$Slot:.getValue (1 samples, 0.08%)
+
+_raw_spin_lock (1 samples, 0.08%)
+
+smp_call_function_single_interrupt (4 samples, 0.30%)
+
+__kmalloc_node_track_caller (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject$RelinkedSlot:.getValue (1 samples, 0.08%)
+
+tcp_send_mss (6 samples, 0.46%)
+
+sched_clock (1 samples, 0.08%)
+
+kmem_cache_alloc_node (4 samples, 0.30%)
+
+_raw_spin_lock_irqsave (1 samples, 0.08%)
+
+tick_sched_handle.isra.17 (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject:.getBase (1 samples, 0.08%)
+
+[unknown] (6 samples, 0.46%)
+
+io/netty/util/internal/AppendableCharSequence:.substring (2 samples, 0.15%)
+
+__inet_lookup_established (2 samples, 0.15%)
+
+apparmor_file_permission (1 samples, 0.08%)
+
+dst_release (1 samples, 0.08%)
+
+io/netty/handler/codec/http/HttpObjectEncoder:.encode (1 samples, 0.08%)
+
+open_exec (1 samples, 0.08%)
+
+tcp_transmit_skb (132 samples, 10.04%) tcp_transmit_skb
+
+
+ttwu_do_wakeup (5 samples, 0.38%)
+
+idle_cpu (1 samples, 0.08%)
+
+__lll_unlock_wake (1 samples, 0.08%)
+
+[unknown] (7 samples, 0.53%)
+
+security_file_permission (2 samples, 0.15%)
+
+[unknown] (1 samples, 0.08%)
+
+__switch_to (1 samples, 0.08%)
+
+io/netty/channel/DefaultChannelPromise:.trySuccess (3 samples, 0.23%)
+
+org/mozilla/javascript/IdScriptableObject:.has (7 samples, 0.53%)
+
+native_write_msr_safe (3 samples, 0.23%)
+
+io/netty/handler/codec/http/DefaultHttpHeaders:.add0 (2 samples, 0.15%)
+
+do_softirq (103 samples, 7.83%) do_softirq
+
+
+rw_verify_area (1 samples, 0.08%)
+
+tcp_poll (1 samples, 0.08%)
+
+tcp_rearm_rto (5 samples, 0.38%)
+
+io/netty/channel/AbstractChannelHandlerContext:.newPromise (1 samples, 0.08%)
+
+tick_nohz_idle_exit (5 samples, 0.38%)
+
+org/mozilla/javascript/BaseFunction:.execIdCall (60 samples, 4.56%) org/m..
+
+
+org/mozilla/javascript/ScriptableObject:.putImpl (1 samples, 0.08%)
+
+_copy_from_user (1 samples, 0.08%)
+
+__netif_receive_skb (34 samples, 2.59%) __..
+
+
+java/util/concurrent/ConcurrentHashMap:.get (3 samples, 0.23%)
+
+fput (1 samples, 0.08%)
+
+JavaThread::thread_main_inner (956 samples, 72.70%) JavaThread::thread_main_inner
+
+
+java/lang/String:.hashCode (1 samples, 0.08%)
+
+io/netty/util/Recycler:.get (2 samples, 0.15%)
+
+[unknown] (6 samples, 0.46%)
+
+__dev_queue_xmit (1 samples, 0.08%)
+
+common_file_perm (1 samples, 0.08%)
+
+org/mozilla/javascript/JavaMembers:.get (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptRuntime:.getPropFunctionAndThisHelper (1 samples, 0.08%)
+
+org/mozilla/javascript/IdScriptableObject:.findInstanceIdInfo (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject:.getSlot (6 samples, 0.46%)
+
+jiffies_to_timeval (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptRuntime:.setName (2 samples, 0.15%)
+
+PSRootsClosurefalse::do_oop (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject:.getSlot (1 samples, 0.08%)
+
+vtable stub (1 samples, 0.08%)
+
+skb_clone (4 samples, 0.30%)
+
+OldToYoungRootsTask::do_it (20 samples, 1.52%)
+
+io/netty/channel/ChannelDuplexHandler:.flush (237 samples, 18.02%) io/netty/channel/ChannelDupl..
+
+
+org/mozilla/javascript/ScriptableObject:.putImpl (1 samples, 0.08%)
+
+mutex_unlock (1 samples, 0.08%)
+
+hrtimer_force_reprogram (1 samples, 0.08%)
+
+stub_execve (1 samples, 0.08%)
+
+sock_poll (3 samples, 0.23%)
+
+org/mozilla/javascript/IdScriptableObject:.setAttributes (5 samples, 0.38%)
+
+_raw_spin_lock_bh (1 samples, 0.08%)
+
+native_write_msr_safe (3 samples, 0.23%)
+
+sched_clock_cpu (1 samples, 0.08%)
+
+io/netty/channel/DefaultChannelPipeline$HeadContext:.flush (232 samples, 17.64%) io/netty/channel/DefaultCha..
+
+
+org/mozilla/javascript/IdScriptableObject:.get (4 samples, 0.30%)
+
+rcu_idle_enter (1 samples, 0.08%)
+
+java (995 samples, 75.67%) java
+
+
+tcp_cleanup_rbuf (2 samples, 0.15%)
+
+org/mozilla/javascript/NativeJavaObject:.initMembers (4 samples, 0.30%)
+
+org/mozilla/javascript/NativeCall:.init (16 samples, 1.22%)
+
+http_parser_execute (2 samples, 0.15%)
+
+_raw_spin_unlock_irqrestore (1 samples, 0.08%)
+
+ThreadRootsTask::do_it (3 samples, 0.23%)
+
+mutex_lock (3 samples, 0.23%)
+
+cpu_startup_entry (23 samples, 1.75%)
+
+itable stub (1 samples, 0.08%)
+
+__srcu_read_lock (2 samples, 0.15%)
+
+org/mozilla/javascript/ScriptableObject:.getSlot (5 samples, 0.38%)
+
+org/vertx/java/core/impl/DefaultVertx:.setContext (1 samples, 0.08%)
+
+ip_rcv_finish (89 samples, 6.77%) ip_rcv_fi..
+
+
+response_complete (13 samples, 0.99%)
+
+io/netty/handler/codec/http/HttpObjectDecoder:.skipControlCharacters (2 samples, 0.15%)
+
+tcp_v4_rcv (27 samples, 2.05%) t..
+
+
+ktime_get_ts (2 samples, 0.15%)
+
+tick_nohz_restart (4 samples, 0.30%)
+
+io/netty/channel/ChannelOutboundHandlerAdapter:.flush (1 samples, 0.08%)
+
+sun/nio/ch/FileDispatcherImpl:.write0 (2 samples, 0.15%)
+
+GCTaskThread::run (28 samples, 2.13%) G..
+
+
+io/netty/handler/codec/http/HttpHeaders:.encode (1 samples, 0.08%)
+
+__kmalloc_node_track_caller (1 samples, 0.08%)
+
+org/mozilla/javascript/IdScriptableObject:.put (25 samples, 1.90%) o..
+
+
+org/mozilla/javascript/IdScriptableObject:.has (2 samples, 0.15%)
+
+atomic_notifier_call_chain (1 samples, 0.08%)
+
+remote_function (4 samples, 0.30%)
+
+org/mozilla/javascript/ScriptableObject:.getSlot (1 samples, 0.08%)
+
+common_file_perm (1 samples, 0.08%)
+
+sun/nio/ch/SocketChannelImpl:.isConnected (2 samples, 0.15%)
+
+org/mozilla/javascript/IdScriptableObject:.has (9 samples, 0.68%)
+
+tcp_init_tso_segs (1 samples, 0.08%)
+
+org/mozilla/javascript/BaseFunction:.findInstanceIdInfo (1 samples, 0.08%)
+
+tcp_v4_do_rcv (77 samples, 5.86%) tcp_v4_..
+
+
+__tcp_push_pending_frames (61 samples, 4.64%) __tcp..
+
+
+org/mozilla/javascript/IdScriptableObject:.findInstanceIdInfo (1 samples, 0.08%)
+
+native_read_tsc (1 samples, 0.08%)
+
+tcp_md5_do_lookup (1 samples, 0.08%)
+
+do_sync_write (186 samples, 14.14%) do_sync_write
+
+
+cpuidle_enter_state (4 samples, 0.30%)
+
+ep_poll_callback (1 samples, 0.08%)
+
+x86_pmu_enable (4 samples, 0.30%)
+
+copy_user_generic_string (3 samples, 0.23%)
+
+perf_pmu_enable (4 samples, 0.30%)
+
+vfs_read (25 samples, 1.90%) v..
+
+
+x86_64_start_reservations (24 samples, 1.83%) x..
+
+
+security_file_permission (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject:.addKnownAbsentSlot (1 samples, 0.08%)
+
+nr_iowait_cpu (1 samples, 0.08%)
+
+__hrtimer_start_range_ns (2 samples, 0.15%)
+
+system_call_after_swapgs (1 samples, 0.08%)
+
+release_sock (2 samples, 0.15%)
+
+org/mozilla/javascript/ScriptableObject:.getSlot (11 samples, 0.84%)
+
+_raw_spin_unlock_irqrestore (1 samples, 0.08%)
+
+itable stub (1 samples, 0.08%)
+
+call_stub (956 samples, 72.70%) call_stub
+
+
+dev_hard_start_xmit (3 samples, 0.23%)
+
+dev_queue_xmit (11 samples, 0.84%)
+
+task_nice (2 samples, 0.15%)
+
+ip_finish_output (119 samples, 9.05%) ip_finish_out..
+
+
+__remove_hrtimer (1 samples, 0.08%)
+
+sys_epoll_wait (4 samples, 0.30%)
+
+rcu_cpu_has_callbacks (1 samples, 0.08%)
+
+java/lang/ThreadLocal:.get (1 samples, 0.08%)
+
+rcu_idle_exit (1 samples, 0.08%)
+
+net_rx_action (97 samples, 7.38%) net_rx_act..
+
+
+lock_sock_nested (1 samples, 0.08%)
+
+mod_timer (2 samples, 0.15%)
+
+apparmor_file_free_security (1 samples, 0.08%)
+
+__remove_hrtimer (1 samples, 0.08%)
+
+tcp_established_options (4 samples, 0.30%)
+
+sk_reset_timer (5 samples, 0.38%)
+
+io/netty/channel/ChannelOutboundHandlerAdapter:.flush (235 samples, 17.87%) io/netty/channel/ChannelOut..
+
+
+org/mozilla/javascript/NativeFunction:.initScriptFunction (1 samples, 0.08%)
+
+menu_reflect (1 samples, 0.08%)
+
+__slab_alloc (3 samples, 0.23%)
+
+PSScavengeKlassClosure::do_klass (1 samples, 0.08%)
+
+__ip_local_out (1 samples, 0.08%)
+
+org/mozilla/javascript/TopLevel:.getBuiltinPrototype (5 samples, 0.38%)
+
+tcp_send_delayed_ack (3 samples, 0.23%)
+
+arch_local_irq_save (1 samples, 0.08%)
+
+__kmalloc_node_track_caller (1 samples, 0.08%)
+
+java/nio/channels/spi/AbstractInterruptibleChannel:.end (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject:.createSlot (15 samples, 1.14%)
+
+apparmor_file_permission (2 samples, 0.15%)
+
+mutex_lock (2 samples, 0.15%)
+
+sys_epoll_ctl (5 samples, 0.38%)
+
+hrtimer_interrupt (1 samples, 0.08%)
+
+ParallelTaskTerminator::offer_termination (2 samples, 0.15%)
+
+dequeue_entity (4 samples, 0.30%)
+
+io/netty/buffer/PooledByteBuf:.deallocate (5 samples, 0.38%)
+
+org/mozilla/javascript/IdScriptableObject:.findInstanceIdInfo (1 samples, 0.08%)
+
+wrk (240 samples, 18.25%) wrk
+
+
+perf_pmu_enable (4 samples, 0.30%)
+
+org/mozilla/javascript/IdScriptableObject:.get (2 samples, 0.15%)
+
+remote_function (4 samples, 0.30%)
+
+__GI___ioctl (5 samples, 0.38%)
+
+socket_readable (2 samples, 0.15%)
+
+epoll_ctl (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject:.putImpl (21 samples, 1.60%)
+
+tick_nohz_stop_sched_tick (4 samples, 0.30%)
+
+io/netty/channel/DefaultChannelPipeline$HeadContext:.write (6 samples, 0.46%)
+
+tcp_write_xmit (147 samples, 11.18%) tcp_write_xmit
+
+
+org/mozilla/javascript/ScriptRuntime:.getPropFunctionAndThisHelper (5 samples, 0.38%)
+
+lock_hrtimer_base.isra.19 (1 samples, 0.08%)
+
+inet_recvmsg (17 samples, 1.29%)
+
+native_write_msr_safe (4 samples, 0.30%)
+
+ip_local_out (46 samples, 3.50%) ip_..
+
+
+java/lang/String:.hashCode (1 samples, 0.08%)
+
+org/mozilla/javascript/IdScriptableObject:.has (1 samples, 0.08%)
+
+local_bh_enable (42 samples, 3.19%) loc..
+
+
+hrtimer_start_range_ns (3 samples, 0.23%)
+
+jlong_disjoint_arraycopy (1 samples, 0.08%)
+
+ep_send_events_proc (4 samples, 0.30%)
+
+org/mozilla/javascript/ScriptableObject:.getParentScope (3 samples, 0.23%)
+
+itable stub (1 samples, 0.08%)
+
+path_openat (1 samples, 0.08%)
+
+activate_task (7 samples, 0.53%)
+
+pick_next_task_fair (1 samples, 0.08%)
+
+security_file_permission (5 samples, 0.38%)
+
+io/netty/channel/ChannelOutboundBuffer:.decrementPendingOutboundBytes (1 samples, 0.08%)
+
+system_call_fastpath (56 samples, 4.26%) syste..
+
+
+org/mozilla/javascript/NativeFunction:.initScriptFunction (6 samples, 0.46%)
+
+ip_local_deliver_finish (30 samples, 2.28%) i..
+
+
+sock_read (2 samples, 0.15%)
+
+deactivate_task (7 samples, 0.53%)
+
+lock_sock_nested (1 samples, 0.08%)
+
+sock_put (1 samples, 0.08%)
+
+mod_timer (3 samples, 0.23%)
+
+aeProcessEvents (171 samples, 13.00%) aeProcessEvents
+
+
+io/netty/buffer/AbstractByteBuf:.ensureWritable (2 samples, 0.15%)
+
+tick_nohz_stop_sched_tick (5 samples, 0.38%)
+
+org/mozilla/javascript/NativeJavaMethod:.findCachedFunction (2 samples, 0.15%)
+
+org/mozilla/javascript/ScriptableObject:.getSlot (1 samples, 0.08%)
+
+io/netty/handler/codec/http/HttpMethod:.valueOf (2 samples, 0.15%)
+
+hrtimer_try_to_cancel (1 samples, 0.08%)
+
+system_call (1 samples, 0.08%)
+
+hrtimer_cancel (1 samples, 0.08%)
+
+system_call_fastpath (196 samples, 14.90%) system_call_fastpath
+
+
+io/netty/channel/AbstractChannelHandlerContext:.read (2 samples, 0.15%)
+
+[unknown] (10 samples, 0.76%)
+
+io/netty/handler/codec/MessageToMessageEncoder:.write (1 samples, 0.08%)
+
+org/mozilla/javascript/IdScriptableObject:.put (47 samples, 3.57%) org..
+
+
+jlong_disjoint_arraycopy (1 samples, 0.08%)
+
+[unknown] (1 samples, 0.08%)
+
+native_read_tsc (1 samples, 0.08%)
+
+io/netty/handler/codec/http/HttpObjectDecoder:.splitHeader (8 samples, 0.61%)
+
+intel_pmu_enable_all (4 samples, 0.30%)
+
+io/netty/handler/codec/http/DefaultHttpHeaders:.set (3 samples, 0.23%)
+
+read_tsc (1 samples, 0.08%)
+
+_raw_spin_lock (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptRuntime:.toObjectOrNull (1 samples, 0.08%)
+
+_raw_spin_lock_irqsave (1 samples, 0.08%)
+
+dequeue_task_fair (6 samples, 0.46%)
+
+org/mozilla/javascript/ScriptRuntime:.getPropFunctionAndThisHelper (1 samples, 0.08%)
+
+do_softirq (38 samples, 2.89%) do..
+
+
+response_complete (2 samples, 0.15%)
+
+get_next_timer_interrupt (3 samples, 0.23%)
+
+__perf_event_enable (4 samples, 0.30%)
+
+_raw_spin_lock_irqsave (1 samples, 0.08%)
+
+lapic_next_deadline (3 samples, 0.23%)
+
+org/mozilla/javascript/ScriptableObject:.createSlot (4 samples, 0.30%)
+
+fput (1 samples, 0.08%)
+
+tcp_rearm_rto (3 samples, 0.23%)
+
+org/mozilla/javascript/ScriptableObject:.getSlot (2 samples, 0.15%)
+
+group_sched_in (4 samples, 0.30%)
+
+__getnstimeofday (1 samples, 0.08%)
+
+java/util/Arrays:.copyOf (1 samples, 0.08%)
+
+local_bh_enable (104 samples, 7.91%) local_bh_en..
+
+
+tcp_event_new_data_sent (3 samples, 0.23%)
+
+read_tsc (2 samples, 0.15%)
+
+system_call_fastpath (6 samples, 0.46%)
+
+tcp_prequeue (1 samples, 0.08%)
+
+call_function_single_interrupt (4 samples, 0.30%)
+
+get_page_from_freelist (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject$Slot:.setAttributes (5 samples, 0.38%)
+
+io/netty/channel/AbstractChannelHandlerContext:.read (4 samples, 0.30%)
+
+org/vertx/java/core/http/impl/VertxHttpHandler:.write (34 samples, 2.59%) or..
+
+
+_raw_spin_lock_irqsave (1 samples, 0.08%)
+
+io/netty/handler/codec/http/HttpObjectDecoder:.splitInitialLine (5 samples, 0.38%)
+
+org/mozilla/javascript/ScriptableObject:.getParentScope (4 samples, 0.30%)
+
+org/mozilla/javascript/IdScriptableObject:.get (3 samples, 0.23%)
+
+org/mozilla/javascript/ScriptRuntime:.getObjectProp (1 samples, 0.08%)
+
+swapper (72 samples, 5.48%) swapper
+
+
+ktime_get (1 samples, 0.08%)
+
+_raw_spin_unlock_irqrestore (1 samples, 0.08%)
+
+java/lang/ThreadLocal:.get (1 samples, 0.08%)
+
+org/mozilla/javascript/gen/file__root_vert_x_2_1_5_sys_mods_io_vertx_lang_js_1_1_0_vertx_http_js_2 (416 samples, 31.63%) org/mozilla/javascript/gen/file__root_vert_x_2_1_5..
+
+
+java/lang/String:.hashCode (1 samples, 0.08%)
+
+__schedule (4 samples, 0.30%)
+
+bictcp_cong_avoid (3 samples, 0.23%)
+
+tcp_rcv_space_adjust (2 samples, 0.15%)
+
+JavaThread::run (956 samples, 72.70%) JavaThread::run
+
+
+apparmor_socket_sendmsg (1 samples, 0.08%)
+
+InstanceKlass::oop_push_contents (8 samples, 0.61%)
+
+sun/nio/ch/SocketChannelImpl:.isConnected (1 samples, 0.08%)
+
+__libc_start_main (6 samples, 0.46%)
+
+tcp_is_cwnd_limited (2 samples, 0.15%)
+
+sun/nio/ch/FileDispatcherImpl:.write0 (203 samples, 15.44%) sun/nio/ch/FileDispatch..
+
+
+internal_add_timer (2 samples, 0.15%)
+
+org/mozilla/javascript/ScriptableObject$Slot:.setAttributes (2 samples, 0.15%)
+
+[unknown] (30 samples, 2.28%) [..
+
+
+io/netty/buffer/AbstractByteBufAllocator:.heapBuffer (3 samples, 0.23%)
+
+__tcp_push_pending_frames (149 samples, 11.33%) __tcp_push_pendi..
+
+
+ClassLoaderDataGraph::oops_do (1 samples, 0.08%)
+
+tick_nohz_stop_idle (1 samples, 0.08%)
+
+io/netty/channel/AbstractChannelHandlerContext:.executor (1 samples, 0.08%)
+
+__skb_clone (1 samples, 0.08%)
+
+tcp_ack (20 samples, 1.52%)
+
+__inet_lookup_established (4 samples, 0.30%)
+
+org/mozilla/javascript/NativeJavaMethod:.findFunction (2 samples, 0.15%)
+
+org/mozilla/javascript/ScriptableObject:.createSlot (4 samples, 0.30%)
+
+enqueue_task (7 samples, 0.53%)
+
+sock_def_readable (2 samples, 0.15%)
+
+org/mozilla/javascript/ScriptableObject:.addKnownAbsentSlot (1 samples, 0.08%)
+
+tcp_data_queue (39 samples, 2.97%) tc..
+
+
+security_file_permission (1 samples, 0.08%)
+
+io/netty/channel/AbstractChannelHandlerContext:.executor (1 samples, 0.08%)
+
+sun/reflect/DelegatingMethodAccessorImpl:.invoke (66 samples, 5.02%) sun/re..
+
+
+__skb_clone (1 samples, 0.08%)
+
+org/vertx/java/platform/impl/RhinoContextFactory:.onContextCreated (1 samples, 0.08%)
+
+tcp_poll (1 samples, 0.08%)
+
+netif_skb_dev_features (1 samples, 0.08%)
+
+ep_scan_ready_list.isra.9 (4 samples, 0.30%)
+
+native_write_msr_safe (4 samples, 0.30%)
+
+copy_user_generic_string (1 samples, 0.08%)
+
+intel_pmu_enable_all (4 samples, 0.30%)
+
+__switch_to (1 samples, 0.08%)
+
+org/mozilla/javascript/IdScriptableObject:.has (4 samples, 0.30%)
+
+__hrtimer_start_range_ns (3 samples, 0.23%)
+
+__srcu_read_lock (2 samples, 0.15%)
+
+io/netty/channel/AbstractChannelHandlerContext:.validatePromise (2 samples, 0.15%)
+
+org/mozilla/javascript/ScriptableObject:.createSlot (11 samples, 0.84%)
+
+org/mozilla/javascript/ScriptableObject:.getSlot (8 samples, 0.61%)
+
+org/mozilla/javascript/NativeJavaMethod:.findCachedFunction (2 samples, 0.15%)
+
+sock_poll (1 samples, 0.08%)
+
+tick_program_event (3 samples, 0.23%)
+
+tcp_transmit_skb (55 samples, 4.18%) tcp_..
+
+
+org/mozilla/javascript/NativeFunction:.initScriptFunction (1 samples, 0.08%)
+
+org/mozilla/javascript/WrapFactory:.wrap (5 samples, 0.38%)
+
+java/lang/String:.getBytes (3 samples, 0.23%)
+
+org/mozilla/javascript/NativeJavaObject:.initMembers (4 samples, 0.30%)
+
+bictcp_cong_avoid (1 samples, 0.08%)
+
+ktime_get_real (3 samples, 0.23%)
+
+java/lang/ThreadLocal:.get (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject:.getSlot (21 samples, 1.60%)
+
+rcu_sysidle_force_exit (2 samples, 0.15%)
+
+org/mozilla/javascript/ScriptableObject$Slot:.getValue (2 samples, 0.15%)
+
+aa_file_perm (1 samples, 0.08%)
+
+tick_sched_timer (1 samples, 0.08%)
+
+sk_reset_timer (3 samples, 0.23%)
+
+org/mozilla/javascript/IdScriptableObject:.findInstanceIdInfo (1 samples, 0.08%)
+
+msecs_to_jiffies (1 samples, 0.08%)
+
+ipv4_dst_check (1 samples, 0.08%)
+
+tcp_write_xmit (60 samples, 4.56%) tcp_w..
+
+
+io/netty/util/Recycler:.recycle (1 samples, 0.08%)
+
+group_sched_in (4 samples, 0.30%)
+
+generic_exec_single (1 samples, 0.08%)
+
+menu_select (2 samples, 0.15%)
+
+org/mozilla/javascript/BaseFunction:.construct (1 samples, 0.08%)
+
+process_backlog (97 samples, 7.38%) process_ba..
+
+
+__pthread_disable_asynccancel (1 samples, 0.08%)
+
+io/netty/handler/codec/http/HttpObjectDecoder:.decode (57 samples, 4.33%) io/ne..
+
+
+schedule_preempt_disabled (4 samples, 0.30%)
+
+rcu_idle_exit (2 samples, 0.15%)
+
+tcp_send_mss (1 samples, 0.08%)
+
+[unknown] (26 samples, 1.98%) [..
+
+
+org/mozilla/javascript/ScriptRuntime:.nameOrFunction (1 samples, 0.08%)
+
+inet_sendmsg (78 samples, 5.93%) inet_se..
+
+
+__getnstimeofday (1 samples, 0.08%)
+
+kfree_skbmem (1 samples, 0.08%)
+
+smp_apic_timer_interrupt (1 samples, 0.08%)
+
+kmalloc_slab (2 samples, 0.15%)
+
+[unknown] (1 samples, 0.08%)
+
+io/netty/handler/codec/http/HttpObjectDecoder:.readHeaders (2 samples, 0.15%)
+
+ip_rcv_finish (32 samples, 2.43%) ip..
+
+
+io/netty/channel/DefaultChannelPipeline$HeadContext:.read (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject:.putImpl (8 samples, 0.61%)
+
+inet_ehashfn (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject:.getSlot (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject:.createSlot (33 samples, 2.51%) or..
+
+
+frame::oops_do_internal (1 samples, 0.08%)
+
+thread_entry (956 samples, 72.70%) thread_entry
+
+
+sun/nio/ch/SelectorImpl:.select (7 samples, 0.53%)
+
+_raw_spin_lock_irq (1 samples, 0.08%)
+
+ttwu_do_activate.constprop.74 (12 samples, 0.91%)
+
+skb_copy_datagram_iovec (1 samples, 0.08%)
+
+Interpreter (956 samples, 72.70%) Interpreter
+
+
+io/netty/handler/codec/http/HttpObjectDecoder:.readHeaders (22 samples, 1.67%)
+
+org/vertx/java/core/http/impl/DefaultHttpServer$ServerHandler:.doMessageReceived (540 samples, 41.06%) org/vertx/java/core/http/impl/DefaultHttpServer$ServerHandler:.doM..
+
+
+_raw_spin_unlock_irqrestore (1 samples, 0.08%)
+
+fget_light (1 samples, 0.08%)
+
+io/netty/handler/codec/http/DefaultHttpHeaders:.contains (1 samples, 0.08%)
+
+kfree_skbmem (1 samples, 0.08%)
+
+__alloc_pages_nodemask (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject:.addKnownAbsentSlot (1 samples, 0.08%)
+
+enqueue_task_fair (5 samples, 0.38%)
+
+perf_pmu_enable (4 samples, 0.30%)
+
+tcp_rcv_established (73 samples, 5.55%) tcp_rcv..
+
+
+org/mozilla/javascript/NativeJavaObject:.initMembers (1 samples, 0.08%)
+
+vfs_write (192 samples, 14.60%) vfs_write
+
+
+fdval (1 samples, 0.08%)
+
+ip_queue_xmit (122 samples, 9.28%) ip_queue_xmit
+
+
+sock_aio_write (82 samples, 6.24%) sock_aio..
+
+
+org/mozilla/javascript/gen/file__root_vert_x_2_1_5_sys_mods_io_vertx_lang_js_1_1_0_vertx_streams_j (1 samples, 0.08%)
+
+aeMain (236 samples, 17.95%) aeMain
+
+
+io/netty/channel/ChannelDuplexHandler:.read (3 samples, 0.23%)
+
+org/vertx/java/core/http/impl/AssembledFullHttpResponse:.toLastContent (2 samples, 0.15%)
+
+internal_add_timer (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject:.getSlot (1 samples, 0.08%)
+
+vtable stub (2 samples, 0.15%)
+
+org/mozilla/javascript/ScriptableObject:.getParentScope (1 samples, 0.08%)
+
+io/netty/buffer/PooledByteBufAllocator:.newDirectBuffer (2 samples, 0.15%)
+
+SpinPause (1 samples, 0.08%)
+
+org/mozilla/javascript/IdScriptableObject:.has (3 samples, 0.23%)
+
+java/nio/charset/CharsetEncoder:.replaceWith (2 samples, 0.15%)
+
+tcp_queue_rcv (2 samples, 0.15%)
+
+stats_record (3 samples, 0.23%)
+
+org/mozilla/javascript/WrapFactory:.wrap (5 samples, 0.38%)
+
+__wake_up_sync_key (27 samples, 2.05%) _..
+
+
+__acct_update_integrals (1 samples, 0.08%)
+
+fget_light (1 samples, 0.08%)
+
+local_bh_enable (1 samples, 0.08%)
+
+eth_type_trans (1 samples, 0.08%)
+
+org/vertx/java/core/net/impl/VertxHandler:.channelRead (555 samples, 42.21%) org/vertx/java/core/net/impl/VertxHandler:.channelRead
+
+
+org/mozilla/javascript/ScriptableObject:.getSlot (1 samples, 0.08%)
+
+sock_put (1 samples, 0.08%)
+
+__kfree_skb (3 samples, 0.23%)
+
+dequeue_task (7 samples, 0.53%)
+
+io/netty/channel/AbstractChannelHandlerContext:.executor (1 samples, 0.08%)
+
+ip_rcv_finish (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptRuntime:.getObjectProp (4 samples, 0.30%)
+
+__tick_nohz_idle_enter (4 samples, 0.30%)
+
+__tcp_ack_snd_check (3 samples, 0.23%)
+
+[unknown] (4 samples, 0.30%)
+
+org/mozilla/javascript/IdScriptableObject:.get (1 samples, 0.08%)
+
+org/mozilla/javascript/NativeFunction:.initScriptFunction (2 samples, 0.15%)
+
+int_sqrt (1 samples, 0.08%)
+
+nmethod::fix_oop_relocations (1 samples, 0.08%)
+
+tcp_sendmsg (1 samples, 0.08%)
+
+java/lang/ThreadLocal:.get (1 samples, 0.08%)
+
+java/lang/String:.hashCode (1 samples, 0.08%)
+
+org/mozilla/javascript/BaseFunction:.findPrototypeId (1 samples, 0.08%)
+
+native_write_msr_safe (3 samples, 0.23%)
+
+perf_pmu_enable (4 samples, 0.30%)
+
+org/mozilla/javascript/gen/file__root_vert_x_2_1_5_sys_mods_io_vertx_lang_js_1_1_0_vertx_http_js_2 (77 samples, 5.86%) org/moz..
+
+
+__netif_receive_skb_core (94 samples, 7.15%) __netif_r..
+
+
+java/lang/String:.hashCode (1 samples, 0.08%)
+
+hrtimer_start (2 samples, 0.15%)
+
+org/mozilla/javascript/ScriptRuntime:.setName (5 samples, 0.38%)
+
+__netif_receive_skb (94 samples, 7.15%) __netif_r..
+
+
+change_protection (1 samples, 0.08%)
+
+io/netty/channel/ChannelOutboundBuffer:.current (1 samples, 0.08%)
+
+io/netty/channel/AbstractChannelHandlerContext:.flush (233 samples, 17.72%) io/netty/channel/AbstractCh..
+
+
+do_softirq_own_stack (103 samples, 7.83%) do_softirq_..
+
+
+do_filp_open (1 samples, 0.08%)
+
+x86_pmu_commit_txn (4 samples, 0.30%)
+
+org/mozilla/javascript/ScriptableObject:.getSlot (1 samples, 0.08%)
+
+io/netty/util/Recycler:.get (1 samples, 0.08%)
+
+_raw_spin_lock (1 samples, 0.08%)
+
+sun/nio/ch/SocketChannelImpl:.isConnected (1 samples, 0.08%)
+
+change_protection_range (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject:.putImpl (12 samples, 0.91%)
+
+__libc_write (1 samples, 0.08%)
+
+org/mozilla/javascript/gen/file__root_vert_x_2_1_5_sys_mods_io_vertx_lang_js_1_1_0_vertx_http_js_2 (513 samples, 39.01%) org/mozilla/javascript/gen/file__root_vert_x_2_1_5_sys_mods_io_..
+
+
+raw_local_deliver (1 samples, 0.08%)
+
+apparmor_file_permission (1 samples, 0.08%)
+
+VMThread::loop (1 samples, 0.08%)
+
+_raw_spin_unlock_irqrestore (1 samples, 0.08%)
+
+io/netty/channel/AbstractChannelHandlerContext:.newPromise (1 samples, 0.08%)
+
+epoll_ctl (7 samples, 0.53%)
+
+io/netty/handler/codec/http/HttpVersion:.compareTo (1 samples, 0.08%)
+
+io/netty/channel/nio/NioEventLoop:.processSelectedKeys (949 samples, 72.17%) io/netty/channel/nio/NioEventLoop:.processSelectedKeys
+
+
+io/netty/handler/codec/http/DefaultHttpHeaders:.init (1 samples, 0.08%)
+
+java/lang/String:.hashCode (2 samples, 0.15%)
+
+org/mozilla/javascript/IdScriptableObject:.findInstanceIdInfo (1 samples, 0.08%)
+
+effective_load.isra.35 (2 samples, 0.15%)
+
+org/mozilla/javascript/ScriptableObject:.getSlot (2 samples, 0.15%)
+
+rcu_sysidle_exit (1 samples, 0.08%)
+
+native_load_tls (1 samples, 0.08%)
+
+org/mozilla/javascript/IdScriptableObject:.get (1 samples, 0.08%)
+
+org/mozilla/javascript/BaseFunction:.findPrototypeId (1 samples, 0.08%)
+
+org/mozilla/javascript/gen/file__root_vert_x_2_1_5_sys_mods_io_vertx_lang_js_1_1_0_vertx_streams_j (6 samples, 0.46%)
+
+system_call_fastpath (22 samples, 1.67%)
+
+org/mozilla/javascript/TopLevel:.getBuiltinPrototype (1 samples, 0.08%)
+
+tcp_current_mss (5 samples, 0.38%)
+
+io/netty/channel/ChannelOutboundBuffer:.incrementPendingOutboundBytes (1 samples, 0.08%)
+
+oopDesc* PSPromotionManager::copy_to_survivor_spacefalse (2 samples, 0.15%)
+
+org/mozilla/javascript/gen/file__root_vert_x_2_1_5_sys_mods_io_vertx_lang_js_1_1_0_vertx_http_js_2 (156 samples, 11.86%) org/mozilla/javas..
+
+
+StealTask::do_it (3 samples, 0.23%)
+
+Interpreter (956 samples, 72.70%) Interpreter
+
+
+PSPromotionManager::drain_stacks_depth (2 samples, 0.15%)
+
+sock_def_readable (32 samples, 2.43%) so..
+
+
+org/mozilla/javascript/IdScriptableObject:.findInstanceIdInfo (1 samples, 0.08%)
+
+perf (6 samples, 0.46%)
+
+__wake_up_common (27 samples, 2.05%) _..
+
+
+org/mozilla/javascript/IdScriptableObject:.has (1 samples, 0.08%)
+
+io/netty/handler/codec/http/HttpObjectDecoder$HeaderParser:.process (1 samples, 0.08%)
+
+common_file_perm (1 samples, 0.08%)
+
+io/netty/buffer/AbstractReferenceCountedByteBuf:.release (5 samples, 0.38%)
+
+hrtimer_force_reprogram (3 samples, 0.23%)
+
+org/vertx/java/core/impl/DefaultVertx:.setContext (1 samples, 0.08%)
+
+msecs_to_jiffies (1 samples, 0.08%)
+
+arch_cpu_idle (7 samples, 0.53%)
+
+[unknown] (91 samples, 6.92%) [unknown]
+
+
+tcp_cleanup_rbuf (1 samples, 0.08%)
+
+release_sock (1 samples, 0.08%)
+
+io/netty/channel/AbstractChannelHandlerContext:.flush (235 samples, 17.87%) io/netty/channel/AbstractCh..
+
+
+io/netty/channel/AbstractChannelHandlerContext:.fireChannelReadComplete (1 samples, 0.08%)
+
+fput (2 samples, 0.15%)
+
+bictcp_acked (1 samples, 0.08%)
+
+java/nio/DirectByteBuffer:.duplicate (1 samples, 0.08%)
+
+io/netty/buffer/AbstractByteBuf:.checkIndex (3 samples, 0.23%)
+
+java/util/HashMap:.getNode (2 samples, 0.15%)
+
+ttwu_stat (1 samples, 0.08%)
+
+io/netty/handler/codec/http/HttpHeaders:.hash (1 samples, 0.08%)
+
+org/vertx/java/core/net/impl/ConnectionBase:.write (38 samples, 2.89%) or..
+
+
+local_apic_timer_interrupt (1 samples, 0.08%)
+
+inet_ehashfn (1 samples, 0.08%)
+
+__srcu_read_unlock (1 samples, 0.08%)
+
+java/nio/channels/spi/AbstractInterruptibleChannel:.begin (1 samples, 0.08%)
+
+skb_clone (1 samples, 0.08%)
+
+io/netty/channel/AbstractChannelHandlerContext:.fireChannelRead (562 samples, 42.74%) io/netty/channel/AbstractChannelHandlerContext:.fireChannelRead
+
+
+ip_local_deliver (89 samples, 6.77%) ip_local_..
+
+
+org/mozilla/javascript/ScriptableObject:.createSlot (8 samples, 0.61%)
+
+itable stub (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject:.getSlot (1 samples, 0.08%)
+
+__do_softirq (36 samples, 2.74%) __..
+
+
+io/netty/handler/codec/http/HttpMethod:.valueOf (2 samples, 0.15%)
+
+clockevents_program_event (3 samples, 0.23%)
+
+tcp_set_skb_tso_segs (1 samples, 0.08%)
+
+io/netty/buffer/AbstractByteBuf:.checkSrcIndex (1 samples, 0.08%)
+
+io/netty/handler/codec/http/HttpVersion:.compareTo (2 samples, 0.15%)
+
+ttwu_do_activate.constprop.74 (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject$Slot:.setAttributes (6 samples, 0.46%)
+
+cpuidle_idle_call (21 samples, 1.60%)
+
+__hrtimer_start_range_ns (2 samples, 0.15%)
+
+io/netty/channel/ChannelOutboundHandlerAdapter:.read (2 samples, 0.15%)
+
+org/mozilla/javascript/ScriptRuntime:.bind (7 samples, 0.53%)
+
+x86_pmu_enable (4 samples, 0.30%)
+
+org/mozilla/javascript/ScriptableObject:.getSlot (1 samples, 0.08%)
+
+sun/nio/ch/EPollArrayWrapper:.poll (5 samples, 0.38%)
+
+org/mozilla/javascript/IdScriptableObject:.setAttributes (12 samples, 0.91%)
+
+sock_read (3 samples, 0.23%)
+
+HandleArea::oops_do (1 samples, 0.08%)
+
+tcp_v4_send_check (1 samples, 0.08%)
+
+tcp_wfree (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject$Slot:.getValue (1 samples, 0.08%)
+
+sun/nio/ch/FileDispatcherImpl:.read0 (1 samples, 0.08%)
+
+org/vertx/java/core/net/impl/VertxHandler:.channelReadComplete (240 samples, 18.25%) org/vertx/java/core/net/impl..
+
+
+rcu_bh_qs (1 samples, 0.08%)
+
+lock_timer_base.isra.35 (1 samples, 0.08%)
+
+io/netty/buffer/PooledUnsafeDirectByteBuf:.setBytes (42 samples, 3.19%) io/..
+
+
+sun/nio/cs/UTF_8$Encoder:.init (3 samples, 0.23%)
+
+io/netty/channel/ChannelDuplexHandler:.read (1 samples, 0.08%)
+
+java/lang/String:.hashCode (1 samples, 0.08%)
+
+account_entity_dequeue (1 samples, 0.08%)
+
+io/netty/channel/AbstractChannelHandlerContext:.executor (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject:.getSlot (17 samples, 1.29%)
+
+io/netty/handler/codec/http/HttpObjectEncoder:.encode (17 samples, 1.29%)
+
+org/mozilla/javascript/ScriptableObject:.addKnownAbsentSlot (2 samples, 0.15%)
+
+ksize (1 samples, 0.08%)
+
+[unknown] (4 samples, 0.30%)
+
+org/mozilla/javascript/ScriptRuntime:.toObjectOrNull (2 samples, 0.15%)
+
+fget_light (1 samples, 0.08%)
+
+sched_clock_idle_sleep_event (1 samples, 0.08%)
+
+sock_aio_write (185 samples, 14.07%) sock_aio_write
+
+
+org/mozilla/javascript/gen/file__root_vert_x_2_1_5_sys_mods_io_vertx_lang_js_1_1_0_vertx_streams_j (1 samples, 0.08%)
+
+smp_call_function_single (5 samples, 0.38%)
+
+org/mozilla/javascript/TopLevel:.getBuiltinPrototype (1 samples, 0.08%)
+
+ip_rcv (91 samples, 6.92%) ip_rcv
+
+
+tcp_sendmsg (176 samples, 13.38%) tcp_sendmsg
+
+
+release_sock (1 samples, 0.08%)
+
+ep_poll_callback (27 samples, 2.05%) e..
+
+
+update_min_vruntime (1 samples, 0.08%)
+
+java/lang/Integer:.toString (1 samples, 0.08%)
+
+itable stub (1 samples, 0.08%)
+
+do_softirq_own_stack (37 samples, 2.81%) do..
+
+
+io/netty/buffer/AbstractByteBufAllocator:.heapBuffer (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject:.getSlot (3 samples, 0.23%)
+
+org/mozilla/javascript/ScriptableObject:.addKnownAbsentSlot (1 samples, 0.08%)
+
+sched_clock_cpu (1 samples, 0.08%)
+
+io/netty/handler/codec/http/HttpHeaders:.encodeAscii0 (2 samples, 0.15%)
+
+org/mozilla/javascript/ScriptRuntime:.toObjectOrNull (1 samples, 0.08%)
+
+inet_sendmsg (1 samples, 0.08%)
+
+VMThread::run (1 samples, 0.08%)
+
+io/netty/handler/codec/http/DefaultHttpHeaders:.init (1 samples, 0.08%)
+
+java/util/HashMap:.getNode (2 samples, 0.15%)
+
+__run_hrtimer (1 samples, 0.08%)
+
+java/nio/channels/spi/AbstractInterruptibleChannel:.begin (1 samples, 0.08%)
+
+io/netty/handler/codec/http/HttpHeaders:.hash (1 samples, 0.08%)
+
+sun/nio/ch/EPollSelectorImpl:.updateSelectedKeys (1 samples, 0.08%)
+
+x86_pmu_enable (4 samples, 0.30%)
+
+thread_main (237 samples, 18.02%) thread_main
+
+
+enqueue_hrtimer (1 samples, 0.08%)
+
+ep_poll (4 samples, 0.30%)
+
+sock_aio_read (7 samples, 0.53%)
+
+io/netty/buffer/AbstractByteBuf:.checkSrcIndex (3 samples, 0.23%)
+
+sock_aio_read (22 samples, 1.67%)
+
+io/netty/handler/codec/http/HttpObjectDecoder$LineParser:.parse (6 samples, 0.46%)
+
+sys_epoll_ctl (5 samples, 0.38%)
+
+java/lang/String:.init (4 samples, 0.30%)
+
+rb_erase (1 samples, 0.08%)
+
+select_estimate_accuracy (5 samples, 0.38%)
+
+link_path_walk (1 samples, 0.08%)
+
+sock_aio_read.part.8 (22 samples, 1.67%)
+
+local_bh_enable_ip (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject:.putImpl (3 samples, 0.23%)
+
+__tcp_select_window (1 samples, 0.08%)
+
+fget_light (1 samples, 0.08%)
+
+io/netty/buffer/AbstractReferenceCountedByteBuf:.release (4 samples, 0.30%)
+
+acct_account_cputime (1 samples, 0.08%)
+
+org/mozilla/javascript/IdScriptableObject:.put (1 samples, 0.08%)
+
+__perf_event_enable (4 samples, 0.30%)
+
+ip_finish_output (46 samples, 3.50%) ip_..
+
+
+__tick_nohz_idle_enter (6 samples, 0.46%)
+
+__skb_clone (4 samples, 0.30%)
+
+org/mozilla/javascript/ScriptableObject:.getPrototype (1 samples, 0.08%)
+
+__switch_to (1 samples, 0.08%)
+
+io/netty/channel/AbstractChannelHandlerContext:.write (35 samples, 2.66%) io..
+
+
+_raw_spin_lock (1 samples, 0.08%)
+
+_raw_spin_unlock_irqrestore (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptRuntime:.setObjectProp (3 samples, 0.23%)
+
+org/mozilla/javascript/IdScriptableObject:.has (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject:.getSlot (2 samples, 0.15%)
+
+java/lang/String:.hashCode (1 samples, 0.08%)
+
+idle_cpu (2 samples, 0.15%)
+
+org/mozilla/javascript/IdScriptableObject:.get (1 samples, 0.08%)
+
+io/netty/util/Recycler:.get (1 samples, 0.08%)
+
+native_write_msr_safe (4 samples, 0.30%)
+
+org/mozilla/javascript/ScriptableObject:.getSlot (2 samples, 0.15%)
+
+ip_output (119 samples, 9.05%) ip_output
+
+
+io/netty/buffer/AbstractByteBuf:.forEachByteAsc0 (3 samples, 0.23%)
+
+skb_network_protocol (1 samples, 0.08%)
+
+enqueue_entity (5 samples, 0.38%)
+
+tcp_established_options (1 samples, 0.08%)
+
+update_process_times (1 samples, 0.08%)
+
+io/netty/channel/AbstractChannelHandlerContext:.read (3 samples, 0.23%)
+
+update_rq_clock.part.63 (1 samples, 0.08%)
+
+sun/nio/ch/EPollArrayWrapper:.epollWait (4 samples, 0.30%)
+
+sock_poll (2 samples, 0.15%)
+
+io/netty/channel/nio/NioEventLoop:.processSelectedKeysOptimized (949 samples, 72.17%) io/netty/channel/nio/NioEventLoop:.processSelectedKeysOptimized
+
+
+java_start (985 samples, 74.90%) java_start
+
+
+mprotect_fixup (1 samples, 0.08%)
+
+ep_scan_ready_list.isra.9 (20 samples, 1.52%)
+
+tcp_v4_do_rcv (23 samples, 1.75%)
+
+sk_stream_alloc_skb (7 samples, 0.53%)
+
+update_curr (2 samples, 0.15%)
+
+tcp_wfree (2 samples, 0.15%)
+
+user_path_at_empty (1 samples, 0.08%)
+
+io/netty/handler/codec/http/DefaultHttpHeaders:.init (1 samples, 0.08%)
+
+io/netty/buffer/AbstractByteBuf:.writeBytes (1 samples, 0.08%)
+
+sun/nio/ch/NativeThread:.current (1 samples, 0.08%)
+
+org/mozilla/javascript/IdScriptableObject:.get (1 samples, 0.08%)
+
+JavaThread::oops_do (3 samples, 0.23%)
+
+org/mozilla/javascript/ScriptableObject:.getBase (2 samples, 0.15%)
+
+ip_local_deliver (1 samples, 0.08%)
+
+org/vertx/java/core/http/impl/ServerConnection:.handleRequest (526 samples, 40.00%) org/vertx/java/core/http/impl/ServerConnection:.handleRequest
+
+
+__hrtimer_start_range_ns (3 samples, 0.23%)
+
+org/mozilla/javascript/NativeFunction:.initScriptFunction (10 samples, 0.76%)
+
+hrtimer_start (1 samples, 0.08%)
+
+intel_idle (11 samples, 0.84%)
+
+org/mozilla/javascript/IdScriptableObject:.has (3 samples, 0.23%)
+
+ktime_get (1 samples, 0.08%)
+
+update_cfs_rq_blocked_load (1 samples, 0.08%)
+
+org/mozilla/javascript/WrapFactory:.setJavaPrimitiveWrap (1 samples, 0.08%)
+
+sun/nio/ch/NativeThread:.current (1 samples, 0.08%)
+
+system_call_fastpath (28 samples, 2.13%) s..
+
+
+org/mozilla/javascript/ScriptableObject:.getSlot (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject:.getSlot (1 samples, 0.08%)
+
+sched_clock_cpu (1 samples, 0.08%)
+
+lapic_next_deadline (3 samples, 0.23%)
+
+io/netty/buffer/UnpooledHeapByteBuf:.init (1 samples, 0.08%)
+
+filename_lookup (1 samples, 0.08%)
+
+jni_fast_GetIntField (1 samples, 0.08%)
+
+org/mozilla/javascript/IdScriptableObject:.put (6 samples, 0.46%)
+
+x86_pmu_commit_txn (4 samples, 0.30%)
+
+__kfree_skb (1 samples, 0.08%)
+
+org/mozilla/javascript/NativeJavaMethod:.call (10 samples, 0.76%)
+
+process_backlog (34 samples, 2.59%) pr..
+
+
+all (1,315 samples, 100%)
+
+io/netty/handler/codec/http/HttpHeaders:.encodeAscii0 (2 samples, 0.15%)
+
+system_call_after_swapgs (6 samples, 0.46%)
+
+_raw_spin_unlock_bh (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject:.getSlot (1 samples, 0.08%)
+
+tcp_event_new_data_sent (6 samples, 0.46%)
+
+_raw_spin_unlock_bh (1 samples, 0.08%)
+
+tcp_schedule_loss_probe (3 samples, 0.23%)
+
+tcp_check_space (3 samples, 0.23%)
+
+dev_queue_xmit (4 samples, 0.30%)
+
+tick_nohz_restart (6 samples, 0.46%)
+
+__tcp_ack_snd_check (5 samples, 0.38%)
+
+user_path_at (1 samples, 0.08%)
+
+socket_readable (60 samples, 4.56%) socke..
+
+
+org/mozilla/javascript/ScriptableObject:.getSlot (4 samples, 0.30%)
+
+OopMapSet::all_do (1 samples, 0.08%)
+
+socket_writeable (1 samples, 0.08%)
+
+internal_add_timer (1 samples, 0.08%)
+
+select_task_rq_fair (4 samples, 0.30%)
+
+loopback_xmit (5 samples, 0.38%)
+
+sys_epoll_wait (56 samples, 4.26%) sys_e..
+
+
+org/mozilla/javascript/ScriptableObject:.getSlot (1 samples, 0.08%)
+
+clockevents_program_event (3 samples, 0.23%)
+
+io/netty/buffer/PooledByteBuf:.deallocate (2 samples, 0.15%)
+
+io/netty/util/Recycler:.get (1 samples, 0.08%)
+
+fsnotify (1 samples, 0.08%)
+
+org/mozilla/javascript/NativeJavaMethod:.call (74 samples, 5.63%) org/moz..
+
+
+org/mozilla/javascript/ScriptRuntime:.setObjectProp (37 samples, 2.81%) or..
+
+
+schedule_preempt_disabled (1 samples, 0.08%)
+
+io/netty/channel/AbstractChannelHandlerContext:.flush (238 samples, 18.10%) io/netty/channel/AbstractCha..
+
+
+tcp_queue_rcv (2 samples, 0.15%)
+
+org/mozilla/javascript/ScriptableObject:.createSlot (5 samples, 0.38%)
+
+tcp_recvmsg (7 samples, 0.53%)
+
+update_curr (1 samples, 0.08%)
+
+java/lang/String:.hashCode (1 samples, 0.08%)
+
+tcp_md5_do_lookup (1 samples, 0.08%)
+
+smp_call_function_single_interrupt (4 samples, 0.30%)
+
+netif_rx (2 samples, 0.15%)
+
+enqueue_to_backlog (1 samples, 0.08%)
+
+_raw_spin_unlock_bh (1 samples, 0.08%)
+
+perf_ioctl (5 samples, 0.38%)
+
+tick_program_event (3 samples, 0.23%)
+
+io/netty/handler/codec/ByteToMessageDecoder:.channelRead (635 samples, 48.29%) io/netty/handler/codec/ByteToMessageDecoder:.channelRead
+
+
+put_prev_task_fair (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject:.createSlot (15 samples, 1.14%)
+
+java/lang/String:.hashCode (1 samples, 0.08%)
+
+sys_mprotect (1 samples, 0.08%)
+
+Monitor::wait (1 samples, 0.08%)
+
+skb_push (1 samples, 0.08%)
+
+java/lang/ThreadLocal:.get (1 samples, 0.08%)
+
+vtable stub (1 samples, 0.08%)
+
+x86_64_start_kernel (24 samples, 1.83%) x..
+
+
+[unknown] (1 samples, 0.08%)
+
+kfree (1 samples, 0.08%)
+
+io/netty/channel/AbstractChannelHandlerContext:.fireChannelReadComplete (241 samples, 18.33%) io/netty/channel/AbstractCha..
+
+
+io/netty/buffer/AbstractByteBuf:.forEachByteAsc0 (3 samples, 0.23%)
+
+Java_sun_nio_ch_FileDispatcherImpl_write0 (1 samples, 0.08%)
+
+do_execve_common.isra.22 (1 samples, 0.08%)
+
+group_sched_in (4 samples, 0.30%)
+
+socket_writeable (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject$RelinkedSlot:.getValue (1 samples, 0.08%)
+
+java/lang/String:.hashCode (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject:.getTopLevelScope (1 samples, 0.08%)
+
+kmem_cache_alloc_node (2 samples, 0.15%)
+
+org/mozilla/javascript/IdScriptableObject:.has (12 samples, 0.91%)
+
+getnstimeofday (1 samples, 0.08%)
+
+java/util/Arrays:.copyOf (1 samples, 0.08%)
+
+arch_cpu_idle (22 samples, 1.67%)
+
+http_parser_execute (30 samples, 2.28%) h..
+
+
+new_slab (2 samples, 0.15%)
+
+io/netty/channel/ChannelDuplexHandler:.flush (1 samples, 0.08%)
+
+generic_smp_call_function_single_interrupt (4 samples, 0.30%)
+
+io/netty/handler/codec/http/DefaultHttpHeaders:.contains (1 samples, 0.08%)
+
+java/lang/ThreadLocal:.get (1 samples, 0.08%)
+
+security_socket_sendmsg (1 samples, 0.08%)
+
+update_cpu_load_nohz (1 samples, 0.08%)
+
+__perf_event_enable (4 samples, 0.30%)
+
+skb_clone (1 samples, 0.08%)
+
+start_thread (237 samples, 18.02%) start_thread
+
+
+mod_timer (3 samples, 0.23%)
+
+tcp_data_queue (9 samples, 0.68%)
+
+org/mozilla/javascript/ScriptableObject:.getSlot (1 samples, 0.08%)
+
+java/lang/String:.trim (1 samples, 0.08%)
+
+net_rx_action (35 samples, 2.66%) ne..
+
+
+inet_sendmsg (177 samples, 13.46%) inet_sendmsg
+
+
+getnstimeofday (3 samples, 0.23%)
+
+io/netty/buffer/AbstractByteBuf:.writeBytes (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject:.getSlot (3 samples, 0.23%)
+
+[unknown] (1 samples, 0.08%)
+
+hrtimer_try_to_cancel (4 samples, 0.30%)
+
+java/nio/charset/Charset:.lookup (2 samples, 0.15%)
+
+org/mozilla/javascript/NativeJavaObject:.initMembers (1 samples, 0.08%)
+
+start_thread (985 samples, 74.90%) start_thread
+
+
+x86_pmu_commit_txn (4 samples, 0.30%)
+
+org/mozilla/javascript/ScriptableObject:.getParentScope (1 samples, 0.08%)
+
+system_call_fastpath (5 samples, 0.38%)
+
+_raw_spin_lock (1 samples, 0.08%)
+
+menu_select (4 samples, 0.30%)
+
+io/netty/handler/codec/http/DefaultHttpHeaders:.add0 (3 samples, 0.23%)
+
+io/netty/buffer/PooledByteBuf:.deallocate (2 samples, 0.15%)
+
+org/mozilla/javascript/BaseFunction:.findInstanceIdInfo (4 samples, 0.30%)
+
+rest_init (24 samples, 1.83%) r..
+
+
+ksoftirqd/3 (1 samples, 0.08%)
+
+group_sched_in (4 samples, 0.30%)
+
+account_user_time (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptRuntime:.name (8 samples, 0.61%)
+
+perf_event_for_each_child (5 samples, 0.38%)
+
+io/netty/handler/codec/http/HttpObjectDecoder:.findWhitespace (1 samples, 0.08%)
+
+java/lang/String:.init (1 samples, 0.08%)
+
+set_next_entity (2 samples, 0.15%)
+
+ip_local_deliver_finish (89 samples, 6.77%) ip_local_..
+
+
+org/mozilla/javascript/NativeJavaMethod:.findCachedFunction (1 samples, 0.08%)
+
+org/mozilla/javascript/IdScriptableObject:.put (12 samples, 0.91%)
+
+hrtimer_start_range_ns (2 samples, 0.15%)
+
+__internal_add_timer (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptRuntime:.getPropFunctionAndThisHelper (9 samples, 0.68%)
+
+smp_call_function_single_interrupt (4 samples, 0.30%)
+
+_raw_spin_lock_bh (1 samples, 0.08%)
+
+__hrtimer_start_range_ns (1 samples, 0.08%)
+
+lock_sock_nested (1 samples, 0.08%)
+
+org/mozilla/javascript/IdScriptableObject$PrototypeValues:.ensureId (1 samples, 0.08%)
+
+sk_reset_timer (3 samples, 0.23%)
+
+org/mozilla/javascript/gen/file__root_vert_x_2_1_5_sys_mods_io_vertx_lang_js_1_1_0_vertx_http_js_2 (154 samples, 11.71%) org/mozilla/javas..
+
+
+io/netty/handler/codec/ByteToMessageDecoder:.channelRead (1 samples, 0.08%)
+
+security_socket_sendmsg (2 samples, 0.15%)
+
+io/netty/handler/codec/http/DefaultHttpHeaders:.add0 (1 samples, 0.08%)
+
+system_call_after_swapgs (1 samples, 0.08%)
+
+hrtimer_cancel (4 samples, 0.30%)
+
+ObjArrayKlass::oop_push_contents (2 samples, 0.15%)
+
+org/mozilla/javascript/IdScriptableObject:.findInstanceIdInfo (1 samples, 0.08%)
+
+org/mozilla/javascript/IdScriptableObject:.has (1 samples, 0.08%)
+
+schedule_hrtimeout_range (20 samples, 1.52%)
+
+org/mozilla/javascript/ScriptableObject:.putImpl (24 samples, 1.83%) o..
+
+
+__fsnotify_parent (1 samples, 0.08%)
+
+vtable stub (1 samples, 0.08%)
+
+__dev_queue_xmit (10 samples, 0.76%)
+
+sys_write (88 samples, 6.69%) sys_write
+
+
+detach_if_pending (1 samples, 0.08%)
+
+socket_writeable (99 samples, 7.53%) socket_wri..
+
+
+org/mozilla/javascript/IdScriptableObject:.findInstanceIdInfo (2 samples, 0.15%)
+
+epoll_ctl (6 samples, 0.46%)
+
+org/vertx/java/core/http/impl/AssembledFullHttpResponse:.toLastContent (1 samples, 0.08%)
+
+org/mozilla/javascript/NativeJavaObject:.get (1 samples, 0.08%)
+
+lock_hrtimer_base.isra.19 (1 samples, 0.08%)
+
+intel_idle (3 samples, 0.23%)
+
+ip_local_deliver (31 samples, 2.36%) i..
+
+
+org/mozilla/javascript/IdScriptableObject:.put (23 samples, 1.75%)
+
+io/netty/handler/codec/ByteToMessageDecoder:.channelReadComplete (242 samples, 18.40%) io/netty/handler/codec/ByteT..
+
+
+tcp_event_data_recv (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptableObject:.getTopScopeValue (1 samples, 0.08%)
+
+tcp_rearm_rto (3 samples, 0.23%)
+
+org/mozilla/javascript/NativeCall:.init (48 samples, 3.65%) org/..
+
+
+tick_nohz_idle_enter (5 samples, 0.38%)
+
+system_call_fastpath (4 samples, 0.30%)
+
+system_call (1 samples, 0.08%)
+
+tick_nohz_idle_enter (6 samples, 0.46%)
+
+tick_program_event (1 samples, 0.08%)
+
+org/mozilla/javascript/ScriptRuntime:.getPropFunctionAndThisHelper (1 samples, 0.08%)
+
+remote_function (4 samples, 0.30%)
+
+tcp_clean_rtx_queue (1 samples, 0.08%)
+
+tick_nohz_idle_exit (7 samples, 0.53%)
+
+org/mozilla/javascript/IdScriptableObject:.put (9 samples, 0.68%)
+
+fsnotify (1 samples, 0.08%)
+
+pick_next_task_fair (2 samples, 0.15%)
+
+do_sync_write (82 samples, 6.24%) do_sync_..
+
+
+sys_write (195 samples, 14.83%) sys_write
+
+
+common_file_perm (1 samples, 0.08%)
+
+account_process_tick (1 samples, 0.08%)
+
diff --git a/tests/benchmarks/_script/flamegraph/files.pl b/tests/benchmarks/_script/flamegraph/files.pl
new file mode 100755
index 00000000000..50426b2e47c
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/files.pl
@@ -0,0 +1,62 @@
+#!/usr/bin/perl -w
+#
+# files.pl Print file sizes in folded format, for a flame graph.
+#
+# This helps you understand storage consumed by a file system, by creating
+# a flame graph visualization of space consumed. This is basically a Perl
+# version of the "find" command, which emits in folded format for piping
+# into flamegraph.pl.
+#
+# Copyright (c) 2017 Brendan Gregg.
+# Licensed under the Apache License, Version 2.0 (the "License")
+#
+# 03-Feb-2017 Brendan Gregg Created this.
+
+use strict;
+use File::Find;
+
+sub usage {
+ print STDERR "USAGE: $0 [--xdev] [DIRECTORY]...\n";
+ print STDERR " eg, $0 /Users\n";
+ print STDERR " To not descend directories on other filesystems:";
+ print STDERR " eg, $0 --xdev /\n";
+ print STDERR "Intended to be piped to flamegraph.pl. Full example:\n";
+ print STDERR " $0 /Users | flamegraph.pl " .
+ "--hash --countname=bytes > files.svg\n";
+ print STDERR " $0 /usr /home /root /etc | flamegraph.pl " .
+ "--hash --countname=bytes > files.svg\n";
+ print STDERR " $0 --xdev / | flamegraph.pl " .
+ "--hash --countname=bytes > files.svg\n";
+ exit 1;
+}
+
+usage() if @ARGV == 0 or $ARGV[0] eq "--help" or $ARGV[0] eq "-h";
+
+my $filter_xdev = 0;
+my $xdev_id;
+
+foreach my $dir (@ARGV) {
+ if ($dir eq "--xdev") {
+ $filter_xdev = 1;
+ } else {
+ find(\&wanted, $dir);
+ }
+}
+
+sub wanted {
+ my ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size) = lstat($_);
+ return unless defined $size;
+ if ($filter_xdev) {
+ if (!$xdev_id) {
+ $xdev_id = $dev;
+ } elsif ($xdev_id ne $dev) {
+ $File::Find::prune = 1;
+ return;
+ }
+ }
+ my $path = $File::Find::name;
+ $path =~ tr/\//;/; # delimiter
+ $path =~ tr/;.a-zA-Z0-9-/_/c; # ditch whitespace and other chars
+ $path =~ s/^;//;
+ print "$path $size\n";
+}
diff --git a/tests/benchmarks/_script/flamegraph/flamegraph.pl b/tests/benchmarks/_script/flamegraph/flamegraph.pl
new file mode 100755
index 00000000000..4536d98bafc
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/flamegraph.pl
@@ -0,0 +1,1318 @@
+#!/usr/bin/perl -w
+#
+# flamegraph.pl flame stack grapher.
+#
+# This takes stack samples and renders a call graph, allowing hot functions
+# and codepaths to be quickly identified. Stack samples can be generated using
+# tools such as DTrace, perf, SystemTap, and Instruments.
+#
+# USAGE: ./flamegraph.pl [options] input.txt > graph.svg
+#
+# grep funcA input.txt | ./flamegraph.pl [options] > graph.svg
+#
+# Then open the resulting .svg in a web browser, for interactivity: mouse-over
+# frames for info, click to zoom, and ctrl-F to search.
+#
+# Options are listed in the usage message (--help).
+#
+# The input is stack frames and sample counts formatted as single lines. Each
+# frame in the stack is semicolon separated, with a space and count at the end
+# of the line. These can be generated for Linux perf script output using
+# stackcollapse-perf.pl, for DTrace using stackcollapse.pl, and for other tools
+# using the other stackcollapse programs. Example input:
+#
+# swapper;start_kernel;rest_init;cpu_idle;default_idle;native_safe_halt 1
+#
+# An optional extra column of counts can be provided to generate a differential
+# flame graph of the counts, colored red for more, and blue for less. This
+# can be useful when using flame graphs for non-regression testing.
+# See the header comment in the difffolded.pl program for instructions.
+#
+# The input functions can optionally have annotations at the end of each
+# function name, following a precedent by some tools (Linux perf's _[k]):
+# _[k] for kernel
+# _[i] for inlined
+# _[j] for jit
+# _[w] for waker
+# Some of the stackcollapse programs support adding these annotations, eg,
+# stackcollapse-perf.pl --kernel --jit. They are used merely for colors by
+# some palettes, eg, flamegraph.pl --color=java.
+#
+# The output flame graph shows relative presence of functions in stack samples.
+# The ordering on the x-axis has no meaning; since the data is samples, time
+# order of events is not known. The order used sorts function names
+# alphabetically.
+#
+# While intended to process stack samples, this can also process stack traces.
+# For example, tracing stacks for memory allocation, or resource usage. You
+# can use --title to set the title to reflect the content, and --countname
+# to change "samples" to "bytes" etc.
+#
+# There are a few different palettes, selectable using --color. By default,
+# the colors are selected at random (except for differentials). Functions
+# called "-" will be printed gray, which can be used for stack separators (eg,
+# between user and kernel stacks).
+#
+# HISTORY
+#
+# This was inspired by Neelakanth Nadgir's excellent function_call_graph.rb
+# program, which visualized function entry and return trace events. As Neel
+# wrote: "The output displayed is inspired by Roch's CallStackAnalyzer which
+# was in turn inspired by the work on vftrace by Jan Boerhout". See:
+# https://blogs.oracle.com/realneel/entry/visualizing_callstacks_via_dtrace_and
+#
+# Copyright 2016 Netflix, Inc.
+# Copyright 2011 Joyent, Inc. All rights reserved.
+# Copyright 2011 Brendan Gregg. All rights reserved.
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at docs/cddl1.txt or
+# http://opensource.org/licenses/CDDL-1.0.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at docs/cddl1.txt.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+# 11-Oct-2014 Adrien Mahieux Added zoom.
+# 21-Nov-2013 Shawn Sterling Added consistent palette file option
+# 17-Mar-2013 Tim Bunce Added options and more tunables.
+# 15-Dec-2011 Dave Pacheco Support for frames with whitespace.
+# 10-Sep-2011 Brendan Gregg Created this.
+
+use strict;
+
+use Getopt::Long;
+
+use open qw(:std :utf8);
+
+# tunables
+my $encoding;
+my $fonttype = "Verdana";
+my $imagewidth = 1200; # max width, pixels
+my $frameheight = 16; # max height is dynamic
+my $fontsize = 12; # base text size
+my $fontwidth = 0.59; # avg width relative to fontsize
+my $minwidth = 0.1; # min function width, pixels or percentage of time
+my $nametype = "Function:"; # what are the names in the data?
+my $countname = "samples"; # what are the counts in the data?
+my $colors = "hot"; # color theme
+my $bgcolors = ""; # background color theme
+my $nameattrfile; # file holding function attributes
+my $timemax; # (override the) sum of the counts
+my $factor = 1; # factor to scale counts by
+my $hash = 0; # color by function name
+my $rand = 0; # color randomly
+my $palette = 0; # if we use consistent palettes (default off)
+my %palette_map; # palette map hash
+my $pal_file = "palette.map"; # palette map file name
+my $stackreverse = 0; # reverse stack order, switching merge end
+my $inverted = 0; # icicle graph
+my $flamechart = 0; # produce a flame chart (sort by time, do not merge stacks)
+my $negate = 0; # switch differential hues
+my $titletext = "\000"; # centered heading
+my $titledefault = "Flame Graph"; # overwritten by --title
+my $titleinverted = "Icicle Graph"; # " "
+my $searchcolor = "rgb(230,0,230)"; # color for search highlighting
+my $notestext = ""; # embedded notes in SVG
+my $subtitletext = ""; # second level title (optional)
+my $help = 0;
+
+sub usage {
+ die < outfile.svg\n
+ --title TEXT # change title text
+ --subtitle TEXT # second level title (optional)
+ --width NUM # width of image (default 1200)
+ --height NUM # height of each frame (default 16)
+ --minwidth NUM # omit smaller functions. In pixels or use "%" for
+ # percentage of time (default 0.1 pixels)
+ --fonttype FONT # font type (default "Verdana")
+ --fontsize NUM # font size (default 12)
+ --countname TEXT # count type label (default "samples")
+ --nametype TEXT # name type label (default "Function:")
+ --colors PALETTE # set color palette. choices are: hot (default), mem,
+ # io, wakeup, chain, java, js, perl, red, green, blue,
+ # aqua, yellow, purple, orange
+ --bgcolors COLOR # set background colors. gradient choices are yellow
+ # (default), blue, green, grey; flat colors use "#rrggbb";
+ # or none to omit a background
+ --hash # colors are keyed by function name hash
+ --random # colors are randomly generated
+ --cp # use consistent palette (palette.map)
+ --reverse # generate stack-reversed flame graph
+ --inverted # icicle graph
+ --flamechart # produce a flame chart (sort by time, do not merge stacks)
+ --negate # switch differential hues (blue<->red)
+ --notes TEXT # add notes comment in SVG (for debugging)
+ --help # this message
+
+ eg,
+ $0 --title="Flame Graph: malloc()" trace.txt > graph.svg
+USAGE_END
+}
+
+GetOptions(
+ 'fonttype=s' => \$fonttype,
+ 'width=i' => \$imagewidth,
+ 'height=i' => \$frameheight,
+ 'encoding=s' => \$encoding,
+ 'fontsize=f' => \$fontsize,
+ 'fontwidth=f' => \$fontwidth,
+ 'minwidth=s' => \$minwidth,
+ 'title=s' => \$titletext,
+ 'subtitle=s' => \$subtitletext,
+ 'nametype=s' => \$nametype,
+ 'countname=s' => \$countname,
+ 'nameattr=s' => \$nameattrfile,
+ 'total=s' => \$timemax,
+ 'factor=f' => \$factor,
+ 'colors=s' => \$colors,
+ 'bgcolors=s' => \$bgcolors,
+ 'hash' => \$hash,
+ 'random' => \$rand,
+ 'cp' => \$palette,
+ 'reverse' => \$stackreverse,
+ 'inverted' => \$inverted,
+ 'flamechart' => \$flamechart,
+ 'negate' => \$negate,
+ 'notes=s' => \$notestext,
+ 'help' => \$help,
+) or usage();
+$help && usage();
+
+# internals
+my $ypad1 = $fontsize * 3; # pad top, include title
+my $ypad2 = $fontsize * 2 + 10; # pad bottom, include labels
+my $ypad3 = $fontsize * 2; # pad top, include subtitle (optional)
+my $xpad = 10; # pad lefm and right
+my $framepad = 1; # vertical padding for frames
+my $depthmax = 0;
+my %Events;
+my %nameattr;
+
+if ($flamechart && $titletext eq "\000") {
+ $titletext = "Flame Chart";
+}
+
+if ($titletext eq "\000") {
+ unless ($inverted) {
+ $titletext = $titledefault;
+ } else {
+ $titletext = $titleinverted;
+ }
+}
+
+if ($nameattrfile) {
+ # The name-attribute file format is a function name followed by a tab then
+ # a sequence of tab separated name=value pairs.
+ open my $attrfh, $nameattrfile or die "Can't read $nameattrfile: $!\n";
+ while (<$attrfh>) {
+ chomp;
+ my ($funcname, $attrstr) = split /\t/, $_, 2;
+ die "Invalid format in $nameattrfile" unless defined $attrstr;
+ $nameattr{$funcname} = { map { split /=/, $_, 2 } split /\t/, $attrstr };
+ }
+}
+
+if ($notestext =~ /[<>]/) {
+ die "Notes string can't contain < or >"
+}
+
+# Ensure minwidth is a valid floating-point number,
+# print usage string if not
+my $minwidth_f;
+if ($minwidth =~ /^([0-9.]+)%?$/) {
+ $minwidth_f = $1;
+} else {
+ warn "Value '$minwidth' is invalid for minwidth, expected a float.\n";
+ usage();
+}
+
+# background colors:
+# - yellow gradient: default (hot, java, js, perl)
+# - green gradient: mem
+# - blue gradient: io, wakeup, chain
+# - gray gradient: flat colors (red, green, blue, ...)
+if ($bgcolors eq "") {
+ # choose a default
+ if ($colors eq "mem") {
+ $bgcolors = "green";
+ } elsif ($colors =~ /^(io|wakeup|chain)$/) {
+ $bgcolors = "blue";
+ } elsif ($colors =~ /^(red|green|blue|aqua|yellow|purple|orange)$/) {
+ $bgcolors = "grey";
+ } else {
+ $bgcolors = "yellow";
+ }
+}
+my ($bgcolor1, $bgcolor2);
+if ($bgcolors eq "yellow") {
+ $bgcolor1 = "#eeeeee"; # background color gradient start
+ $bgcolor2 = "#eeeeb0"; # background color gradient stop
+} elsif ($bgcolors eq "blue") {
+ $bgcolor1 = "#eeeeee"; $bgcolor2 = "#e0e0ff";
+} elsif ($bgcolors eq "green") {
+ $bgcolor1 = "#eef2ee"; $bgcolor2 = "#e0ffe0";
+} elsif ($bgcolors eq "grey") {
+ $bgcolor1 = "#f8f8f8"; $bgcolor2 = "#e8e8e8";
+} elsif ($bgcolors =~ /^#......$/) {
+ $bgcolor1 = $bgcolor2 = $bgcolors;
+} elsif ($bgcolors ne 'none') {
+ die "Unrecognized bgcolor option \"$bgcolors\""
+}
+
+# SVG functions
+{ package SVG;
+ sub new {
+ my $class = shift;
+ my $self = {};
+ bless ($self, $class);
+ return $self;
+ }
+
+ sub header {
+ my ($self, $w, $h) = @_;
+ my $enc_attr = '';
+ if (defined $encoding) {
+ $enc_attr = qq{ encoding="$encoding"};
+ }
+ $self->{svg} .= <
+
+
+
+
+SVG
+ }
+
+ sub include {
+ my ($self, $content) = @_;
+ $self->{svg} .= $content;
+ }
+
+ sub colorAllocate {
+ my ($self, $r, $g, $b) = @_;
+ return "rgb($r,$g,$b)";
+ }
+
+ sub group_start {
+ my ($self, $attr) = @_;
+
+ my @g_attr = map {
+ exists $attr->{$_} ? sprintf(qq/$_="%s"/, $attr->{$_}) : ()
+ } qw(id class);
+ push @g_attr, $attr->{g_extra} if $attr->{g_extra};
+ if ($attr->{href}) {
+ my @a_attr;
+ push @a_attr, sprintf qq/xlink:href="%s"/, $attr->{href} if $attr->{href};
+ # default target=_top else links will open within SVG
+ push @a_attr, sprintf qq/target="%s"/, $attr->{target} || "_top";
+ push @a_attr, $attr->{a_extra} if $attr->{a_extra};
+ $self->{svg} .= sprintf qq/\n/, join(' ', (@a_attr, @g_attr));
+ } else {
+ $self->{svg} .= sprintf qq/\n/, join(' ', @g_attr);
+ }
+
+ $self->{svg} .= sprintf qq/%s<\/title>/, $attr->{title}
+ if $attr->{title}; # should be first element within g container
+ }
+
+ sub group_end {
+ my ($self, $attr) = @_;
+ $self->{svg} .= $attr->{href} ? qq/<\/a>\n/ : qq/<\/g>\n/;
+ }
+
+ sub filledRectangle {
+ my ($self, $x1, $y1, $x2, $y2, $fill, $extra) = @_;
+ $x1 = sprintf "%0.1f", $x1;
+ $x2 = sprintf "%0.1f", $x2;
+ my $w = sprintf "%0.1f", $x2 - $x1;
+ my $h = sprintf "%0.1f", $y2 - $y1;
+ $extra = defined $extra ? $extra : "";
+ $self->{svg} .= qq/<rect x="$x1" y="$y1" width="$w" height="$h" fill="$fill" $extra \/>\n/;
+ }
+
+ sub stringTTF {
+ my ($self, $id, $x, $y, $str, $extra) = @_;
+ $x = sprintf "%0.2f", $x;
+ $id = defined $id ? qq/id="$id"/ : "";
+ $extra ||= "";
+ $self->{svg} .= qq/<text $id x="$x" y="$y" $extra>$str<\/text>\n/;
+ }
+
+ sub svg {
+ my $self = shift;
+ return "$self->{svg}</svg>\n";
+ }
+ 1;
+}
+
+sub namehash {
+ # Generate a vector hash for the name string, weighting early over
+ # later characters. We want to pick the same colors for function
+ # names across different flame graphs.
+ my $name = shift;
+ my $vector = 0;
+ my $weight = 1;
+ my $max = 1;
+ my $mod = 10;
+ # if module name present, trunc to 1st char
+ $name =~ s/.(.*?)`//;
+ foreach my $c (split //, $name) {
+ my $i = (ord $c) % $mod;
+ $vector += ($i / ($mod++ - 1)) * $weight;
+ $max += 1 * $weight;
+ $weight *= 0.70;
+ last if $mod > 12;
+ }
+ return (1 - $vector / $max)
+}
+
+sub sum_namehash {
+ my $name = shift;
+ return unpack("%32W*", $name);
+}
+
+sub random_namehash {
+ # Generate a random hash for the name string.
+ # This ensures that functions with the same name have the same color,
+ # both within a flamegraph and across multiple flamegraphs without
+ # needing to set a palette and while preserving the original flamegraph
+ # optic, unlike what happens with --hash.
+ my $name = shift;
+ my $hash = sum_namehash($name);
+ srand($hash);
+ return rand(1)
+}
+
+sub color {
+ my ($type, $hash, $name) = @_;
+ my ($v1, $v2, $v3);
+
+ if ($hash) {
+ $v1 = namehash($name);
+ $v2 = $v3 = namehash(scalar reverse $name);
+ } elsif ($rand) {
+ $v1 = rand(1);
+ $v2 = rand(1);
+ $v3 = rand(1);
+ } else {
+ $v1 = random_namehash($name);
+ $v2 = random_namehash($name);
+ $v3 = random_namehash($name);
+ }
+
+ # theme palettes
+ if (defined $type and $type eq "hot") {
+ my $r = 205 + int(50 * $v3);
+ my $g = 0 + int(230 * $v1);
+ my $b = 0 + int(55 * $v2);
+ return "rgb($r,$g,$b)";
+ }
+ if (defined $type and $type eq "mem") {
+ my $r = 0;
+ my $g = 190 + int(50 * $v2);
+ my $b = 0 + int(210 * $v1);
+ return "rgb($r,$g,$b)";
+ }
+ if (defined $type and $type eq "io") {
+ my $r = 80 + int(60 * $v1);
+ my $g = $r;
+ my $b = 190 + int(55 * $v2);
+ return "rgb($r,$g,$b)";
+ }
+ if (defined $type and $type eq "libgit2") {
+ my $alpha = sprintf("%.2f", 0.2 + (0.8 * (($v1 + $v2) / 2)));
+ return ($v3 > 0.5) ?
+ "rgba(241,80,47,$alpha)" :
+ "rgba(55,125,205,$alpha)";
+ }
+
+ # multi palettes
+ if (defined $type and $type eq "java") {
+ # Handle both annotations (_[j], _[i], ...; which are
+ # accurate), as well as input that lacks any annotations, as
+ # best as possible. Without annotations, we get a little hacky
+ # and match on java|org|com, etc.
+ if ($name =~ m:_\[j\]$:) { # jit annotation
+ $type = "green";
+ } elsif ($name =~ m:_\[i\]$:) { # inline annotation
+ $type = "aqua";
+ } elsif ($name =~ m:^L?(java|javax|jdk|net|org|com|io|sun)/:) { # Java
+ $type = "green";
+ } elsif ($name =~ /:::/) { # Java, typical perf-map-agent method separator
+ $type = "green";
+ } elsif ($name =~ /::/) { # C++
+ $type = "yellow";
+ } elsif ($name =~ m:_\[k\]$:) { # kernel annotation
+ $type = "orange";
+ } elsif ($name =~ /::/) { # C++
+ $type = "yellow";
+ } else { # system
+ $type = "red";
+ }
+ # fall-through to color palettes
+ }
+ if (defined $type and $type eq "perl") {
+ if ($name =~ /::/) { # C++
+ $type = "yellow";
+ } elsif ($name =~ m:Perl: or $name =~ m:\.pl:) { # Perl
+ $type = "green";
+ } elsif ($name =~ m:_\[k\]$:) { # kernel
+ $type = "orange";
+ } else { # system
+ $type = "red";
+ }
+ # fall-through to color palettes
+ }
+ if (defined $type and $type eq "js") {
+ # Handle both annotations (_[j], _[i], ...; which are
+ # accurate), as well as input that lacks any annotations, as
+ # best as possible. Without annotations, we get a little hacky,
+ # and match on a "/" with a ".js", etc.
+ if ($name =~ m:_\[j\]$:) { # jit annotation
+ if ($name =~ m:/:) {
+ $type = "green"; # source
+ } else {
+ $type = "aqua"; # builtin
+ }
+ } elsif ($name =~ /::/) { # C++
+ $type = "yellow";
+ } elsif ($name =~ m:/.*\.js:) { # JavaScript (match "/" in path)
+ $type = "green";
+ } elsif ($name =~ m/:/) { # JavaScript (match ":" in builtin)
+ $type = "aqua";
+ } elsif ($name =~ m/^ $/) { # Missing symbol
+ $type = "green";
+ } elsif ($name =~ m:_\[k\]:) { # kernel
+ $type = "orange";
+ } else { # system
+ $type = "red";
+ }
+ # fall-through to color palettes
+ }
+ if (defined $type and $type eq "wakeup") {
+ $type = "aqua";
+ # fall-through to color palettes
+ }
+ if (defined $type and $type eq "chain") {
+ if ($name =~ m:_\[w\]:) { # waker
+ $type = "aqua"
+ } else { # off-CPU
+ $type = "blue";
+ }
+ # fall-through to color palettes
+ }
+
+ # color palettes
+ if (defined $type and $type eq "red") {
+ my $r = 200 + int(55 * $v1);
+ my $x = 50 + int(80 * $v1);
+ return "rgb($r,$x,$x)";
+ }
+ if (defined $type and $type eq "green") {
+ my $g = 200 + int(55 * $v1);
+ my $x = 50 + int(60 * $v1);
+ return "rgb($x,$g,$x)";
+ }
+ if (defined $type and $type eq "blue") {
+ my $b = 205 + int(50 * $v1);
+ my $x = 80 + int(60 * $v1);
+ return "rgb($x,$x,$b)";
+ }
+ if (defined $type and $type eq "yellow") {
+ my $x = 175 + int(55 * $v1);
+ my $b = 50 + int(20 * $v1);
+ return "rgb($x,$x,$b)";
+ }
+ if (defined $type and $type eq "purple") {
+ my $x = 190 + int(65 * $v1);
+ my $g = 80 + int(60 * $v1);
+ return "rgb($x,$g,$x)";
+ }
+ if (defined $type and $type eq "aqua") {
+ my $r = 50 + int(60 * $v1);
+ my $g = 165 + int(55 * $v1);
+ my $b = 165 + int(55 * $v1);
+ return "rgb($r,$g,$b)";
+ }
+ if (defined $type and $type eq "orange") {
+ my $r = 190 + int(65 * $v1);
+ my $g = 90 + int(65 * $v1);
+ return "rgb($r,$g,0)";
+ }
+
+ return "rgb(0,0,0)";
+}
+
+sub color_scale {
+ my ($value, $max) = @_;
+ my ($r, $g, $b) = (255, 255, 255);
+ $value = -$value if $negate;
+ if ($value > 0) {
+ $g = $b = int(210 * ($max - $value) / $max);
+ } elsif ($value < 0) {
+ $r = $g = int(210 * ($max + $value) / $max);
+ }
+ return "rgb($r,$g,$b)";
+}
+
+sub color_map {
+ my ($colors, $func) = @_;
+ if (exists $palette_map{$func}) {
+ return $palette_map{$func};
+ } else {
+ $palette_map{$func} = color($colors, $hash, $func);
+ return $palette_map{$func};
+ }
+}
+
+sub write_palette {
+ open(FILE, ">$pal_file");
+ foreach my $key (sort keys %palette_map) {
+ print FILE $key."->".$palette_map{$key}."\n";
+ }
+ close(FILE);
+}
+
+sub read_palette {
+ if (-e $pal_file) {
+ open(FILE, $pal_file) or die "can't open file $pal_file: $!";
+ while ( my $line = <FILE>) {
+ chomp($line);
+ (my $key, my $value) = split("->",$line);
+ $palette_map{$key}=$value;
+ }
+ close(FILE)
+ }
+}
+
+my %Node; # Hash of merged frame data
+my %Tmp;
+
+# flow() merges two stacks, storing the merged frames and value data in %Node.
+sub flow {
+ my ($last, $this, $v, $d) = @_;
+
+ my $len_a = @$last - 1;
+ my $len_b = @$this - 1;
+
+ my $i = 0;
+ my $len_same;
+ for (; $i <= $len_a; $i++) {
+ last if $i > $len_b;
+ last if $last->[$i] ne $this->[$i];
+ }
+ $len_same = $i;
+
+ for ($i = $len_a; $i >= $len_same; $i--) {
+ my $k = "$last->[$i];$i";
+ # a unique ID is constructed from "func;depth;etime";
+ # func-depth isn't unique, it may be repeated later.
+ $Node{"$k;$v"}->{stime} = delete $Tmp{$k}->{stime};
+ if (defined $Tmp{$k}->{delta}) {
+ $Node{"$k;$v"}->{delta} = delete $Tmp{$k}->{delta};
+ }
+ delete $Tmp{$k};
+ }
+
+ for ($i = $len_same; $i <= $len_b; $i++) {
+ my $k = "$this->[$i];$i";
+ $Tmp{$k}->{stime} = $v;
+ if (defined $d) {
+ $Tmp{$k}->{delta} += $i == $len_b ? $d : 0;
+ }
+ }
+
+ return $this;
+}
+
+# parse input
+my @Data;
+my @SortedData;
+my $last = [];
+my $time = 0;
+my $delta = undef;
+my $ignored = 0;
+my $line;
+my $maxdelta = 1;
+
+# reverse if needed
+foreach (<>) {
+ chomp;
+ $line = $_;
+ if ($stackreverse) {
+ # there may be an extra samples column for differentials
+ # XXX todo: redo these REs as one. It's repeated below.
+ my($stack, $samples) = (/^(.*)\s+?(\d+(?:\.\d*)?)$/);
+ my $samples2 = undef;
+ if ($stack =~ /^(.*)\s+?(\d+(?:\.\d*)?)$/) {
+ $samples2 = $samples;
+ ($stack, $samples) = $stack =~ (/^(.*)\s+?(\d+(?:\.\d*)?)$/);
+ unshift @Data, join(";", reverse split(";", $stack)) . " $samples $samples2";
+ } else {
+ unshift @Data, join(";", reverse split(";", $stack)) . " $samples";
+ }
+ } else {
+ unshift @Data, $line;
+ }
+}
+
+if ($flamechart) {
+ # In flame chart mode, just reverse the data so time moves from left to right.
+ @SortedData = reverse @Data;
+} else {
+ @SortedData = sort @Data;
+}
+
+# process and merge frames
+foreach (@SortedData) {
+ chomp;
+ # process: folded_stack count
+ # eg: func_a;func_b;func_c 31
+ my ($stack, $samples) = (/^(.*)\s+?(\d+(?:\.\d*)?)$/);
+ unless (defined $samples and defined $stack) {
+ ++$ignored;
+ next;
+ }
+
+ # there may be an extra samples column for differentials:
+ my $samples2 = undef;
+ if ($stack =~ /^(.*)\s+?(\d+(?:\.\d*)?)$/) {
+ $samples2 = $samples;
+ ($stack, $samples) = $stack =~ (/^(.*)\s+?(\d+(?:\.\d*)?)$/);
+ }
+ $delta = undef;
+ if (defined $samples2) {
+ $delta = $samples2 - $samples;
+ $maxdelta = abs($delta) if abs($delta) > $maxdelta;
+ }
+
+ # for chain graphs, annotate waker frames with "_[w]", for later
+ # coloring. This is a hack, but has a precedent ("_[k]" from perf).
+ if ($colors eq "chain") {
+ my @parts = split ";--;", $stack;
+ my @newparts = ();
+ $stack = shift @parts;
+ $stack .= ";--;";
+ foreach my $part (@parts) {
+ $part =~ s/;/_[w];/g;
+ $part .= "_[w]";
+ push @newparts, $part;
+ }
+ $stack .= join ";--;", @parts;
+ }
+
+ # merge frames and populate %Node:
+ $last = flow($last, [ '', split ";", $stack ], $time, $delta);
+
+ if (defined $samples2) {
+ $time += $samples2;
+ } else {
+ $time += $samples;
+ }
+}
+flow($last, [], $time, $delta);
+
+if ($countname eq "samples") {
+ # If $countname is used, it's likely that we're not measuring in stack samples
+ # (e.g. time could be the unit), so don't warn.
+ warn "Stack count is low ($time). Did something go wrong?\n" if $time < 100;
+}
+
+warn "Ignored $ignored lines with invalid format\n" if $ignored;
+unless ($time) {
+ warn "ERROR: No stack counts found\n";
+ my $im = SVG->new();
+ # emit an error message SVG, for tools automating flamegraph use
+ my $imageheight = $fontsize * 5;
+ $im->header($imagewidth, $imageheight);
+ $im->stringTTF(undef, int($imagewidth / 2), $fontsize * 2,
+ "ERROR: No valid input provided to flamegraph.pl.");
+ print $im->svg;
+ exit 2;
+}
+if ($timemax and $timemax < $time) {
+ warn "Specified --total $timemax is less than actual total $time, so ignored\n"
+ if $timemax/$time > 0.02; # only warn is significant (e.g., not rounding etc)
+ undef $timemax;
+}
+$timemax ||= $time;
+
+my $widthpertime = ($imagewidth - 2 * $xpad) / $timemax;
+
+# Treat as a percentage of time if the string ends in a "%".
+my $minwidth_time;
+if ($minwidth =~ /%$/) {
+ $minwidth_time = $timemax * $minwidth_f / 100;
+} else {
+ $minwidth_time = $minwidth_f / $widthpertime;
+}
+
+# prune blocks that are too narrow and determine max depth
+while (my ($id, $node) = each %Node) {
+ my ($func, $depth, $etime) = split ";", $id;
+ my $stime = $node->{stime};
+ die "missing start for $id" if not defined $stime;
+
+ if (($etime-$stime) < $minwidth_time) {
+ delete $Node{$id};
+ next;
+ }
+ $depthmax = $depth if $depth > $depthmax;
+}
+
+# draw canvas, and embed interactive JavaScript program
+my $imageheight = (($depthmax + 1) * $frameheight) + $ypad1 + $ypad2;
+$imageheight += $ypad3 if $subtitletext ne "";
+my $titlesize = $fontsize + 5;
+my $im = SVG->new();
+my ($black, $vdgrey, $dgrey) = (
+ $im->colorAllocate(0, 0, 0),
+ $im->colorAllocate(160, 160, 160),
+ $im->colorAllocate(200, 200, 200),
+ );
+$im->header($imagewidth, $imageheight);
+my $backgroundinc = '';
+
+if ($bgcolors ne 'none') {
+ $backgroundinc = <<INC;
+<defs>
+ <linearGradient id="background" y1="0" y2="1" x1="0" x2="0" >
+ <stop stop-color="$bgcolor1" offset="5%" />
+ <stop stop-color="$bgcolor2" offset="95%" />
+ </linearGradient>
+</defs>
+INC
+}
+
+my $inc = <<INC;
+${backgroundinc}
+<style type="text/css">
+ text { font-family:$fonttype; font-size:${fontsize}px; fill:$black; }
+ #search, #ignorecase { opacity:0.1; cursor:pointer; }
+ #search:hover, #search.show, #ignorecase:hover, #ignorecase.show { opacity:1; }
+ #subtitle { text-anchor:middle; font-color:$vdgrey; }
+ #title { text-anchor:middle; font-size:${titlesize}px}
+ #unzoom { cursor:pointer; }
+ #frames > *:hover { stroke:black; stroke-width:0.5; cursor:pointer; }
+ .hide { display:none; }
+ .parent { opacity:0.5; }
+</style>
+<script type="text/ecmascript">
+<![CDATA[
+ "use strict";
+ var details, searchbtn, unzoombtn, matchedtxt, svg, searching, currentSearchTerm, ignorecase, ignorecaseBtn;
+ function init(evt) {
+ details = document.getElementById("details").firstChild;
+ searchbtn = document.getElementById("search");
+ ignorecaseBtn = document.getElementById("ignorecase");
+ unzoombtn = document.getElementById("unzoom");
+ matchedtxt = document.getElementById("matched");
+ svg = document.getElementsByTagName("svg")[0];
+ searching = 0;
+ currentSearchTerm = null;
+
+ // use GET parameters to restore a flamegraphs state.
+ var params = get_params();
+ if (params.x && params.y)
+ zoom(find_group(document.querySelector('[x="' + params.x + '"][y="' + params.y + '"]')));
+ if (params.s) search(params.s);
+ }
+
+ // event listeners
+ window.addEventListener("click", function(e) {
+ var target = find_group(e.target);
+ if (target) {
+ if (target.nodeName == "a") {
+ if (e.ctrlKey === false) return;
+ e.preventDefault();
+ }
+ if (target.classList.contains("parent")) unzoom(true);
+ zoom(target);
+ if (!document.querySelector('.parent')) {
+ // we have basically done a clearzoom so clear the url
+ var params = get_params();
+ if (params.x) delete params.x;
+ if (params.y) delete params.y;
+ history.replaceState(null, null, parse_params(params));
+ unzoombtn.classList.add("hide");
+ return;
+ }
+
+ // set parameters for zoom state
+ var el = target.querySelector("rect");
+ if (el && el.attributes && el.attributes.y && el.attributes._orig_x) {
+ var params = get_params()
+ params.x = el.attributes._orig_x.value;
+ params.y = el.attributes.y.value;
+ history.replaceState(null, null, parse_params(params));
+ }
+ }
+ else if (e.target.id == "unzoom") clearzoom();
+ else if (e.target.id == "search") search_prompt();
+ else if (e.target.id == "ignorecase") toggle_ignorecase();
+ }, false)
+
+ // mouse-over for info
+ // show
+ window.addEventListener("mouseover", function(e) {
+ var target = find_group(e.target);
+ if (target) details.nodeValue = "$nametype " + g_to_text(target);
+ }, false)
+
+ // clear
+ window.addEventListener("mouseout", function(e) {
+ var target = find_group(e.target);
+ if (target) details.nodeValue = ' ';
+ }, false)
+
+ // ctrl-F for search
+ // ctrl-I to toggle case-sensitive search
+ window.addEventListener("keydown",function (e) {
+ if (e.keyCode === 114 || (e.ctrlKey && e.keyCode === 70)) {
+ e.preventDefault();
+ search_prompt();
+ }
+ else if (e.ctrlKey && e.keyCode === 73) {
+ e.preventDefault();
+ toggle_ignorecase();
+ }
+ }, false)
+
+ // functions
+ function get_params() {
+ var params = {};
+ var paramsarr = window.location.search.substr(1).split('&');
+ for (var i = 0; i < paramsarr.length; ++i) {
+ var tmp = paramsarr[i].split("=");
+ if (!tmp[0] || !tmp[1]) continue;
+ params[tmp[0]] = decodeURIComponent(tmp[1]);
+ }
+ return params;
+ }
+ function parse_params(params) {
+ var uri = "?";
+ for (var key in params) {
+ uri += key + '=' + encodeURIComponent(params[key]) + '&';
+ }
+ if (uri.slice(-1) == "&")
+ uri = uri.substring(0, uri.length - 1);
+ if (uri == '?')
+ uri = window.location.href.split('?')[0];
+ return uri;
+ }
+ function find_child(node, selector) {
+ var children = node.querySelectorAll(selector);
+ if (children.length) return children[0];
+ }
+ function find_group(node) {
+ var parent = node.parentElement;
+ if (!parent) return;
+ if (parent.id == "frames") return node;
+ return find_group(parent);
+ }
+ function orig_save(e, attr, val) {
+ if (e.attributes["_orig_" + attr] != undefined) return;
+ if (e.attributes[attr] == undefined) return;
+ if (val == undefined) val = e.attributes[attr].value;
+ e.setAttribute("_orig_" + attr, val);
+ }
+ function orig_load(e, attr) {
+ if (e.attributes["_orig_"+attr] == undefined) return;
+ e.attributes[attr].value = e.attributes["_orig_" + attr].value;
+ e.removeAttribute("_orig_"+attr);
+ }
+ function g_to_text(e) {
+ var text = find_child(e, "title").firstChild.nodeValue;
+ return (text)
+ }
+ function g_to_func(e) {
+ var func = g_to_text(e);
+ // if there's any manipulation we want to do to the function
+ // name before it's searched, do it here before returning.
+ return (func);
+ }
+ function update_text(e) {
+ var r = find_child(e, "rect");
+ var t = find_child(e, "text");
+ var w = parseFloat(r.attributes.width.value) -3;
+ var txt = find_child(e, "title").textContent.replace(/\\([^(]*\\)\$/,"");
+ t.attributes.x.value = parseFloat(r.attributes.x.value) + 3;
+
+ // Smaller than this size won't fit anything
+ if (w < 2 * $fontsize * $fontwidth) {
+ t.textContent = "";
+ return;
+ }
+
+ t.textContent = txt;
+ var sl = t.getSubStringLength(0, txt.length);
+ // check if only whitespace or if we can fit the entire string into width w
+ if (/^ *\$/.test(txt) || sl < w)
+ return;
+
+ // this isn't perfect, but gives a good starting point
+ // and avoids calling getSubStringLength too often
+ var start = Math.floor((w/sl) * txt.length);
+ for (var x = start; x > 0; x = x-2) {
+ if (t.getSubStringLength(0, x + 2) <= w) {
+ t.textContent = txt.substring(0, x) + "..";
+ return;
+ }
+ }
+ t.textContent = "";
+ }
+
+ // zoom
+ function zoom_reset(e) {
+ if (e.attributes != undefined) {
+ orig_load(e, "x");
+ orig_load(e, "width");
+ }
+ if (e.childNodes == undefined) return;
+ for (var i = 0, c = e.childNodes; i < c.length; i++) {
+ zoom_reset(c[i]);
+ }
+ }
+ function zoom_child(e, x, ratio) {
+ if (e.attributes != undefined) {
+ if (e.attributes.x != undefined) {
+ orig_save(e, "x");
+ e.attributes.x.value = (parseFloat(e.attributes.x.value) - x - $xpad) * ratio + $xpad;
+ if (e.tagName == "text")
+ e.attributes.x.value = find_child(e.parentNode, "rect[x]").attributes.x.value + 3;
+ }
+ if (e.attributes.width != undefined) {
+ orig_save(e, "width");
+ e.attributes.width.value = parseFloat(e.attributes.width.value) * ratio;
+ }
+ }
+
+ if (e.childNodes == undefined) return;
+ for (var i = 0, c = e.childNodes; i < c.length; i++) {
+ zoom_child(c[i], x - $xpad, ratio);
+ }
+ }
+ function zoom_parent(e) {
+ if (e.attributes) {
+ if (e.attributes.x != undefined) {
+ orig_save(e, "x");
+ e.attributes.x.value = $xpad;
+ }
+ if (e.attributes.width != undefined) {
+ orig_save(e, "width");
+ e.attributes.width.value = parseInt(svg.width.baseVal.value) - ($xpad * 2);
+ }
+ }
+ if (e.childNodes == undefined) return;
+ for (var i = 0, c = e.childNodes; i < c.length; i++) {
+ zoom_parent(c[i]);
+ }
+ }
+ function zoom(node) {
+ var attr = find_child(node, "rect").attributes;
+ var width = parseFloat(attr.width.value);
+ var xmin = parseFloat(attr.x.value);
+ var xmax = parseFloat(xmin + width);
+ var ymin = parseFloat(attr.y.value);
+ var ratio = (svg.width.baseVal.value - 2 * $xpad) / width;
+
+ // XXX: Workaround for JavaScript float issues (fix me)
+ var fudge = 0.0001;
+
+ unzoombtn.classList.remove("hide");
+
+ var el = document.getElementById("frames").children;
+ for (var i = 0; i < el.length; i++) {
+ var e = el[i];
+ var a = find_child(e, "rect").attributes;
+ var ex = parseFloat(a.x.value);
+ var ew = parseFloat(a.width.value);
+ var upstack;
+ // Is it an ancestor
+ if ($inverted == 0) {
+ upstack = parseFloat(a.y.value) > ymin;
+ } else {
+ upstack = parseFloat(a.y.value) < ymin;
+ }
+ if (upstack) {
+ // Direct ancestor
+ if (ex <= xmin && (ex+ew+fudge) >= xmax) {
+ e.classList.add("parent");
+ zoom_parent(e);
+ update_text(e);
+ }
+ // not in current path
+ else
+ e.classList.add("hide");
+ }
+ // Children maybe
+ else {
+ // no common path
+ if (ex < xmin || ex + fudge >= xmax) {
+ e.classList.add("hide");
+ }
+ else {
+ zoom_child(e, xmin, ratio);
+ update_text(e);
+ }
+ }
+ }
+ search();
+ }
+ function unzoom(dont_update_text) {
+ unzoombtn.classList.add("hide");
+ var el = document.getElementById("frames").children;
+ for(var i = 0; i < el.length; i++) {
+ el[i].classList.remove("parent");
+ el[i].classList.remove("hide");
+ zoom_reset(el[i]);
+ if(!dont_update_text) update_text(el[i]);
+ }
+ search();
+ }
+ function clearzoom() {
+ unzoom();
+
+ // remove zoom state
+ var params = get_params();
+ if (params.x) delete params.x;
+ if (params.y) delete params.y;
+ history.replaceState(null, null, parse_params(params));
+ }
+
+ // search
+ function toggle_ignorecase() {
+ ignorecase = !ignorecase;
+ if (ignorecase) {
+ ignorecaseBtn.classList.add("show");
+ } else {
+ ignorecaseBtn.classList.remove("show");
+ }
+ reset_search();
+ search();
+ }
+ function reset_search() {
+ var el = document.querySelectorAll("#frames rect");
+ for (var i = 0; i < el.length; i++) {
+ orig_load(el[i], "fill")
+ }
+ var params = get_params();
+ delete params.s;
+ history.replaceState(null, null, parse_params(params));
+ }
+ function search_prompt() {
+ if (!searching) {
+ var term = prompt("Enter a search term (regexp " +
+ "allowed, eg: ^ext4_)"
+ + (ignorecase ? ", ignoring case" : "")
+ + "\\nPress Ctrl-i to toggle case sensitivity", "");
+ if (term != null) search(term);
+ } else {
+ reset_search();
+ searching = 0;
+ currentSearchTerm = null;
+ searchbtn.classList.remove("show");
+ searchbtn.firstChild.nodeValue = "Search"
+ matchedtxt.classList.add("hide");
+ matchedtxt.firstChild.nodeValue = ""
+ }
+ }
+ function search(term) {
+ if (term) currentSearchTerm = term;
+ if (currentSearchTerm === null) return;
+
+ var re = new RegExp(currentSearchTerm, ignorecase ? 'i' : '');
+ var el = document.getElementById("frames").children;
+ var matches = new Object();
+ var maxwidth = 0;
+ for (var i = 0; i < el.length; i++) {
+ var e = el[i];
+ var func = g_to_func(e);
+ var rect = find_child(e, "rect");
+ if (func == null || rect == null)
+ continue;
+
+ // Save max width. Only works as we have a root frame
+ var w = parseFloat(rect.attributes.width.value);
+ if (w > maxwidth)
+ maxwidth = w;
+
+ if (func.match(re)) {
+ // highlight
+ var x = parseFloat(rect.attributes.x.value);
+ orig_save(rect, "fill");
+ rect.attributes.fill.value = "$searchcolor";
+
+ // remember matches
+ if (matches[x] == undefined) {
+ matches[x] = w;
+ } else {
+ if (w > matches[x]) {
+ // overwrite with parent
+ matches[x] = w;
+ }
+ }
+ searching = 1;
+ }
+ }
+ if (!searching)
+ return;
+ var params = get_params();
+ params.s = currentSearchTerm;
+ history.replaceState(null, null, parse_params(params));
+
+ searchbtn.classList.add("show");
+ searchbtn.firstChild.nodeValue = "Reset Search";
+
+ // calculate percent matched, excluding vertical overlap
+ var count = 0;
+ var lastx = -1;
+ var lastw = 0;
+ var keys = Array();
+ for (k in matches) {
+ if (matches.hasOwnProperty(k))
+ keys.push(k);
+ }
+ // sort the matched frames by their x location
+ // ascending, then width descending
+ keys.sort(function(a, b){
+ return a - b;
+ });
+ // Step through frames saving only the biggest bottom-up frames
+ // thanks to the sort order. This relies on the tree property
+ // where children are always smaller than their parents.
+ var fudge = 0.0001; // JavaScript floating point
+ for (var k in keys) {
+ var x = parseFloat(keys[k]);
+ var w = matches[keys[k]];
+ if (x >= lastx + lastw - fudge) {
+ count += w;
+ lastx = x;
+ lastw = w;
+ }
+ }
+ // display matched percent
+ matchedtxt.classList.remove("hide");
+ var pct = 100 * count / maxwidth;
+ if (pct != 100) pct = pct.toFixed(1)
+ matchedtxt.firstChild.nodeValue = "Matched: " + pct + "%";
+ }
+]]>
+</script>
+INC
+$im->include($inc);
+$im->filledRectangle(0, 0, $imagewidth, $imageheight, 'url(#background)');
+$im->stringTTF("title", int($imagewidth / 2), $fontsize * 2, $titletext) if $titletext ne "";
+$im->stringTTF("subtitle", int($imagewidth / 2), $fontsize * 4, $subtitletext) if $subtitletext ne "";
+$im->stringTTF("details", $xpad, $imageheight - ($ypad2 / 2), " ");
+$im->stringTTF("unzoom", $xpad, $fontsize * 2, "Reset Zoom", 'class="hide"');
+$im->stringTTF("search", $imagewidth - $xpad - 100, $fontsize * 2, "Search");
+$im->stringTTF("ignorecase", $imagewidth - $xpad - 16, $fontsize * 2, "ic");
+$im->stringTTF("matched", $imagewidth - $xpad - 100, $imageheight - ($ypad2 / 2), " ");
+
+if ($palette) {
+ read_palette();
+}
+
+# draw frames
+$im->group_start({id => "frames"});
+while (my ($id, $node) = each %Node) {
+ my ($func, $depth, $etime) = split ";", $id;
+ my $stime = $node->{stime};
+ my $delta = $node->{delta};
+
+ $etime = $timemax if $func eq "" and $depth == 0;
+
+ my $x1 = $xpad + $stime * $widthpertime;
+ my $x2 = $xpad + $etime * $widthpertime;
+ my ($y1, $y2);
+ unless ($inverted) {
+ $y1 = $imageheight - $ypad2 - ($depth + 1) * $frameheight + $framepad;
+ $y2 = $imageheight - $ypad2 - $depth * $frameheight;
+ } else {
+ $y1 = $ypad1 + $depth * $frameheight;
+ $y2 = $ypad1 + ($depth + 1) * $frameheight - $framepad;
+ }
+
+ # Add commas per perlfaq5:
+ # https://perldoc.perl.org/perlfaq5#How-can-I-output-my-numbers-with-commas-added?
+ my $samples = sprintf "%.0f", ($etime - $stime) * $factor;
+ (my $samples_txt = $samples)
+ =~ s/(^[-+]?\d+?(?=(?>(?:\d{3})+)(?!\d))|\G\d{3}(?=\d))/$1,/g;
+
+ my $info;
+ if ($func eq "" and $depth == 0) {
+ $info = "all ($samples_txt $countname, 100%)";
+ } else {
+ my $pct = sprintf "%.2f", ((100 * $samples) / ($timemax * $factor));
+ my $escaped_func = $func;
+ # clean up SVG breaking characters:
+ $escaped_func =~ s/&/&/g;
+ $escaped_func =~ s/</</g;
+ $escaped_func =~ s/>/>/g;
+ $escaped_func =~ s/"/"/g;
+ $escaped_func =~ s/_\[[kwij]\]$//; # strip any annotation
+ unless (defined $delta) {
+ $info = "$escaped_func ($samples_txt $countname, $pct%)";
+ } else {
+ my $d = $negate ? -$delta : $delta;
+ my $deltapct = sprintf "%.2f", ((100 * $d) / ($timemax * $factor));
+ $deltapct = $d > 0 ? "+$deltapct" : $deltapct;
+ $info = "$escaped_func ($samples_txt $countname, $pct%; $deltapct%)";
+ }
+ }
+
+ my $nameattr = { %{ $nameattr{$func}||{} } }; # shallow clone
+ $nameattr->{title} ||= $info;
+ $im->group_start($nameattr);
+
+ my $color;
+ if ($func eq "--") {
+ $color = $vdgrey;
+ } elsif ($func eq "-") {
+ $color = $dgrey;
+ } elsif (defined $delta) {
+ $color = color_scale($delta, $maxdelta);
+ } elsif ($palette) {
+ $color = color_map($colors, $func);
+ } else {
+ $color = color($colors, $hash, $func);
+ }
+ $im->filledRectangle($x1, $y1, $x2, $y2, $color, 'rx="2" ry="2"');
+
+ my $chars = int( ($x2 - $x1) / ($fontsize * $fontwidth));
+ my $text = "";
+ if ($chars >= 3) { # room for one char plus two dots
+ $func =~ s/_\[[kwij]\]$//; # strip any annotation
+ $text = substr $func, 0, $chars;
+ substr($text, -2, 2) = ".." if $chars < length $func;
+ $text =~ s/&/&/g;
+ $text =~ s/</</g;
+ $text =~ s/>/>/g;
+ }
+ $im->stringTTF(undef, $x1 + 3, 3 + ($y1 + $y2) / 2, $text);
+
+ $im->group_end($nameattr);
+}
+$im->group_end();
+
+print $im->svg;
+
+if ($palette) {
+ write_palette();
+}
+
+# vim: ts=8 sts=8 sw=8 noexpandtab
diff --git a/tests/benchmarks/_script/flamegraph/jmaps b/tests/benchmarks/_script/flamegraph/jmaps
new file mode 100755
index 00000000000..f8014f5a82f
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/jmaps
@@ -0,0 +1,104 @@
+#!/bin/bash
+#
+# jmaps - creates java /tmp/perf-PID.map symbol maps for all java processes.
+#
+# This is a helper script that finds all running "java" processes, then executes
+# perf-map-agent on them all, creating symbol map files in /tmp. These map files
+# are read by perf_events (aka "perf") when doing system profiles (specifically,
+# the "report" and "script" subcommands).
+#
+# USAGE: jmaps [-u]
+# -u # unfoldall: include inlined symbols
+#
+# My typical workflow is this:
+#
+# perf record -F 99 -a -g -- sleep 30; jmaps
+# perf script > out.stacks
+# ./stackcollapse-perf.pl out.stacks | ./flamegraph.pl --color=java --hash > out.stacks.svg
+#
+# The stackcollapse-perf.pl and flamegraph.pl programs come from:
+# https://github.com/brendangregg/FlameGraph
+#
+# REQUIREMENTS:
+# Tune two environment settings below.
+#
+# 13-Feb-2015 Brendan Gregg Created this.
+# 20-Feb-2017 " " Added -u for unfoldall.
+
+JAVA_HOME=${JAVA_HOME:-/usr/lib/jvm/java-8-oracle}
+AGENT_HOME=${AGENT_HOME:-/usr/lib/jvm/perf-map-agent} # from https://github.com/jvm-profiling-tools/perf-map-agent
+debug=0
+
+if [[ "$USER" != root ]]; then
+ echo "ERROR: not root user? exiting..."
+ exit
+fi
+
+if [[ ! -x $JAVA_HOME ]]; then
+ echo "ERROR: JAVA_HOME not set correctly; edit $0 and fix"
+ exit
+fi
+
+if [[ ! -x $AGENT_HOME ]]; then
+ echo "ERROR: AGENT_HOME not set correctly; edit $0 and fix"
+ exit
+fi
+
+if [[ "$1" == "-u" ]]; then
+ opts=unfoldall
+fi
+
+# figure out where the agent files are:
+AGENT_OUT=""
+AGENT_JAR=""
+if [[ -e $AGENT_HOME/out/attach-main.jar ]]; then
+ AGENT_JAR=$AGENT_HOME/out/attach-main.jar
+elif [[ -e $AGENT_HOME/attach-main.jar ]]; then
+ AGENT_JAR=$AGENT_HOME/attach-main.jar
+fi
+if [[ -e $AGENT_HOME/out/libperfmap.so ]]; then
+ AGENT_OUT=$AGENT_HOME/out
+elif [[ -e $AGENT_HOME/libperfmap.so ]]; then
+ AGENT_OUT=$AGENT_HOME
+fi
+if [[ "$AGENT_OUT" == "" || "$AGENT_JAR" == "" ]]; then
+ echo "ERROR: Missing perf-map-agent files in $AGENT_HOME. Check installation."
+ exit
+fi
+
+# Fetch map for all "java" processes
+echo "Fetching maps for all java processes..."
+for pid in $(pgrep -x java); do
+ mapfile=/tmp/perf-$pid.map
+ [[ -e $mapfile ]] && rm $mapfile
+
+ cmd="cd $AGENT_OUT; $JAVA_HOME/bin/java -Xms32m -Xmx128m -cp $AGENT_JAR:$JAVA_HOME/lib/tools.jar net.virtualvoid.perf.AttachOnce $pid $opts"
+ (( debug )) && echo $cmd
+
+ user=$(ps ho user -p $pid)
+ group=$(ps ho group -p $pid)
+ if [[ "$user" != root ]]; then
+ if [[ "$user" == [0-9]* ]]; then
+ # UID only, likely GID too, run sudo with #UID:
+ cmd="sudo -u '#'$user -g '#'$group sh -c '$cmd'"
+ else
+ cmd="sudo -u $user -g $group sh -c '$cmd'"
+ fi
+ fi
+
+ echo "Mapping PID $pid (user $user):"
+ if (( debug )); then
+ time eval $cmd
+ else
+ eval $cmd
+ fi
+ if [[ -e "$mapfile" ]]; then
+ chown root $mapfile
+ chmod 666 $mapfile
+ else
+ echo "ERROR: $mapfile not created."
+ fi
+
+ echo "wc(1): $(wc $mapfile)"
+ echo
+done
diff --git a/tests/benchmarks/_script/flamegraph/pkgsplit-perf.pl b/tests/benchmarks/_script/flamegraph/pkgsplit-perf.pl
new file mode 100755
index 00000000000..3a9902da49f
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/pkgsplit-perf.pl
@@ -0,0 +1,86 @@
+#!/usr/bin/perl -w
+#
+# pkgsplit-perf.pl Split IP samples on package names "/", eg, Java.
+#
+# This is for the creation of Java package flame graphs. Example steps:
+#
+# perf record -F 199 -a -- sleep 30; ./jmaps
+# perf script | ./pkgsplit-perf.pl | ./flamegraph.pl > out.svg
+#
+# Note that stack traces are not sampled (no -g), as we split Java package
+# names into frames rather than stack frames.
+#
+# (jmaps is a helper script for automating perf-map-agent: Java symbol dumps.)
+#
+# The default output of "perf script" varies between kernel versions, so we'll
+# need to deal with that here. I could make people use the perf script option
+# to pick fields, so our input is static, but A) I prefer the simplicity of
+# just saying: run "perf script", and B) the option to choose fields itself
+# changed between kernel versions! -f became -F.
+#
+# Copyright 2017 Netflix, Inc.
+# Licensed under the Apache License, Version 2.0 (the "License")
+#
+# 20-Sep-2016 Brendan Gregg Created this.
+
+use strict;
+
+my $include_pname = 1; # include process names in stacks
+my $include_pid = 0; # include process ID with process name
+my $include_tid = 0; # include process & thread ID with process name
+
+while (<>) {
+ # filter comments
+ next if /^#/;
+
+ # filter idle events
+ next if /xen_hypercall_sched_op|cpu_idle|native_safe_halt/;
+
+ my ($pid, $tid, $pname);
+
+ # Linux 3.13:
+ # java 13905 [000] 8048.096572: cpu-clock: 7fd781ac3053 Ljava/util/Arrays$ArrayList;::toArray (/tmp/perf-12149.map)
+ # java 8301 [050] 13527.392454: cycles: 7fa8a80d9bff Dictionary::find(int, unsigned int, Symbol*, ClassLoaderData*, Handle, Thread*) (/usr/lib/jvm/java-8-oracle-1.8.0.121/jre/lib/amd64/server/libjvm.so)
+ # java 4567/8603 [023] 13527.389886: cycles: 7fa863349895 Lcom/google/gson/JsonObject;::add (/tmp/perf-4567.map)
+ #
+ # Linux 4.8:
+ # java 30894 [007] 452884.077440: 10101010 cpu-clock: 7f0acc8eff67 Lsun/nio/ch/SocketChannelImpl;::read+0x27 (/tmp/perf-30849.map)
+ # bash 26858/26858 [006] 5440237.995639: cpu-clock: 433573 [unknown] (/bin/bash)
+ #
+ if (/^\s+(\S.+?)\s+(\d+)\/*(\d+)*\s.*?:.*:/) {
+ # parse process name and pid/tid
+ if ($3) {
+ ($pid, $tid) = ($2, $3);
+ } else {
+ ($pid, $tid) = ("?", $2);
+ }
+
+ if ($include_tid) {
+ $pname = "$1-$pid/$tid";
+ } elsif ($include_pid) {
+ $pname = "$1-$pid";
+ } else {
+ $pname = $1;
+ }
+ $pname =~ tr/ /_/;
+ } else {
+ # not a match
+ next;
+ }
+
+ # parse rest of line
+ s/^.*?:.*?:\s+//;
+ s/ \(.*?\)$//;
+ chomp;
+ my ($addr, $func) = split(' ', $_, 2);
+
+ # strip Java's leading "L"
+ $func =~ s/^L//;
+
+ # replace numbers with X
+ $func =~ s/[0-9]/X/g;
+
+ # colon delimitered
+ $func =~ s:/:;:g;
+ print "$pname;$func 1\n";
+}
diff --git a/tests/benchmarks/_script/flamegraph/range-perf.pl b/tests/benchmarks/_script/flamegraph/range-perf.pl
new file mode 100755
index 00000000000..0fca6decd23
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/range-perf.pl
@@ -0,0 +1,137 @@
+#!/usr/bin/perl -w
+#
+# range-perf Extract a time range from Linux "perf script" output.
+#
+# USAGE EXAMPLE:
+#
+# perf record -F 100 -a -- sleep 60
+# perf script | ./perf2range.pl 10 20 # range 10 to 20 seconds only
+# perf script | ./perf2range.pl 0 0.5 # first half second only
+#
+# MAKING A SERIES OF FLAME GRAPHS:
+#
+# Let's say you had the output of "perf script" in a file, out.stacks01, which
+# was for a 180 second profile. The following command creates a series of
+# flame graphs for each 10 second interval:
+#
+# for i in `seq 0 10 170`; do cat out.stacks01 | \
+# ./perf2range.pl $i $((i + 10)) | ./stackcollapse-perf.pl | \
+# grep -v cpu_idle | ./flamegraph.pl --hash --color=java \
+# --title="range $i $((i + 10))" > out.range_$i.svg; echo $i done; done
+#
+# In that example, I used "--color=java" for the Java palette, and excluded
+# the idle CPU task. Customize as needed.
+#
+# Copyright 2017 Netflix, Inc.
+# Licensed under the Apache License, Version 2.0 (the "License")
+#
+# 21-Feb-2017 Brendan Gregg Created this.
+
+use strict;
+use Getopt::Long;
+use POSIX 'floor';
+
+sub usage {
+ die <<USAGE_END;
+USAGE: $0 [options] min_seconds max_seconds
+ --timeraw # use raw timestamps from perf
+ --timezerosecs # time starts at 0 secs, but keep offset from perf
+ eg,
+ $0 10 20 # only include samples between 10 and 20 seconds
+USAGE_END
+}
+
+my $timeraw = 0;
+my $timezerosecs = 0;
+GetOptions(
+ 'timeraw' => \$timeraw,
+ 'timezerosecs' => \$timezerosecs,
+) or usage();
+
+if (@ARGV < 2 || $ARGV[0] eq "-h" || $ARGV[0] eq "--help") {
+ usage();
+ exit;
+}
+my $begin = $ARGV[0];
+my $end = $ARGV[1];
+
+#
+# Parsing
+#
+# IP only examples:
+#
+# java 52025 [026] 99161.926202: cycles:
+# java 14341 [016] 252732.474759: cycles: 7f36571947c0 nmethod::is_nmethod() const (/...
+# java 14514 [022] 28191.353083: cpu-clock: 7f92b4fdb7d4 Ljava_util_List$size$0;::call (/tmp/perf-11936.map)
+# swapper 0 [002] 6035557.056977: 10101010 cpu-clock: ffffffff810013aa xen_hypercall_sched_op+0xa (/lib/modules/4.9-virtual/build/vmlinux)
+# bash 25370 603are 6036.991603: 10101010 cpu-clock: 4b931e [unknown] (/bin/bash)
+# bash 25370/25370 6036036.799684: cpu-clock: 4b913b [unknown] (/bin/bash)
+# other combinations are possible.
+#
+# Stack examples (-g):
+#
+# swapper 0 [021] 28648.467059: cpu-clock:
+# ffffffff810013aa xen_hypercall_sched_op ([kernel.kallsyms])
+# ffffffff8101cb2f default_idle ([kernel.kallsyms])
+# ffffffff8101d406 arch_cpu_idle ([kernel.kallsyms])
+# ffffffff810bf475 cpu_startup_entry ([kernel.kallsyms])
+# ffffffff81010228 cpu_bringup_and_idle ([kernel.kallsyms])
+#
+# java 14375 [022] 28648.467079: cpu-clock:
+# 7f92bdd98965 Ljava/io/OutputStream;::write (/tmp/perf-11936.map)
+# 7f8808cae7a8 [unknown] ([unknown])
+#
+# swapper 0 [005] 5076.836336: cpu-clock:
+# ffffffff81051586 native_safe_halt ([kernel.kallsyms])
+# ffffffff8101db4f default_idle ([kernel.kallsyms])
+# ffffffff8101e466 arch_cpu_idle ([kernel.kallsyms])
+# ffffffff810c2b31 cpu_startup_entry ([kernel.kallsyms])
+# ffffffff810427cd start_secondary ([kernel.kallsyms])
+#
+# swapper 0 [002] 6034779.719110: 10101010 cpu-clock:
+# 2013aa xen_hypercall_sched_op+0xfe20000a (/lib/modules/4.9-virtual/build/vmlinux)
+# a72f0e default_idle+0xfe20001e (/lib/modules/4.9-virtual/build/vmlinux)
+# 2392bf arch_cpu_idle+0xfe20000f (/lib/modules/4.9-virtual/build/vmlinux)
+# a73333 default_idle_call+0xfe200023 (/lib/modules/4.9-virtual/build/vmlinux)
+# 2c91a4 cpu_startup_entry+0xfe2001c4 (/lib/modules/4.9-virtual/build/vmlinux)
+# 22b64a cpu_bringup_and_idle+0xfe20002a (/lib/modules/4.9-virtual/build/vmlinux)
+#
+# bash 25370/25370 6035935.188539: cpu-clock:
+# b9218 [unknown] (/bin/bash)
+# 2037fe8 [unknown] ([unknown])
+# other combinations are possible.
+#
+# This regexp matches the event line, and puts time in $1, and the event name
+# in $2:
+#
+my $event_regexp = qr/ +([0-9\.]+): *\S* *(\S+):/;
+
+my $line;
+my $start = 0;
+my $ok = 0;
+my $time;
+
+while (1) {
+ $line = <STDIN>;
+ last unless defined $line;
+ next if $line =~ /^#/; # skip comments
+
+ if ($line =~ $event_regexp) {
+ my ($ts, $event) = ($1, $2, $3);
+ $start = $ts if $start == 0;
+
+ if ($timezerosecs) {
+ $time = $ts - floor($start);
+ } elsif (!$timeraw) {
+ $time = $ts - $start;
+ } else {
+ $time = $ts; # raw times
+ }
+
+ $ok = 1 if $time >= $begin;
+ # assume samples are in time order:
+ exit if $time > $end;
+ }
+
+ print $line if $ok;
+}
diff --git a/tests/benchmarks/_script/flamegraph/record-test.sh b/tests/benchmarks/_script/flamegraph/record-test.sh
new file mode 100755
index 00000000000..569ecc966bb
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/record-test.sh
@@ -0,0 +1,21 @@
+#!/bin/bash
+#
+# record-test.sh - Overwrite flame graph test result files.
+#
+# See test.sh, which checks these resulting files.
+#
+# Currently only tests stackcollapse-perf.pl.
+
+set -v -x
+
+# ToDo: add some form of --inline, and --inline --context tests. These are
+# tricky since they use addr2line, whose output will vary based on the test
+# system's binaries and symbol tables.
+for opt in pid tid kernel jit all addrs; do
+ for testfile in test/*.txt ; do
+ echo testing $testfile : $opt
+ outfile=${testfile#*/}
+ outfile=test/results/${outfile%.txt}"-collapsed-${opt}.txt"
+ ./stackcollapse-perf.pl --"${opt}" "${testfile}" 2> /dev/null > $outfile
+ done
+done
diff --git a/tests/benchmarks/_script/flamegraph/stackcollapse-aix.pl b/tests/benchmarks/_script/flamegraph/stackcollapse-aix.pl
new file mode 100755
index 00000000000..8456d56b918
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/stackcollapse-aix.pl
@@ -0,0 +1,61 @@
+#!/usr/bin/perl -ws
+#
+# stackcollapse-aix Collapse AIX /usr/bin/procstack backtraces
+#
+# Parse a list of backtraces as generated with the poor man's aix-perf.pl
+# profiler
+#
+
+use strict;
+
+my $process = "";
+my $current = "";
+my $previous_function = "";
+
+my %stacks;
+
+while(<>) {
+ chomp;
+ if (m/^\d+:/) {
+ if(!($current eq "")) {
+ $current = $process . ";" . $current;
+ $stacks{$current} += 1;
+ $current = "";
+ }
+ m/^\d+: ([^ ]*)/;
+ $process = $1;
+ $current = "";
+ }
+ elsif(m/^---------- tid# \d+/){
+ if(!($current eq "")) {
+ $current = $process . ";" . $current;
+ $stacks{$current} += 1;
+ }
+ $current = "";
+ }
+ elsif(m/^(0x[0-9abcdef]*) *([^ ]*) ([^ ]*) ([^ ]*)/) {
+ my $function = $2;
+ my $alt = $1;
+ $function=~s/\(.*\)?//;
+ if($function =~ /^\[.*\]$/) {
+ $function = $alt;
+ }
+ if ($current) {
+ $current = $function . ";" . $current;
+ }
+ else {
+ $current = $function;
+ }
+ }
+}
+
+if(!($current eq "")) {
+ $current = $process . ";" . $current;
+ $stacks{$current} += 1;
+ $current = "";
+ $process = "";
+}
+
+foreach my $k (sort { $a cmp $b } keys %stacks) {
+ print "$k $stacks{$k}\n";
+}
diff --git a/tests/benchmarks/_script/flamegraph/stackcollapse-bpftrace.pl b/tests/benchmarks/_script/flamegraph/stackcollapse-bpftrace.pl
new file mode 100755
index 00000000000..f458c3e3af1
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/stackcollapse-bpftrace.pl
@@ -0,0 +1,72 @@
+#!/usr/bin/perl -w
+#
+# stackcollapse-bpftrace.pl collapse bpftrace samples into single lines.
+#
+# USAGE ./stackcollapse-bpftrace.pl infile > outfile
+#
+# Example input:
+#
+# @[
+# _raw_spin_lock_bh+0
+# tcp_recvmsg+808
+# inet_recvmsg+81
+# sock_recvmsg+67
+# sock_read_iter+144
+# new_sync_read+228
+# __vfs_read+41
+# vfs_read+142
+# sys_read+85
+# do_syscall_64+115
+# entry_SYSCALL_64_after_hwframe+61
+# ]: 3
+#
+# Example output:
+#
+# entry_SYSCALL_64_after_hwframe+61;do_syscall_64+115;sys_read+85;vfs_read+142;__vfs_read+41;new_sync_read+228;sock_read_iter+144;sock_recvmsg+67;inet_recvmsg+81;tcp_recvmsg+808;_raw_spin_lock_bh+0 3
+#
+# Copyright 2018 Peter Sanford. All rights reserved.
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+#
+# (http://www.gnu.org/copyleft/gpl.html)
+#
+
+use strict;
+
+my @stack;
+my $in_stack = 0;
+
+foreach (<>) {
+ chomp;
+ if (!$in_stack) {
+ if (/^@\[$/) {
+ $in_stack = 1;
+ } elsif (/^@\[,\s(.*)\]: (\d+)/) {
+ print $1 . " $2\n";
+ }
+ } else {
+ if (m/^,?\s?(.*)\]: (\d+)/) {
+ if (length $1) {
+ push(@stack, $1);
+ }
+ print join(';', reverse(@stack)) . " $2\n";
+ $in_stack = 0;
+ @stack = ();
+ } else {
+ $_ =~ s/^\s+//;
+ push(@stack, $_);
+ }
+ }
+}
diff --git a/tests/benchmarks/_script/flamegraph/stackcollapse-chrome-tracing.py b/tests/benchmarks/_script/flamegraph/stackcollapse-chrome-tracing.py
new file mode 100755
index 00000000000..b4869781d90
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/stackcollapse-chrome-tracing.py
@@ -0,0 +1,144 @@
+#!/usr/bin/python
+#
+# stackcolllapse-chrome-tracing.py collapse Trace Event Format [1]
+# callstack events into single lines.
+#
+# [1] https://github.com/catapult-project/catapult/wiki/Trace-Event-Format
+#
+# USAGE: ./stackcollapse-chrome-tracing.py input_json [input_json...] > outfile
+#
+# Example input:
+#
+# {"traceEvents":[
+# {"pid":1,"tid":2,"ts":0,"ph":"X","name":"Foo","dur":50},
+# {"pid":1,"tid":2,"ts":10,"ph":"X","name":"Bar","dur":30}
+# ]}
+#
+# Example output:
+#
+# Foo 20.0
+# Foo;Bar 30.0
+#
+# Input may contain many stack trace events from many processes/threads.
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at docs/cddl1.txt or
+# http://opensource.org/licenses/CDDL-1.0.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at docs/cddl1.txt.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+# 4-Jan-2018 Marcin Kolny Created this.
+import argparse
+import json
+
+stack_identifiers = {}
+
+
+class Event:
+ def __init__(self, label, timestamp, dur):
+ self.label = label
+ self.timestamp = timestamp
+ self.duration = dur
+ self.total_duration = dur
+
+ def get_stop_timestamp(self):
+ return self.timestamp + self.duration
+
+
+def cantor_pairing(a, b):
+ s = a + b
+ return s * (s + 1) / 2 + b
+
+
+def get_trace_events(trace_file, events_dict):
+ json_data = json.load(trace_file)
+
+ for entry in json_data['traceEvents']:
+ if entry['ph'] == 'X':
+ cantor_val = cantor_pairing(int(entry['tid']), int(entry['pid']))
+ if 'dur' not in entry:
+ continue
+ if cantor_val not in events_dict:
+ events_dict[cantor_val] = []
+ events_dict[cantor_val].append(Event(entry['name'], float(entry['ts']), float(entry['dur'])))
+
+
+def load_events(trace_files):
+ events = {}
+
+ for trace_file in trace_files:
+ get_trace_events(trace_file, events)
+
+ for key in events:
+ events[key].sort(key=lambda x: x.timestamp)
+
+ return events
+
+
+def save_stack(stack):
+ first = True
+ event = None
+ identifier = ''
+
+ for event in stack:
+ if first:
+ first = False
+ else:
+ identifier += ';'
+ identifier += event.label
+
+ if not event:
+ return
+
+ if identifier in stack_identifiers:
+ stack_identifiers[identifier] += event.total_duration
+ else:
+ stack_identifiers[identifier] = event.total_duration
+
+
+def load_stack_identifiers(events):
+ event_stack = []
+
+ for e in events:
+ if not event_stack:
+ event_stack.append(e)
+ else:
+ while event_stack and event_stack[-1].get_stop_timestamp() <= e.timestamp:
+ save_stack(event_stack)
+ event_stack.pop()
+
+ if event_stack:
+ event_stack[-1].total_duration -= e.duration
+
+ event_stack.append(e)
+
+ while event_stack:
+ save_stack(event_stack)
+ event_stack.pop()
+
+
+parser = argparse.ArgumentParser()
+parser.add_argument('input_file', nargs='+',
+ type=argparse.FileType('r'),
+ help='Chrome Tracing input files')
+args = parser.parse_args()
+
+all_events = load_events(args.input_file)
+for tid_pid in all_events:
+ load_stack_identifiers(all_events[tid_pid])
+
+for identifiers, duration in stack_identifiers.items():
+ print(identifiers + ' ' + str(duration))
diff --git a/tests/benchmarks/_script/flamegraph/stackcollapse-elfutils.pl b/tests/benchmarks/_script/flamegraph/stackcollapse-elfutils.pl
new file mode 100755
index 00000000000..c5e6b17e44b
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/stackcollapse-elfutils.pl
@@ -0,0 +1,98 @@
+#!/usr/bin/perl -w
+#
+# stackcollapse-elfutils Collapse elfutils stack (eu-stack) backtraces
+#
+# Parse a list of elfutils backtraces as generated with the poor man's
+# profiler [1]:
+#
+# for x in $(seq 1 "$nsamples"); do
+# eu-stack -p "$pid" "$@"
+# sleep "$sleeptime"
+# done
+#
+# [1] http://poormansprofiler.org/
+#
+# Copyright 2014 Gabriel Corona. All rights reserved.
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at docs/cddl1.txt or
+# http://opensource.org/licenses/CDDL-1.0.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at docs/cddl1.txt.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+
+use strict;
+use Getopt::Long;
+
+my $with_pid = 0;
+my $with_tid = 0;
+
+GetOptions('pid' => \$with_pid,
+ 'tid' => \$with_tid)
+or die <<USAGE_END;
+USAGE: $0 [options] infile > outfile\n
+ --pid # include PID
+ --tid # include TID
+USAGE_END
+
+my $pid = "";
+my $tid = "";
+my $current = "";
+my $previous_function = "";
+
+my %stacks;
+
+sub add_current {
+ if(!($current eq "")) {
+ my $entry;
+ if ($with_tid) {
+ $current = "TID=$tid;$current";
+ }
+ if ($with_pid) {
+ $current = "PID=$pid;$current";
+ }
+ $stacks{$current} += 1;
+ $current = "";
+ }
+}
+
+while(<>) {
+ chomp;
+ if (m/^PID ([0-9]*)/) {
+ add_current();
+ $pid = $1;
+ }
+ elsif(m/^TID ([0-9]*)/) {
+ add_current();
+ $tid = $1;
+ } elsif(m/^#[0-9]* *0x[0-9a-f]* (.*)/) {
+ if ($current eq "") {
+ $current = $1;
+ } else {
+ $current = "$1;$current";
+ }
+ } elsif(m/^#[0-9]* *0x[0-9a-f]*/) {
+ if ($current eq "") {
+ $current = "[unknown]";
+ } else {
+ $current = "[unknown];$current";
+ }
+ }
+}
+add_current();
+
+foreach my $k (sort { $a cmp $b } keys %stacks) {
+ print "$k $stacks{$k}\n";
+}
diff --git a/tests/benchmarks/_script/flamegraph/stackcollapse-faulthandler.pl b/tests/benchmarks/_script/flamegraph/stackcollapse-faulthandler.pl
new file mode 100755
index 00000000000..4fe74ffa7b8
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/stackcollapse-faulthandler.pl
@@ -0,0 +1,61 @@
+#!/usr/bin/perl -ws
+#
+# stackcollapse-faulthandler Collapse Python faulthandler backtraces
+#
+# Parse a list of Python faulthandler backtraces as generated with
+# faulthandler.dump_traceback_later.
+#
+# Copyright 2014 Gabriel Corona. All rights reserved.
+# Copyright 2017 Jonathan Kolb. All rights reserved.
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at docs/cddl1.txt or
+# http://opensource.org/licenses/CDDL-1.0.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at docs/cddl1.txt.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+
+use strict;
+
+my $current = "";
+
+my %stacks;
+
+while(<>) {
+ chomp;
+ if (m/^Thread/) {
+ $current=""
+ }
+ elsif(m/^ File "([^"]*)", line ([0-9]*) in (.*)/) {
+ my $function = $1 . ":" . $2 . ":" . $3;
+ if ($current eq "") {
+ $current = $function;
+ } else {
+ $current = $function . ";" . $current;
+ }
+ } elsif(!($current eq "")) {
+ $stacks{$current} += 1;
+ $current = "";
+ }
+}
+
+if(!($current eq "")) {
+ $stacks{$current} += 1;
+ $current = "";
+}
+
+foreach my $k (sort { $a cmp $b } keys %stacks) {
+ print "$k $stacks{$k}\n";
+}
diff --git a/tests/benchmarks/_script/flamegraph/stackcollapse-gdb.pl b/tests/benchmarks/_script/flamegraph/stackcollapse-gdb.pl
new file mode 100755
index 00000000000..8e9831b22e5
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/stackcollapse-gdb.pl
@@ -0,0 +1,72 @@
+#!/usr/bin/perl -ws
+#
+# stackcollapse-gdb Collapse GDB backtraces
+#
+# Parse a list of GDB backtraces as generated with the poor man's
+# profiler [1]:
+#
+# for x in $(seq 1 500); do
+# gdb -ex "set pagination 0" -ex "thread apply all bt" -batch -p $pid 2> /dev/null
+# sleep 0.01
+# done
+#
+# [1] http://poormansprofiler.org/
+#
+# Copyright 2014 Gabriel Corona. All rights reserved.
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at docs/cddl1.txt or
+# http://opensource.org/licenses/CDDL-1.0.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at docs/cddl1.txt.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+
+use strict;
+
+my $current = "";
+my $previous_function = "";
+
+my %stacks;
+
+while(<>) {
+ chomp;
+ if (m/^Thread/) {
+ $current=""
+ }
+ elsif(m/^#[0-9]* *([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*)/) {
+ my $function = $3;
+ my $alt = $1;
+ if(not($1 =~ /0x[a-zA-Z0-9]*/)) {
+ $function = $alt;
+ }
+ if ($current eq "") {
+ $current = $function;
+ } else {
+ $current = $function . ";" . $current;
+ }
+ } elsif(!($current eq "")) {
+ $stacks{$current} += 1;
+ $current = "";
+ }
+}
+
+if(!($current eq "")) {
+ $stacks{$current} += 1;
+ $current = "";
+}
+
+foreach my $k (sort { $a cmp $b } keys %stacks) {
+ print "$k $stacks{$k}\n";
+}
diff --git a/tests/benchmarks/_script/flamegraph/stackcollapse-go.pl b/tests/benchmarks/_script/flamegraph/stackcollapse-go.pl
new file mode 100755
index 00000000000..3b2ce3c552f
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/stackcollapse-go.pl
@@ -0,0 +1,150 @@
+#!/usr/bin/perl -w
+#
+# stackcollapse-go.pl collapse golang samples into single lines.
+#
+# Parses golang smaples generated by "go tool pprof" and outputs stacks as
+# single lines, with methods separated by semicolons, and then a space and an
+# occurrence count. For use with flamegraph.pl.
+#
+# USAGE: ./stackcollapse-go.pl infile > outfile
+#
+# Example Input:
+# ...
+# Samples:
+# samples/count cpu/nanoseconds
+# 1 10000000: 1 2
+# 2 10000000: 3 2
+# 1 10000000: 4 2
+# ...
+# Locations
+# 1: 0x58b265 scanblock :0 s=0
+# 2: 0x599530 GC :0 s=0
+# 3: 0x58a999 flushptrbuf :0 s=0
+# 4: 0x58d6a8 runtime.MSpan_Sweep :0 s=0
+# ...
+# Mappings
+# ...
+#
+# Example Output:
+#
+# GC;flushptrbuf 2
+# GC;runtime.MSpan_Sweep 1
+# GC;scanblock 1
+#
+# Input may contain many stacks as generated from go tool pprof:
+#
+# go tool pprof -seconds=60 -raw -output=a.pprof http://$ADDR/debug/pprof/profile
+#
+# For format of text profile, See golang/src/internal/pprof/profile/profile.go
+#
+# Copyright 2017 Sijie Yang (yangsijie@baidu.com). All rights reserved.
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+#
+# (http://www.gnu.org/copyleft/gpl.html)
+#
+# 16-Jan-2017 Sijie Yang Created this.
+
+use strict;
+
+use Getopt::Long;
+
+# tunables
+my $help = 0;
+
+sub usage {
+ die <<USAGE_END;
+USAGE: $0 infile > outfile\n
+USAGE_END
+}
+
+GetOptions(
+ 'help' => \$help,
+) or usage();
+$help && usage();
+
+# internals
+my $state = "ignore";
+my %stacks;
+my %frames;
+my %collapsed;
+
+sub remember_stack {
+ my ($stack, $count) = @_;
+ $stacks{$stack} += $count;
+}
+
+#
+# Output stack string in required format. For example, for the following samples,
+# format_statck() would return GC;runtime.MSpan_Sweep for stack "4 2"
+#
+# Locations
+# 1: 0x58b265 scanblock :0 s=0
+# 2: 0x599530 GC :0 s=0
+# 3: 0x58a999 flushptrbuf :0 s=0
+# 4: 0x58d6a8 runtime.MSpan_Sweep :0 s=0
+#
+sub format_statck {
+ my ($stack) = @_;
+ my @loc_list = split(/ /, $stack);
+
+ for (my $i=0; $i<=$#loc_list; $i++) {
+ my $loc_name = $frames{$loc_list[$i]};
+ $loc_list[$i] = $loc_name if ($loc_name);
+ }
+ return join(";", reverse(@loc_list));
+}
+
+foreach (<>) {
+ next if m/^#/;
+ chomp;
+
+ if ($state eq "ignore") {
+ if (/Samples:/) {
+ $state = "sample";
+ next;
+ }
+
+ } elsif ($state eq "sample") {
+ if (/^\s*([0-9]+)\s*[0-9]+: ([0-9 ]+)/) {
+ my $samples = $1;
+ my $stack = $2;
+ remember_stack($stack, $samples);
+ } elsif (/Locations/) {
+ $state = "location";
+ next;
+ }
+
+ } elsif ($state eq "location") {
+ if (/^\s*([0-9]*): 0x[0-9a-f]+ (M=[0-9]+ )?([^ ]+) .*/) {
+ my $loc_id = $1;
+ my $loc_name = $3;
+ $frames{$loc_id} = $loc_name;
+ } elsif (/Mappings/) {
+ $state = "mapping";
+ last;
+ }
+ }
+}
+
+foreach my $k (keys %stacks) {
+ my $stack = format_statck($k);
+ my $count = $stacks{$k};
+ $collapsed{$stack} += $count;
+}
+
+foreach my $k (sort { $a cmp $b } keys %collapsed) {
+ print "$k $collapsed{$k}\n";
+}
diff --git a/tests/benchmarks/_script/flamegraph/stackcollapse-ibmjava.pl b/tests/benchmarks/_script/flamegraph/stackcollapse-ibmjava.pl
new file mode 100644
index 00000000000..f8ffa8bd4d7
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/stackcollapse-ibmjava.pl
@@ -0,0 +1,145 @@
+#!/usr/bin/perl -w
+#
+# stackcollapse-ibmjava.pl collapse jstack samples into single lines.
+#
+# Parses Java stacks generated by IBM Java with methods separated by semicolons,
+# and then a space and an occurrence count.
+#
+# USAGE: ./stackcollapse-ibmjava.pl infile > outfile
+#
+# Example input:
+#
+# NULL
+# 1XMTHDINFO Thread Details
+# NULL
+# NULL
+# 3XMTHREADINFO "Default Executor-thread-149164" J9VMThread:0x0000000008132B00, j9thread_t:0x000000001A810B90, java/lang/Thread:0x0000000712BE8E48, state:R, prio=5
+# 3XMJAVALTHREAD (java/lang/Thread getId:0x3493E, isDaemon:true)
+# 3XMTHREADINFO1 (native thread ID:0x3158, native priority:0x5, native policy:UNKNOWN, vmstate:R, vm thread flags:0x00000001)
+# 3XMCPUTIME CPU usage total: 0.421875000 secs, user: 0.343750000 secs, system: 0.078125000 secs, current category="Application"
+# 3XMHEAPALLOC Heap bytes allocated since last GC cycle=0 (0x0)
+# 3XMTHREADINFO3 Java callstack:
+# 4XESTACKTRACE at java/net/SocketInputStream.socketRead0(Native Method)
+# 4XESTACKTRACE at java/net/SocketInputStream.socketRead(SocketInputStream.java:127(Compiled Code))
+# 4XESTACKTRACE at java/net/SocketInputStream.read(SocketInputStream.java:182(Compiled Code))
+# 4XESTACKTRACE at java/net/SocketInputStream.read(SocketInputStream.java:152(Compiled Code))
+# 4XESTACKTRACE at java/io/FilterInputStream.read(FilterInputStream.java:144(Compiled Code))
+# ...
+# 4XESTACKTRACE at java/lang/Thread.run(Thread.java:785(Compiled Code))
+#
+# Example output:
+#
+# Default Executor-thread-149164;java/lang/Thread.run;java/net/SocketInputStream/read;java/net/SocketInputStream.socketRead0 1
+#
+#
+# Copyright 2014 Federico Juinio. All rights reserved.
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+#
+# (http://www.gnu.org/copyleft/gpl.html)
+#
+# 23-Aug-2023 Federico Juinio created this based from stackcollapse-jstack.pl
+
+use strict;
+
+use Getopt::Long;
+
+# tunables
+my $include_tname = 1; # include thread names in stacks
+my $include_tid = 0; # include thread IDs in stacks
+my $shorten_pkgs = 0; # shorten package names
+my $help = 0;
+
+sub usage {
+ die <<USAGE_END;
+USAGE: $0 [options] infile > outfile\n
+ --include-tname
+ --no-include-tname # include/omit thread names in stacks (default: include)
+ --include-tid
+ --no-include-tid # include/omit thread IDs in stacks (default: omit)
+ --shorten-pkgs
+ --no-shorten-pkgs # (don't) shorten package names (default: don't shorten)
+
+ eg,
+ $0 --no-include-tname stacks.txt > collapsed.txt
+USAGE_END
+}
+
+GetOptions(
+ 'include-tname!' => \$include_tname,
+ 'include-tid!' => \$include_tid,
+ 'shorten-pkgs!' => \$shorten_pkgs,
+ 'help' => \$help,
+) or usage();
+$help && usage();
+
+
+# internals
+my %collapsed;
+
+sub remember_stack {
+ my ($stack, $count) = @_;
+ $collapsed{$stack} += $count;
+}
+
+my @stack;
+my $tname;
+my $state = "?";
+
+foreach (<>) {
+ next if m/^#/;
+ chomp;
+
+ if (m/^3XMTHREADINFO3 Native callstack:/) {
+ # save stack
+ if (defined $tname) { unshift @stack, $tname; }
+ remember_stack(join(";", @stack), 1) if @stack;
+ undef @stack;
+ undef $tname;
+ $state = "?";
+ next;
+ }
+
+ # look for thread header line and parse thread name and state
+ if (/^3XMTHREADINFO "([^"]*).* state:(.*), /) {
+ my $name = $1;
+ if ($include_tname) {
+ $tname = $name;
+ }
+ $state = $2;
+ # special handling for "Anonymous native threads"
+ } elsif (/3XMTHREADINFO Anonymous native thread/) {
+ $tname = "Anonymous native thread";
+ # look for thread id
+ } elsif (/^3XMTHREADINFO1 \(native thread ID:([^ ]*), native priority/) {
+ if ($include_tname && $include_tid) {
+ $tname = $tname . "-" . $1
+ }
+ # collect stack frames
+ } elsif (/^4XESTACKTRACE at ([^\(]*)/) {
+ my $func = $1;
+ if ($shorten_pkgs) {
+ my ($pkgs, $clsFunc) = ( $func =~ m/(.*\.)([^.]+\.[^.]+)$/ );
+ $pkgs =~ s/(\w)\w*/$1/g;
+ $func = $pkgs . $clsFunc;
+ }
+ unshift @stack, $func;
+
+ }
+}
+
+foreach my $k (sort { $a cmp $b } keys %collapsed) {
+ print "$k $collapsed{$k}\n";
+}
diff --git a/tests/benchmarks/_script/flamegraph/stackcollapse-instruments.pl b/tests/benchmarks/_script/flamegraph/stackcollapse-instruments.pl
new file mode 100755
index 00000000000..3cbaa87bc27
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/stackcollapse-instruments.pl
@@ -0,0 +1,34 @@
+#!/usr/bin/perl -w
+#
+# stackcollapse-instruments.pl
+#
+# Parses a file containing a call tree as produced by XCode Instruments
+# (Edit > Deep Copy) and produces output suitable for flamegraph.pl.
+#
+# USAGE: ./stackcollapse-instruments.pl infile > outfile
+
+use strict;
+
+my @stack = ();
+
+<>;
+foreach (<>) {
+ chomp;
+ /\d+\.\d+ (?:min|s|ms)\s+\d+\.\d+%\s+(\d+(?:\.\d+)?) (min|s|ms)\t \t(\s*)(.+)/ or die;
+ my $func = $4;
+ my $depth = length ($3);
+ $stack [$depth] = $4;
+ foreach my $i (0 .. $depth - 1) {
+ print $stack [$i];
+ print ";";
+ }
+
+ my $time = 0 + $1;
+ if ($2 eq "min") {
+ $time *= 60*1000;
+ } elsif ($2 eq "s") {
+ $time *= 1000;
+ }
+
+ printf("%s %.0f\n", $func, $time);
+}
diff --git a/tests/benchmarks/_script/flamegraph/stackcollapse-java-exceptions.pl b/tests/benchmarks/_script/flamegraph/stackcollapse-java-exceptions.pl
new file mode 100755
index 00000000000..19badbca6cb
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/stackcollapse-java-exceptions.pl
@@ -0,0 +1,72 @@
+#!/usr/bin/perl -w
+#
+# stackcolllapse-java-exceptions.pl collapse java exceptions (found in logs) into single lines.
+#
+# Parses Java error stacks found in a log file and outputs them as
+# single lines, with methods separated by semicolons, and then a space and an
+# occurrence count. Inspired by stackcollapse-jstack.pl except that it does
+# not act as a performance profiler.
+#
+# It can be useful if a Java process dumps a lot of different stacks in its logs
+# and you want to quickly identify the biggest culprits.
+#
+# USAGE: ./stackcollapse-java-exceptions.pl infile > outfile
+#
+# Copyright 2018 Paul de Verdiere. All rights reserved.
+
+use strict;
+use Getopt::Long;
+
+# tunables
+my $shorten_pkgs = 0; # shorten package names
+my $no_pkgs = 0; # really shorten package names!!
+my $help = 0;
+
+sub usage {
+ die <<USAGE_END;
+USAGE: $0 [options] infile > outfile\n
+ --shorten-pkgs : shorten package names
+ --no-pkgs : suppress package names (makes SVG much more readable)
+
+USAGE_END
+}
+
+GetOptions(
+ 'shorten-pkgs!' => \$shorten_pkgs,
+ 'no-pkgs!' => \$no_pkgs,
+ 'help' => \$help,
+) or usage();
+$help && usage();
+
+my %collapsed;
+
+sub remember_stack {
+ my ($stack, $count) = @_;
+ $collapsed{$stack} += $count;
+}
+
+my @stack;
+
+foreach (<>) {
+ chomp;
+
+ if (/^\s*at ([^\(]*)/) {
+ my $func = $1;
+ if ($shorten_pkgs || $no_pkgs) {
+ my ($pkgs, $clsFunc) = ( $func =~ m/(.*\.)([^.]+\.[^.]+)$/ );
+ $pkgs =~ s/(\w)\w*/$1/g;
+ $func = $no_pkgs ? $clsFunc: $pkgs . $clsFunc;
+ }
+ unshift @stack, $func;
+ } elsif (@stack ) {
+ next if m/.*waiting on .*/;
+ remember_stack(join(";", @stack), 1) if @stack;
+ undef @stack;
+ }
+}
+
+remember_stack(join(";", @stack), 1) if @stack;
+
+foreach my $k (sort { $a cmp $b } keys %collapsed) {
+ print "$k $collapsed{$k}\n";
+}
diff --git a/tests/benchmarks/_script/flamegraph/stackcollapse-jstack.pl b/tests/benchmarks/_script/flamegraph/stackcollapse-jstack.pl
new file mode 100755
index 00000000000..da5740b6ee6
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/stackcollapse-jstack.pl
@@ -0,0 +1,176 @@
+#!/usr/bin/perl -w
+#
+# stackcollapse-jstack.pl collapse jstack samples into single lines.
+#
+# Parses Java stacks generated by jstack(1) and outputs RUNNABLE stacks as
+# single lines, with methods separated by semicolons, and then a space and an
+# occurrence count. This also filters some other "RUNNABLE" states that we
+# know are probably not running, such as epollWait. For use with flamegraph.pl.
+#
+# You want this to process the output of at least 100 jstack(1)s. ie, run it
+# 100 times with a sleep interval, and append to a file. This is really a poor
+# man's Java profiler, due to the overheads of jstack(1), and how it isn't
+# capturing stacks asynchronously. For a better profiler, see:
+# http://www.brendangregg.com/blog/2014-06-12/java-flame-graphs.html
+#
+# USAGE: ./stackcollapse-jstack.pl infile > outfile
+#
+# Example input:
+#
+# "MyProg" #273 daemon prio=9 os_prio=0 tid=0x00007f273c038800 nid=0xe3c runnable [0x00007f28a30f2000]
+# java.lang.Thread.State: RUNNABLE
+# at java.net.SocketInputStream.socketRead0(Native Method)
+# at java.net.SocketInputStream.read(SocketInputStream.java:121)
+# ...
+# at java.lang.Thread.run(Thread.java:744)
+#
+# Example output:
+#
+# MyProg;java.lang.Thread.run;java.net.SocketInputStream.read;java.net.SocketInputStream.socketRead0 1
+#
+# Input may be created and processed using:
+#
+# i=0; while (( i++ < 200 )); do jstack PID >> out.jstacks; sleep 10; done
+# cat out.jstacks | ./stackcollapse-jstack.pl > out.stacks-folded
+#
+# WARNING: jstack(1) incurs overheads. Test before use, or use a real profiler.
+#
+# Copyright 2014 Brendan Gregg. All rights reserved.
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+#
+# (http://www.gnu.org/copyleft/gpl.html)
+#
+# 14-Sep-2014 Brendan Gregg Created this.
+
+use strict;
+
+use Getopt::Long;
+
+# tunables
+my $include_tname = 1; # include thread names in stacks
+my $include_tid = 0; # include thread IDs in stacks
+my $shorten_pkgs = 0; # shorten package names
+my $help = 0;
+
+sub usage {
+ die <<USAGE_END;
+USAGE: $0 [options] infile > outfile\n
+ --include-tname
+ --no-include-tname # include/omit thread names in stacks (default: include)
+ --include-tid
+ --no-include-tid # include/omit thread IDs in stacks (default: omit)
+ --shorten-pkgs
+ --no-shorten-pkgs # (don't) shorten package names (default: don't shorten)
+
+ eg,
+ $0 --no-include-tname stacks.txt > collapsed.txt
+USAGE_END
+}
+
+GetOptions(
+ 'include-tname!' => \$include_tname,
+ 'include-tid!' => \$include_tid,
+ 'shorten-pkgs!' => \$shorten_pkgs,
+ 'help' => \$help,
+) or usage();
+$help && usage();
+
+
+# internals
+my %collapsed;
+
+sub remember_stack {
+ my ($stack, $count) = @_;
+ $collapsed{$stack} += $count;
+}
+
+my @stack;
+my $tname;
+my $state = "?";
+
+foreach (<>) {
+ next if m/^#/;
+ chomp;
+
+ if (m/^$/) {
+ # only include RUNNABLE states
+ goto clear if $state ne "RUNNABLE";
+
+ # save stack
+ if (defined $tname) { unshift @stack, $tname; }
+ remember_stack(join(";", @stack), 1) if @stack;
+clear:
+ undef @stack;
+ undef $tname;
+ $state = "?";
+ next;
+ }
+
+ #
+ # While parsing jstack output, the $state variable may be altered from
+ # RUNNABLE to other states. This causes the stacks to be filtered later,
+ # since only RUNNABLE stacks are included.
+ #
+
+ if (/^"([^"]*)/) {
+ my $name = $1;
+
+ if ($include_tname) {
+ $tname = $name;
+ unless ($include_tid) {
+ $tname =~ s/-\d+$//;
+ }
+ }
+
+ # set state for various background threads
+ $state = "BACKGROUND" if $name =~ /C. CompilerThread/;
+ $state = "BACKGROUND" if $name =~ /Signal Dispatcher/;
+ $state = "BACKGROUND" if $name =~ /Service Thread/;
+ $state = "BACKGROUND" if $name =~ /Attach Listener/;
+
+ } elsif (/java.lang.Thread.State: (\S+)/) {
+ $state = $1 if $state eq "?";
+ } elsif (/^\s*at ([^\(]*)/) {
+ my $func = $1;
+ if ($shorten_pkgs) {
+ my ($pkgs, $clsFunc) = ( $func =~ m/(.*\.)([^.]+\.[^.]+)$/ );
+ $pkgs =~ s/(\w)\w*/$1/g;
+ $func = $pkgs . $clsFunc;
+ }
+ unshift @stack, $func;
+
+ # fix state for epollWait
+ $state = "WAITING" if $func =~ /epollWait/;
+ $state = "WAITING" if $func =~ /EPoll\.wait/;
+
+
+ # fix state for various networking functions
+ $state = "NETWORK" if $func =~ /socketAccept$/;
+ $state = "NETWORK" if $func =~ /Socket.*accept0$/;
+ $state = "NETWORK" if $func =~ /socketRead0$/;
+
+ } elsif (/^\s*-/ or /^2\d\d\d-/ or /^Full thread dump/ or
+ /^JNI global references:/) {
+ # skip these info lines
+ next;
+ } else {
+ warn "Unrecognized line: $_";
+ }
+}
+
+foreach my $k (sort { $a cmp $b } keys %collapsed) {
+ print "$k $collapsed{$k}\n";
+}
diff --git a/tests/benchmarks/_script/flamegraph/stackcollapse-ljp.awk b/tests/benchmarks/_script/flamegraph/stackcollapse-ljp.awk
new file mode 100755
index 00000000000..59aaae3d73b
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/stackcollapse-ljp.awk
@@ -0,0 +1,74 @@
+#!/usr/bin/awk -f
+#
+# stackcollapse-ljp.awk collapse lightweight java profile reports
+# into single lines stacks.
+#
+# Parses a list of multiline stacks generated by:
+#
+# https://code.google.com/p/lightweight-java-profiler
+#
+# and outputs a semicolon separated stack followed by a space and a count.
+#
+# USAGE: ./stackcollapse-ljp.pl infile > outfile
+#
+# Example input:
+#
+# 42 3 my_func_b(prog.java:455)
+# my_func_a(prog.java:123)
+# java.lang.Thread.run(Thread.java:744)
+# [...]
+#
+# Example output:
+#
+# java.lang.Thread.run;my_func_a;my_func_b 42
+#
+# The unused number is the number of frames in each stack.
+#
+# Copyright 2014 Brendan Gregg. All rights reserved.
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at docs/cddl1.txt or
+# http://opensource.org/licenses/CDDL-1.0.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at docs/cddl1.txt.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+# 12-Jun-2014 Brendan Gregg Created this.
+
+$1 == "Total" {
+ # We're done. Print last stack and exit.
+ print stack, count
+ exit
+}
+
+{
+ # Strip file location. Comment this out to keep.
+ gsub(/\(.*\)/, "")
+}
+
+NF == 3 {
+ # New stack begins. Print previous buffered stack.
+ if (count)
+ print stack, count
+
+ # Begin a new stack.
+ count = $1
+ stack = $3
+}
+
+NF == 1 {
+ # Build stack.
+ stack = $1 ";" stack
+}
diff --git a/tests/benchmarks/_script/flamegraph/stackcollapse-perf-sched.awk b/tests/benchmarks/_script/flamegraph/stackcollapse-perf-sched.awk
new file mode 100755
index 00000000000..e1a122d459e
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/stackcollapse-perf-sched.awk
@@ -0,0 +1,228 @@
+#!/usr/bin/awk -f
+
+#
+# This program generates collapsed off-cpu stacks fit for use by flamegraph.pl
+# from scheduler data collected via perf_events.
+#
+# Outputs the cumulative time off cpu in us for each distinct stack observed.
+#
+# Some awk variables further control behavior:
+#
+# record_tid If truthy, causes all stack traces to include the
+# command and LWP id.
+#
+# record_wake_stack If truthy, stacks include the frames from the wakeup
+# event in addition to the sleep event.
+# See http://www.brendangregg.com/FlameGraphs/offcpuflamegraphs.html#Wakeup
+#
+# recurse If truthy, attempt to recursively identify and
+# visualize the full wakeup stack chain.
+# See http://www.brendangregg.com/FlameGraphs/offcpuflamegraphs.html#ChainGraph
+#
+# Note that this is only an approximation, as only the
+# last sleep event is recorded (e.g. if a thread slept
+# multiple times before waking another thread, only the
+# last sleep event is used). Implies record_wake_stack=1
+#
+# To set any of these variables from the command line, run via:
+#
+# stackcollapse-perf-sched.awk -v recurse=1
+#
+# == Important warning ==
+#
+# WARNING: tracing all scheduler events is very high overhead in perf. Even
+# more alarmingly, there appear to be bugs in perf that prevent it from reliably
+# getting consistent traces (even with large trace buffers), causing it to
+# produce empty perf.data files with error messages of the form:
+#
+# 0x952790 [0x736d]: failed to process type: 3410
+#
+# This failure is not determinisitic, so re-executing perf record will
+# eventually succeed.
+#
+# == Usage ==
+#
+# First, record data via perf_events:
+#
+# sudo perf record -g -e 'sched:sched_switch' \
+# -e 'sched:sched_stat_sleep' -e 'sched:sched_stat_blocked' \
+# -p <pid> -o perf.data -- sleep 1
+#
+# Then post process with this script:
+#
+# sudo perf script -f time,comm,pid,tid,event,ip,sym,dso,trace -i perf.data | \
+# stackcollapse-perf-sched.awk -v recurse=1 | \
+# flamegraph.pl --color=io --countname=us >out.svg
+#
+
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at docs/cddl1.txt or
+# http://opensource.org/licenses/CDDL-1.0.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at docs/cddl1.txt.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+
+#
+# Copyright (c) 2015 by MemSQL. All rights reserved.
+#
+
+#
+# Match a perf captured variable, returning just the contents. For example, for
+# the following line, get_perf_captured_variable("pid") would return "27235":
+#
+# swapper 0 [006] 708189.626415: sched:sched_stat_sleep: comm=memsqld pid=27235 delay=100078421 [ns
+#
+function get_perf_captured_variable(variable)
+{
+ match($0, variable "=[^[:space:]]+")
+ return substr($0, RSTART + length(variable) + 1,
+ RLENGTH - length(variable) - 1)
+}
+
+#
+# The timestamp is the first field that ends in a colon, e.g.:
+#
+# swapper 0 [006] 708189.626415: sched:sched_stat_sleep: comm=memsqld pid=27235 delay=100078421 [ns
+#
+# or
+#
+# swapper 0/0 708189.626415: sched:sched_stat_sleep: comm=memsqld pid=27235 delay=100078421 [ns]
+#
+function get_perf_timestamp()
+{
+ match($0, " [^ :]+:")
+ return substr($0, RSTART + 1, RLENGTH - 2)
+}
+
+!/^#/ && /sched:sched_switch/ {
+ switchcommand = get_perf_captured_variable("comm")
+
+ switchpid = get_perf_captured_variable("prev_pid")
+
+ switchtime=get_perf_timestamp()
+
+ switchstack=""
+}
+
+#
+# Strip the function name from a stack entry
+#
+# Stack entry is expected to be formatted like:
+# c60849 MyClass::Foo(unsigned long) (/home/areece/a.out)
+#
+function get_function_name()
+{
+ # We start from 2 since we don't need the hex offset.
+ # We stop at NF - 1 since we don't need the library path.
+ funcname = $2
+ for (i = 3; i <= NF - 1; i++) {
+ funcname = funcname " " $i
+ }
+ return funcname
+}
+
+(switchpid != 0 && /^\s/) {
+ if (switchstack == "") {
+ switchstack = get_function_name()
+ } else {
+ switchstack = get_function_name() ";" switchstack
+ }
+}
+
+(switchpid != 0 && /^$/) {
+ switch_stacks[switchpid] = switchstack
+ delete last_switch_stacks[switchpid]
+ switch_time[switchpid] = switchtime
+
+ switchpid=0
+ switchcommand=""
+ switchstack=""
+}
+
+!/^#/ && (/sched:sched_stat_sleep/ || /sched:sched_stat_blocked/) {
+ wakecommand=$1
+ wakepid=$2
+
+ waketime=get_perf_timestamp()
+
+ stat_next_command = get_perf_captured_variable("comm")
+
+ stat_next_pid = get_perf_captured_variable("pid")
+
+ stat_delay_ns = int(get_perf_captured_variable("delay"))
+
+ wakestack=""
+}
+
+(stat_next_pid != 0 && /^\s/) {
+ if (wakestack == "") {
+ wakestack = get_function_name()
+ } else {
+ # We build the wakestack in reverse order.
+ wakestack = wakestack ";" get_function_name()
+ }
+}
+
+(stat_next_pid != 0 && /^$/) {
+ #
+ # For some reason, perf appears to output duplicate
+ # sched:sched_stat_sleep and sched:sched_stat_blocked events. We only
+ # handle the first event.
+ #
+ if (stat_next_pid in switch_stacks) {
+ last_wake_time[stat_next_pid] = waketime
+
+ stack = switch_stacks[stat_next_pid]
+ if (recurse || record_wake_stack) {
+ stack = stack ";" wakestack
+ if (record_tid) {
+ stack = stack ";" wakecommand "-" wakepid
+ } else {
+ stack = stack ";" wakecommand
+ }
+ }
+
+ if (recurse) {
+ if (last_wake_time[wakepid] > last_switch_time[stat_next_pid]) {
+ stack = stack ";-;" last_switch_stacks[wakepid]
+ }
+ last_switch_stacks[stat_next_pid] = stack
+ }
+
+ delete switch_stacks[stat_next_pid]
+
+ if (record_tid) {
+ stack_times[stat_next_command "-" stat_next_pid ";" stack] += stat_delay_ns
+ } else {
+ stack_times[stat_next_command ";" stack] += stat_delay_ns
+ }
+ }
+
+ wakecommand=""
+ wakepid=0
+ stat_next_pid=0
+ stat_next_command=""
+ stat_delay_ms=0
+}
+
+END {
+ for (stack in stack_times) {
+ if (int(stack_times[stack] / 1000) > 0) {
+ print stack, int(stack_times[stack] / 1000)
+ }
+ }
+}
diff --git a/tests/benchmarks/_script/flamegraph/stackcollapse-perf.pl b/tests/benchmarks/_script/flamegraph/stackcollapse-perf.pl
new file mode 100755
index 00000000000..3ff39bfb87f
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/stackcollapse-perf.pl
@@ -0,0 +1,435 @@
+#!/usr/bin/perl -w
+#
+# stackcollapse-perf.pl collapse perf samples into single lines.
+#
+# Parses a list of multiline stacks generated by "perf script", and
+# outputs a semicolon separated stack followed by a space and a count.
+# If memory addresses (+0xd) are present, they are stripped, and resulting
+# identical stacks are colased with their counts summed.
+#
+# USAGE: ./stackcollapse-perf.pl [options] infile > outfile
+#
+# Run "./stackcollapse-perf.pl -h" to list options.
+#
+# Example input:
+#
+# swapper 0 [000] 158665.570607: cpu-clock:
+# ffffffff8103ce3b native_safe_halt ([kernel.kallsyms])
+# ffffffff8101c6a3 default_idle ([kernel.kallsyms])
+# ffffffff81013236 cpu_idle ([kernel.kallsyms])
+# ffffffff815bf03e rest_init ([kernel.kallsyms])
+# ffffffff81aebbfe start_kernel ([kernel.kallsyms].init.text)
+# [...]
+#
+# Example output:
+#
+# swapper;start_kernel;rest_init;cpu_idle;default_idle;native_safe_halt 1
+#
+# Input may be created and processed using:
+#
+# perf record -a -g -F 997 sleep 60
+# perf script | ./stackcollapse-perf.pl > out.stacks-folded
+#
+# The output of "perf script" should include stack traces. If these are missing
+# for you, try manually selecting the perf script output; eg:
+#
+# perf script -f comm,pid,tid,cpu,time,event,ip,sym,dso,trace | ...
+#
+# This is also required for the --pid or --tid options, so that the output has
+# both the PID and TID.
+#
+# Copyright 2012 Joyent, Inc. All rights reserved.
+# Copyright 2012 Brendan Gregg. All rights reserved.
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at docs/cddl1.txt or
+# http://opensource.org/licenses/CDDL-1.0.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at docs/cddl1.txt.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+# 02-Mar-2012 Brendan Gregg Created this.
+# 02-Jul-2014 " " Added process name to stacks.
+
+use strict;
+use Getopt::Long;
+
+my %collapsed;
+
+sub remember_stack {
+ my ($stack, $count) = @_;
+ $collapsed{$stack} += $count;
+}
+my $annotate_kernel = 0; # put an annotation on kernel function
+my $annotate_jit = 0; # put an annotation on jit symbols
+my $annotate_all = 0; # enale all annotations
+my $include_pname = 1; # include process names in stacks
+my $include_pid = 0; # include process ID with process name
+my $include_tid = 0; # include process & thread ID with process name
+my $include_addrs = 0; # include raw address where a symbol can't be found
+my $tidy_java = 1; # condense Java signatures
+my $tidy_generic = 1; # clean up function names a little
+my $target_pname; # target process name from perf invocation
+my $event_filter = ""; # event type filter, defaults to first encountered event
+my $event_defaulted = 0; # whether we defaulted to an event (none provided)
+my $event_warning = 0; # if we printed a warning for the event
+
+my $show_inline = 0;
+my $show_context = 0;
+
+my $srcline_in_input = 0; # if there are extra lines with source location (perf script -F+srcline)
+GetOptions('inline' => \$show_inline,
+ 'context' => \$show_context,
+ 'srcline' => \$srcline_in_input,
+ 'pid' => \$include_pid,
+ 'kernel' => \$annotate_kernel,
+ 'jit' => \$annotate_jit,
+ 'all' => \$annotate_all,
+ 'tid' => \$include_tid,
+ 'addrs' => \$include_addrs,
+ 'event-filter=s' => \$event_filter)
+or die <<USAGE_END;
+USAGE: $0 [options] infile > outfile\n
+ --pid # include PID with process names [1]
+ --tid # include TID and PID with process names [1]
+ --inline # un-inline using addr2line
+ --all # all annotations (--kernel --jit)
+ --kernel # annotate kernel functions with a _[k]
+ --jit # annotate jit functions with a _[j]
+ --context # adds source context to --inline
+ --srcline # parses output of 'perf script -F+srcline' and adds source context
+ --addrs # include raw addresses where symbols can't be found
+ --event-filter=EVENT # event name filter\n
+[1] perf script must emit both PID and TIDs for these to work; eg, Linux < 4.1:
+ perf script -f comm,pid,tid,cpu,time,event,ip,sym,dso,trace
+ for Linux >= 4.1:
+ perf script -F comm,pid,tid,cpu,time,event,ip,sym,dso,trace
+ If you save this output add --header on Linux >= 3.14 to include perf info.
+USAGE_END
+
+if ($annotate_all) {
+ $annotate_kernel = $annotate_jit = 1;
+}
+
+my %inlineCache;
+
+my %nmCache;
+
+sub inlineCacheAdd {
+ my ($pc, $mod, $result) = @_;
+ if (defined($inlineCache{$pc})) {
+ $inlineCache{$pc}{$mod} = $result;
+ } else {
+ $inlineCache{$pc} = {$mod => $result};
+ }
+}
+
+# for the --inline option
+sub inline {
+ my ($pc, $rawfunc, $mod) = @_;
+
+ return $inlineCache{$pc}{$mod} if defined($inlineCache{$pc}{$mod});
+
+ # capture addr2line output
+ my $a2l_output = `addr2line -a $pc -e $mod -i -f -s -C`;
+
+ # remove first line
+ $a2l_output =~ s/^(.*\n){1}//;
+
+ if ($a2l_output =~ /\?\?\n\?\?:0/) {
+ # if addr2line fails and rawfunc is func+offset, then fall back to it
+ if ($rawfunc =~ /^(.+)\+0x([0-9a-f]+)$/) {
+ my $func = $1;
+ my $addr = hex $2;
+
+ $nmCache{$mod}=`nm $mod` unless defined $nmCache{$mod};
+
+ if ($nmCache{$mod} =~ /^([0-9a-f]+) . \Q$func\E$/m) {
+ my $base = hex $1;
+ my $newPc = sprintf "0x%x", $base+$addr;
+ my $result = inline($newPc, '', $mod);
+ inlineCacheAdd($pc, $mod, $result);
+ return $result;
+ }
+ }
+ }
+
+ my @fullfunc;
+ my $one_item = "";
+ for (split /^/, $a2l_output) {
+ chomp $_;
+
+ # remove discriminator info if exists
+ $_ =~ s/ \(discriminator \S+\)//;
+
+ if ($one_item eq "") {
+ $one_item = $_;
+ } else {
+ if ($show_context == 1) {
+ unshift @fullfunc, $one_item . ":$_";
+ } else {
+ unshift @fullfunc, $one_item;
+ }
+ $one_item = "";
+ }
+ }
+
+ my $result = join ";" , @fullfunc;
+
+ inlineCacheAdd($pc, $mod, $result);
+
+ return $result;
+}
+
+my @stack;
+my $pname;
+my $m_pid;
+my $m_tid;
+my $m_period;
+
+#
+# Main loop
+#
+while (defined($_ = <>)) {
+
+ # find the name of the process launched by perf, by stepping backwards
+ # over the args to find the first non-option (no dash):
+ if (/^# cmdline/) {
+ my @args = split ' ', $_;
+ foreach my $arg (reverse @args) {
+ if ($arg !~ /^-/) {
+ $target_pname = $arg;
+ $target_pname =~ s:.*/::; # strip pathname
+ last;
+ }
+ }
+ }
+
+ # skip remaining comments
+ next if m/^#/;
+ chomp;
+
+ # end of stack. save cached data.
+ if (m/^$/) {
+ # ignore filtered samples
+ next if not $pname;
+
+ if ($include_pname) {
+ if (defined $pname) {
+ unshift @stack, $pname;
+ } else {
+ unshift @stack, "";
+ }
+ }
+ remember_stack(join(";", @stack), $m_period) if @stack;
+ undef @stack;
+ undef $pname;
+ next;
+ }
+
+ #
+ # event record start
+ #
+ if (/^(\S.+?)\s+(\d+)\/*(\d+)*\s+/) {
+ # default "perf script" output has TID but not PID
+ # eg, "java 25607 4794564.109216: 1 cycles:"
+ # eg, "java 12688 [002] 6544038.708352: 235 cpu-clock:"
+ # eg, "V8 WorkerThread 25607 4794564.109216: 104345 cycles:"
+ # eg, "java 24636/25607 [000] 4794564.109216: 1 cycles:"
+ # eg, "java 12688/12764 6544038.708352: 10309278 cpu-clock:"
+ # eg, "V8 WorkerThread 24636/25607 [000] 94564.109216: 100 cycles:"
+ # other combinations possible
+ my ($comm, $pid, $tid, $period) = ($1, $2, $3, "");
+ if (not $tid) {
+ $tid = $pid;
+ $pid = "?";
+ }
+
+ if (/:\s*(\d+)*\s+(\S+):\s*$/) {
+ $period = $1;
+ my $event = $2;
+
+ if ($event_filter eq "") {
+ # By default only show events of the first encountered
+ # event type. Merging together different types, such as
+ # instructions and cycles, produces misleading results.
+ $event_filter = $event;
+ $event_defaulted = 1;
+ } elsif ($event ne $event_filter) {
+ if ($event_defaulted and $event_warning == 0) {
+ # only print this warning if necessary:
+ # when we defaulted and there was
+ # multiple event types.
+ print STDERR "Filtering for events of type: $event\n";
+ $event_warning = 1;
+ }
+ next;
+ }
+ }
+
+ if (not $period) {
+ $period = 1
+ }
+ ($m_pid, $m_tid, $m_period) = ($pid, $tid, $period);
+
+ if ($include_tid) {
+ $pname = "$comm-$m_pid/$m_tid";
+ } elsif ($include_pid) {
+ $pname = "$comm-$m_pid";
+ } else {
+ $pname = "$comm";
+ }
+ $pname =~ tr/ /_/;
+
+ #
+ # stack line
+ #
+ } elsif (/^\s*(\w+)\s*(.+) \((.*)\)/) {
+ # ignore filtered samples
+ next if not $pname;
+
+ my ($pc, $rawfunc, $mod) = ($1, $2, $3);
+
+ if ($show_inline == 1 && $mod !~ m/(perf-\d+.map|kernel\.|\[[^\]]+\])/) {
+ my $inlineRes = inline($pc, $rawfunc, $mod);
+ # - empty result this happens e.g., when $mod does not exist or is a path to a compressed kernel module
+ # if this happens, the user will see error message from addr2line written to stderr
+ # - if addr2line results in "??" , then it's much more sane to fall back than produce a '??' in graph
+ if($inlineRes ne "" and $inlineRes ne "??" and $inlineRes ne "??:??:0" ) {
+ unshift @stack, $inlineRes;
+ next;
+ }
+ }
+
+ # Linux 4.8 included symbol offsets in perf script output by default, eg:
+ # 7fffb84c9afc cpu_startup_entry+0x800047c022ec ([kernel.kallsyms])
+ # strip these off:
+ $rawfunc =~ s/\+0x[\da-f]+$//;
+
+ next if $rawfunc =~ /^\(/; # skip process names
+
+ my $is_unknown=0;
+ my @inline;
+ for (split /\->/, $rawfunc) {
+ my $func = $_;
+
+ if ($func eq "[unknown]") {
+ if ($mod ne "[unknown]") { # use module name instead, if known
+ $func = $mod;
+ $func =~ s/.*\///;
+ } else {
+ $func = "unknown";
+ $is_unknown=1;
+ }
+
+ if ($include_addrs) {
+ $func = "\[$func \<$pc\>\]";
+ } else {
+ $func = "\[$func\]";
+ }
+ }
+
+ if ($tidy_generic) {
+ $func =~ s/;/:/g;
+ if ($func !~ m/\.\(.*\)\./) {
+ # This doesn't look like a Go method name (such as
+ # "net/http.(*Client).Do"), so everything after the first open
+ # paren (that is not part of an "(anonymous namespace)") is
+ # just noise.
+ $func =~ s/\((?!anonymous namespace\)).*//;
+ }
+ # now tidy this horrible thing:
+ # 13a80b608e0a RegExp:[&<>\"\'] (/tmp/perf-7539.map)
+ $func =~ tr/"\'//d;
+ # fall through to $tidy_java
+ }
+
+ if ($tidy_java and $pname =~ m/^java/) {
+ # along with $tidy_generic, converts the following:
+ # Lorg/mozilla/javascript/ContextFactory;.call(Lorg/mozilla/javascript/ContextAction;)Ljava/lang/Object;
+ # Lorg/mozilla/javascript/ContextFactory;.call(Lorg/mozilla/javascript/C
+ # Lorg/mozilla/javascript/MemberBox;.<init>(Ljava/lang/reflect/Method;)V
+ # into:
+ # org/mozilla/javascript/ContextFactory:.call
+ # org/mozilla/javascript/ContextFactory:.call
+ # org/mozilla/javascript/MemberBox:.init
+ $func =~ s/^L// if $func =~ m:/:;
+ }
+
+ #
+ # Annotations
+ #
+ # detect inlined from the @inline array
+ # detect kernel from the module name; eg, frames to parse include:
+ # ffffffff8103ce3b native_safe_halt ([kernel.kallsyms])
+ # 8c3453 tcp_sendmsg (/lib/modules/4.3.0-rc1-virtual/build/vmlinux)
+ # 7d8 ipv4_conntrack_local+0x7f8f80b8 ([nf_conntrack_ipv4])
+ # detect jit from the module name; eg:
+ # 7f722d142778 Ljava/io/PrintStream;::print (/tmp/perf-19982.map)
+ if (scalar(@inline) > 0) {
+ $func .= "_[i]" unless $func =~ m/\_\[i\]/; # inlined
+ } elsif ($annotate_kernel == 1 && $mod =~ m/(^\[|vmlinux$)/ && $mod !~ /unknown/) {
+ $func .= "_[k]"; # kernel
+ } elsif ($annotate_jit == 1 && $mod =~ m:/tmp/perf-\d+\.map:) {
+ $func .= "_[j]" unless $func =~ m/\_\[j\]/; # jitted
+ }
+
+ #
+ # Source lines
+ #
+ #
+ # Sample outputs:
+ # | a.out 35081 252436.005167: 667783 cycles:
+ # | 408ebb some_method_name+0x8b (/full/path/to/a.out)
+ # | uniform_int_dist.h:300
+ # | 4069f5 main+0x935 (/full/path/to/a.out)
+ # | file.cpp:137
+ # | 7f6d2148eb25 __libc_start_main+0xd5 (/lib64/libc-2.33.so)
+ # | libc-2.33.so[27b25]
+ #
+ # | a.out 35081 252435.738165: 306459 cycles:
+ # | 7f6d213c2750 [unknown] (/usr/lib64/libkmod.so.2.3.6)
+ # | libkmod.so.2.3.6[6750]
+ #
+ # | a.out 35081 252435.738373: 315813 cycles:
+ # | 7f6d215ca51b __strlen_avx2+0x4b (/lib64/libc-2.33.so)
+ # | libc-2.33.so[16351b]
+ # | 7ffc71ee9580 [unknown] ([unknown])
+ # |
+ #
+ # | a.out 35081 252435.718940: 247984 cycles:
+ # | ffffffff814f9302 up_write+0x32 ([kernel.kallsyms])
+ # | [kernel.kallsyms][ffffffff814f9302]
+ if($srcline_in_input and not $is_unknown){
+ $_ = <>;
+ chomp;
+ s/\[.*?\]//g;
+ s/^\s*//g;
+ s/\s*$//g;
+ $func.=':'.$_ unless $_ eq "";
+ }
+
+ push @inline, $func;
+ }
+
+ unshift @stack, @inline;
+ } else {
+ warn "Unrecognized line: $_";
+ }
+}
+
+foreach my $k (sort { $a cmp $b } keys %collapsed) {
+ print "$k $collapsed{$k}\n";
+}
diff --git a/tests/benchmarks/_script/flamegraph/stackcollapse-pmc.pl b/tests/benchmarks/_script/flamegraph/stackcollapse-pmc.pl
new file mode 100755
index 00000000000..5bd7c2dada4
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/stackcollapse-pmc.pl
@@ -0,0 +1,74 @@
+#!/usr/bin/env perl
+#
+# Copyright (c) 2014 Ed Maste. All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# 1. Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions and the following disclaimer in the
+# documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+# SUCH DAMAGE.
+#
+# stackcollapse-pmc.pl collapse hwpmc samples into single lines.
+#
+# Parses a list of multiline stacks generated by "hwpmc -G", and outputs a
+# semicolon-separated stack followed by a space and a count.
+#
+# Usage:
+# pmcstat -S unhalted-cycles -O pmc.out
+# pmcstat -R pmc.out -z16 -G pmc.graph
+# stackcollapse-pmc.pl pmc.graph > pmc.stack
+#
+# Example input:
+#
+# 03.07% [17] witness_unlock @ /boot/kernel/kernel
+# 70.59% [12] __mtx_unlock_flags
+# 16.67% [2] selfdfree
+# 100.0% [2] sys_poll
+# 100.0% [2] amd64_syscall
+# 08.33% [1] pmap_ts_referenced
+# 100.0% [1] vm_pageout
+# 100.0% [1] fork_exit
+# ...
+#
+# Example output:
+#
+# amd64_syscall;sys_poll;selfdfree;__mtx_unlock_flags;witness_unlock 2
+# amd64_syscall;sys_poll;pmap_ts_referenced;__mtx_unlock_flagsgeout;fork_exit 1
+# ...
+
+use warnings;
+use strict;
+
+my @stack;
+my $prev_count;
+my $prev_indent = -1;
+
+while (defined($_ = <>)) {
+ if (m/^( *)[0-9.]+% \[([0-9]+)\]\s*(\S+)/) {
+ my $indent = length($1);
+ if ($indent <= $prev_indent) {
+ print join(';', reverse(@stack[0 .. $prev_indent])) .
+ " $prev_count\n";
+ }
+ $stack[$indent] = $3;
+ $prev_count = $2;
+ $prev_indent = $indent;
+ }
+}
+print join(';', reverse(@stack[0 .. $prev_indent])) . " $prev_count\n";
diff --git a/tests/benchmarks/_script/flamegraph/stackcollapse-recursive.pl b/tests/benchmarks/_script/flamegraph/stackcollapse-recursive.pl
new file mode 100755
index 00000000000..9eae54592c4
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/stackcollapse-recursive.pl
@@ -0,0 +1,60 @@
+#!/usr/bin/perl -ws
+#
+# stackcollapse-recursive Collapse direct recursive backtraces
+#
+# Post-process a stack list and merge direct recursive calls:
+#
+# Example input:
+#
+# main;recursive;recursive;recursive;helper 1
+#
+# Output:
+#
+# main;recursive;helper 1
+#
+# Copyright 2014 Gabriel Corona. All rights reserved.
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at docs/cddl1.txt or
+# http://opensource.org/licenses/CDDL-1.0.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at docs/cddl1.txt.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+
+my %stacks;
+
+while(<>) {
+ chomp;
+ my ($stack_, $value) = (/^(.*)\s+?(\d+(?:\.\d*)?)$/);
+ if ($stack_) {
+ my @stack = split(/;/, $stack_);
+
+ my @result = ();
+ my $i;
+ my $last="";
+ for($i=0; $i!=@stack; ++$i) {
+ if(!($stack[$i] eq $last)) {
+ $result[@result] = $stack[$i];
+ $last = $stack[$i];
+ }
+ }
+
+ $stacks{join(";", @result)} += $value;
+ }
+}
+
+foreach my $k (sort { $a cmp $b } keys %stacks) {
+ print "$k $stacks{$k}\n";
+}
diff --git a/tests/benchmarks/_script/flamegraph/stackcollapse-sample.awk b/tests/benchmarks/_script/flamegraph/stackcollapse-sample.awk
new file mode 100755
index 00000000000..bafc4af3468
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/stackcollapse-sample.awk
@@ -0,0 +1,231 @@
+#!/usr/bin/awk -f
+#
+# Uses MacOS' /usr/bin/sample to generate a flamegraph of a process
+#
+# Usage:
+#
+# sudo sample [pid] -file /dev/stdout | stackcollapse-sample.awk | flamegraph.pl
+#
+# Options:
+#
+# The output will show the name of the library/framework at the call-site
+# with the form AppKit`NSApplication or libsystem`start_wqthread.
+#
+# If showing the framework or library name is not required, pass
+# MODULES=0 as an argument of the sample program.
+#
+# The generated SVG will be written to the output stream, and can be piped
+# into flamegraph.pl directly, or written to a file for conversion later.
+#
+# ---
+#
+# Copyright (c) 2017, Apple Inc.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# 1. Redistributions of source code must retain the above copyright notice,
+# this list of conditions and the following disclaimer.
+#
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+# this list of conditions and the following disclaimer in the documentation
+# and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+#
+
+BEGIN {
+
+ # Command line options
+ MODULES = 1 # Allows the user to enable/disable printing of modules.
+
+ # Internal variables
+ _FOUND_STACK = 0 # Found the stack traces in the output.
+ _LEVEL = -1 # The current level of indentation we are running.
+
+ # The set of symbols to ignore for 'waiting' threads, for ease of use.
+ # This will hide waiting threads from the view, making it easier to
+ # see what is actually running in the sample. These may be adjusted
+ # as necessary or appended to if other symbols need to be filtered out.
+
+ _IGNORE["libsystem_kernel`__psynch_cvwait"] = 1
+ _IGNORE["libsystem_kernel`__select"] = 1
+ _IGNORE["libsystem_kernel`__semwait_signal"] = 1
+ _IGNORE["libsystem_kernel`__ulock_wait"] = 1
+ _IGNORE["libsystem_kernel`__wait4"] = 1
+ _IGNORE["libsystem_kernel`__workq_kernreturn"] = 1
+ _IGNORE["libsystem_kernel`kevent"] = 1
+ _IGNORE["libsystem_kernel`mach_msg_trap"] = 1
+ _IGNORE["libsystem_kernel`read"] = 1
+ _IGNORE["libsystem_kernel`semaphore_wait_trap"] = 1
+
+ # The same set of symbols as above, without the module name.
+ _IGNORE["__psynch_cvwait"] = 1
+ _IGNORE["__select"] = 1
+ _IGNORE["__semwait_signal"] = 1
+ _IGNORE["__ulock_wait"] = 1
+ _IGNORE["__wait4"] = 1
+ _IGNORE["__workq_kernreturn"] = 1
+ _IGNORE["kevent"] = 1
+ _IGNORE["mach_msg_trap"] = 1
+ _IGNORE["read"] = 1
+ _IGNORE["semaphore_wait_trap"] = 1
+
+}
+
+# This is the first line in the /usr/bin/sample output that indicates the
+# samples follow subsequently. Until we see this line, the rest is ignored.
+
+/^Call graph/ {
+ _FOUND_STACK = 1
+}
+
+# This is found when we have reached the end of the stack output.
+# Identified by the string "Total number in stack (...)".
+
+/^Total number/ {
+ _FOUND_STACK = 0
+ printStack(_NEST,0)
+}
+
+# Prints the stack from FROM to TO (where FROM > TO)
+# Called when indenting back from a previous level, or at the end
+# of processing to flush the last recorded sample
+
+function printStack(FROM,TO) {
+
+ # We ignore certain blocking wait states, in the absence of being
+ # able to filter these threads from collection, otherwise
+ # we'll end up with many threads of equal length that represent
+ # the total time the sample was collected.
+ #
+ # Note that we need to collect the information to ensure that the
+ # timekeeping for the parental functions is appropriately adjusted
+ #Â so we just avoid printing it out when that occurs.
+ _PRINT_IT = !_IGNORE[_NAMES[FROM]]
+
+ # We run through all the names, from the root to the leaf, so that
+ # we generate a line that flamegraph.pl will like, of the form:
+ # Thread1234;example`main;example`otherFn 1234
+
+ for(l = FROM; l>=TO; l--) {
+ if (_PRINT_IT) {
+ printf("%s", _NAMES[0])
+ for(i=1; i<=l; i++) {
+ printf(";%s", _NAMES[i])
+ }
+ print " " _TIMES[l]
+ }
+
+ # We clean up our current state to avoid bugs.
+ delete _NAMES[l]
+ delete _TIMES[l]
+ }
+}
+
+# This is where we process each line, of the form:
+# 5130 Thread_8749954
+# + 5130 start_wqthread (in libsystem_pthread.dylib) ...
+# + 4282 _pthread_wqthread (in libsystem_pthread.dylib) ...
+# + ! 4282 __doworkq_kernreturn (in libsystem_kernel.dylib) ...
+# + 848 _pthread_wqthread (in libsystem_pthread.dylib) ...
+# + 848 __doworkq_kernreturn (in libsystem_kernel.dylib) ...
+
+_FOUND_STACK && match($0,/^ [^0-9]*[0-9]/) {
+
+ # We maintain two counters:
+ # _LEVEL: the high water mark of the indentation level we have seen.
+ # _NEST: the current indentation level.
+ #
+ # We keep track of these two levels such that when the nesting level
+ # decreases, we print out the current state of where we are.
+
+ _NEST=(RLENGTH-5)/2
+ sub(/^[^0-9]*/,"") # Normalise the leading content so we start with time.
+ _TIME=$1 # The time recorded by 'sample', first integer value.
+
+ # The function name is in one or two parts, depending on what kind of
+ # function it is.
+ #
+ # If it is a standard C or C++ function, it will be of the form:
+ # exampleFunction
+ # Example::Function
+ #
+ # If it is an Objective-C funtion, it will be of the form:
+ # -[NSExample function]
+ # +[NSExample staticFunction]
+ # -[NSExample function:withParameter]
+ # +[NSExample staticFunction:withParameter:andAnother]
+
+ _FN1 = $2
+ _FN2 = $3
+
+ # If it is a standard C or C++ function then the following word will
+ # either be blank, or the text '(in', so we jut use the first one:
+
+ if (_FN2 == "(in" || _FN2 == "") {
+ _FN =_FN1
+ } else {
+ # Otherwise we concatenate the first two parts with .
+ _FN = _FN1 "." _FN2
+ }
+
+ # Modules are shown with '(in libfoo.dylib)' or '(in AppKit)'
+
+ _MODULE = ""
+ match($0, /\(in [^)]*\)/)
+
+ if (RSTART > 0 && MODULES) {
+
+ # Strip off the '(in ' (4 chars) and the final ')' char (1 char)
+ _MODULE = substr($0, RSTART+4, RLENGTH-5)
+
+ # Remove the .dylib function, since it adds no value.
+ gsub(/\.dylib/, "", _MODULE)
+
+ # The function name is 'module`functionName'
+ _FN = _MODULE "`" _FN
+ }
+
+ # Now we have set up the variables, we can decide how to apply it
+ # If we are descending in the nesting, we don't print anything out:
+ # a
+ # ab
+ # abc
+ #
+ # We only print out something when we go back a level, or hit the end:
+ # abcd
+ # abe < prints out the stack up until this point, i.e. abcd
+
+ # We store a pair of arrays, indexed by the nesting level:
+ #
+ # _TIMES - a list of the time reported to that function
+ # _NAMES - a list of the function names for each current stack trace
+
+ # If we are backtracking, we need to flush the current output.
+ if (_NEST <= _LEVEL) {
+ printStack(_LEVEL,_NEST)
+ }
+
+ # Record the name and time of the function where we are.
+ _NAMES[_NEST] = _FN
+ _TIMES[_NEST] = _TIME
+
+ # We subtract the time we took from our parent so we don't double count.
+ if (_NEST > 0) {
+ _TIMES[_NEST-1] -= _TIME
+ }
+
+ # Raise the high water mark of the level we have reached.
+ _LEVEL = _NEST
+}
diff --git a/tests/benchmarks/_script/flamegraph/stackcollapse-stap.pl b/tests/benchmarks/_script/flamegraph/stackcollapse-stap.pl
new file mode 100755
index 00000000000..bca4046192f
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/stackcollapse-stap.pl
@@ -0,0 +1,84 @@
+#!/usr/bin/perl -w
+#
+# stackcollapse-stap.pl collapse multiline SystemTap stacks
+# into single lines.
+#
+# Parses a multiline stack followed by a number on a separate line, and
+# outputs a semicolon separated stack followed by a space and the number.
+# If memory addresses (+0xd) are present, they are stripped, and resulting
+# identical stacks are colased with their counts summed.
+#
+# USAGE: ./stackcollapse.pl infile > outfile
+#
+# Example input:
+#
+# 0xffffffff8103ce3b : native_safe_halt+0xb/0x10 [kernel]
+# 0xffffffff8101c6a3 : default_idle+0x53/0x1d0 [kernel]
+# 0xffffffff81013236 : cpu_idle+0xd6/0x120 [kernel]
+# 0xffffffff815bf03e : rest_init+0x72/0x74 [kernel]
+# 0xffffffff81aebbfe : start_kernel+0x3ba/0x3c5 [kernel]
+# 2404
+#
+# Example output:
+#
+# start_kernel;rest_init;cpu_idle;default_idle;native_safe_halt 2404
+#
+# Input may contain many stacks as generated from SystemTap.
+#
+# Copyright 2011 Joyent, Inc. All rights reserved.
+# Copyright 2011 Brendan Gregg. All rights reserved.
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at docs/cddl1.txt or
+# http://opensource.org/licenses/CDDL-1.0.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at docs/cddl1.txt.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+# 16-Feb-2012 Brendan Gregg Created this.
+
+use strict;
+
+my %collapsed;
+
+sub remember_stack {
+ my ($stack, $count) = @_;
+ $collapsed{$stack} += $count;
+}
+
+my @stack;
+
+foreach (<>) {
+ chomp;
+
+ if (m/^\s*(\d+)+$/) {
+ remember_stack(join(";", @stack), $1);
+ @stack = ();
+ next;
+ }
+
+ next if (m/^\s*$/);
+
+ my $frame = $_;
+ $frame =~ s/^\s*//;
+ $frame =~ s/\+[^+]*$//;
+ $frame =~ s/.* : //;
+ $frame = "-" if $frame eq "";
+ unshift @stack, $frame;
+}
+
+foreach my $k (sort { $a cmp $b } keys %collapsed) {
+ printf "$k $collapsed{$k}\n";
+}
diff --git a/tests/benchmarks/_script/flamegraph/stackcollapse-vsprof.pl b/tests/benchmarks/_script/flamegraph/stackcollapse-vsprof.pl
new file mode 100755
index 00000000000..a13c1daab35
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/stackcollapse-vsprof.pl
@@ -0,0 +1,98 @@
+#!/usr/bin/perl -w
+#
+# stackcollapse-vsprof.pl
+#
+# Parses the CSV file containing a call tree from a visual studio profiler and produces an output suitable for flamegraph.pl.
+#
+# USAGE: perl stackcollapse-vsprof.pl infile > outfile
+#
+# WORKFLOW:
+#
+# This example assumes you have visual studio 2015 installed.
+#
+# 1. Profile C++ your application using visual studio
+# 2. On visual studio, choose export the call tree as csv
+# 3. Generate a flamegraph: perl stackcollapse-vsprof CallTreeSummary.csv | perl flamegraph.pl > result_vsprof.svg
+#
+# INPUT EXAMPLE :
+#
+# Level,Function Name,Inclusive Samples,Exclusive Samples,Inclusive Samples %,Exclusive Samples %,Module Name,
+# 1,"main","8,735",0,100.00,0.00,"an_executable.exe",
+# 2,"testing::UnitTest::Run","8,735",0,100.00,0.00,"an_executable.exe",
+# 3,"boost::trim_end_iter_select<std::iterator<std::val<std::types<char> > >,boost::is_classifiedF>",306,16,3.50,0.18,"an_executable.exe",
+#
+# OUTPUT EXAMPLE :
+#
+# main;testing::UnitTest::Run;boost::trim_end_iter_select<std::iterator<std::val<std::types<char>>>,boost::is_classifiedF> 306
+
+use strict;
+
+sub massage_function_names;
+sub parse_integer;
+sub print_stack_trace;
+
+# data initialization
+my @stack = ();
+my $line_number = 0;
+my $previous_samples = 0;
+
+my $num_args = $#ARGV + 1;
+if ($num_args != 1) {
+ print "$ARGV[0]\n";
+ print "Usage : stackcollapse-vsprof.pl <in.cvs> > out.txt\n";
+ exit;
+}
+
+my $input_csv_file = $ARGV[0];
+my $line_parser_rx = qr{
+ ^\s*(\d+?), # level in the stack
+ ("[^"]+" | [^,]+), # function name (beware of spaces)
+ ("[^"]+" | [^,]+), # number of samples (beware of locale number formatting)
+}ox;
+
+open(my $fh, '<', $input_csv_file) or die "Can't read file '$input_csv_file' [$!]\n";
+
+while (my $current_line = <$fh>){
+ $line_number = $line_number + 1;
+
+ # to discard first line which typically contains headers
+ next if $line_number == 1;
+ next if $current_line =~ /^\s*$/o;
+
+ ($current_line =~ $line_parser_rx) or die "Error in regular expression at line $line_number : $current_line\n";
+
+ my $level = int $1;
+ my $function = massage_function_names($2);
+ my $samples = parse_integer($3);
+ my $stack_len = @stack;
+
+ #print "[DEBUG] $line_number : $level $function $samples $stack_len\n";
+
+ next if not $level;
+ ($level <= $stack_len + 1) or die "Error in stack at line $line_number : $current_line\n";
+
+ if ($level <= $stack_len) {
+ print_stack_trace(\@stack, $previous_samples);
+ my $to_remove = $level - $stack_len - 1;
+ splice(@stack, $to_remove);
+ }
+
+ $stack_len < 1000 or die "Stack overflow at line $line_number";
+ push(@stack, $function);
+ $previous_samples = $samples;
+}
+print_stack_trace(\@stack, $previous_samples);
+
+sub massage_function_names {
+ return ($_[0] =~ s/\s*|^"|"$//gro);
+}
+
+sub parse_integer {
+ return int ($_[0] =~ s/[., ]|^"|"$//gro);
+}
+
+sub print_stack_trace {
+ my ($stack_ref, $sample) = @_;
+ my $stack_trace = join(";", @$stack_ref);
+ print "$stack_trace $sample\n";
+}
diff --git a/tests/benchmarks/_script/flamegraph/stackcollapse-vtune-mc.pl b/tests/benchmarks/_script/flamegraph/stackcollapse-vtune-mc.pl
new file mode 100755
index 00000000000..e132ab08cf3
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/stackcollapse-vtune-mc.pl
@@ -0,0 +1,103 @@
+#!/usr/bin/perl -w
+#
+# stackcollapse-vtune-mc.pl
+#
+# Parses the CSV file containing a call tree from Intel VTune memory-consumption profiler and produces an output suitable for flamegraph.pl.
+#
+# USAGE: perl stackcollapse-vtune-mc.pl [options] infile > outfile
+#
+# WORKFLOW:
+#
+# This assumes you have Intel VTune installed and on path (using Command Line)
+#
+# 1. Profile C++ application tachyon (example shipped with Intel VTune 2019):
+#
+# amplxe-cl -collect memory-consumption -r mc_tachyon -- ./tachyon
+#
+# 2. Export raw VTune data to csv file:
+# ### for Intel VTune 2019
+# amplxe-cl -R top-down -call-stack-mode all \
+# -column="Allocations:Self","Allocation Size:Self","Module" \
+# -report-out allocations.csv -format csv \
+# -csv-delimiter comma -r mc_tachyon
+#
+# 3. Generate a flamegraph:
+# ## Generate for allocations amount.
+# perl stackcollapse-vtune-mc.pl allocations.csv > out.folded
+# perl flamegraph.pl --countname=allocations out.folded > vtune_tachyon_mc.svg
+#
+# ## Or you can generate for allocation size in bytes.
+# perl stackcollapse-vtune-mc.pl -s allocations.csv > out.folded
+# perl flamegraph.pl --countname=allocations out.folded > vtune_tachyon_mc_size.svg
+#
+# AUTHOR: Rohith Bakkannagari
+# 27-Nov-2019 UnpluggedCoder Forked from stackcollapse-vtune.pl, for memory-consumption flamegraph
+
+use strict;
+use Getopt::Long;
+
+sub usage {
+ die <<USAGE_END;
+Usage : $0 [options] allocations.csv > out.folded\n
+ --size # Accumulate allocation size in bytes instead of allocation counts.\n
+NOTE : The csv file should exported by `amplxe-cl` tool with the exact -column parameter shows below.
+ amplxe-cl -R top-down -call-stack-mode all \
+ -column="Allocations:Self","Allocation Size:Self","Module" \
+ -report-out allocations.csv -format csv \
+ -csv-delimiter comma -r mc_tachyon
+USAGE_END
+}
+
+# data initialization
+my @stack = ();
+my $rowCounter = 0; # flag for row number
+
+my $accSize = '';
+GetOptions ('size' => \$accSize)
+or usage();
+
+my $numArgs = $#ARGV + 1;
+if ($numArgs != 1){
+ usage();
+ exit;
+}
+
+my $inputCSVFile = $ARGV[0];
+open(my $fh, '<', $inputCSVFile) or die "Can't read file '$inputCSVFile' [$!]\n";
+
+while (my $currLine = <$fh>){
+ # discard warning line
+ next if $rowCounter == 0 && rindex($currLine, "war:", 0) == 0;
+ $rowCounter = $rowCounter + 1;
+ # to discard first row which typically contains headers
+ next if $rowCounter == 1;
+ chomp $currLine;
+ #VTune - sometimes the call stack information is enclosed in double quotes (?). To remove double quotes.
+ $currLine =~ s/\"//g;
+
+ ### for Intel VTune 2019
+ ### CSV header should be like below
+ ### Function Stack,Allocation Size:Self,Deallocation Size:Self,Allocations:Self,Module
+ $currLine =~ /(\s*)(.*?),([0-9]*?\.?[0-9]*?),([0-9]*?\.?[0-9]*?),([0-9]*?\.?[0-9]*?),(.*)/ or die "Error in regular expression on the current line $currLine\n";
+ my $func = $2.'('.$6.')'; # function(module)
+ my $depth = length ($1);
+ my $allocBytes = $3; # allocation size
+ my $allocs = $5; # allocations
+
+ my $tempString = '';
+ $stack [$depth] = $func;
+ if ($accSize){
+ next if $allocBytes eq '';
+ foreach my $i (0 .. $depth - 1) {
+ $tempString = $tempString.$stack[$i].";";
+ }
+ $tempString = $tempString.$func." $allocBytes\n";
+ } else {
+ next if $allocs == 0;
+ foreach my $i (0 .. $depth - 1) {
+ $tempString = $tempString.$stack[$i].";";
+ }
+ $tempString = $tempString.$func." $allocs\n";
+ }
+ print "$tempString";
+}
diff --git a/tests/benchmarks/_script/flamegraph/stackcollapse-vtune.pl b/tests/benchmarks/_script/flamegraph/stackcollapse-vtune.pl
new file mode 100644
index 00000000000..2a13e3b2d95
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/stackcollapse-vtune.pl
@@ -0,0 +1,97 @@
+#!/usr/bin/perl -w
+#
+# stackcollapse-vtune.pl
+#
+# Parses the CSV file containing a call tree from Intel VTune hotspots profiler and produces an output suitable for flamegraph.pl.
+#
+# USAGE: perl stackcollapse-vtune.pl infile > outfile
+#
+# WORKFLOW:
+#
+# This assumes you have Intel VTune installed and on path (using Command Line)
+#
+# 1. Profile C++ application tachyon_find_hotspots (example shipped with Intel VTune 2013):
+#
+# amplxe-cl -collect hotspots -r result_vtune_tachyon -- ./tachyon_find_hotspots
+#
+# 2. Export raw VTune data to csv file:
+#
+##### VTune 2013 & 2015
+# amplxe-cl -R top-down -report-out result_vtune_tachyon.csv -filter "Function Stack" -format csv -csv-delimiter comma -r result_vtune_tachyon
+#### VTune 2016
+# amplxe-cl.exe -R top-down -call-stack-mode all -column="CPU Time:Self","Module" -report-output result_vtune_tachyon.csv -filter "Function Stack" -format csv -csv-delimiter comma -r result_vtune_tachyon
+#
+# 3. Generate a flamegraph:
+#
+# perl stackcollapse-vtune result_vtune_tachyon.csv | perl flamegraph.pl > result_vtune_tachyon.svg
+#
+# AUTHOR: Rohith Bakkannagari
+
+use strict;
+
+# data initialization
+my @stack = ();
+my $rowCounter = 0; #flag for row number
+
+my $numArgs = $#ARGV + 1;
+if ($numArgs != 1)
+{
+print "$ARGV[0]\n";
+print "Usage : stackcollapse-vtune.pl <out.cvs> > out.txt\n";
+exit;
+}
+
+my $inputCSVFile = $ARGV[0];
+my $funcOnly = '';
+my $depth = 0;
+my $selfTime = 0;
+my $dllName = '';
+
+open(my $fh, '<', $inputCSVFile) or die "Can't read file '$inputCSVFile' [$!]\n";
+
+while (my $currLine = <$fh>){
+ $rowCounter = $rowCounter + 1;
+ # to discard first row which typically contains headers
+ next if $rowCounter == 1;
+ chomp $currLine;
+
+ ### VTune 2013 & 2015
+ #VTune - sometimes the call stack information is enclosed in double quotes (?). To remove double quotes. Not necessary for XCode instruments (MAC)
+ $currLine =~ s/\"//g;
+ $currLine =~ /(\s*)(.*),(.*),.*,([0-9]*\.?[0-9]+)/ or die "Error in regular expression on the current line\n";
+ $dllName = $3;
+ $func = $dllName.'!'.$2; # Eg : m_lxe.dll!MathWorks::lxe::IrEngineDecorator::Apply
+ $depth = length ($1);
+ $selfTime = $4*1000; # selfTime in msec
+ ### VTune 2013 & 2015
+
+ ### VTune 2016
+ # $currLine =~ /(\s*)(.*?),([0-9]*\.?[0-9]+?),(.*)/ or die "Error in regular expression on the current line $currLine\n";
+ # if ($2 =~ /\"/)
+ # {
+ # $currLine =~ /(\s*)\"(.*?)\",([0-9]*\.?[0-9]+?),(.*)/ or die "Error in regular expression on the current line $currLine\n";
+ # $funcOnly = $2;
+ # $depth = length ($1);
+ # $selfTime = $3*1000; # selfTime in msec
+ # $dllName = $4;
+ # }
+ # else
+ # {
+ # $funcOnly = $2;
+ # $depth = length ($1);
+ # $selfTime = $3*1000; # selfTime in msec
+ # $dllName = $4;
+ # }
+ # my $func = $dllName.'!'.$funcOnly; # Eg : m_lxe.dll!MathWorks::lxe::IrEngineDecorator::Apply
+ ### VTune 2016
+
+ my $tempString = '';
+ $stack [$depth] = $func;
+ foreach my $i (0 .. $depth - 1) {
+ $tempString = $tempString.$stack[$i].";";
+ }
+ $tempString = $tempString.$func." $selfTime\n";
+ if ($selfTime != 0){
+ print "$tempString";
+ }
+}
diff --git a/tests/benchmarks/_script/flamegraph/stackcollapse-wcp.pl b/tests/benchmarks/_script/flamegraph/stackcollapse-wcp.pl
new file mode 100755
index 00000000000..4d1d58434a0
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/stackcollapse-wcp.pl
@@ -0,0 +1,69 @@
+#!/usr/bin/perl -ws
+#
+# stackcollapse-wcp Collapse wallClockProfiler backtraces
+#
+# Parse a list of GDB backtraces as generated by https://github.com/jasonrohrer/wallClockProfiler
+#
+# Copyright 2014 Gabriel Corona. All rights reserved.
+# Portions Copyright 2020 Ștefan Talpalaru <stefantalpalaru@yahoo.com>
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at docs/cddl1.txt or
+# http://opensource.org/licenses/CDDL-1.0.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at docs/cddl1.txt.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+
+use strict;
+
+my $current = "";
+my $start_processing = 0;
+my $samples = 0;
+my %stacks;
+
+while(<>) {
+ s/^\s+|\s+$//g;
+
+ if (m/^Full stacks/) {
+ $start_processing = 1;
+ next;
+ }
+
+ if (not $start_processing) {
+ next;
+ }
+
+ if(m/^\d+\.\d+% =+ \((\d+) samples\)/) {
+ # 99.791% ===================================== (17194 samples)
+ $samples = $1;
+ next;
+ } elsif (m/^\d+: (.*)$/) {
+ # 1: poll__YNjd8fE6xG8CRNwfLnrx0g_2 (at /mnt/sde1/storage/nim-beacon-chain-clean/vendor/nim-chronos/chronos/asyncloop.nim:343)
+ my $function = $1;
+ if ($current eq "") {
+ $current = $function;
+ } else {
+ $current = $function . ";" . $current;
+ }
+ } elsif (m/^$/ and $current ne "") {
+ $stacks{$current} += $samples;
+ $current = "";
+ }
+}
+
+foreach my $k (sort { $a cmp $b } keys %stacks) {
+ print "$k $stacks{$k}\n";
+}
+
diff --git a/tests/benchmarks/_script/flamegraph/stackcollapse-xdebug.php b/tests/benchmarks/_script/flamegraph/stackcollapse-xdebug.php
new file mode 100755
index 00000000000..52cc3d65a0c
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/stackcollapse-xdebug.php
@@ -0,0 +1,197 @@
+#!/usr/bin/php
+<?php
+#
+# Copyright 2018 Miriam Lauter (lauter.miriam@gmail.com). All rights reserved.
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+#
+# (http://www.gnu.org/copyleft/gpl.html)
+#
+# 13-Apr-2018 Miriam Lauter Created this.
+
+ini_set('error_log', null);
+$optind = null;
+$args = getopt("htc", ["help"], $optind);
+if (isset($args['h']) || isset($args['help'])) {
+ usage();
+}
+
+function usage($exit = 0) {
+ echo <<<EOT
+stackcollapse-xdebug.php collapse php function traces into single lines.
+
+Parses php samples generated by xdebug with xdebug.trace_format = 1
+and outputs stacks as single lines, with methods separated by semicolons,
+and then a space and an occurrence count. For use with flamegraph.pl.
+See https://github.com/brendangregg/FlameGraph.
+
+USAGE: ./stackcollapse-xdebug.php [OPTIONS] infile > outfile
+ -h --help Show this message
+ -t Weight stack counts by duration using the time index in the trace (default)
+ -c Invocation counts only. Simply count stacks in the trace and sum duplicates, don't weight by duration.
+
+Example input:
+For more info on xdebug and generating traces see
+https://xdebug.org/docs/execution_trace.
+
+Version: 2.0.0RC4-dev
+TRACE START [2007-05-06 18:29:01]
+1 0 0 0.010870 114112 {main} 1 ../trace.php 0
+2 1 0 0.032009 114272 str_split 0 ../trace.php 8
+2 1 1 0.032073 116632
+2 2 0 0.033505 117424 ret_ord 1 ../trace.php 10
+3 3 0 0.033531 117584 ord 0 ../trace.php 5
+3 3 1 0.033551 117584
+...
+TRACE END [2007-05-06 18:29:01]
+
+Example output:
+
+- c
+{main};str_split 1
+{main};ret_ord;ord 6
+
+-t
+{main} 23381
+{main};str_split 64
+{main};ret_ord 215
+{main};ret_ord;ord 106
+
+EOT;
+
+ exit($exit);
+}
+
+function collapseStack(array $stack, string $func_name_key): string {
+ return implode(';', array_column($stack, $func_name_key));
+}
+
+function addCurrentStackToStacks(array $stack, float $dur, array &$stacks) {
+ $collapsed = implode(';', $stack);
+ $duration = SCALE_FACTOR * $dur;
+
+ if (array_key_exists($collapsed, $stacks)) {
+ $stacks[$collapsed] += $duration;
+ } else {
+ $stacks[$collapsed] = $duration;
+ }
+}
+
+function isEOTrace(string $l) {
+ $pattern = "/^(\\t|TRACE END)/";
+ return preg_match($pattern, $l);
+}
+
+$filename = $argv[$optind] ?? null;
+if ($filename === null) {
+ usage(1);
+}
+
+$do_time = !isset($args['c']);
+
+// First make sure our file is consistently formatted with only one \t delimiting each field
+$out = [];
+$retval = null;
+exec("sed -in 's/\t\+/\t/g' " . escapeshellarg($filename), $out, $retval);
+if ($retval !== 0) {
+ usage(1);
+}
+
+$handle = fopen($filename, 'r');
+
+if ($handle === false) {
+ echo "Unable to open $filename \n\n";
+ usage(1);
+}
+
+// Loop till we find TRACE START
+while ($l = fgets($handle)) {
+ if (strpos($l, "TRACE START") === 0) {
+ break;
+ }
+}
+
+const SCALE_FACTOR = 1000000;
+$stacks = [];
+$current_stack = [];
+$was_exit = false;
+$prev_start_time = 0;
+
+if ($do_time) {
+ // Weight counts by duration
+ // Xdebug trace time indices have 6 sigfigs of precision
+ // We have a perfect trace, but let's instead pretend that
+ // this was collected by sampling at 10^6 Hz
+ // then each millionth of a second this stack took to execute is 1 count
+ while ($l = fgets($handle)) {
+ if (isEOTrace($l)) {
+ break;
+ }
+
+ $parts = explode("\t", $l);
+ list($level, $fn_no, $is_exit, $time) = $parts;
+
+ if ($is_exit) {
+ if (empty($current_stack)) {
+ echo "[WARNING] Found function exit without corresponding entrance. Discarding line. Check your input.\n";
+ continue;
+ }
+
+ addCurrentStackToStacks($current_stack, $time - $prev_start_time, $stacks);
+ array_pop($current_stack);
+ } else {
+ $func_name = $parts[5];
+
+ if (!empty($current_stack)) {
+ addCurrentStackToStacks($current_stack, $time - $prev_start_time, $stacks);
+ }
+
+ $current_stack[] = $func_name;
+ }
+ $prev_start_time = $time;
+ }
+} else {
+ // Counts only
+ while ($l = fgets($handle)) {
+ if (isEOTrace($l)) {
+ break;
+ }
+
+ $parts = explode("\t", $l);
+ list($level, $fn_no, $is_exit) = $parts;
+
+ if ($is_exit === "1") {
+ if (!$was_exit) {
+ $collapsed = implode(";", $current_stack);
+ if (array_key_exists($collapsed, $stacks)) {
+ $stacks[$collapsed]++;
+ } else {
+ $stacks[$collapsed] = 1;
+ }
+ }
+
+ array_pop($current_stack);
+ $was_exit = true;
+ } else {
+ $func_name = $parts[5];
+ $current_stack[] = $func_name;
+ $was_exit = false;
+ }
+ }
+}
+
+foreach ($stacks as $stack => $count) {
+ echo "$stack $count\n";
+}
diff --git a/tests/benchmarks/_script/flamegraph/stackcollapse.pl b/tests/benchmarks/_script/flamegraph/stackcollapse.pl
new file mode 100755
index 00000000000..1e00c521368
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/stackcollapse.pl
@@ -0,0 +1,109 @@
+#!/usr/bin/perl -w
+#
+# stackcollapse.pl collapse multiline stacks into single lines.
+#
+# Parses a multiline stack followed by a number on a separate line, and
+# outputs a semicolon separated stack followed by a space and the number.
+# If memory addresses (+0xd) are present, they are stripped, and resulting
+# identical stacks are colased with their counts summed.
+#
+# USAGE: ./stackcollapse.pl infile > outfile
+#
+# Example input:
+#
+# unix`i86_mwait+0xd
+# unix`cpu_idle_mwait+0xf1
+# unix`idle+0x114
+# unix`thread_start+0x8
+# 1641
+#
+# Example output:
+#
+# unix`thread_start;unix`idle;unix`cpu_idle_mwait;unix`i86_mwait 1641
+#
+# Input may contain many stacks, and can be generated using DTrace. The
+# first few lines of input are skipped (see $headerlines).
+#
+# Copyright 2011 Joyent, Inc. All rights reserved.
+# Copyright 2011 Brendan Gregg. All rights reserved.
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at docs/cddl1.txt or
+# http://opensource.org/licenses/CDDL-1.0.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at docs/cddl1.txt.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+# 14-Aug-2011 Brendan Gregg Created this.
+
+use strict;
+
+my $headerlines = 3; # number of input lines to skip
+my $includeoffset = 0; # include function offset (except leafs)
+my %collapsed;
+
+sub remember_stack {
+ my ($stack, $count) = @_;
+ $collapsed{$stack} += $count;
+}
+
+my $nr = 0;
+my @stack;
+
+foreach (<>) {
+ next if $nr++ < $headerlines;
+ chomp;
+
+ if (m/^\s*(\d+)+$/) {
+ my $count = $1;
+ my $joined = join(";", @stack);
+
+ # trim leaf offset if these were retained:
+ $joined =~ s/\+[^+]*$// if $includeoffset;
+
+ remember_stack($joined, $count);
+ @stack = ();
+ next;
+ }
+
+ next if (m/^\s*$/);
+
+ my $frame = $_;
+ $frame =~ s/^\s*//;
+ $frame =~ s/\+[^+]*$// unless $includeoffset;
+
+ # Remove arguments from C++ function names:
+ $frame =~ s/(::.*)[(<].*/$1/;
+
+ $frame = "-" if $frame eq "";
+
+ my @inline;
+ for (split /\->/, $frame) {
+ my $func = $_;
+
+ # Strip out L and ; included in java stacks
+ $func =~ tr/\;/:/;
+ $func =~ s/^L//;
+ $func .= "_[i]" if scalar(@inline) > 0; #inlined
+
+ push @inline, $func;
+ }
+
+ unshift @stack, @inline;
+}
+
+foreach my $k (sort { $a cmp $b } keys %collapsed) {
+ print "$k $collapsed{$k}\n";
+}
diff --git a/tests/benchmarks/_script/flamegraph/test.sh b/tests/benchmarks/_script/flamegraph/test.sh
new file mode 100755
index 00000000000..3592f351f10
--- /dev/null
+++ b/tests/benchmarks/_script/flamegraph/test.sh
@@ -0,0 +1,26 @@
+#!/bin/bash
+#
+# test.sh - Check flame graph software vs test result files.
+#
+# This is used to detect regressions in the flame graph software.
+# See record-test.sh, which refreshes these files after intended software
+# changes.
+#
+# Currently only tests stackcollapse-perf.pl.
+
+set -euo pipefail
+set -x
+set -v
+
+# ToDo: add some form of --inline, and --inline --context tests. These are
+# tricky since they use addr2line, whose output will vary based on the test
+# system's binaries and symbol tables.
+for opt in pid tid kernel jit all addrs; do
+ for testfile in test/*.txt ; do
+ echo testing $testfile : $opt
+ outfile=${testfile#*/}
+ outfile=test/results/${outfile%.txt}"-collapsed-${opt}.txt"
+ perl ./stackcollapse-perf.pl --"${opt}" "${testfile}" 2> /dev/null | diff -u - "${outfile}"
+ perl ./flamegraph.pl "${outfile}" > /dev/null
+ done
+done
diff --git a/tests/benchmarks/benchmark.sh b/tests/benchmarks/benchmark.sh
index 4a89807b789..4f39a0b14e9 100755
--- a/tests/benchmarks/benchmark.sh
+++ b/tests/benchmarks/benchmark.sh
@@ -6,14 +6,17 @@ set -eo pipefail
# parse the command line
#
-usage() { echo "usage: $(basename "$0") [--cli <path>] [--baseline-cli <path>] [--suite <suite>] [--json <path>] [--zip <path>] [--verbose] [--debug]"; }
+usage() { echo "usage: $(basename "$0") [--cli <path>] [--name <cli-name>] [--baseline-cli <path>] [--suite <suite>] [--admin] [--json <path>] [--flamegraph] [--zip <path>] [--verbose] [--debug]"; }
TEST_CLI="git"
+TEST_CLI_NAME=
BASELINE_CLI=
SUITE=
JSON_RESULT=
+FLAMEGRAPH=
ZIP_RESULT=
OUTPUT_DIR=
+ADMIN=
VERBOSE=
DEBUG=
NEXT=
@@ -22,6 +25,9 @@ for a in "$@"; do
if [ "${NEXT}" = "cli" ]; then
TEST_CLI="${a}"
NEXT=
+ elif [ "${NEXT}" = "name" ]; then
+ TEST_CLI_NAME="${a}"
+ NEXT=
elif [ "${NEXT}" = "baseline-cli" ]; then
BASELINE_CLI="${a}"
NEXT=
@@ -41,6 +47,10 @@ for a in "$@"; do
NEXT="cli"
elif [[ "${a}" == "-c"* ]]; then
TEST_CLI="${a/-c/}"
+ elif [ "${a}" = "n" ] || [ "${a}" = "--name" ]; then
+ NEXT="name"
+ elif [[ "${a}" == "-n"* ]]; then
+ TEST_CLI_NAME="${a/-n/}"
elif [ "${a}" = "b" ] || [ "${a}" = "--baseline-cli" ]; then
NEXT="baseline-cli"
elif [[ "${a}" == "-b"* ]]; then
@@ -49,6 +59,8 @@ for a in "$@"; do
NEXT="suite"
elif [[ "${a}" == "-s"* ]]; then
SUITE="${a/-s/}"
+ elif [ "${a}" == "--admin" ]; then
+ ADMIN=1
elif [ "${a}" = "-v" ] || [ "${a}" == "--verbose" ]; then
VERBOSE=1
elif [ "${a}" == "--debug" ]; then
@@ -58,6 +70,8 @@ for a in "$@"; do
NEXT="json"
elif [[ "${a}" == "-j"* ]]; then
JSON_RESULT="${a/-j/}"
+ elif [ "${a}" = "-F" ] || [ "${a}" == "--flamegraph" ]; then
+ FLAMEGRAPH=1
elif [ "${a}" = "-z" ] || [ "${a}" == "--zip" ]; then
NEXT="zip"
elif [[ "${a}" == "-z"* ]]; then
@@ -92,11 +106,11 @@ SYSTEM_KERNEL=$(uname -v)
fullpath() {
if [[ "$(uname -s)" == "MINGW"* && $(cygpath -u "${TEST_CLI}") == "/"* ]]; then
- echo "${TEST_CLI}"
+ echo "$1"
elif [[ "${TEST_CLI}" == "/"* ]]; then
- echo "${TEST_CLI}"
+ echo "$1"
else
- which "${TEST_CLI}"
+ which "$1"
fi
}
@@ -108,9 +122,20 @@ cli_version() {
fi
}
+cli_commit() {
+ if [[ "$(uname -s)" == "MINGW"* ]]; then
+ BUILD_OPTIONS=$($(cygpath -u "$1") version --build-options)
+ else
+ BUILD_OPTIONS=$("$1" version --build-options)
+ fi
+
+ echo "${BUILD_OPTIONS}" | { grep '^built from commit: ' || echo "unknown"; } | sed -e 's/^built from commit: //'
+}
+
TEST_CLI_NAME=$(basename "${TEST_CLI}")
TEST_CLI_PATH=$(fullpath "${TEST_CLI}")
TEST_CLI_VERSION=$(cli_version "${TEST_CLI}")
+TEST_CLI_COMMIT=$(cli_commit "${TEST_CLI}")
if [ "${BASELINE_CLI}" != "" ]; then
if [[ "${BASELINE_CLI}" == "/"* ]]; then
@@ -122,6 +147,7 @@ if [ "${BASELINE_CLI}" != "" ]; then
BASELINE_CLI_NAME=$(basename "${BASELINE_CLI}")
BASELINE_CLI_PATH=$(fullpath "${BASELINE_CLI}")
BASELINE_CLI_VERSION=$(cli_version "${BASELINE_CLI}")
+ BASELINE_CLI_COMMIT=$(cli_commit "${BASELINE_CLI}")
fi
#
@@ -200,14 +226,29 @@ for TEST_PATH in "${BENCHMARK_DIR}"/*; do
SHOW_OUTPUT="--show-output"
fi
+ if [ "${ADMIN}" = "1" ]; then
+ ALLOW_ADMIN="--admin"
+ fi
+
OUTPUT_FILE="${OUTPUT_DIR}/${TEST_FILE}.out"
- JSON_FILE="${OUTPUT_DIR}/${TEST_FILE}.json"
ERROR_FILE="${OUTPUT_DIR}/${TEST_FILE}.err"
+ JSON_FILE="${OUTPUT_DIR}/${TEST_FILE}.json"
+ FLAMEGRAPH_FILE="${OUTPUT_DIR}/${TEST_FILE}.svg"
FAILED=
- ${TEST_PATH} --cli "${TEST_CLI}" --baseline-cli "${BASELINE_CLI}" --json "${JSON_FILE}" ${SHOW_OUTPUT} >"${OUTPUT_FILE}" 2>"${ERROR_FILE}" || FAILED=1
+ {
+ ${TEST_PATH} --cli "${TEST_CLI}" --baseline-cli "${BASELINE_CLI}" --json "${JSON_FILE}" ${ALLOW_ADMIN} ${SHOW_OUTPUT} >"${OUTPUT_FILE}" 2>"${ERROR_FILE}";
+ FAILED=$?
+ } || true
- if [ "${FAILED}" = "1" ]; then
+ if [ "${FAILED}" = "2" ]; then
+ if [ "${VERBOSE}" != "1" ]; then
+ echo "skipped!"
+ fi
+
+ indent < "${ERROR_FILE}"
+ continue
+ elif [ "${FAILED}" != "0" ]; then
if [ "${VERBOSE}" != "1" ]; then
echo "failed!"
fi
@@ -230,15 +271,56 @@ for TEST_PATH in "${BENCHMARK_DIR}"/*; do
two_mean=$(humanize_secs "${two_mean}")
two_stddev=$(humanize_secs "${two_stddev}")
- echo "${one_mean} ± ${one_stddev} vs ${two_mean} ± ${two_stddev}"
+ echo -n "${one_mean} ± ${one_stddev} vs ${two_mean} ± ${two_stddev}"
else
- echo "${one_mean} ± ${one_stddev}"
+ echo -n "${one_mean} ± ${one_stddev}"
fi
done
fi
# add our metadata to the hyperfine json result
jq ". |= { \"name\": \"${TEST_NAME}\" } + ." < "${JSON_FILE}" > "${JSON_FILE}.new" && mv "${JSON_FILE}.new" "${JSON_FILE}"
+
+ # run with flamegraph output if requested
+ if [ "${FLAMEGRAPH}" ]; then
+ PROFILER_OUTPUT_FILE="${OUTPUT_DIR}/${TEST_FILE}-profiler.out"
+ PROFILER_ERROR_FILE="${OUTPUT_DIR}/${TEST_FILE}-profiler.err"
+
+ if [ "${VERBOSE}" = "1" ]; then
+ echo " Profiling and creating flamegraph ..."
+ else
+ echo -n " -- profiling..."
+ fi
+
+ RESULT=
+ { ${TEST_PATH} --cli "${TEST_CLI}" --profile --flamegraph "${FLAMEGRAPH_FILE}" >>"${PROFILER_OUTPUT_FILE}" 2>>"${PROFILER_ERROR_FILE}" || RESULT=$?; }
+
+ if [ "${VERBOSE}" = "1" ]; then
+ indent < "${PROFILER_OUTPUT_FILE}"
+ indent < "${PROFILER_ERROR_FILE}"
+ else
+ # error code 2 indicates a non-fatal error creating
+ # the flamegraph
+ if [ "${RESULT}" = "" -o "${RESULT}" = "0" ]; then
+ echo " done."
+ elif [ "${RESULT}" = "2" ]; then
+ echo " missing resources."
+ elif [ "${RESULT}" = "3" ]; then
+ echo " sample too small."
+
+ indent < "${PROFILER_ERROR_FILE}"
+ elif [ "${RESULT}" = "4" ]; then
+ echo " unavailable."
+ else
+ echo " failed."
+
+ indent < "${PROFILER_ERROR_FILE}"
+ ANY_FAILED=1
+ fi
+ fi
+ else
+ echo ""
+ fi
done
TIME_END=$(time_in_ms)
@@ -263,8 +345,8 @@ if [ "${JSON_RESULT}" != "" ]; then
SYSTEM_JSON="{ \"os\": \"${SYSTEM_OS}\", \"kernel\": \"${SYSTEM_KERNEL}\" }"
TIME_JSON="{ \"start\": ${TIME_START}, \"end\": ${TIME_END} }"
- TEST_CLI_JSON="{ \"name\": \"${TEST_CLI_NAME}\", \"path\": \"$(escape "${TEST_CLI_PATH}")\", \"version\": \"${TEST_CLI_VERSION}\" }"
- BASELINE_CLI_JSON="{ \"name\": \"${BASELINE_CLI_NAME}\", \"path\": \"$(escape "${BASELINE_CLI_PATH}")\", \"version\": \"${BASELINE_CLI_VERSION}\" }"
+ TEST_CLI_JSON="{ \"name\": \"${TEST_CLI_NAME}\", \"path\": \"$(escape "${TEST_CLI_PATH}")\", \"version\": \"${TEST_CLI_VERSION}\", \"commit\": \"${TEST_CLI_COMMIT}\" }"
+ BASELINE_CLI_JSON="{ \"name\": \"${BASELINE_CLI_NAME}\", \"path\": \"$(escape "${BASELINE_CLI_PATH}")\", \"version\": \"${BASELINE_CLI_VERSION}\", \"commit\": \"${BASELINE_CLI_COMMIT}\" }"
if [ "${BASELINE_CLI}" != "" ]; then
EXECUTOR_JSON="{ \"baseline\": ${BASELINE_CLI_JSON}, \"cli\": ${TEST_CLI_JSON} }"
@@ -290,6 +372,7 @@ if [ "$CLEANUP_DIR" = "1" ]; then
rm -f "${OUTPUT_DIR}"/*.out
rm -f "${OUTPUT_DIR}"/*.err
rm -f "${OUTPUT_DIR}"/*.json
+ rm -f "${OUTPUT_DIR}"/*.svg
rmdir "${OUTPUT_DIR}"
fi
diff --git a/tests/benchmarks/benchmark_helpers.sh b/tests/benchmarks/benchmark_helpers.sh
index 14dbb43c1c0..cf0cd512129 100644
--- a/tests/benchmarks/benchmark_helpers.sh
+++ b/tests/benchmarks/benchmark_helpers.sh
@@ -7,20 +7,29 @@ set -eo pipefail
# command-line parsing
#
-usage() { echo "usage: $(basename "$0") [--cli <path>] [--baseline-cli <path>] [--output-style <style>] [--json <path>]"; }
+usage() { echo "usage: $(basename "$0") [--cli <path>] [--baseline-cli <path>] [--admin] [--output-style <style>] [--json <path>] [--show-output] [--output-style <style>] [--profile] [--flamegraph <path>]"; }
NEXT=
BASELINE_CLI=
TEST_CLI="git"
-JSON=
+ADMIN=
SHOW_OUTPUT=
+JSON=
+PROFILE=
+FLAMEGRAPH=
-if [ "$CI" != "" ]; then
+if [ "$CI" != "" -a -t 1 ]; then
OUTPUT_STYLE="color"
else
OUTPUT_STYLE="auto"
fi
+HELP_GIT_REMOTE="https://github.com/git/git"
+HELP_LINUX_REMOTE="https://github.com/torvalds/linux"
+HELP_RESOURCE_REPO="https://github.com/libgit2/benchmark-resources"
+
+BENCHMARK_DIR=${BENCHMARK_DIR:=$(dirname "$0")}
+
#
# parse the arguments to the outer script that's including us; these are arguments that
# the `benchmark.sh` passes (or that a user could specify when running an individual test)
@@ -39,6 +48,9 @@ for a in "$@"; do
elif [ "${NEXT}" = "json" ]; then
JSON="${a}"
NEXT=
+ elif [ "${NEXT}" = "flamegraph" ]; then
+ FLAMEGRAPH="${a}"
+ NEXT=
elif [ "${a}" = "-c" ] || [ "${a}" = "--cli" ]; then
NEXT="cli"
elif [[ "${a}" == "-c"* ]]; then
@@ -49,13 +61,21 @@ for a in "$@"; do
BASELINE_CLI="${a/-b/}"
elif [ "${a}" == "--output-style" ]; then
NEXT="output-style"
- elif [ "${a}" = "-j" ] || [ "${a}" = "--json" ]; then
- NEXT="json"
- elif [[ "${a}" == "-j"* ]]; then
- JSON="${a}"
elif [ "${a}" = "--show-output" ]; then
SHOW_OUTPUT=1
OUTPUT_STYLE=
+ elif [ "${a}" = "-j" ] || [ "${a}" = "--json" ]; then
+ NEXT="json"
+ elif [[ "${a}" == "-j"* ]]; then
+ JSON="${a/-j/}"
+ elif [ "${a}" = "-p" ] || [ "${a}" = "--profile" ]; then
+ PROFILE=1
+ elif [ "${a}" = "--admin" ]; then
+ ADMIN=1
+ elif [ "${a}" = "-F" ] || [ "${a}" = "--flamegraph" ]; then
+ NEXT="flamegraph"
+ elif [[ "${a}" == "-F"* ]]; then
+ FLAMEGRAPH="${a/-F/}"
else
echo "$(basename "$0"): unknown option: ${a}" 1>&2
usage 1>&2
@@ -96,7 +116,7 @@ temp_dir() {
fi
}
-create_preparescript() {
+create_prepare_script() {
# add some functions for users to use in preparation
cat >> "${SANDBOX_DIR}/prepare.sh" << EOF
set -e
@@ -202,6 +222,30 @@ create_preparescript() {
cp -R "\${RESOURCES_DIR}/\${RESOURCE}" "\${SANDBOX_DIR}/"
}
+ sandbox_resource() {
+ RESOURCE="\${1}"
+
+ if [ "\${RESOURCE}" = "" ]; then
+ echo "usage: sandbox_resource <path>" 1>&2
+ exit 1
+ fi
+
+ RESOURCE_UPPER=\$(echo "\${RESOURCE}" | tr '[:lower:]' '[:upper:]' | sed -e "s/-/_/g")
+ RESOURCE_PATH=\$(eval echo "\\\${BENCHMARK_\${RESOURCE_UPPER}_PATH}")
+
+ if [ "\${RESOURCE_PATH}" = "" -a "\${BENCHMARK_RESOURCES_PATH}" != "" ]; then
+ RESOURCE_PATH="\${BENCHMARK_RESOURCES_PATH}/\${RESOURCE}"
+ fi
+
+ if [ ! -f "\${RESOURCE_PATH}" ]; then
+ echo "sandbox: the resource \"\${RESOURCE}\" does not exist"
+ exit 1
+ fi
+
+ rm -rf "\${SANDBOX_DIR:?}/\${RESOURCE}"
+ cp -R "\${RESOURCE_PATH}" "\${SANDBOX_DIR}/\${RESOURCE}"
+ }
+
sandbox_repo() {
RESOURCE="\${1}"
@@ -218,6 +262,26 @@ create_preparescript() {
fi
}
+ clone_repo() {
+ REPO="\${1}"
+
+ if [ "\${REPO}" = "" ]; then
+ echo "usage: clone_repo <repo>" 1>&2
+ exit 1
+ fi
+
+ REPO_UPPER=\$(echo "\${REPO}" | tr '[:lower:]' '[:upper:]')
+ REPO_URL=\$(eval echo "\\\${BENCHMARK_\${REPO_UPPER}_PATH}")
+
+ if [ "\${REPO_URL}" = "" ]; then
+ echo "\$0: unknown repository '\${REPO}'" 1>&2
+ exit 1
+ fi
+
+ rm -rf "\${SANDBOX_DIR:?}/\${REPO}"
+ git clone "\${REPO_URL}" "\${SANDBOX_DIR}/\${REPO}"
+ }
+
cd "\${SANDBOX_DIR}"
EOF
@@ -229,10 +293,7 @@ EOF
echo "${SANDBOX_DIR}/prepare.sh"
}
-create_runscript() {
- SCRIPT_NAME="${1}"; shift
- CLI_PATH="${1}"; shift
-
+start_dir() {
if [[ "${CHDIR}" = "/"* ]]; then
START_DIR="${CHDIR}"
elif [ "${CHDIR}" != "" ]; then
@@ -241,6 +302,15 @@ create_runscript() {
START_DIR="${SANDBOX_DIR}"
fi
+ echo "${START_DIR}"
+}
+
+create_run_script() {
+ SCRIPT_NAME="${1}"; shift
+ CLI_PATH="${1}"; shift
+
+ START_DIR=$(start_dir)
+
# our run script starts by chdir'ing to the sandbox or repository directory
echo -n "cd \"${START_DIR}\" && \"${CLI_PATH}\"" >> "${SANDBOX_DIR}/${SCRIPT_NAME}.sh"
@@ -248,16 +318,12 @@ create_runscript() {
echo -n " \"${a}\"" >> "${SANDBOX_DIR}/${SCRIPT_NAME}.sh"
done
+ echo "" >> "${SANDBOX_DIR}/${SCRIPT_NAME}.sh"
+
echo "${SANDBOX_DIR}/${SCRIPT_NAME}.sh"
}
-gitbench_usage() { echo "usage: gitbench command..."; }
-
-#
-# this is the function that the outer script calls to actually do the sandboxing and
-# invocation of hyperfine.
-#
-gitbench() {
+parse_arguments() {
NEXT=
# this test should run the given command in preparation of the tests
@@ -272,6 +338,9 @@ gitbench() {
# this test should run `n` warmups
WARMUP=0
+ # this test requires administrative privileges
+ REQUIRES_ADMIN=0
+
if [ "$*" = "" ]; then
gitbench_usage 1>&2
exit 1
@@ -293,6 +362,11 @@ gitbench() {
NEXT="prepare"
elif [ "${a}" = "--chdir" ]; then
NEXT="chdir"
+ elif [ "${a}" = "--requires-admin" ]; then
+ REQUIRES_ADMIN=1
+ elif [[ "${a}" == "--" ]]; then
+ shift
+ break
elif [[ "${a}" == "--"* ]]; then
echo "unknown argument: \"${a}\"" 1>&2
gitbench_usage 1>&2
@@ -310,34 +384,93 @@ gitbench() {
exit 1
fi
- # sanity check
+ echo "PREPARE=\"${PREPARE}\""
+ echo "CHDIR=\"${CHDIR}\""
+ echo "WARMUP=\"${WARMUP}\""
+ echo "REQUIRES_ADMIN=\"${REQUIRES_ADMIN}\""
- for a in "${SANDBOX[@]}"; do
- if [ ! -d "$(resources_dir)/${a}" ]; then
- echo "$0: no resource '${a}' found" 1>&2
- exit 1
- fi
+ echo -n "GIT_ARGUMENTS=("
+
+ for arg in $@; do
+ echo -n " \"${arg}\""
done
+ echo " )"
+}
+
+gitbench_usage() { echo "usage: gitbench [--requires-admin] [--warmup <count>] [--prepare <command>] [--chdir <directory>] command..."; }
+
+exec_profiler() {
+ if [ "${BASELINE_CLI}" != "" ]; then
+ echo "$0: baseline is not supported in profiling mode" 1>&2
+ exit 1
+ fi
- if [ "$REPOSITORY" != "" ]; then
- if [ ! -d "$(resources_dir)/${REPOSITORY}" ]; then
- echo "$0: no repository resource '${REPOSITORY}' found" 1>&2
+ if [ "${SHOW_OUTPUT}" != "" ]; then
+ echo "$0: show-output is not supported in profiling mode" 1>&2
+ exit 1
+ fi
+
+ if [ "$JSON" != "" ]; then
+ echo "$0: json is not supported in profiling mode" 1>&2
+ exit 1
+ fi
+
+ SYSTEM=$(uname -s)
+
+ TEST_CLI_PATH=$(fullpath "${TEST_CLI}")
+ START_DIR=$(start_dir)
+
+ if [ "${SYSTEM}" = "Linux" ]; then
+ if [ "${OUTPUT_STYLE}" = "color" ]; then
+ COLOR_ARG="always"
+ elif [ "${OUTPUT_STYLE}" = "none" ]; then
+ COLOR_ARG="never"
+ elif [ "${OUTPUT_STYLE}" = "auto" ]; then
+ COLOR_ARG="auto"
+ else
+ echo "$0: unknown output-style option" 1>&2
exit 1
fi
- fi
- # set up our sandboxing
+ bash "${PREPARE_SCRIPT}"
+ ( cd "${START_DIR}" && perf record -F 999 -a -g -o "${SANDBOX_DIR}/perf.data" -- "${TEST_CLI_PATH}" "${GIT_ARGUMENTS[@]}" )
- SANDBOX_DIR="$(temp_dir)"
+ # we may not have samples if the process exited quickly
+ SAMPLES=$(perf report -D -i "${SANDBOX_DIR}/perf.data" | { grep "RECORD_SAMPLE" || test $? = 1; } | wc -l)
+
+ if [ "${SAMPLES}" = "0" ]; then
+ echo "$0: no profiling samples created" 1>&2
+ exit 3
+ fi
+
+ if [ "${FLAMEGRAPH}" = "" ]; then
+ perf report --stdio --stdio-color "${COLOR_ARG}" -i "${SANDBOX_DIR}/perf.data"
+ else
+ perf script -i "${SANDBOX_DIR}/perf.data" | "${BENCHMARK_DIR}/_script/flamegraph/stackcollapse-perf.pl" > "${SANDBOX_DIR}/perf.data.folded"
+ perl "${BENCHMARK_DIR}/_script/flamegraph/flamegraph.pl" -title "" -colors "libgit2" -bgcolors "none" "${SANDBOX_DIR}/perf.data.folded" > "${FLAMEGRAPH}"
+ fi
+ else
+ # macos - requires system integrity protection is disabled :(
+ # dtrace -s "bash ${TEST_RUN_SCRIPT}" -o filename -n "profile-997 /execname == \"${TEST_CLI}\"/ { @[ustack(100)] = count(); }"
+ echo "$0: profiling is not supported on ${SYSTEM}" 1>&2
+ exit 4
+ fi
+}
+
+exec_hyperfine() {
+ if [ "$FLAMEGRAPH" != "" ]; then
+ echo "$0: flamegraph is not supported in standard mode" 1>&2
+ exit 1
+ fi
if [ "${BASELINE_CLI}" != "" ]; then
BASELINE_CLI_PATH=$(fullpath "${BASELINE_CLI}")
- BASELINE_RUN_SCRIPT=$(create_runscript "baseline" "${BASELINE_CLI_PATH}" "$@")
+ BASELINE_RUN_SCRIPT=$(create_run_script "baseline" "${BASELINE_CLI_PATH}" "${GIT_ARGUMENTS[@]}")
fi
+
TEST_CLI_PATH=$(fullpath "${TEST_CLI}")
- TEST_RUN_SCRIPT=$(create_runscript "test" "${TEST_CLI_PATH}" "$@")
+ TEST_RUN_SCRIPT=$(create_run_script "test" "${TEST_CLI_PATH}" "${GIT_ARGUMENTS[@]}")
- PREPARE_SCRIPT="$(create_preparescript)"
ARGUMENTS=("--prepare" "bash ${PREPARE_SCRIPT}" "--warmup" "${WARMUP}")
if [ "${OUTPUT_STYLE}" != "" ]; then
@@ -353,11 +486,104 @@ gitbench() {
fi
if [ "${BASELINE_CLI}" != "" ]; then
- ARGUMENTS+=("-n" "${BASELINE_CLI} $*" "bash ${BASELINE_RUN_SCRIPT}")
+ ARGUMENTS+=("-n" "${BASELINE_CLI} ${GIT_ARGUMENTS[*]}" "bash ${BASELINE_RUN_SCRIPT}")
fi
- ARGUMENTS+=("-n" "${TEST_CLI} $*" "bash ${TEST_RUN_SCRIPT}")
+ ARGUMENTS+=("-n" "${TEST_CLI} ${GIT_ARGUMENTS[*]}" "bash ${TEST_RUN_SCRIPT}")
hyperfine "${ARGUMENTS[@]}"
- rm -rf "${SANDBOX_DIR:?}"
+}
+
+#
+# this is the function that the outer script calls to actually do the sandboxing and
+# invocation of hyperfine.
+#
+gitbench() {
+ argument_data=$(parse_arguments "$@")
+ eval ${argument_data}
+
+ # sanity check
+
+ for a in "${SANDBOX[@]}"; do
+ if [ ! -d "$(resources_dir)/${a}" ]; then
+ echo "$0: no resource '${a}' found" 1>&2
+ exit 1
+ fi
+ done
+
+ # set up our sandboxing
+
+ SANDBOX_DIR="$(temp_dir)"
+ PREPARE_SCRIPT="$(create_prepare_script)"
+
+ if [ "${PROFILE}" != "" ]; then
+ exec_profiler
+ else
+ exec_hyperfine
+ fi
+
+# rm -rf "${SANDBOX_DIR:?}"
+}
+
+# helper script to ensure that --admin is specified
+needs_admin() {
+ if [ "${ADMIN}" != "1" ]; then
+ echo "$0: skipping administrator test" 1>&2
+ echo "" 1>&2
+ echo "This benchmark needs administrative (root) privileges. To run it," 1>&2
+ echo "specify '--admin' to the benchmark." 1>&2
+ exit 2
+ fi
+}
+
+# helper script to give useful error messages about configuration
+needs_repo() {
+ REPO="${1}"
+
+ if [ "${REPO}" = "" ]; then
+ echo "usage: needs_repo <repo>" 1>&2
+ exit 1
+ fi
+
+ REPO_UPPER=$(echo "${REPO}" | tr '[:lower:]' '[:upper:]')
+ REPO_PATH=$(eval echo "\${BENCHMARK_${REPO_UPPER}_PATH}")
+ REPO_REMOTE_URL=$(eval echo "\${HELP_${REPO_UPPER}_REMOTE}")
+
+ if [ "${REPO_PATH}" = "" ]; then
+ echo "$0: '${REPO}' repository not configured" 1>&2
+ echo "" 1>&2
+ echo "This benchmark needs an on-disk '${REPO}' repository. First, clone the" 1>&2
+ echo "remote repository ('${REPO_REMOTE_URL}') locally then set" 1>&2
+ echo "the 'BENCHMARK_${REPO_UPPER}_PATH' environment variable to the path that" 1>&2
+ echo "contains the repository locally, then run this benchmark again." 1>&2
+ exit 2
+ fi
+}
+
+# helper script to give useful error messages about configuration
+needs_resource() {
+ RESOURCE="${1}"
+
+ if [ "${RESOURCE}" = "" ]; then
+ echo "usage: needs_resource <resource>" 1>&2
+ exit 1
+ fi
+
+ RESOURCE_UPPER=$(echo "${RESOURCE}" | tr '[:lower:]' '[:upper:]' | sed -e "s/-/_/g")
+ RESOURCE_PATH=$(eval echo "\${BENCHMARK_${RESOURCE_UPPER}_PATH}")
+
+ if [ "${RESOURCE_PATH}" = "" -a "${BENCHMARK_RESOURCES_PATH}" != "" ]; then
+ RESOURCE_PATH="${BENCHMARK_RESOURCES_PATH}/${RESOURCE}"
+ fi
+
+ if [ "${RESOURCE_PATH}" = "" ]; then
+ echo "$0: '${RESOURCE}' resource path not configured" 1>&2
+ echo "" 1>&2
+ echo "This benchmark needs an on-disk resource named '${RESOURCE}'." 1>&2
+ echo "First, clone the additional benchmark resources locally (from" 1>&2
+ echo "'${HELP_RESOURCE_REPO}'), then set the" 1>& 2
+ echo "'BENCHMARK_RESOURCES_PATH' environment variable to the path that" 1>&2
+ echo "contains the resources locally, then run this benchmark again." 1>&2
+ exit 2
+ fi
}
diff --git a/tests/benchmarks/blame__git b/tests/benchmarks/blame__git
new file mode 100755
index 00000000000..1664f737b90
--- /dev/null
+++ b/tests/benchmarks/blame__git
@@ -0,0 +1,11 @@
+#!/bin/bash -e
+
+. "$(dirname "$0")/benchmark_helpers.sh"
+
+needs_repo git
+
+gitbench --prepare "clone_repo git && cd git && git reset --hard v2.45.0" \
+ --warmup 5 \
+ --chdir "git" \
+ -- \
+ --no-pager blame "git.c"
diff --git a/tests/benchmarks/blame__linux b/tests/benchmarks/blame__linux
new file mode 100755
index 00000000000..20c5db5bbe5
--- /dev/null
+++ b/tests/benchmarks/blame__linux
@@ -0,0 +1,11 @@
+#!/bin/bash -e
+
+. "$(dirname "$0")/benchmark_helpers.sh"
+
+needs_repo linux
+
+gitbench --prepare "clone_repo linux && cd linux && git reset --hard v6.9" \
+ --warmup 5 \
+ --chdir "linux" \
+ -- \
+ --no-pager blame "Makefile"
diff --git a/tests/benchmarks/blame__simple b/tests/benchmarks/blame__simple
new file mode 100755
index 00000000000..f13e2cb060f
--- /dev/null
+++ b/tests/benchmarks/blame__simple
@@ -0,0 +1,9 @@
+#!/bin/bash -e
+
+. "$(dirname "$0")/benchmark_helpers.sh"
+
+gitbench --prepare "sandbox_repo testrepo && cd testrepo && git reset --hard HEAD" \
+ --warmup 5 \
+ --chdir "testrepo" \
+ -- \
+ --no-pager blame "branch_file.txt"
diff --git a/tests/benchmarks/hash-object__text_100kb b/tests/benchmarks/hash-object__text_100kb
index d77f224b996..7c2a84125ae 100755
--- a/tests/benchmarks/hash-object__text_100kb
+++ b/tests/benchmarks/hash-object__text_100kb
@@ -2,6 +2,6 @@
. "$(dirname "$0")/benchmark_helpers.sh"
-gitbench --prepare "create_text_file text_100kb 102400 &&
- flush_disk_cache" \
+gitbench --prepare "create_text_file text_100kb 102400" \
+ --warmup 5 \
hash-object "text_100kb"
diff --git a/tests/benchmarks/hash-object__text_10mb b/tests/benchmarks/hash-object__text_10mb
index 215afc6c3ab..311ddca4c27 100755
--- a/tests/benchmarks/hash-object__text_10mb
+++ b/tests/benchmarks/hash-object__text_10mb
@@ -2,6 +2,6 @@
. "$(dirname "$0")/benchmark_helpers.sh"
-gitbench --prepare "create_text_file text_10mb 10485760 &&
- flush_disk_cache" \
+gitbench --prepare "create_text_file text_10mb 10485760" \
+ --warmup 5 \
hash-object "text_10mb"
diff --git a/tests/benchmarks/hash-object__text_1kb b/tests/benchmarks/hash-object__text_1kb
index 1348b2fea66..44c06ead7a3 100755
--- a/tests/benchmarks/hash-object__text_1kb
+++ b/tests/benchmarks/hash-object__text_1kb
@@ -2,6 +2,6 @@
. "$(dirname "$0")/benchmark_helpers.sh"
-gitbench --prepare "create_text_file text_1kb 1024 &&
- flush_disk_cache" \
+gitbench --prepare "create_text_file text_1kb 1024" \
+ --warmup 5 \
hash-object "text_1kb"
diff --git a/tests/benchmarks/hash-object__text_cached_100kb b/tests/benchmarks/hash-object__text_cached_100kb
deleted file mode 100755
index 7c2a84125ae..00000000000
--- a/tests/benchmarks/hash-object__text_cached_100kb
+++ /dev/null
@@ -1,7 +0,0 @@
-#!/bin/bash -e
-
-. "$(dirname "$0")/benchmark_helpers.sh"
-
-gitbench --prepare "create_text_file text_100kb 102400" \
- --warmup 5 \
- hash-object "text_100kb"
diff --git a/tests/benchmarks/hash-object__text_cached_10mb b/tests/benchmarks/hash-object__text_cached_10mb
deleted file mode 100755
index 311ddca4c27..00000000000
--- a/tests/benchmarks/hash-object__text_cached_10mb
+++ /dev/null
@@ -1,7 +0,0 @@
-#!/bin/bash -e
-
-. "$(dirname "$0")/benchmark_helpers.sh"
-
-gitbench --prepare "create_text_file text_10mb 10485760" \
- --warmup 5 \
- hash-object "text_10mb"
diff --git a/tests/benchmarks/hash-object__text_cached_1kb b/tests/benchmarks/hash-object__text_cached_1kb
deleted file mode 100755
index 44c06ead7a3..00000000000
--- a/tests/benchmarks/hash-object__text_cached_1kb
+++ /dev/null
@@ -1,7 +0,0 @@
-#!/bin/bash -e
-
-. "$(dirname "$0")/benchmark_helpers.sh"
-
-gitbench --prepare "create_text_file text_1kb 1024" \
- --warmup 5 \
- hash-object "text_1kb"
diff --git a/tests/benchmarks/hash-object__text_nocache_100kb b/tests/benchmarks/hash-object__text_nocache_100kb
new file mode 100755
index 00000000000..374936ae567
--- /dev/null
+++ b/tests/benchmarks/hash-object__text_nocache_100kb
@@ -0,0 +1,9 @@
+#!/bin/bash -e
+
+. "$(dirname "$0")/benchmark_helpers.sh"
+
+needs_admin
+
+gitbench --prepare "create_text_file text_100kb 102400 &&
+ flush_disk_cache" \
+ hash-object "text_100kb"
diff --git a/tests/benchmarks/hash-object__text_nocache_10mb b/tests/benchmarks/hash-object__text_nocache_10mb
new file mode 100755
index 00000000000..8678fd57df8
--- /dev/null
+++ b/tests/benchmarks/hash-object__text_nocache_10mb
@@ -0,0 +1,9 @@
+#!/bin/bash -e
+
+. "$(dirname "$0")/benchmark_helpers.sh"
+
+needs_admin
+
+gitbench --prepare "create_text_file text_10mb 10485760 &&
+ flush_disk_cache" \
+ hash-object "text_10mb"
diff --git a/tests/benchmarks/hash-object__text_nocache_1kb b/tests/benchmarks/hash-object__text_nocache_1kb
new file mode 100755
index 00000000000..4e25ba9fd99
--- /dev/null
+++ b/tests/benchmarks/hash-object__text_nocache_1kb
@@ -0,0 +1,9 @@
+#!/bin/bash -e
+
+. "$(dirname "$0")/benchmark_helpers.sh"
+
+needs_admin
+
+gitbench --prepare "create_text_file text_1kb 1024 &&
+ flush_disk_cache" \
+ hash-object "text_1kb"
diff --git a/tests/benchmarks/hash-object__write_text_100kb b/tests/benchmarks/hash-object__write_text_100kb
index fb72c092745..6803eeeaef7 100755
--- a/tests/benchmarks/hash-object__write_text_100kb
+++ b/tests/benchmarks/hash-object__write_text_100kb
@@ -3,7 +3,7 @@
. "$(dirname "$0")/benchmark_helpers.sh"
gitbench --prepare "sandbox_repo empty_standard_repo &&
- create_text_file text_100kb 102400 &&
- flush_disk_cache" \
+ create_text_file text_100kb 102400" \
+ --warmup 5 \
--chdir "empty_standard_repo" \
- hash-object -w "../text_100kb"
+ hash-object "../text_100kb"
diff --git a/tests/benchmarks/hash-object__write_text_10mb b/tests/benchmarks/hash-object__write_text_10mb
index 9da091986fd..4335cc86e41 100755
--- a/tests/benchmarks/hash-object__write_text_10mb
+++ b/tests/benchmarks/hash-object__write_text_10mb
@@ -3,7 +3,7 @@
. "$(dirname "$0")/benchmark_helpers.sh"
gitbench --prepare "sandbox_repo empty_standard_repo &&
- create_text_file text_10mb 10485760 &&
- flush_disk_cache" \
+ create_text_file text_10mb 10485760" \
+ --warmup 5 \
--chdir "empty_standard_repo" \
hash-object "../text_10mb"
diff --git a/tests/benchmarks/hash-object__write_text_1kb b/tests/benchmarks/hash-object__write_text_1kb
index ca34393adc6..8a4c5c97b3f 100755
--- a/tests/benchmarks/hash-object__write_text_1kb
+++ b/tests/benchmarks/hash-object__write_text_1kb
@@ -3,7 +3,7 @@
. "$(dirname "$0")/benchmark_helpers.sh"
gitbench --prepare "sandbox_repo empty_standard_repo &&
- create_text_file text_1kb 1024 &&
- flush_disk_cache" \
+ create_text_file text_1kb 1024" \
+ --warmup 5 \
--chdir "empty_standard_repo" \
hash-object "../text_1kb"
diff --git a/tests/benchmarks/hash-object__write_text_cached_100kb b/tests/benchmarks/hash-object__write_text_nocache_100kb
similarity index 50%
rename from tests/benchmarks/hash-object__write_text_cached_100kb
rename to tests/benchmarks/hash-object__write_text_nocache_100kb
index 6803eeeaef7..b2f2d4c7e7d 100755
--- a/tests/benchmarks/hash-object__write_text_cached_100kb
+++ b/tests/benchmarks/hash-object__write_text_nocache_100kb
@@ -2,8 +2,10 @@
. "$(dirname "$0")/benchmark_helpers.sh"
+needs_admin
+
gitbench --prepare "sandbox_repo empty_standard_repo &&
- create_text_file text_100kb 102400" \
- --warmup 5 \
+ create_text_file text_100kb 102400 &&
+ flush_disk_cache" \
--chdir "empty_standard_repo" \
- hash-object "../text_100kb"
+ hash-object -w "../text_100kb"
diff --git a/tests/benchmarks/hash-object__write_text_cached_10mb b/tests/benchmarks/hash-object__write_text_nocache_10mb
similarity index 63%
rename from tests/benchmarks/hash-object__write_text_cached_10mb
rename to tests/benchmarks/hash-object__write_text_nocache_10mb
index 4335cc86e41..66c9d6d3112 100755
--- a/tests/benchmarks/hash-object__write_text_cached_10mb
+++ b/tests/benchmarks/hash-object__write_text_nocache_10mb
@@ -2,8 +2,10 @@
. "$(dirname "$0")/benchmark_helpers.sh"
+needs_admin
+
gitbench --prepare "sandbox_repo empty_standard_repo &&
- create_text_file text_10mb 10485760" \
- --warmup 5 \
+ create_text_file text_10mb 10485760 &&
+ flush_disk_cache" \
--chdir "empty_standard_repo" \
hash-object "../text_10mb"
diff --git a/tests/benchmarks/hash-object__write_text_cached_1kb b/tests/benchmarks/hash-object__write_text_nocache_1kb
similarity index 63%
rename from tests/benchmarks/hash-object__write_text_cached_1kb
rename to tests/benchmarks/hash-object__write_text_nocache_1kb
index 8a4c5c97b3f..c66fda5335a 100755
--- a/tests/benchmarks/hash-object__write_text_cached_1kb
+++ b/tests/benchmarks/hash-object__write_text_nocache_1kb
@@ -2,8 +2,10 @@
. "$(dirname "$0")/benchmark_helpers.sh"
+needs_admin
+
gitbench --prepare "sandbox_repo empty_standard_repo &&
- create_text_file text_1kb 1024" \
- --warmup 5 \
+ create_text_file text_1kb 1024 &&
+ flush_disk_cache" \
--chdir "empty_standard_repo" \
hash-object "../text_1kb"
diff --git a/tests/benchmarks/indexpack__250mb b/tests/benchmarks/indexpack__250mb
new file mode 100755
index 00000000000..5bd964786ae
--- /dev/null
+++ b/tests/benchmarks/indexpack__250mb
@@ -0,0 +1,11 @@
+#!/bin/bash -e
+
+. "$(dirname "$0")/benchmark_helpers.sh"
+
+needs_resource packfile-250mb
+
+gitbench --prepare "git init --bare dest.git && sandbox_resource packfile-250mb && mv packfile-250mb dest.git/packfile-250mb.pack" \
+ --warmup 5 \
+ --chdir "dest.git" \
+ -- \
+ index-pack packfile-250mb.pack
diff --git a/tests/clar/clar.c b/tests/clar/clar.c
index c9c3fde3827..f28d6af08b9 100644
--- a/tests/clar/clar.c
+++ b/tests/clar/clar.c
@@ -4,7 +4,12 @@
* This file is part of clar, distributed under the ISC license.
* For full terms see the included COPYING file.
*/
-#include <assert.h>
+
+#define _BSD_SOURCE
+#define _DARWIN_C_SOURCE
+#define _DEFAULT_SOURCE
+
+#include <errno.h>
#include <setjmp.h>
#include <stdlib.h>
#include <stdio.h>
@@ -13,21 +18,35 @@
#include <stdarg.h>
#include <wchar.h>
#include <time.h>
+#include <inttypes.h>
/* required for sandboxing */
#include <sys/types.h>
#include <sys/stat.h>
+#if defined(__UCLIBC__) && ! defined(__UCLIBC_HAS_WCHAR__)
+ /*
+ * uClibc can optionally be built without wchar support, in which case
+ * the installed <wchar.h> is a stub that only defines the `whar_t`
+ * type but none of the functions typically declared by it.
+ */
+#else
+# define CLAR_HAVE_WCHAR
+#endif
+
#ifdef _WIN32
+# define WIN32_LEAN_AND_MEAN
# include <windows.h>
# include <io.h>
-# include <shellapi.h>
# include <direct.h>
# define _MAIN_CC __cdecl
# ifndef stat
# define stat(path, st) _stat(path, st)
+ typedef struct _stat STAT_T;
+# else
+ typedef struct stat STAT_T;
# endif
# ifndef mkdir
# define mkdir(path, mode) _mkdir(path)
@@ -60,30 +79,11 @@
# else
# define p_snprintf snprintf
# endif
-
-# ifndef PRIuZ
-# define PRIuZ "Iu"
-# endif
-# ifndef PRIxZ
-# define PRIxZ "Ix"
-# endif
-
-# if defined(_MSC_VER) || defined(__MINGW32__)
- typedef struct stat STAT_T;
-# else
- typedef struct _stat STAT_T;
-# endif
#else
# include <sys/wait.h> /* waitpid(2) */
# include <unistd.h>
# define _MAIN_CC
# define p_snprintf snprintf
-# ifndef PRIuZ
-# define PRIuZ "zu"
-# endif
-# ifndef PRIxZ
-# define PRIxZ "zx"
-# endif
typedef struct stat STAT_T;
#endif
@@ -94,13 +94,15 @@
static void fs_rm(const char *_source);
static void fs_copy(const char *_source, const char *dest);
+#ifdef CLAR_FIXTURE_PATH
static const char *
fixture_path(const char *base, const char *fixture_name);
+#endif
struct clar_error {
const char *file;
const char *function;
- size_t line_number;
+ uintmax_t line_number;
const char *error_msg;
char *description;
@@ -162,6 +164,10 @@ static struct {
struct clar_report *reports;
struct clar_report *last_report;
+ const char *invoke_file;
+ const char *invoke_func;
+ size_t invoke_line;
+
void (*local_cleanup)(void *);
void *local_cleanup_payload;
@@ -193,11 +199,14 @@ static void clar_print_shutdown(int test_count, int suite_count, int error_count
static void clar_print_error(int num, const struct clar_report *report, const struct clar_error *error);
static void clar_print_ontest(const char *suite_name, const char *test_name, int test_number, enum cl_test_status failed);
static void clar_print_onsuite(const char *suite_name, int suite_index);
+static void clar_print_onabortv(const char *msg, va_list argp);
static void clar_print_onabort(const char *msg, ...);
/* From clar_sandbox.c */
-static void clar_unsandbox(void);
-static int clar_sandbox(void);
+static void clar_tempdir_init(void);
+static void clar_tempdir_shutdown(void);
+static int clar_sandbox_create(const char *suite_name, const char *test_name);
+static int clar_sandbox_cleanup(void);
/* From summary.h */
static struct clar_summary *clar_summary_init(const char *filename);
@@ -216,6 +225,15 @@ static int clar_summary_shutdown(struct clar_summary *fp);
_clar.trace_payload); \
} while (0)
+static void clar_abort(const char *msg, ...)
+{
+ va_list argp;
+ va_start(argp, msg);
+ clar_print_onabortv(msg, argp);
+ va_end(argp);
+ exit(-1);
+}
+
void cl_trace_register(cl_trace_cb *cb, void *payload)
{
_clar.pfn_trace_cb = cb;
@@ -269,9 +287,7 @@ static double clar_time_diff(clar_time *start, clar_time *end)
static void clar_time_now(clar_time *out)
{
- struct timezone tz;
-
- gettimeofday(out, &tz);
+ gettimeofday(out, NULL);
}
static double clar_time_diff(clar_time *start, clar_time *end)
@@ -294,6 +310,8 @@ clar_run_test(
CL_TRACE(CL_TRACE__TEST__BEGIN);
+ clar_sandbox_create(suite->name, test->name);
+
_clar.last_report->start = time(NULL);
clar_time_now(&start);
@@ -318,9 +336,13 @@ clar_run_test(
if (_clar.local_cleanup != NULL)
_clar.local_cleanup(_clar.local_cleanup_payload);
+ clar__clear_invokepoint();
+
if (cleanup->ptr != NULL)
cleanup->ptr();
+ clar_sandbox_cleanup();
+
CL_TRACE(CL_TRACE__TEST__END);
_clar.tests_ran++;
@@ -384,7 +406,8 @@ clar_run_suite(const struct clar_suite *suite, const char *filter)
_clar.active_test = test[i].name;
- report = calloc(1, sizeof(struct clar_report));
+ if ((report = calloc(1, sizeof(*report))) == NULL)
+ clar_abort("Failed to allocate report.\n");
report->suite = _clar.active_suite;
report->test = _clar.active_test;
report->test_number = _clar.tests_ran;
@@ -422,7 +445,7 @@ clar_usage(const char *arg)
printf(" -t Display results in tap format\n");
printf(" -l Print suite names\n");
printf(" -r[filename] Write summary file (to the optional filename)\n");
- exit(-1);
+ exit(1);
}
static void
@@ -430,18 +453,11 @@ clar_parse_args(int argc, char **argv)
{
int i;
- /* Verify options before execute */
for (i = 1; i < argc; ++i) {
char *argument = argv[i];
- if (argument[0] != '-' || argument[1] == '\0'
- || strchr("sixvqQtlr", argument[1]) == NULL) {
+ if (argument[0] != '-' || argument[1] == '\0')
clar_usage(argv[0]);
- }
- }
-
- for (i = 1; i < argc; ++i) {
- char *argument = argv[i];
switch (argument[1]) {
case 's':
@@ -454,8 +470,13 @@ clar_parse_args(int argc, char **argv)
argument += offset;
arglen = strlen(argument);
- if (arglen == 0)
- clar_usage(argv[0]);
+ if (arglen == 0) {
+ if (i + 1 == argc)
+ clar_usage(argv[0]);
+
+ argument = argv[++i];
+ arglen = strlen(argument);
+ }
for (j = 0; j < _clar_suite_count; ++j) {
suitelen = strlen(_clar_suites[j].name);
@@ -472,14 +493,12 @@ clar_parse_args(int argc, char **argv)
++found;
- if (!exact)
- _clar.verbosity = MAX(_clar.verbosity, 1);
-
switch (action) {
case 's': {
- struct clar_explicit *explicit =
- calloc(1, sizeof(struct clar_explicit));
- assert(explicit);
+ struct clar_explicit *explicit;
+
+ if ((explicit = calloc(1, sizeof(*explicit))) == NULL)
+ clar_abort("Failed to allocate explicit test.\n");
explicit->suite_idx = j;
explicit->filter = argument;
@@ -503,27 +522,39 @@ clar_parse_args(int argc, char **argv)
}
}
- if (!found) {
- clar_print_onabort("No suite matching '%s' found.\n", argument);
- exit(-1);
- }
+ if (!found)
+ clar_abort("No suite matching '%s' found.\n", argument);
+
break;
}
case 'q':
+ if (argument[2] != '\0')
+ clar_usage(argv[0]);
+
_clar.report_errors_only = 1;
break;
case 'Q':
+ if (argument[2] != '\0')
+ clar_usage(argv[0]);
+
_clar.exit_on_error = 1;
break;
case 't':
+ if (argument[2] != '\0')
+ clar_usage(argv[0]);
+
_clar.output_format = CL_OUTPUT_TAP;
break;
case 'l': {
size_t j;
+
+ if (argument[2] != '\0')
+ clar_usage(argv[0]);
+
printf("Test suites (use -s<name> to run just one):\n");
for (j = 0; j < _clar_suite_count; ++j)
printf(" %3d: %s\n", (int)j, _clar_suites[j].name);
@@ -532,17 +563,27 @@ clar_parse_args(int argc, char **argv)
}
case 'v':
+ if (argument[2] != '\0')
+ clar_usage(argv[0]);
+
_clar.verbosity++;
break;
case 'r':
_clar.write_summary = 1;
free(_clar.summary_filename);
- _clar.summary_filename = *(argument + 2) ? strdup(argument + 2) : NULL;
+
+ if (*(argument + 2)) {
+ if ((_clar.summary_filename = strdup(argument + 2)) == NULL)
+ clar_abort("Failed to allocate summary filename.\n");
+ } else {
+ _clar.summary_filename = NULL;
+ }
+
break;
default:
- assert(!"Unexpected commandline argument!");
+ clar_usage(argv[0]);
}
}
}
@@ -564,22 +605,18 @@ clar_test_init(int argc, char **argv)
if (!_clar.summary_filename &&
(summary_env = getenv("CLAR_SUMMARY")) != NULL) {
_clar.write_summary = 1;
- _clar.summary_filename = strdup(summary_env);
+ if ((_clar.summary_filename = strdup(summary_env)) == NULL)
+ clar_abort("Failed to allocate summary filename.\n");
}
if (_clar.write_summary && !_clar.summary_filename)
- _clar.summary_filename = strdup("summary.xml");
+ if ((_clar.summary_filename = strdup("summary.xml")) == NULL)
+ clar_abort("Failed to allocate summary filename.\n");
- if (_clar.write_summary &&
- !(_clar.summary = clar_summary_init(_clar.summary_filename))) {
- clar_print_onabort("Failed to open the summary file\n");
- exit(-1);
- }
+ if (_clar.write_summary)
+ _clar.summary = clar_summary_init(_clar.summary_filename);
- if (clar_sandbox() < 0) {
- clar_print_onabort("Failed to sandbox the test runner.\n");
- exit(-1);
- }
+ clar_tempdir_init();
}
int
@@ -611,12 +648,11 @@ clar_test_shutdown(void)
_clar.total_errors
);
- clar_unsandbox();
+ clar_tempdir_shutdown();
- if (_clar.write_summary && clar_summary_shutdown(_clar.summary) < 0) {
- clar_print_onabort("Failed to write the summary file\n");
- exit(-1);
- }
+ if (_clar.write_summary && clar_summary_shutdown(_clar.summary) < 0)
+ clar_abort("Failed to write the summary file '%s: %s.\n",
+ _clar.summary_filename, strerror(errno));
for (explicit = _clar.explicit; explicit; explicit = explicit_next) {
explicit_next = explicit->next;
@@ -624,6 +660,14 @@ clar_test_shutdown(void)
}
for (report = _clar.reports; report; report = report_next) {
+ struct clar_error *error, *error_next;
+
+ for (error = report->errors; error; error = error_next) {
+ free(error->description);
+ error_next = error->next;
+ free(error);
+ }
+
report_next = report->next;
free(report);
}
@@ -647,9 +691,9 @@ static void abort_test(void)
{
if (!_clar.trampoline_enabled) {
clar_print_onabort(
- "Fatal error: a cleanup method raised an exception.");
+ "Fatal error: a cleanup method raised an exception.\n");
clar_report_errors(_clar.last_report);
- exit(-1);
+ exit(1);
}
CL_TRACE(CL_TRACE__TEST__LONGJMP);
@@ -671,7 +715,10 @@ void clar__fail(
const char *description,
int should_abort)
{
- struct clar_error *error = calloc(1, sizeof(struct clar_error));
+ struct clar_error *error;
+
+ if ((error = calloc(1, sizeof(*error))) == NULL)
+ clar_abort("Failed to allocate error.\n");
if (_clar.last_report->errors == NULL)
_clar.last_report->errors = error;
@@ -681,13 +728,14 @@ void clar__fail(
_clar.last_report->last_error = error;
- error->file = file;
- error->function = function;
- error->line_number = line;
+ error->file = _clar.invoke_file ? _clar.invoke_file : file;
+ error->function = _clar.invoke_func ? _clar.invoke_func : function;
+ error->line_number = _clar.invoke_line ? _clar.invoke_line : line;
error->error_msg = error_msg;
- if (description != NULL)
- error->description = strdup(description);
+ if (description != NULL &&
+ (error->description = strdup(description)) == NULL)
+ clar_abort("Failed to allocate description.\n");
_clar.total_errors++;
_clar.last_report->status = CL_TEST_FAILURE;
@@ -761,6 +809,7 @@ void clar__assert_equal(
}
}
}
+#ifdef CLAR_HAVE_WCHAR
else if (!strcmp("%ls", fmt)) {
const wchar_t *wcs1 = va_arg(args, const wchar_t *);
const wchar_t *wcs2 = va_arg(args, const wchar_t *);
@@ -796,8 +845,9 @@ void clar__assert_equal(
}
}
}
- else if (!strcmp("%"PRIuZ, fmt) || !strcmp("%"PRIxZ, fmt)) {
- size_t sz1 = va_arg(args, size_t), sz2 = va_arg(args, size_t);
+#endif /* CLAR_HAVE_WCHAR */
+ else if (!strcmp("%"PRIuMAX, fmt) || !strcmp("%"PRIxMAX, fmt)) {
+ uintmax_t sz1 = va_arg(args, uintmax_t), sz2 = va_arg(args, uintmax_t);
is_equal = (sz1 == sz2);
if (!is_equal) {
int offset = p_snprintf(buf, sizeof(buf), fmt, sz1);
@@ -809,7 +859,8 @@ void clar__assert_equal(
void *p1 = va_arg(args, void *), *p2 = va_arg(args, void *);
is_equal = (p1 == p2);
if (!is_equal)
- p_snprintf(buf, sizeof(buf), "%p != %p", p1, p2);
+ p_snprintf(buf, sizeof(buf), "0x%"PRIxPTR" != 0x%"PRIxPTR,
+ (uintptr_t)p1, (uintptr_t)p2);
}
else {
int i1 = va_arg(args, int), i2 = va_arg(args, int);
@@ -833,6 +884,23 @@ void cl_set_cleanup(void (*cleanup)(void *), void *opaque)
_clar.local_cleanup_payload = opaque;
}
+void clar__set_invokepoint(
+ const char *file,
+ const char *func,
+ size_t line)
+{
+ _clar.invoke_file = file;
+ _clar.invoke_func = func;
+ _clar.invoke_line = line;
+}
+
+void clar__clear_invokepoint(void)
+{
+ _clar.invoke_file = NULL;
+ _clar.invoke_func = NULL;
+ _clar.invoke_line = 0;
+}
+
#include "clar/sandbox.h"
#include "clar/fixtures.h"
#include "clar/fs.h"
diff --git a/tests/clar/clar.h b/tests/clar/clar.h
index 8c22382bd56..ca72292ae91 100644
--- a/tests/clar/clar.h
+++ b/tests/clar/clar.h
@@ -8,6 +8,25 @@
#define __CLAR_TEST_H__
#include <stdlib.h>
+#include <limits.h>
+
+#if defined(_WIN32) && defined(CLAR_WIN32_LONGPATHS)
+# define CLAR_MAX_PATH 4096
+#elif defined(_WIN32)
+# define CLAR_MAX_PATH MAX_PATH
+#else
+# define CLAR_MAX_PATH PATH_MAX
+#endif
+
+#ifndef CLAR_SELFTEST
+# define CLAR_CURRENT_FILE __FILE__
+# define CLAR_CURRENT_LINE __LINE__
+# define CLAR_CURRENT_FUNC __func__
+#else
+# define CLAR_CURRENT_FILE "file"
+# define CLAR_CURRENT_LINE 42
+# define CLAR_CURRENT_FUNC "func"
+#endif
enum cl_test_status {
CL_TEST_OK,
@@ -30,6 +49,7 @@ void clar_test_shutdown(void);
int clar_test(int argc, char *argv[]);
const char *clar_sandbox_path(void);
+const char *clar_tempdir_path(void);
void cl_set_cleanup(void (*cleanup)(void *), void *opaque);
void cl_fs_cleanup(void);
@@ -83,19 +103,33 @@ void cl_fixture_cleanup(const char *fixture_name);
const char *cl_fixture_basename(const char *fixture_name);
#endif
+/**
+ * Invoke a helper function, which itself will use `cl_assert`
+ * constructs. This will preserve the stack information of the
+ * current call point, so that function name and line number
+ * information is shown from the line of the test, instead of
+ * the helper function.
+ */
+#define cl_invoke(expr) \
+ do { \
+ clar__set_invokepoint(CLAR_CURRENT_FILE, CLAR_CURRENT_FUNC, CLAR_CURRENT_LINE); \
+ expr; \
+ clar__clear_invokepoint(); \
+ } while(0)
+
/**
* Assertion macros with explicit error message
*/
-#define cl_must_pass_(expr, desc) clar__assert((expr) >= 0, __FILE__, __func__, __LINE__, "Function call failed: " #expr, desc, 1)
-#define cl_must_fail_(expr, desc) clar__assert((expr) < 0, __FILE__, __func__, __LINE__, "Expected function call to fail: " #expr, desc, 1)
-#define cl_assert_(expr, desc) clar__assert((expr) != 0, __FILE__, __func__, __LINE__, "Expression is not true: " #expr, desc, 1)
+#define cl_must_pass_(expr, desc) clar__assert((expr) >= 0, CLAR_CURRENT_FILE, CLAR_CURRENT_FUNC, CLAR_CURRENT_LINE, "Function call failed: " #expr, desc, 1)
+#define cl_must_fail_(expr, desc) clar__assert((expr) < 0, CLAR_CURRENT_FILE, CLAR_CURRENT_FUNC, CLAR_CURRENT_LINE, "Expected function call to fail: " #expr, desc, 1)
+#define cl_assert_(expr, desc) clar__assert((expr) != 0, CLAR_CURRENT_FILE, CLAR_CURRENT_FUNC, CLAR_CURRENT_LINE, "Expression is not true: " #expr, desc, 1)
/**
* Check macros with explicit error message
*/
-#define cl_check_pass_(expr, desc) clar__assert((expr) >= 0, __FILE__, __func__, __LINE__, "Function call failed: " #expr, desc, 0)
-#define cl_check_fail_(expr, desc) clar__assert((expr) < 0, __FILE__, __func__, __LINE__, "Expected function call to fail: " #expr, desc, 0)
-#define cl_check_(expr, desc) clar__assert((expr) != 0, __FILE__, __func__, __LINE__, "Expression is not true: " #expr, desc, 0)
+#define cl_check_pass_(expr, desc) clar__assert((expr) >= 0, CLAR_CURRENT_FILE, CLAR_CURRENT_FUNC, CLAR_CURRENT_LINE, "Function call failed: " #expr, desc, 0)
+#define cl_check_fail_(expr, desc) clar__assert((expr) < 0, CLAR_CURRENT_FILE, CLAR_CURRENT_FUNC, CLAR_CURRENT_LINE, "Expected function call to fail: " #expr, desc, 0)
+#define cl_check_(expr, desc) clar__assert((expr) != 0, CLAR_CURRENT_FILE, CLAR_CURRENT_FUNC, CLAR_CURRENT_LINE, "Expression is not true: " #expr, desc, 0)
/**
* Assertion macros with no error message
@@ -114,33 +148,33 @@ const char *cl_fixture_basename(const char *fixture_name);
/**
* Forced failure/warning
*/
-#define cl_fail(desc) clar__fail(__FILE__, __func__, __LINE__, "Test failed.", desc, 1)
-#define cl_warning(desc) clar__fail(__FILE__, __func__, __LINE__, "Warning during test execution:", desc, 0)
+#define cl_fail(desc) clar__fail(CLAR_CURRENT_FILE, CLAR_CURRENT_FUNC, CLAR_CURRENT_LINE, "Test failed.", desc, 1)
+#define cl_warning(desc) clar__fail(CLAR_CURRENT_FILE, CLAR_CURRENT_FUNC, CLAR_CURRENT_LINE, "Warning during test execution:", desc, 0)
#define cl_skip() clar__skip()
/**
* Typed assertion macros
*/
-#define cl_assert_equal_s(s1,s2) clar__assert_equal(__FILE__,__func__,__LINE__,"String mismatch: " #s1 " != " #s2, 1, "%s", (s1), (s2))
-#define cl_assert_equal_s_(s1,s2,note) clar__assert_equal(__FILE__,__func__,__LINE__,"String mismatch: " #s1 " != " #s2 " (" #note ")", 1, "%s", (s1), (s2))
+#define cl_assert_equal_s(s1,s2) clar__assert_equal(CLAR_CURRENT_FILE,CLAR_CURRENT_FUNC,CLAR_CURRENT_LINE,"String mismatch: " #s1 " != " #s2, 1, "%s", (s1), (s2))
+#define cl_assert_equal_s_(s1,s2,note) clar__assert_equal(CLAR_CURRENT_FILE,CLAR_CURRENT_FUNC,CLAR_CURRENT_LINE,"String mismatch: " #s1 " != " #s2 " (" #note ")", 1, "%s", (s1), (s2))
-#define cl_assert_equal_wcs(wcs1,wcs2) clar__assert_equal(__FILE__,__func__,__LINE__,"String mismatch: " #wcs1 " != " #wcs2, 1, "%ls", (wcs1), (wcs2))
-#define cl_assert_equal_wcs_(wcs1,wcs2,note) clar__assert_equal(__FILE__,__func__,__LINE__,"String mismatch: " #wcs1 " != " #wcs2 " (" #note ")", 1, "%ls", (wcs1), (wcs2))
+#define cl_assert_equal_wcs(wcs1,wcs2) clar__assert_equal(CLAR_CURRENT_FILE,CLAR_CURRENT_FUNC,CLAR_CURRENT_LINE,"String mismatch: " #wcs1 " != " #wcs2, 1, "%ls", (wcs1), (wcs2))
+#define cl_assert_equal_wcs_(wcs1,wcs2,note) clar__assert_equal(CLAR_CURRENT_FILE,CLAR_CURRENT_FUNC,CLAR_CURRENT_LINE,"String mismatch: " #wcs1 " != " #wcs2 " (" #note ")", 1, "%ls", (wcs1), (wcs2))
-#define cl_assert_equal_strn(s1,s2,len) clar__assert_equal(__FILE__,__func__,__LINE__,"String mismatch: " #s1 " != " #s2, 1, "%.*s", (s1), (s2), (int)(len))
-#define cl_assert_equal_strn_(s1,s2,len,note) clar__assert_equal(__FILE__,__func__,__LINE__,"String mismatch: " #s1 " != " #s2 " (" #note ")", 1, "%.*s", (s1), (s2), (int)(len))
+#define cl_assert_equal_strn(s1,s2,len) clar__assert_equal(CLAR_CURRENT_FILE,CLAR_CURRENT_FUNC,CLAR_CURRENT_LINE,"String mismatch: " #s1 " != " #s2, 1, "%.*s", (s1), (s2), (int)(len))
+#define cl_assert_equal_strn_(s1,s2,len,note) clar__assert_equal(CLAR_CURRENT_FILE,CLAR_CURRENT_FUNC,CLAR_CURRENT_LINE,"String mismatch: " #s1 " != " #s2 " (" #note ")", 1, "%.*s", (s1), (s2), (int)(len))
-#define cl_assert_equal_wcsn(wcs1,wcs2,len) clar__assert_equal(__FILE__,__func__,__LINE__,"String mismatch: " #wcs1 " != " #wcs2, 1, "%.*ls", (wcs1), (wcs2), (int)(len))
-#define cl_assert_equal_wcsn_(wcs1,wcs2,len,note) clar__assert_equal(__FILE__,__func__,__LINE__,"String mismatch: " #wcs1 " != " #wcs2 " (" #note ")", 1, "%.*ls", (wcs1), (wcs2), (int)(len))
+#define cl_assert_equal_wcsn(wcs1,wcs2,len) clar__assert_equal(CLAR_CURRENT_FILE,CLAR_CURRENT_FUNC,CLAR_CURRENT_LINE,"String mismatch: " #wcs1 " != " #wcs2, 1, "%.*ls", (wcs1), (wcs2), (int)(len))
+#define cl_assert_equal_wcsn_(wcs1,wcs2,len,note) clar__assert_equal(CLAR_CURRENT_FILE,CLAR_CURRENT_FUNC,CLAR_CURRENT_LINE,"String mismatch: " #wcs1 " != " #wcs2 " (" #note ")", 1, "%.*ls", (wcs1), (wcs2), (int)(len))
-#define cl_assert_equal_i(i1,i2) clar__assert_equal(__FILE__,__func__,__LINE__,#i1 " != " #i2, 1, "%d", (int)(i1), (int)(i2))
-#define cl_assert_equal_i_(i1,i2,note) clar__assert_equal(__FILE__,__func__,__LINE__,#i1 " != " #i2 " (" #note ")", 1, "%d", (i1), (i2))
-#define cl_assert_equal_i_fmt(i1,i2,fmt) clar__assert_equal(__FILE__,__func__,__LINE__,#i1 " != " #i2, 1, (fmt), (int)(i1), (int)(i2))
+#define cl_assert_equal_i(i1,i2) clar__assert_equal(CLAR_CURRENT_FILE,CLAR_CURRENT_FUNC,CLAR_CURRENT_LINE,#i1 " != " #i2, 1, "%d", (int)(i1), (int)(i2))
+#define cl_assert_equal_i_(i1,i2,note) clar__assert_equal(CLAR_CURRENT_FILE,CLAR_CURRENT_FUNC,CLAR_CURRENT_LINE,#i1 " != " #i2 " (" #note ")", 1, "%d", (i1), (i2))
+#define cl_assert_equal_i_fmt(i1,i2,fmt) clar__assert_equal(CLAR_CURRENT_FILE,CLAR_CURRENT_FUNC,CLAR_CURRENT_LINE,#i1 " != " #i2, 1, (fmt), (int)(i1), (int)(i2))
-#define cl_assert_equal_b(b1,b2) clar__assert_equal(__FILE__,__func__,__LINE__,#b1 " != " #b2, 1, "%d", (int)((b1) != 0),(int)((b2) != 0))
+#define cl_assert_equal_b(b1,b2) clar__assert_equal(CLAR_CURRENT_FILE,CLAR_CURRENT_FUNC,CLAR_CURRENT_LINE,#b1 " != " #b2, 1, "%d", (int)((b1) != 0),(int)((b2) != 0))
-#define cl_assert_equal_p(p1,p2) clar__assert_equal(__FILE__,__func__,__LINE__,"Pointer mismatch: " #p1 " != " #p2, 1, "%p", (p1), (p2))
+#define cl_assert_equal_p(p1,p2) clar__assert_equal(CLAR_CURRENT_FILE,CLAR_CURRENT_FUNC,CLAR_CURRENT_LINE,"Pointer mismatch: " #p1 " != " #p2, 1, "%p", (p1), (p2))
void clar__skip(void);
@@ -170,4 +204,11 @@ void clar__assert_equal(
const char *fmt,
...);
+void clar__set_invokepoint(
+ const char *file,
+ const char *func,
+ size_t line);
+
+void clar__clear_invokepoint(void);
+
#endif
diff --git a/tests/clar/clar/fixtures.h b/tests/clar/clar/fixtures.h
index 77033d36507..9f1023df594 100644
--- a/tests/clar/clar/fixtures.h
+++ b/tests/clar/clar/fixtures.h
@@ -1,7 +1,8 @@
+#ifdef CLAR_FIXTURE_PATH
static const char *
fixture_path(const char *base, const char *fixture_name)
{
- static char _path[4096];
+ static char _path[CLAR_MAX_PATH];
size_t root_len;
root_len = strlen(base);
@@ -20,7 +21,6 @@ fixture_path(const char *base, const char *fixture_name)
return _path;
}
-#ifdef CLAR_FIXTURE_PATH
const char *cl_fixture(const char *fixture_name)
{
return fixture_path(CLAR_FIXTURE_PATH, fixture_name);
@@ -28,7 +28,7 @@ const char *cl_fixture(const char *fixture_name)
void cl_fixture_sandbox(const char *fixture_name)
{
- fs_copy(cl_fixture(fixture_name), _clar_path);
+ fs_copy(cl_fixture(fixture_name), clar_sandbox_path());
}
const char *cl_fixture_basename(const char *fixture_name)
@@ -45,6 +45,6 @@ const char *cl_fixture_basename(const char *fixture_name)
void cl_fixture_cleanup(const char *fixture_name)
{
- fs_rm(fixture_path(_clar_path, cl_fixture_basename(fixture_name)));
+ fs_rm(fixture_path(clar_sandbox_path(), cl_fixture_basename(fixture_name)));
}
#endif
diff --git a/tests/clar/clar/fs.h b/tests/clar/clar/fs.h
index 44ede457258..42fa4719468 100644
--- a/tests/clar/clar/fs.h
+++ b/tests/clar/clar/fs.h
@@ -8,12 +8,6 @@
#ifdef _WIN32
-#ifdef CLAR_WIN32_LONGPATHS
-# define CLAR_MAX_PATH 4096
-#else
-# define CLAR_MAX_PATH MAX_PATH
-#endif
-
#define RM_RETRY_COUNT 5
#define RM_RETRY_DELAY 10
@@ -146,7 +140,7 @@ fs_rm_wait(WCHAR *_wpath)
ERROR_PATH_NOT_FOUND == last_error)
return 0;
- Sleep(RM_RETRY_DELAY * retries * retries);
+ Sleep(RM_RETRY_DELAY * retries * retries);
}
while (retries++ <= RM_RETRY_COUNT);
@@ -295,7 +289,11 @@ fs_copy(const char *_source, const char *_dest)
void
cl_fs_cleanup(void)
{
- fs_rm(fixture_path(_clar_path, "*"));
+#ifdef CLAR_FIXTURE_PATH
+ fs_rm(fixture_path(clar_tempdir_path(), "*"));
+#else
+ ((void)fs_copy); /* unused */
+#endif
}
#else
@@ -514,7 +512,7 @@ fs_rm(const char *path)
void
cl_fs_cleanup(void)
{
- clar_unsandbox();
- clar_sandbox();
+ clar_tempdir_shutdown();
+ clar_tempdir_init();
}
#endif
diff --git a/tests/clar/clar/print.h b/tests/clar/clar/print.h
index c17e2f693bd..f577c01c40a 100644
--- a/tests/clar/clar/print.h
+++ b/tests/clar/clar/print.h
@@ -21,7 +21,7 @@ static void clar_print_clap_error(int num, const struct clar_report *report, con
{
printf(" %d) Failure:\n", num);
- printf("%s::%s [%s:%"PRIuZ"]\n",
+ printf("%s::%s [%s:%"PRIuMAX"]\n",
report->suite,
report->test,
error->file,
@@ -47,8 +47,8 @@ static void clar_print_clap_ontest(const char *suite_name, const char *test_name
switch (status) {
case CL_TEST_OK: printf("ok\n"); break;
case CL_TEST_FAILURE: printf("fail\n"); break;
- case CL_TEST_SKIP: printf("skipped"); break;
- case CL_TEST_NOTRUN: printf("notrun"); break;
+ case CL_TEST_SKIP: printf("skipped\n"); break;
+ case CL_TEST_NOTRUN: printf("notrun\n"); break;
}
} else {
switch (status) {
@@ -136,7 +136,7 @@ static void clar_print_tap_ontest(const char *suite_name, const char *test_name,
printf(" at:\n");
printf(" file: '"); print_escaped(error->file); printf("'\n");
- printf(" line: %" PRIuZ "\n", error->line_number);
+ printf(" line: %" PRIuMAX "\n", error->line_number);
printf(" function: '%s'\n", error->function);
printf(" ---\n");
@@ -202,10 +202,15 @@ static void clar_print_onsuite(const char *suite_name, int suite_index)
PRINT(onsuite, suite_name, suite_index);
}
+static void clar_print_onabortv(const char *msg, va_list argp)
+{
+ PRINT(onabort, msg, argp);
+}
+
static void clar_print_onabort(const char *msg, ...)
{
va_list argp;
va_start(argp, msg);
- PRINT(onabort, msg, argp);
+ clar_print_onabortv(msg, argp);
va_end(argp);
}
diff --git a/tests/clar/clar/sandbox.h b/tests/clar/clar/sandbox.h
index 0ba1479620a..ff431599d52 100644
--- a/tests/clar/clar/sandbox.h
+++ b/tests/clar/clar/sandbox.h
@@ -2,7 +2,17 @@
#include <sys/syslimits.h>
#endif
-static char _clar_path[4096 + 1];
+/*
+ * The tempdir is the temporary directory for the entirety of the clar
+ * process execution. The sandbox is an individual temporary directory
+ * for the execution of an individual test. Sandboxes are deleted
+ * entirely after test execution to avoid pollution across tests.
+ */
+
+static char _clar_tempdir[CLAR_MAX_PATH];
+static size_t _clar_tempdir_len;
+
+static char _clar_sandbox[CLAR_MAX_PATH];
static int
is_valid_tmp_path(const char *path)
@@ -15,7 +25,10 @@ is_valid_tmp_path(const char *path)
if (!S_ISDIR(st.st_mode))
return 0;
- return (access(path, W_OK) == 0);
+ if (access(path, W_OK) != 0)
+ return 0;
+
+ return (strlen(path) < CLAR_MAX_PATH);
}
static int
@@ -25,20 +38,17 @@ find_tmp_path(char *buffer, size_t length)
static const size_t var_count = 5;
static const char *env_vars[] = {
"CLAR_TMP", "TMPDIR", "TMP", "TEMP", "USERPROFILE"
- };
+ };
- size_t i;
+ size_t i;
for (i = 0; i < var_count; ++i) {
const char *env = getenv(env_vars[i]);
+
if (!env)
continue;
if (is_valid_tmp_path(env)) {
-#ifdef __APPLE__
- if (length >= PATH_MAX && realpath(env, buffer) != NULL)
- return 0;
-#endif
strncpy(buffer, env, length - 1);
buffer[length - 1] = '\0';
return 0;
@@ -47,21 +57,18 @@ find_tmp_path(char *buffer, size_t length)
/* If the environment doesn't say anything, try to use /tmp */
if (is_valid_tmp_path("/tmp")) {
-#ifdef __APPLE__
- if (length >= PATH_MAX && realpath("/tmp", buffer) != NULL)
- return 0;
-#endif
strncpy(buffer, "/tmp", length - 1);
buffer[length - 1] = '\0';
return 0;
}
#else
- DWORD env_len = GetEnvironmentVariable("CLAR_TMP", buffer, (DWORD)length);
- if (env_len > 0 && env_len < (DWORD)length)
+ DWORD len = GetEnvironmentVariable("CLAR_TMP", buffer, (DWORD)length);
+ if (len > 0 && len < (DWORD)length)
return 0;
- if (GetTempPath((DWORD)length, buffer))
+ len = GetTempPath((DWORD)length, buffer);
+ if (len > 0 && len < (DWORD)length)
return 0;
#endif
@@ -75,17 +82,53 @@ find_tmp_path(char *buffer, size_t length)
return -1;
}
-static void clar_unsandbox(void)
+static int canonicalize_tmp_path(char *buffer)
+{
+#ifdef _WIN32
+ char tmp[CLAR_MAX_PATH], *p;
+ DWORD ret;
+
+ ret = GetFullPathName(buffer, CLAR_MAX_PATH, tmp, NULL);
+
+ if (ret == 0 || ret > CLAR_MAX_PATH)
+ return -1;
+
+ ret = GetLongPathName(tmp, buffer, CLAR_MAX_PATH);
+
+ if (ret == 0 || ret > CLAR_MAX_PATH)
+ return -1;
+
+ /* normalize path to POSIX forward slashes */
+ for (p = buffer; *p; p++)
+ if (*p == '\\')
+ *p = '/';
+
+ return 0;
+#elif defined(CLAR_HAS_REALPATH)
+ char tmp[CLAR_MAX_PATH];
+
+ if (realpath(buffer, tmp) == NULL)
+ return -1;
+
+ strcpy(buffer, tmp);
+ return 0;
+#else
+ (void)buffer;
+ return 0;
+#endif
+}
+
+static void clar_tempdir_shutdown(void)
{
- if (_clar_path[0] == '\0')
+ if (_clar_tempdir[0] == '\0')
return;
cl_must_pass(chdir(".."));
- fs_rm(_clar_path);
+ fs_rm(_clar_tempdir);
}
-static int build_sandbox_path(void)
+static int build_tempdir_path(void)
{
#ifdef CLAR_TMPDIR
const char path_tail[] = CLAR_TMPDIR "_XXXXXX";
@@ -95,60 +138,153 @@ static int build_sandbox_path(void)
size_t len;
- if (find_tmp_path(_clar_path, sizeof(_clar_path)) < 0)
+ if (find_tmp_path(_clar_tempdir, sizeof(_clar_tempdir)) < 0 ||
+ canonicalize_tmp_path(_clar_tempdir) < 0)
return -1;
- len = strlen(_clar_path);
+ len = strlen(_clar_tempdir);
-#ifdef _WIN32
- { /* normalize path to POSIX forward slashes */
- size_t i;
- for (i = 0; i < len; ++i) {
- if (_clar_path[i] == '\\')
- _clar_path[i] = '/';
- }
- }
-#endif
+ if (len + strlen(path_tail) + 2 > CLAR_MAX_PATH)
+ return -1;
- if (_clar_path[len - 1] != '/') {
- _clar_path[len++] = '/';
- }
+ if (_clar_tempdir[len - 1] != '/')
+ _clar_tempdir[len++] = '/';
- strncpy(_clar_path + len, path_tail, sizeof(_clar_path) - len);
+ strncpy(_clar_tempdir + len, path_tail, sizeof(_clar_tempdir) - len);
#if defined(__MINGW32__)
- if (_mktemp(_clar_path) == NULL)
+ if (_mktemp(_clar_tempdir) == NULL)
return -1;
- if (mkdir(_clar_path, 0700) != 0)
+ if (mkdir(_clar_tempdir, 0700) != 0)
return -1;
#elif defined(_WIN32)
- if (_mktemp_s(_clar_path, sizeof(_clar_path)) != 0)
+ if (_mktemp_s(_clar_tempdir, sizeof(_clar_tempdir)) != 0)
return -1;
- if (mkdir(_clar_path, 0700) != 0)
+ if (mkdir(_clar_tempdir, 0700) != 0)
+ return -1;
+#elif defined(__sun) || defined(__TANDEM)
+ if (mktemp(_clar_tempdir) == NULL)
+ return -1;
+
+ if (mkdir(_clar_tempdir, 0700) != 0)
return -1;
#else
- if (mkdtemp(_clar_path) == NULL)
+ if (mkdtemp(_clar_tempdir) == NULL)
return -1;
#endif
+ _clar_tempdir_len = strlen(_clar_tempdir);
return 0;
}
-static int clar_sandbox(void)
+static void clar_tempdir_init(void)
+{
+ if (_clar_tempdir[0] == '\0' && build_tempdir_path() < 0)
+ clar_abort("Failed to build tempdir path.\n");
+
+ if (chdir(_clar_tempdir) != 0)
+ clar_abort("Failed to change into tempdir '%s': %s.\n",
+ _clar_tempdir, strerror(errno));
+
+#if !defined(CLAR_SANDBOX_TEST_NAMES) && defined(_WIN32)
+ srand(clock() ^ (unsigned int)time(NULL) ^ GetCurrentProcessId() ^ GetCurrentThreadId());
+#elif !defined(CLAR_SANDBOX_TEST_NAMES)
+ srand(clock() ^ time(NULL) ^ (getpid() << 16));
+#endif
+}
+
+static void append(char *dst, const char *src)
{
- if (_clar_path[0] == '\0' && build_sandbox_path() < 0)
+ char *d;
+ const char *s;
+
+ for (d = dst; *d; d++)
+ ;
+
+ for (s = src; *s; d++, s++)
+ if (*s == ':')
+ *d = '_';
+ else
+ *d = *s;
+
+ *d = '\0';
+}
+
+static int clar_sandbox_create(const char *suite_name, const char *test_name)
+{
+#ifndef CLAR_SANDBOX_TEST_NAMES
+ char alpha[] = "0123456789abcdef";
+ int num = rand();
+#endif
+
+ cl_assert(_clar_sandbox[0] == '\0');
+
+ /*
+ * We may want to use test names as sandbox directory names for
+ * readability, _however_ on platforms with restrictions for short
+ * file / folder names (eg, Windows), this may be too long.
+ */
+#ifdef CLAR_SANDBOX_TEST_NAMES
+ cl_assert(strlen(_clar_tempdir) + strlen(suite_name) + strlen(test_name) + 3 < CLAR_MAX_PATH);
+
+ strcpy(_clar_sandbox, _clar_tempdir);
+ _clar_sandbox[_clar_tempdir_len] = '/';
+ _clar_sandbox[_clar_tempdir_len + 1] = '\0';
+
+ append(_clar_sandbox, suite_name);
+ append(_clar_sandbox, "__");
+ append(_clar_sandbox, test_name);
+#else
+ ((void)suite_name);
+ ((void)test_name);
+ ((void)append);
+
+ cl_assert(strlen(_clar_tempdir) + 9 < CLAR_MAX_PATH);
+
+ strcpy(_clar_sandbox, _clar_tempdir);
+ _clar_sandbox[_clar_tempdir_len] = '/';
+
+ _clar_sandbox[_clar_tempdir_len + 1] = alpha[(num & 0xf0000000) >> 28];
+ _clar_sandbox[_clar_tempdir_len + 2] = alpha[(num & 0x0f000000) >> 24];
+ _clar_sandbox[_clar_tempdir_len + 3] = alpha[(num & 0x00f00000) >> 20];
+ _clar_sandbox[_clar_tempdir_len + 4] = alpha[(num & 0x000f0000) >> 16];
+ _clar_sandbox[_clar_tempdir_len + 5] = alpha[(num & 0x0000f000) >> 12];
+ _clar_sandbox[_clar_tempdir_len + 6] = alpha[(num & 0x00000f00) >> 8];
+ _clar_sandbox[_clar_tempdir_len + 7] = alpha[(num & 0x000000f0) >> 4];
+ _clar_sandbox[_clar_tempdir_len + 8] = alpha[(num & 0x0000000f) >> 0];
+ _clar_sandbox[_clar_tempdir_len + 9] = '\0';
+#endif
+
+ if (mkdir(_clar_sandbox, 0700) != 0)
return -1;
- if (chdir(_clar_path) != 0)
+ if (chdir(_clar_sandbox) != 0)
return -1;
return 0;
}
-const char *clar_sandbox_path(void)
+static int clar_sandbox_cleanup(void)
{
- return _clar_path;
+ cl_assert(_clar_sandbox[0] != '\0');
+
+ if (chdir(_clar_tempdir) != 0)
+ return -1;
+
+ fs_rm(_clar_sandbox);
+ _clar_sandbox[0] = '\0';
+
+ return 0;
+}
+
+const char *clar_tempdir_path(void)
+{
+ return _clar_tempdir;
}
+const char *clar_sandbox_path(void)
+{
+ return _clar_sandbox;
+}
diff --git a/tests/clar/clar/summary.h b/tests/clar/clar/summary.h
index 4dd352e28b8..0d0b646fe75 100644
--- a/tests/clar/clar/summary.h
+++ b/tests/clar/clar/summary.h
@@ -66,16 +66,12 @@ struct clar_summary *clar_summary_init(const char *filename)
struct clar_summary *summary;
FILE *fp;
- if ((fp = fopen(filename, "w")) == NULL) {
- perror("fopen");
- return NULL;
- }
+ if ((fp = fopen(filename, "w")) == NULL)
+ clar_abort("Failed to open the summary file '%s': %s.\n",
+ filename, strerror(errno));
- if ((summary = malloc(sizeof(struct clar_summary))) == NULL) {
- perror("malloc");
- fclose(fp);
- return NULL;
- }
+ if ((summary = malloc(sizeof(struct clar_summary))) == NULL)
+ clar_abort("Failed to allocate summary.\n");
summary->filename = filename;
summary->fp = fp;
diff --git a/tests/clar/clar_libgit2.c b/tests/clar/clar_libgit2.c
index 54122997df7..c4a2dfc7e48 100644
--- a/tests/clar/clar_libgit2.c
+++ b/tests/clar/clar_libgit2.c
@@ -103,10 +103,10 @@ int cl_setenv(const char *name, const char *value)
{
wchar_t *wide_name, *wide_value = NULL;
- cl_assert(git__utf8_to_16_alloc(&wide_name, name) >= 0);
+ cl_assert(git_utf8_to_16_alloc(&wide_name, name) >= 0);
if (value) {
- cl_assert(git__utf8_to_16_alloc(&wide_value, value) >= 0);
+ cl_assert(git_utf8_to_16_alloc(&wide_value, value) >= 0);
cl_assert(SetEnvironmentVariableW(wide_name, wide_value));
} else {
/* Windows XP returns 0 (failed) when passing NULL for lpValue when
@@ -649,7 +649,7 @@ void cl_sandbox_set_homedir(const char *home)
if (home) {
git_libgit2_opts(GIT_OPT_SET_HOMEDIR, home);
} else {
- git_str_joinpath(&path, clar_sandbox_path(), "__home");
+ git_str_joinpath(&path, clar_tempdir_path(), "__home");
if (!git_fs_path_exists(path.ptr))
cl_must_pass(p_mkdir(path.ptr, 0777));
@@ -664,7 +664,7 @@ void cl_sandbox_set_search_path_defaults(void)
{
git_str path = GIT_STR_INIT;
- git_str_joinpath(&path, clar_sandbox_path(), "__config");
+ git_str_joinpath(&path, clar_tempdir_path(), "__config");
if (!git_fs_path_exists(path.ptr))
cl_must_pass(p_mkdir(path.ptr, 0777));
diff --git a/tests/clar/clar_libgit2.h b/tests/clar/clar_libgit2.h
index c33b5d28bed..c6cad6835f7 100644
--- a/tests/clar/clar_libgit2.h
+++ b/tests/clar/clar_libgit2.h
@@ -166,10 +166,28 @@ GIT_INLINE(void) clar__assert_equal_oid(
}
}
+GIT_INLINE(void) clar__assert_equal_oidstr(
+ const char *file, const char *func, int line, const char *desc,
+ const char *one_str, const git_oid *two)
+{
+ git_oid one;
+ git_oid_t oid_type = git_oid_type(two);
+
+ if (git_oid_from_prefix(&one, one_str, git_oid_hexsize(oid_type), oid_type) < 0) {
+ clar__fail(file, func, line, desc, "could not parse oid string", 1);
+ } else {
+ clar__assert_equal_oid(file, func, line, desc, &one, two);
+ }
+}
+
#define cl_assert_equal_oid(one, two) \
clar__assert_equal_oid(__FILE__, __func__, __LINE__, \
"OID mismatch: " #one " != " #two, (one), (two))
+#define cl_assert_equal_oidstr(one_str, two) \
+ clar__assert_equal_oidstr(__FILE__, __func__, __LINE__, \
+ "OID mismatch: " #one_str " != " #two, (one_str), (two))
+
/*
* Some utility macros for building long strings
*/
diff --git a/tests/clar/clar_libgit2_alloc.c b/tests/clar/clar_libgit2_alloc.c
new file mode 100644
index 00000000000..54eacd543e2
--- /dev/null
+++ b/tests/clar/clar_libgit2_alloc.c
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include "clar_libgit2_alloc.h"
+
+static size_t bytes_available;
+
+/*
+ * The clar allocator uses a tagging mechanism for pointers that
+ * prepends the actual pointer's number bytes as `size_t`.
+ *
+ * First, this is required in order to be able to implement
+ * proper bookkeeping of allocated bytes in both `free` and
+ * `realloc`.
+ *
+ * Second, it may also be able to spot bugs that are
+ * otherwise hard to grasp, as the returned pointer cannot be
+ * free'd directly via free(3P). Instead, one is forced to use
+ * the tandem of `cl__malloc` and `cl__free`, as otherwise the
+ * code is going to crash hard. This is considered to be a
+ * feature, as it helps e.g. in finding cases where by accident
+ * malloc(3P) and free(3P) were used instead of git__malloc and
+ * git__free, respectively.
+ *
+ * The downside is obviously that each allocation grows by
+ * sizeof(size_t) bytes. As the allocator is for testing purposes
+ * only, this tradeoff is considered to be perfectly fine,
+ * though.
+ */
+
+static void *cl__malloc(size_t len, const char *file, int line)
+{
+ char *ptr = NULL;
+ size_t alloclen;
+
+ GIT_UNUSED(file);
+ GIT_UNUSED(line);
+
+ if (len > bytes_available)
+ goto out;
+
+ if (GIT_ADD_SIZET_OVERFLOW(&alloclen, len, sizeof(size_t)) ||
+ (ptr = malloc(alloclen)) == NULL)
+ goto out;
+ memcpy(ptr, &len, sizeof(size_t));
+
+ bytes_available -= len;
+
+out:
+ return ptr ? ptr + sizeof(size_t) : NULL;
+}
+
+static void cl__free(void *ptr)
+{
+ if (ptr) {
+ char *p = ptr;
+ size_t len;
+ memcpy(&len, p - sizeof(size_t), sizeof(size_t));
+ free(p - sizeof(size_t));
+ bytes_available += len;
+ }
+}
+
+static void *cl__realloc(void *ptr, size_t size, const char *file, int line)
+{
+ size_t copybytes = 0;
+ char *p = ptr;
+ void *new;
+
+ if (p)
+ memcpy(©bytes, p - sizeof(size_t), sizeof(size_t));
+
+ if (copybytes > size)
+ copybytes = size;
+
+ if ((new = cl__malloc(size, file, line)) == NULL)
+ goto out;
+
+ if (p) {
+ memcpy(new, p, copybytes);
+ cl__free(p);
+ }
+
+out:
+ return new;
+}
+
+void cl_alloc_limit(size_t bytes)
+{
+ git_allocator alloc;
+
+ alloc.gmalloc = cl__malloc;
+ alloc.grealloc = cl__realloc;
+ alloc.gfree = cl__free;
+
+ git_allocator_setup(&alloc);
+
+ bytes_available = bytes;
+}
+
+void cl_alloc_reset(void)
+{
+ git_allocator_setup(NULL);
+}
diff --git a/tests/clar/clar_libgit2_alloc.h b/tests/clar/clar_libgit2_alloc.h
new file mode 100644
index 00000000000..78a18b67d16
--- /dev/null
+++ b/tests/clar/clar_libgit2_alloc.h
@@ -0,0 +1,11 @@
+#ifndef __CLAR_LIBGIT2_ALLOC__
+#define __CLAR_LIBGIT2_ALLOC__
+
+#include "clar.h"
+#include "common.h"
+#include "git2/sys/alloc.h"
+
+void cl_alloc_limit(size_t bytes);
+void cl_alloc_reset(void);
+
+#endif
diff --git a/tests/clar/clar_libgit2_timer.c b/tests/clar/clar_libgit2_timer.c
index 2330f9351d1..6c75413be7e 100644
--- a/tests/clar/clar_libgit2_timer.c
+++ b/tests/clar/clar_libgit2_timer.c
@@ -8,23 +8,23 @@ void cl_perf_timer__init(cl_perf_timer *t)
void cl_perf_timer__start(cl_perf_timer *t)
{
- t->time_started = git__timer();
+ t->time_started = git_time_monotonic();
}
void cl_perf_timer__stop(cl_perf_timer *t)
{
- double time_now = git__timer();
+ uint64_t time_now = git_time_monotonic();
t->last = time_now - t->time_started;
t->sum += t->last;
}
-double cl_perf_timer__last(const cl_perf_timer *t)
+uint64_t cl_perf_timer__last(const cl_perf_timer *t)
{
return t->last;
}
-double cl_perf_timer__sum(const cl_perf_timer *t)
+uint64_t cl_perf_timer__sum(const cl_perf_timer *t)
{
return t->sum;
}
diff --git a/tests/clar/clar_libgit2_timer.h b/tests/clar/clar_libgit2_timer.h
index 7571a52e997..88706727884 100644
--- a/tests/clar/clar_libgit2_timer.h
+++ b/tests/clar/clar_libgit2_timer.h
@@ -4,13 +4,13 @@
struct cl_perf_timer
{
/* cumulative running time across all start..stop intervals */
- double sum;
+ uint64_t sum;
/* value of last start..stop interval */
- double last;
+ uint64_t last;
/* clock value at start */
- double time_started;
+ uint64_t time_started;
};
#define CL_PERF_TIMER_INIT {0}
@@ -24,12 +24,12 @@ void cl_perf_timer__stop(cl_perf_timer *t);
/**
* return value of last start..stop interval in seconds.
*/
-double cl_perf_timer__last(const cl_perf_timer *t);
+uint64_t cl_perf_timer__last(const cl_perf_timer *t);
/**
* return cumulative running time across all start..stop
* intervals in seconds.
*/
-double cl_perf_timer__sum(const cl_perf_timer *t);
+uint64_t cl_perf_timer__sum(const cl_perf_timer *t);
#endif /* __CLAR_LIBGIT2_TIMER__ */
diff --git a/tests/clar/clar_libgit2_trace.c b/tests/clar/clar_libgit2_trace.c
index ebb0f41dda7..f33b019e1e0 100644
--- a/tests/clar/clar_libgit2_trace.c
+++ b/tests/clar/clar_libgit2_trace.c
@@ -164,7 +164,7 @@ static void _cl_trace_cb__event_handler(
switch (ev) {
case CL_TRACE__SUITE_BEGIN:
git_trace(GIT_TRACE_TRACE, "\n\n%s\n%s: Begin Suite", HR, suite_name);
-#if 0 && defined(GIT_WIN32_LEAKCHECK)
+#if 0 && defined(GIT_DEBUG_LEAKCHECK_WIN32)
git_win32__crtdbg_stacktrace__dump(
GIT_WIN32__CRTDBG_STACKTRACE__SET_MARK,
suite_name);
@@ -172,7 +172,7 @@ static void _cl_trace_cb__event_handler(
break;
case CL_TRACE__SUITE_END:
-#if 0 && defined(GIT_WIN32_LEAKCHECK)
+#if 0 && defined(GIT_DEBUG_LEAKCHECK_WIN32)
/* As an example of checkpointing, dump leaks within this suite.
* This may generate false positives for things like the global
* TLS error state and maybe the odb cache since they aren't
@@ -197,7 +197,7 @@ static void _cl_trace_cb__event_handler(
case CL_TRACE__TEST__END:
cl_perf_timer__stop(&s_timer_test);
- git_trace(GIT_TRACE_TRACE, "%s::%s: End Test (%.3f %.3f)", suite_name, test_name,
+ git_trace(GIT_TRACE_TRACE, "%s::%s: End Test (%" PRIuZ " %" PRIuZ ")", suite_name, test_name,
cl_perf_timer__last(&s_timer_run),
cl_perf_timer__last(&s_timer_test));
break;
diff --git a/tests/clar/main.c b/tests/clar/main.c
index e3f4fe740bd..cdd4630790d 100644
--- a/tests/clar/main.c
+++ b/tests/clar/main.c
@@ -1,7 +1,7 @@
#include "clar_libgit2.h"
#include "clar_libgit2_trace.h"
-#ifdef GIT_WIN32_LEAKCHECK
+#ifdef GIT_DEBUG_LEAKCHECK_WIN32
# include "win32/w32_leakcheck.h"
#endif
@@ -37,7 +37,7 @@ int main(int argc, char *argv[])
cl_global_trace_disable();
git_libgit2_shutdown();
-#ifdef GIT_WIN32_LEAKCHECK
+#ifdef GIT_DEBUG_LEAKCHECK_WIN32
if (git_win32_leakcheck_has_leaks())
res = res || 1;
#endif
diff --git a/tests/headertest/CMakeLists.txt b/tests/headertest/CMakeLists.txt
index c70ce1ae19c..b352458d513 100644
--- a/tests/headertest/CMakeLists.txt
+++ b/tests/headertest/CMakeLists.txt
@@ -3,8 +3,7 @@
# even when they have aggressive C90 warnings enabled.
add_executable(headertest headertest.c)
-set_target_properties(headertest PROPERTIES C_STANDARD 90)
-set_target_properties(headertest PROPERTIES C_EXTENSIONS OFF)
+
target_include_directories(headertest PRIVATE ${LIBGIT2_INCLUDES})
if (MSVC)
diff --git a/tests/libgit2/CMakeLists.txt b/tests/libgit2/CMakeLists.txt
index 866122d1c8c..7a4bb476ca5 100644
--- a/tests/libgit2/CMakeLists.txt
+++ b/tests/libgit2/CMakeLists.txt
@@ -1,5 +1,9 @@
# tests: the unit and integration tests for libgit2
+if(NOT "${CMAKE_VERSION}" VERSION_LESS 3.27)
+ cmake_policy(SET CMP0148 OLD)
+endif()
+
set(Python_ADDITIONAL_VERSIONS 3 2.7)
find_package(PythonInterp)
@@ -14,6 +18,7 @@ set(TEST_PATH "${CMAKE_CURRENT_SOURCE_DIR}")
add_definitions(-DCLAR_FIXTURE_PATH=\"${CLAR_FIXTURES}\")
add_definitions(-DCLAR_TMPDIR=\"libgit2_tests\")
add_definitions(-DCLAR_WIN32_LONGPATHS)
+add_definitions(-DCLAR_HAS_REALPATH)
add_definitions(-D_FILE_OFFSET_BITS=64)
# Ensure that we do not use deprecated functions internally
@@ -40,9 +45,7 @@ set_source_files_properties(
add_executable(libgit2_tests ${SRC_CLAR} ${SRC_TEST} ${LIBGIT2_OBJECTS})
-set_target_properties(libgit2_tests PROPERTIES C_STANDARD 90)
set_target_properties(libgit2_tests PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR})
-
target_include_directories(libgit2_tests PRIVATE ${TEST_INCLUDES} ${LIBGIT2_INCLUDES} ${LIBGIT2_DEPENDENCY_INCLUDES})
target_include_directories(libgit2_tests SYSTEM PRIVATE ${LIBGIT2_SYSTEM_INCLUDES})
target_link_libraries(libgit2_tests ${LIBGIT2_SYSTEM_LIBS})
@@ -65,7 +68,7 @@ endif()
include(AddClarTest)
add_clar_test(libgit2_tests offline -v -xonline)
-add_clar_test(libgit2_tests invasive -v -sfilter::stream::bigfile -sodb::largefiles -siterator::workdir::filesystem_gunk -srepo::init -srepo::init::at_filesystem_root)
+add_clar_test(libgit2_tests invasive -v -sfilter::stream::bigfile -sodb::largefiles -siterator::workdir::filesystem_gunk -srepo::init -srepo::init::at_filesystem_root -sonline::clone::connect_timeout_default)
add_clar_test(libgit2_tests online -v -sonline -xonline::customcert)
add_clar_test(libgit2_tests online_customcert -v -sonline::customcert)
add_clar_test(libgit2_tests gitdaemon -v -sonline::push)
diff --git a/tests/libgit2/apply/apply_helpers.c b/tests/libgit2/apply/apply_helpers.c
index e78b8ffcb09..384038722f8 100644
--- a/tests/libgit2/apply/apply_helpers.c
+++ b/tests/libgit2/apply/apply_helpers.c
@@ -14,7 +14,7 @@ static int iterator_compare(const git_index_entry *entry, void *_data)
struct iterator_compare_data *data = (struct iterator_compare_data *)_data;
cl_assert_equal_i(GIT_INDEX_ENTRY_STAGE(entry), data->expected[data->idx].stage);
- cl_git_pass(git_oid__fromstr(&expected_id, data->expected[data->idx].oid_str, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected_id, data->expected[data->idx].oid_str, GIT_OID_SHA1));
cl_assert_equal_oid(&entry->id, &expected_id);
cl_assert_equal_i(entry->mode, data->expected[data->idx].mode);
cl_assert_equal_s(entry->path, data->expected[data->idx].path);
diff --git a/tests/libgit2/apply/apply_helpers.h b/tests/libgit2/apply/apply_helpers.h
index 82094773e15..b1a1479de45 100644
--- a/tests/libgit2/apply/apply_helpers.h
+++ b/tests/libgit2/apply/apply_helpers.h
@@ -1,4 +1,5 @@
#include "../merge/merge_helpers.h"
+#include "../diff/diff_helpers.h"
#define TEST_REPO_PATH "merge-recursive"
diff --git a/tests/libgit2/apply/both.c b/tests/libgit2/apply/both.c
index 1331e7ea452..d3d040c985c 100644
--- a/tests/libgit2/apply/both.c
+++ b/tests/libgit2/apply/both.c
@@ -12,7 +12,7 @@ void test_apply_both__initialize(void)
repo = cl_git_sandbox_init(TEST_REPO_PATH);
- git_oid__fromstr(&oid, "539bd011c4822c560c1d17cab095006b7a10f707", GIT_OID_SHA1);
+ git_oid_from_string(&oid, "539bd011c4822c560c1d17cab095006b7a10f707", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, repo, &oid));
cl_git_pass(git_reset(repo, (git_object *)commit, GIT_RESET_HARD, NULL));
git_commit_free(commit);
@@ -42,8 +42,8 @@ void test_apply_both__generated_diff(void)
size_t both_expected_cnt = sizeof(both_expected) /
sizeof(struct merge_index_entry);
- git_oid__fromstr(&a_oid, "539bd011c4822c560c1d17cab095006b7a10f707", GIT_OID_SHA1);
- git_oid__fromstr(&b_oid, "7c7bf85e978f1d18c0566f702d2cb7766b9c8d4f", GIT_OID_SHA1);
+ git_oid_from_string(&a_oid, "539bd011c4822c560c1d17cab095006b7a10f707", GIT_OID_SHA1);
+ git_oid_from_string(&b_oid, "7c7bf85e978f1d18c0566f702d2cb7766b9c8d4f", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&a_commit, repo, &a_oid));
cl_git_pass(git_commit_lookup(&b_commit, repo, &b_oid));
@@ -78,7 +78,7 @@ void test_apply_both__parsed_diff(void)
size_t both_expected_cnt = sizeof(both_expected) /
sizeof(struct merge_index_entry);
- cl_git_pass(git_diff_from_buffer(&diff,
+ cl_git_pass(diff_from_buffer(&diff,
DIFF_MODIFY_TWO_FILES, strlen(DIFF_MODIFY_TWO_FILES)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL));
@@ -102,7 +102,7 @@ void test_apply_both__removes_file(void)
size_t both_expected_cnt = sizeof(both_expected) /
sizeof(struct merge_index_entry);
- cl_git_pass(git_diff_from_buffer(&diff, DIFF_DELETE_FILE,
+ cl_git_pass(diff_from_buffer(&diff, DIFF_DELETE_FILE,
strlen(DIFF_DELETE_FILE)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL));
@@ -128,7 +128,7 @@ void test_apply_both__adds_file(void)
size_t both_expected_cnt = sizeof(both_expected) /
sizeof(struct merge_index_entry);
- cl_git_pass(git_diff_from_buffer(&diff,
+ cl_git_pass(diff_from_buffer(&diff,
DIFF_ADD_FILE, strlen(DIFF_ADD_FILE)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL));
@@ -161,7 +161,7 @@ void test_apply_both__application_failure_leaves_index_unmodified(void)
cl_git_pass(git_index_write(index));
git_index_free(index);
- cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file)));
+ cl_git_pass(diff_from_buffer(&diff, diff_file, strlen(diff_file)));
cl_git_fail_with(GIT_EAPPLYFAIL, git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL));
validate_apply_index(repo, index_expected, index_expected_cnt);
@@ -192,13 +192,13 @@ void test_apply_both__index_must_match_workdir(void)
memset(&idx_entry, 0, sizeof(git_index_entry));
idx_entry.mode = 0100644;
idx_entry.path = "asparagus.txt";
- cl_git_pass(git_oid__fromstr(&idx_entry.id, "06d3fefb8726ab1099acc76e02dfb85e034b2538", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&idx_entry.id, "06d3fefb8726ab1099acc76e02dfb85e034b2538", GIT_OID_SHA1));
cl_git_pass(git_index_add(index, &idx_entry));
cl_git_pass(git_index_write(index));
git_index_free(index);
- cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file)));
+ cl_git_pass(diff_from_buffer(&diff, diff_file, strlen(diff_file)));
cl_git_fail_with(GIT_EAPPLYFAIL, git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL));
git_diff_free(diff);
@@ -214,7 +214,7 @@ void test_apply_both__index_mode_must_match_workdir(void)
/* Set a file in the working directory executable. */
cl_must_pass(p_chmod("merge-recursive/asparagus.txt", 0755));
- cl_git_pass(git_diff_from_buffer(&diff, DIFF_MODIFY_TWO_FILES,
+ cl_git_pass(diff_from_buffer(&diff, DIFF_MODIFY_TWO_FILES,
strlen(DIFF_MODIFY_TWO_FILES)));
cl_git_fail_with(GIT_EAPPLYFAIL, git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL));
@@ -248,7 +248,7 @@ void test_apply_both__application_failure_leaves_workdir_unmodified(void)
cl_git_pass(git_index_write(index));
git_index_free(index);
- cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file)));
+ cl_git_pass(diff_from_buffer(&diff, diff_file, strlen(diff_file)));
cl_git_fail_with(GIT_EAPPLYFAIL, git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL));
validate_apply_workdir(repo, workdir_expected, workdir_expected_cnt);
@@ -290,7 +290,7 @@ void test_apply_both__keeps_nonconflicting_changes(void)
memset(&idx_entry, 0, sizeof(git_index_entry));
idx_entry.mode = 0100644;
idx_entry.path = "beef.txt";
- cl_git_pass(git_oid__fromstr(&idx_entry.id, "898d12687fb35be271c27c795a6b32c8b51da79e", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&idx_entry.id, "898d12687fb35be271c27c795a6b32c8b51da79e", GIT_OID_SHA1));
cl_git_pass(git_index_add(index, &idx_entry));
cl_git_pass(git_index_remove(index, "bouilli.txt", 0));
@@ -301,7 +301,7 @@ void test_apply_both__keeps_nonconflicting_changes(void)
cl_git_rmfile("merge-recursive/oyster.txt");
cl_git_rewritefile("merge-recursive/gravy.txt", "Hello, world.\n");
- cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file)));
+ cl_git_pass(diff_from_buffer(&diff, diff_file, strlen(diff_file)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL));
validate_apply_index(repo, index_expected, index_expected_cnt);
@@ -341,7 +341,7 @@ void test_apply_both__can_apply_nonconflicting_file_changes(void)
cl_git_pass(git_index_write(index));
git_index_free(index);
- cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file)));
+ cl_git_pass(diff_from_buffer(&diff, diff_file, strlen(diff_file)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL));
validate_apply_index(repo, both_expected, both_expected_cnt);
@@ -386,12 +386,12 @@ void test_apply_both__honors_crlf_attributes(void)
cl_git_rmfile("merge-recursive/asparagus.txt");
cl_git_rmfile("merge-recursive/veal.txt");
- git_oid__fromstr(&oid, "539bd011c4822c560c1d17cab095006b7a10f707", GIT_OID_SHA1);
+ git_oid_from_string(&oid, "539bd011c4822c560c1d17cab095006b7a10f707", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, repo, &oid));
cl_git_pass(git_reset(repo, (git_object *)commit, GIT_RESET_HARD, NULL));
git_commit_free(commit);
- cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file)));
+ cl_git_pass(diff_from_buffer(&diff, diff_file, strlen(diff_file)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL));
validate_apply_index(repo, index_expected, index_expected_cnt);
@@ -415,7 +415,7 @@ void test_apply_both__rename(void)
size_t both_expected_cnt = sizeof(both_expected) /
sizeof(struct merge_index_entry);
- cl_git_pass(git_diff_from_buffer(&diff, DIFF_RENAME_FILE,
+ cl_git_pass(diff_from_buffer(&diff, DIFF_RENAME_FILE,
strlen(DIFF_RENAME_FILE)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL));
@@ -440,7 +440,7 @@ void test_apply_both__rename_and_modify(void)
size_t both_expected_cnt = sizeof(both_expected) /
sizeof(struct merge_index_entry);
- cl_git_pass(git_diff_from_buffer(&diff, DIFF_RENAME_AND_MODIFY_FILE,
+ cl_git_pass(diff_from_buffer(&diff, DIFF_RENAME_AND_MODIFY_FILE,
strlen(DIFF_RENAME_AND_MODIFY_FILE)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL));
@@ -465,7 +465,7 @@ void test_apply_both__rename_a_to_b_to_c(void)
size_t both_expected_cnt = sizeof(both_expected) /
sizeof(struct merge_index_entry);
- cl_git_pass(git_diff_from_buffer(&diff, DIFF_RENAME_A_TO_B_TO_C,
+ cl_git_pass(diff_from_buffer(&diff, DIFF_RENAME_A_TO_B_TO_C,
strlen(DIFF_RENAME_A_TO_B_TO_C)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL));
@@ -490,7 +490,7 @@ void test_apply_both__rename_a_to_b_to_c_exact(void)
size_t both_expected_cnt = sizeof(both_expected) /
sizeof(struct merge_index_entry);
- cl_git_pass(git_diff_from_buffer(&diff, DIFF_RENAME_A_TO_B_TO_C_EXACT,
+ cl_git_pass(diff_from_buffer(&diff, DIFF_RENAME_A_TO_B_TO_C_EXACT,
strlen(DIFF_RENAME_A_TO_B_TO_C_EXACT)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL));
@@ -515,7 +515,7 @@ void test_apply_both__rename_circular(void)
size_t both_expected_cnt = sizeof(both_expected) /
sizeof(struct merge_index_entry);
- cl_git_pass(git_diff_from_buffer(&diff, DIFF_RENAME_CIRCULAR,
+ cl_git_pass(diff_from_buffer(&diff, DIFF_RENAME_CIRCULAR,
strlen(DIFF_RENAME_CIRCULAR)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL));
@@ -539,7 +539,7 @@ void test_apply_both__rename_2_to_1(void)
size_t both_expected_cnt = sizeof(both_expected) /
sizeof(struct merge_index_entry);
- cl_git_pass(git_diff_from_buffer(&diff, DIFF_RENAME_2_TO_1,
+ cl_git_pass(diff_from_buffer(&diff, DIFF_RENAME_2_TO_1,
strlen(DIFF_RENAME_2_TO_1)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL));
@@ -565,7 +565,7 @@ void test_apply_both__rename_1_to_2(void)
size_t both_expected_cnt = sizeof(both_expected) /
sizeof(struct merge_index_entry);
- cl_git_pass(git_diff_from_buffer(&diff, DIFF_RENAME_1_TO_2,
+ cl_git_pass(diff_from_buffer(&diff, DIFF_RENAME_1_TO_2,
strlen(DIFF_RENAME_1_TO_2)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL));
@@ -590,7 +590,7 @@ void test_apply_both__two_deltas_one_file(void)
size_t both_expected_cnt = sizeof(both_expected) /
sizeof(struct merge_index_entry);
- cl_git_pass(git_diff_from_buffer(&diff, DIFF_TWO_DELTAS_ONE_FILE,
+ cl_git_pass(diff_from_buffer(&diff, DIFF_TWO_DELTAS_ONE_FILE,
strlen(DIFF_TWO_DELTAS_ONE_FILE)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL));
@@ -616,7 +616,7 @@ void test_apply_both__two_deltas_one_new_file(void)
size_t both_expected_cnt = sizeof(both_expected) /
sizeof(struct merge_index_entry);
- cl_git_pass(git_diff_from_buffer(&diff, DIFF_TWO_DELTAS_ONE_NEW_FILE,
+ cl_git_pass(diff_from_buffer(&diff, DIFF_TWO_DELTAS_ONE_NEW_FILE,
strlen(DIFF_TWO_DELTAS_ONE_NEW_FILE)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL));
@@ -641,7 +641,7 @@ void test_apply_both__rename_and_modify_deltas(void)
size_t both_expected_cnt = sizeof(both_expected) /
sizeof(struct merge_index_entry);
- cl_git_pass(git_diff_from_buffer(&diff, DIFF_RENAME_AND_MODIFY_DELTAS,
+ cl_git_pass(diff_from_buffer(&diff, DIFF_RENAME_AND_MODIFY_DELTAS,
strlen(DIFF_RENAME_AND_MODIFY_DELTAS)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL));
@@ -667,7 +667,7 @@ void test_apply_both__rename_delta_after_modify_delta(void)
size_t both_expected_cnt = sizeof(both_expected) /
sizeof(struct merge_index_entry);
- cl_git_pass(git_diff_from_buffer(&diff, DIFF_RENAME_AFTER_MODIFY,
+ cl_git_pass(diff_from_buffer(&diff, DIFF_RENAME_AFTER_MODIFY,
strlen(DIFF_RENAME_AFTER_MODIFY)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL));
@@ -681,7 +681,7 @@ void test_apply_both__cant_rename_after_modify_nonexistent_target_path(void)
{
git_diff *diff;
- cl_git_pass(git_diff_from_buffer(&diff, DIFF_RENAME_AFTER_MODIFY_TARGET_PATH,
+ cl_git_pass(diff_from_buffer(&diff, DIFF_RENAME_AFTER_MODIFY_TARGET_PATH,
strlen(DIFF_RENAME_AFTER_MODIFY_TARGET_PATH)));
cl_git_fail(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL));
@@ -692,7 +692,7 @@ void test_apply_both__cant_modify_source_path_after_rename(void)
{
git_diff *diff;
- cl_git_pass(git_diff_from_buffer(&diff, DIFF_RENAME_AND_MODIFY_SOURCE_PATH,
+ cl_git_pass(diff_from_buffer(&diff, DIFF_RENAME_AND_MODIFY_SOURCE_PATH,
strlen(DIFF_RENAME_AND_MODIFY_SOURCE_PATH)));
cl_git_fail(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL));
@@ -714,7 +714,7 @@ void test_apply_both__readd_deleted_file(void)
size_t both_expected_cnt = sizeof(both_expected) /
sizeof(struct merge_index_entry);
- cl_git_pass(git_diff_from_buffer(&diff, DIFF_DELETE_AND_READD_FILE,
+ cl_git_pass(diff_from_buffer(&diff, DIFF_DELETE_AND_READD_FILE,
strlen(DIFF_DELETE_AND_READD_FILE)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL));
@@ -728,7 +728,7 @@ void test_apply_both__cant_remove_file_twice(void)
{
git_diff *diff;
- cl_git_pass(git_diff_from_buffer(&diff, DIFF_REMOVE_FILE_TWICE,
+ cl_git_pass(diff_from_buffer(&diff, DIFF_REMOVE_FILE_TWICE,
strlen(DIFF_REMOVE_FILE_TWICE)));
cl_git_fail(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL));
@@ -739,7 +739,7 @@ void test_apply_both__cant_add_invalid_filename(void)
{
git_diff *diff;
- cl_git_pass(git_diff_from_buffer(&diff, DIFF_ADD_INVALID_FILENAME,
+ cl_git_pass(diff_from_buffer(&diff, DIFF_ADD_INVALID_FILENAME,
strlen(DIFF_ADD_INVALID_FILENAME)));
cl_git_fail(git_apply(repo, diff, GIT_APPLY_LOCATION_BOTH, NULL));
diff --git a/tests/libgit2/apply/callbacks.c b/tests/libgit2/apply/callbacks.c
index 2f9af310161..cda06e6c6b3 100644
--- a/tests/libgit2/apply/callbacks.c
+++ b/tests/libgit2/apply/callbacks.c
@@ -12,7 +12,7 @@ void test_apply_callbacks__initialize(void)
repo = cl_git_sandbox_init(TEST_REPO_PATH);
- git_oid__fromstr(&oid, "539bd011c4822c560c1d17cab095006b7a10f707", GIT_OID_SHA1);
+ git_oid_from_string(&oid, "539bd011c4822c560c1d17cab095006b7a10f707", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, repo, &oid));
cl_git_pass(git_reset(repo, (git_object *)commit, GIT_RESET_HARD, NULL));
git_commit_free(commit);
@@ -40,7 +40,7 @@ void test_apply_callbacks__delta_aborts(void)
opts.delta_cb = delta_abort_cb;
- cl_git_pass(git_diff_from_buffer(&diff,
+ cl_git_pass(diff_from_buffer(&diff,
DIFF_MODIFY_TWO_FILES, strlen(DIFF_MODIFY_TWO_FILES)));
cl_git_fail_with(-99,
git_apply(repo, diff, GIT_APPLY_LOCATION_INDEX, &opts));
@@ -79,7 +79,7 @@ void test_apply_callbacks__delta_can_skip(void)
opts.delta_cb = delta_skip_cb;
- cl_git_pass(git_diff_from_buffer(&diff,
+ cl_git_pass(diff_from_buffer(&diff,
DIFF_MODIFY_TWO_FILES, strlen(DIFF_MODIFY_TWO_FILES)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_WORKDIR, &opts));
@@ -117,7 +117,7 @@ void test_apply_callbacks__hunk_can_skip(void)
opts.hunk_cb = hunk_skip_odds_cb;
opts.payload = &count;
- cl_git_pass(git_diff_from_buffer(&diff,
+ cl_git_pass(diff_from_buffer(&diff,
DIFF_MANY_CHANGES_ONE, strlen(DIFF_MANY_CHANGES_ONE)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_WORKDIR, &opts));
diff --git a/tests/libgit2/apply/check.c b/tests/libgit2/apply/check.c
index d055d455b8f..8f37e00b1f9 100644
--- a/tests/libgit2/apply/check.c
+++ b/tests/libgit2/apply/check.c
@@ -12,7 +12,7 @@ void test_apply_check__initialize(void)
repo = cl_git_sandbox_init(TEST_REPO_PATH);
- git_oid__fromstr(&oid, "539bd011c4822c560c1d17cab095006b7a10f707", GIT_OID_SHA1);
+ git_oid_from_string(&oid, "539bd011c4822c560c1d17cab095006b7a10f707", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, repo, &oid));
cl_git_pass(git_reset(repo, (git_object *)commit, GIT_RESET_HARD, NULL));
git_commit_free(commit);
@@ -32,8 +32,8 @@ void test_apply_check__generate_diff(void)
git_diff_options diff_opts = GIT_DIFF_OPTIONS_INIT;
git_apply_options opts = GIT_APPLY_OPTIONS_INIT;
- cl_git_pass(git_oid__fromstr(&a_oid, "539bd011c4822c560c1d17cab095006b7a10f707", GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&b_oid, "7c7bf85e978f1d18c0566f702d2cb7766b9c8d4f", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&a_oid, "539bd011c4822c560c1d17cab095006b7a10f707", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&b_oid, "7c7bf85e978f1d18c0566f702d2cb7766b9c8d4f", GIT_OID_SHA1));
cl_git_pass(git_commit_lookup(&a_commit, repo, &a_oid));
cl_git_pass(git_commit_lookup(&b_commit, repo, &b_oid));
@@ -60,7 +60,7 @@ void test_apply_check__parsed_diff(void)
git_apply_options opts = GIT_APPLY_OPTIONS_INIT;
opts.flags |= GIT_APPLY_CHECK;
- cl_git_pass(git_diff_from_buffer(&diff,
+ cl_git_pass(diff_from_buffer(&diff,
DIFF_MODIFY_TWO_FILES, strlen(DIFF_MODIFY_TWO_FILES)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_INDEX, &opts));
@@ -76,7 +76,7 @@ void test_apply_check__binary(void)
git_apply_options opts = GIT_APPLY_OPTIONS_INIT;
opts.flags |= GIT_APPLY_CHECK;
- cl_git_pass(git_diff_from_buffer(&diff,
+ cl_git_pass(diff_from_buffer(&diff,
DIFF_MODIFY_TWO_FILES_BINARY,
strlen(DIFF_MODIFY_TWO_FILES_BINARY)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_INDEX, &opts));
@@ -112,7 +112,7 @@ void test_apply_check__does_not_apply(void)
git_index_free(index);
opts.flags |= GIT_APPLY_CHECK;
- cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file)));
+ cl_git_pass(diff_from_buffer(&diff, diff_file, strlen(diff_file)));
cl_git_fail_with(GIT_EAPPLYFAIL, git_apply(repo, diff, GIT_APPLY_LOCATION_INDEX, &opts));
validate_apply_index(repo, index_expected, index_expected_cnt);
diff --git a/tests/libgit2/apply/index.c b/tests/libgit2/apply/index.c
index 2dc0d53cb34..e0fb7f2a455 100644
--- a/tests/libgit2/apply/index.c
+++ b/tests/libgit2/apply/index.c
@@ -12,7 +12,7 @@ void test_apply_index__initialize(void)
repo = cl_git_sandbox_init(TEST_REPO_PATH);
- git_oid__fromstr(&oid, "539bd011c4822c560c1d17cab095006b7a10f707", GIT_OID_SHA1);
+ git_oid_from_string(&oid, "539bd011c4822c560c1d17cab095006b7a10f707", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, repo, &oid));
cl_git_pass(git_reset(repo, (git_object *)commit, GIT_RESET_HARD, NULL));
git_commit_free(commit);
@@ -42,8 +42,8 @@ void test_apply_index__generate_diff(void)
size_t index_expected_cnt = sizeof(index_expected) /
sizeof(struct merge_index_entry);
- git_oid__fromstr(&a_oid, "539bd011c4822c560c1d17cab095006b7a10f707", GIT_OID_SHA1);
- git_oid__fromstr(&b_oid, "7c7bf85e978f1d18c0566f702d2cb7766b9c8d4f", GIT_OID_SHA1);
+ git_oid_from_string(&a_oid, "539bd011c4822c560c1d17cab095006b7a10f707", GIT_OID_SHA1);
+ git_oid_from_string(&b_oid, "7c7bf85e978f1d18c0566f702d2cb7766b9c8d4f", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&a_commit, repo, &a_oid));
cl_git_pass(git_commit_lookup(&b_commit, repo, &b_oid));
@@ -78,7 +78,7 @@ void test_apply_index__parsed_diff(void)
size_t index_expected_cnt = sizeof(index_expected) /
sizeof(struct merge_index_entry);
- cl_git_pass(git_diff_from_buffer(&diff,
+ cl_git_pass(diff_from_buffer(&diff,
DIFF_MODIFY_TWO_FILES, strlen(DIFF_MODIFY_TWO_FILES)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_INDEX, NULL));
@@ -102,7 +102,7 @@ void test_apply_index__removes_file(void)
size_t index_expected_cnt = sizeof(index_expected) /
sizeof(struct merge_index_entry);
- cl_git_pass(git_diff_from_buffer(&diff, DIFF_DELETE_FILE,
+ cl_git_pass(diff_from_buffer(&diff, DIFF_DELETE_FILE,
strlen(DIFF_DELETE_FILE)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_INDEX, NULL));
@@ -128,7 +128,7 @@ void test_apply_index__adds_file(void)
size_t index_expected_cnt = sizeof(index_expected) /
sizeof(struct merge_index_entry);
- cl_git_pass(git_diff_from_buffer(&diff,
+ cl_git_pass(diff_from_buffer(&diff,
DIFF_ADD_FILE, strlen(DIFF_ADD_FILE)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_INDEX, NULL));
@@ -169,7 +169,7 @@ void test_apply_index__modified_workdir_with_unmodified_index_is_ok(void)
cl_git_rmfile("merge-recursive/asparagus.txt");
cl_git_rewritefile("merge-recursive/veal.txt", "Hello, world.\n");
- cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file)));
+ cl_git_pass(diff_from_buffer(&diff, diff_file, strlen(diff_file)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_INDEX, NULL));
validate_apply_index(repo, index_expected, index_expected_cnt);
@@ -201,7 +201,7 @@ void test_apply_index__application_failure_leaves_index_unmodified(void)
cl_git_pass(git_index_write(index));
git_index_free(index);
- cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file)));
+ cl_git_pass(diff_from_buffer(&diff, diff_file, strlen(diff_file)));
cl_git_fail_with(GIT_EAPPLYFAIL, git_apply(repo, diff, GIT_APPLY_LOCATION_INDEX, NULL));
validate_apply_index(repo, index_expected, index_expected_cnt);
@@ -233,14 +233,14 @@ void test_apply_index__keeps_nonconflicting_changes(void)
memset(&idx_entry, 0, sizeof(git_index_entry));
idx_entry.mode = 0100644;
idx_entry.path = "beef.txt";
- cl_git_pass(git_oid__fromstr(&idx_entry.id, "898d12687fb35be271c27c795a6b32c8b51da79e", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&idx_entry.id, "898d12687fb35be271c27c795a6b32c8b51da79e", GIT_OID_SHA1));
cl_git_pass(git_index_add(index, &idx_entry));
cl_git_pass(git_index_remove(index, "bouilli.txt", 0));
cl_git_pass(git_index_write(index));
git_index_free(index);
- cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file)));
+ cl_git_pass(diff_from_buffer(&diff, diff_file, strlen(diff_file)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_INDEX, NULL));
validate_apply_index(repo, index_expected, index_expected_cnt);
@@ -279,13 +279,13 @@ void test_apply_index__can_apply_nonconflicting_file_changes(void)
memset(&idx_entry, 0, sizeof(git_index_entry));
idx_entry.mode = 0100644;
idx_entry.path = "asparagus.txt";
- cl_git_pass(git_oid__fromstr(&idx_entry.id, "06d3fefb8726ab1099acc76e02dfb85e034b2538", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&idx_entry.id, "06d3fefb8726ab1099acc76e02dfb85e034b2538", GIT_OID_SHA1));
cl_git_pass(git_index_add(index, &idx_entry));
cl_git_pass(git_index_write(index));
git_index_free(index);
- cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file)));
+ cl_git_pass(diff_from_buffer(&diff, diff_file, strlen(diff_file)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_INDEX, NULL));
validate_apply_index(repo, index_expected, index_expected_cnt);
@@ -311,7 +311,7 @@ void test_apply_index__change_mode(void)
size_t index_expected_cnt = sizeof(index_expected) /
sizeof(struct merge_index_entry);
- cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file)));
+ cl_git_pass(diff_from_buffer(&diff, diff_file, strlen(diff_file)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_INDEX, NULL));
validate_apply_index(repo, index_expected, index_expected_cnt);
diff --git a/tests/libgit2/apply/tree.c b/tests/libgit2/apply/tree.c
index 667bb9d401a..0e5b65fd7c1 100644
--- a/tests/libgit2/apply/tree.c
+++ b/tests/libgit2/apply/tree.c
@@ -35,8 +35,8 @@ void test_apply_tree__one(void)
{ 0100644, "a7b066537e6be7109abfe4ff97b675d4e077da20", 0, "veal.txt" },
};
- git_oid__fromstr(&a_oid, "539bd011c4822c560c1d17cab095006b7a10f707", GIT_OID_SHA1);
- git_oid__fromstr(&b_oid, "7c7bf85e978f1d18c0566f702d2cb7766b9c8d4f", GIT_OID_SHA1);
+ git_oid_from_string(&a_oid, "539bd011c4822c560c1d17cab095006b7a10f707", GIT_OID_SHA1);
+ git_oid_from_string(&b_oid, "7c7bf85e978f1d18c0566f702d2cb7766b9c8d4f", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&a_commit, repo, &a_oid));
cl_git_pass(git_commit_lookup(&b_commit, repo, &b_oid));
@@ -75,13 +75,13 @@ void test_apply_tree__adds_file(void)
{ 0100644, "94d2c01087f48213bd157222d54edfefd77c9bba", 0, "veal.txt" },
};
- git_oid__fromstr(&a_oid, "539bd011c4822c560c1d17cab095006b7a10f707", GIT_OID_SHA1);
+ git_oid_from_string(&a_oid, "539bd011c4822c560c1d17cab095006b7a10f707", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&a_commit, repo, &a_oid));
cl_git_pass(git_commit_tree(&a_tree, a_commit));
- cl_git_pass(git_diff_from_buffer(&diff,
+ cl_git_pass(diff_from_buffer(&diff,
DIFF_ADD_FILE, strlen(DIFF_ADD_FILE)));
cl_git_pass(git_apply_to_tree(&index, repo, a_tree, diff, NULL));
diff --git a/tests/libgit2/apply/workdir.c b/tests/libgit2/apply/workdir.c
index e1011d114cc..6b95ec04bce 100644
--- a/tests/libgit2/apply/workdir.c
+++ b/tests/libgit2/apply/workdir.c
@@ -12,7 +12,7 @@ void test_apply_workdir__initialize(void)
repo = cl_git_sandbox_init(TEST_REPO_PATH);
- git_oid__fromstr(&oid, "539bd011c4822c560c1d17cab095006b7a10f707", GIT_OID_SHA1);
+ git_oid_from_string(&oid, "539bd011c4822c560c1d17cab095006b7a10f707", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, repo, &oid));
cl_git_pass(git_reset(repo, (git_object *)commit, GIT_RESET_HARD, NULL));
git_commit_free(commit);
@@ -42,8 +42,8 @@ void test_apply_workdir__generated_diff(void)
size_t workdir_expected_cnt = sizeof(workdir_expected) /
sizeof(struct merge_index_entry);
- git_oid__fromstr(&a_oid, "539bd011c4822c560c1d17cab095006b7a10f707", GIT_OID_SHA1);
- git_oid__fromstr(&b_oid, "7c7bf85e978f1d18c0566f702d2cb7766b9c8d4f", GIT_OID_SHA1); cl_git_pass(git_commit_lookup(&a_commit, repo, &a_oid));
+ git_oid_from_string(&a_oid, "539bd011c4822c560c1d17cab095006b7a10f707", GIT_OID_SHA1);
+ git_oid_from_string(&b_oid, "7c7bf85e978f1d18c0566f702d2cb7766b9c8d4f", GIT_OID_SHA1); cl_git_pass(git_commit_lookup(&a_commit, repo, &a_oid));
cl_git_pass(git_commit_lookup(&b_commit, repo, &b_oid));
cl_git_pass(git_commit_tree(&a_tree, a_commit));
@@ -77,7 +77,7 @@ void test_apply_workdir__parsed_diff(void)
size_t workdir_expected_cnt = sizeof(workdir_expected) /
sizeof(struct merge_index_entry);
- cl_git_pass(git_diff_from_buffer(&diff,
+ cl_git_pass(diff_from_buffer(&diff,
DIFF_MODIFY_TWO_FILES, strlen(DIFF_MODIFY_TWO_FILES)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_WORKDIR, NULL));
@@ -101,7 +101,7 @@ void test_apply_workdir__removes_file(void)
size_t workdir_expected_cnt = sizeof(workdir_expected) /
sizeof(struct merge_index_entry);
- cl_git_pass(git_diff_from_buffer(&diff, DIFF_DELETE_FILE,
+ cl_git_pass(diff_from_buffer(&diff, DIFF_DELETE_FILE,
strlen(DIFF_DELETE_FILE)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_WORKDIR, NULL));
@@ -127,7 +127,7 @@ void test_apply_workdir__adds_file(void)
size_t workdir_expected_cnt = sizeof(workdir_expected) /
sizeof(struct merge_index_entry);
- cl_git_pass(git_diff_from_buffer(&diff,
+ cl_git_pass(diff_from_buffer(&diff,
DIFF_ADD_FILE, strlen(DIFF_ADD_FILE)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_WORKDIR, NULL));
@@ -171,13 +171,13 @@ void test_apply_workdir__modified_index_with_unmodified_workdir_is_ok(void)
idx_entry.mode = 0100644;
idx_entry.path = "veal.txt";
- cl_git_pass(git_oid__fromstr(&idx_entry.id, "ffb36e513f5fdf8a6ba850a20142676a2ac4807d", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&idx_entry.id, "ffb36e513f5fdf8a6ba850a20142676a2ac4807d", GIT_OID_SHA1));
cl_git_pass(git_index_add(index, &idx_entry));
cl_git_pass(git_index_remove(index, "asparagus.txt", 0));
cl_git_pass(git_index_write(index));
- cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file)));
+ cl_git_pass(diff_from_buffer(&diff, diff_file, strlen(diff_file)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_WORKDIR, NULL));
validate_apply_index(repo, index_expected, index_expected_cnt);
@@ -208,7 +208,7 @@ void test_apply_workdir__application_failure_leaves_workdir_unmodified(void)
cl_git_rewritefile("merge-recursive/veal.txt",
"This is a modification.\n");
- cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file)));
+ cl_git_pass(diff_from_buffer(&diff, diff_file, strlen(diff_file)));
cl_git_fail_with(GIT_EAPPLYFAIL, git_apply(repo, diff, GIT_APPLY_LOCATION_WORKDIR, NULL));
validate_apply_workdir(repo, workdir_expected, workdir_expected_cnt);
@@ -233,7 +233,7 @@ void test_apply_workdir__keeps_nonconflicting_changes(void)
cl_git_rmfile("merge-recursive/oyster.txt");
cl_git_rewritefile("merge-recursive/gravy.txt", "Hello, world.\n");
- cl_git_pass(git_diff_from_buffer(&diff,
+ cl_git_pass(diff_from_buffer(&diff,
DIFF_MODIFY_TWO_FILES, strlen(DIFF_MODIFY_TWO_FILES)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_WORKDIR, NULL));
@@ -268,7 +268,7 @@ void test_apply_workdir__can_apply_nonconflicting_file_changes(void)
cl_git_append2file("merge-recursive/asparagus.txt",
"This line is added in the workdir.\n");
- cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file)));
+ cl_git_pass(diff_from_buffer(&diff, diff_file, strlen(diff_file)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_WORKDIR, NULL));
validate_index_unchanged(repo);
@@ -295,7 +295,7 @@ void test_apply_workdir__change_mode(void)
size_t workdir_expected_cnt = sizeof(workdir_expected) /
sizeof(struct merge_index_entry);
- cl_git_pass(git_diff_from_buffer(&diff, diff_file, strlen(diff_file)));
+ cl_git_pass(diff_from_buffer(&diff, diff_file, strlen(diff_file)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_WORKDIR, NULL));
validate_index_unchanged(repo);
@@ -321,7 +321,7 @@ void test_apply_workdir__apply_many_changes_one(void)
size_t workdir_expected_cnt = sizeof(workdir_expected) /
sizeof(struct merge_index_entry);
- cl_git_pass(git_diff_from_buffer(&diff,
+ cl_git_pass(diff_from_buffer(&diff,
DIFF_MANY_CHANGES_ONE, strlen(DIFF_MANY_CHANGES_ONE)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_WORKDIR, &opts));
@@ -347,7 +347,7 @@ void test_apply_workdir__apply_many_changes_two(void)
size_t workdir_expected_cnt = sizeof(workdir_expected) /
sizeof(struct merge_index_entry);
- cl_git_pass(git_diff_from_buffer(&diff,
+ cl_git_pass(diff_from_buffer(&diff,
DIFF_MANY_CHANGES_TWO, strlen(DIFF_MANY_CHANGES_TWO)));
cl_git_pass(git_apply(repo, diff, GIT_APPLY_LOCATION_WORKDIR, &opts));
diff --git a/tests/libgit2/attr/repo.c b/tests/libgit2/attr/repo.c
index abd2381541d..4c71bddb75c 100644
--- a/tests/libgit2/attr/repo.c
+++ b/tests/libgit2/attr/repo.c
@@ -309,6 +309,27 @@ void test_attr_repo__bare_repo_with_index(void)
cl_assert(GIT_ATTR_IS_UNSPECIFIED(values[3]));
}
+void test_attr_repo__inmemory_repo_without_index(void)
+{
+ const char *names[1] = { "fake" };
+ const char *values[1];
+ git_repository *inmemory;
+ git_index *index = NULL;
+
+ /* setup bare in-memory repo without index */
+ cl_git_pass(git_repository_new(&inmemory));
+ cl_assert(git_repository_is_bare(inmemory));
+
+ /* verify repo isn't given an index upfront in future */
+ git_repository_index(&index, inmemory);
+ cl_assert(!index);
+
+ /* check attributes can be queried without error due to missing index */
+ cl_git_pass(git_attr_get_many(values, inmemory, 0, "fake.txt", 1, names));
+
+ git_repository_free(inmemory);
+}
+
void test_attr_repo__sysdir(void)
{
git_str sysdir = GIT_STR_INIT;
diff --git a/tests/libgit2/blame/blame_helpers.c b/tests/libgit2/blame/blame_helpers.c
index 8aeaa58866a..c8c3d48329f 100644
--- a/tests/libgit2/blame/blame_helpers.c
+++ b/tests/libgit2/blame/blame_helpers.c
@@ -18,7 +18,7 @@ void check_blame_hunk_index(git_repository *repo, git_blame *blame, int idx,
size_t start_line, size_t len, char boundary, const char *commit_id, const char *orig_path)
{
char expected[GIT_OID_SHA1_HEXSIZE+1] = {0}, actual[GIT_OID_SHA1_HEXSIZE+1] = {0};
- const git_blame_hunk *hunk = git_blame_get_hunk_byindex(blame, idx);
+ const git_blame_hunk *hunk = git_blame_hunk_byindex(blame, idx);
cl_assert(hunk);
if (!strncmp(commit_id, "0000", 4)) {
diff --git a/tests/libgit2/blame/buffer.c b/tests/libgit2/blame/buffer.c
index 06d5042dd05..cf70dbb31bc 100644
--- a/tests/libgit2/blame/buffer.c
+++ b/tests/libgit2/blame/buffer.c
@@ -17,32 +17,223 @@ void test_blame_buffer__cleanup(void)
git_repository_free(g_repo);
}
+
+void test_blame_buffer__4_edits(void)
+{
+
+ const char *buffer = "\
+EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\
+EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\
+xEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\
+EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\
+x\n\
+BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\
+xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\
+BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\
+xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\
+\n\
+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\
+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\
+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\
+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\n";
+
+ cl_git_pass(git_blame_buffer(&g_bufferblame, g_fileblame, buffer, strlen(buffer)));
+ check_blame_hunk_index(g_repo, g_bufferblame, 0, 1, 2, 0, "da237394", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 1, 3, 1, 0, "000000", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 2, 4, 1, 0, "da237394", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 3, 5, 1, 0, "000000", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 4, 6, 1, 0, "63d671eb", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 5, 7, 1, 0, "000000", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 6, 8, 1, 0, "63d671eb", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 7, 9, 1, 0, "000000", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 8, 10, 1, 0, "63d671eb", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 9, 11, 5, 0, "aa06ecca", "b.txt");
+}
+
+void test_blame_buffer__two_added_lines_and_one_modified(void)
+{
+
+ const char *buffer = "\
+EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\
+EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\
+EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\
+x\n\
+EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\
+x\n\
+BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\
+xBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\
+BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\
+BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\
+\n\
+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\
+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\
+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\
+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\n";
+
+ cl_git_pass(git_blame_buffer(&g_bufferblame, g_fileblame, buffer, strlen(buffer)));
+ check_blame_hunk_index(g_repo, g_bufferblame, 0, 1, 3, 0, "da237394", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 1, 4, 1, 0, "000000", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 2, 5, 1, 0, "da237394", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 3, 6, 1, 0, "000000", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 4, 7, 1, 0, "63d671eb", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 5, 8, 1, 0, "000000", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 6, 9, 3, 0, "63d671eb", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 7, 12, 5, 0, "aa06ecca", "b.txt");
+}
+
+void test_blame_buffer__two_added_lines(void)
+{
+
+ const char *buffer = "\
+EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\
+EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\
+EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\
+abc\n\
+EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\
+def\n\
+BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\
+BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\
+BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\
+BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\
+\n\
+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\
+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\
+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\
+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\n";
+
+ cl_git_pass(git_blame_buffer(&g_bufferblame, g_fileblame, buffer, strlen(buffer)));
+ check_blame_hunk_index(g_repo, g_bufferblame, 0, 1, 3, 0, "da237394", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 1, 4, 1, 0, "000000", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 2, 5, 1, 0, "da237394", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 3, 6, 1, 0, "000000", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 4, 7, 5, 0, "63d671eb", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 5, 12, 5, 0, "aa06ecca", "b.txt");
+}
+
+void test_blame_buffer__added_blocks(void)
+{
+
+ const char *buffer = "\
+EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\
+EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\
+EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\
+EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\
+\n\
+abcdefg\n\
+hijlmno\n\
+pqrstuv\n\
+BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\
+BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\
+BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\
+BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\
+abcdefg\n\
+hijlmno\n\
+pqrstuv\n\
+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\
+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\
+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\
+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\
+\n\
+abcdefg\n\
+hijlmno\n\
+pqrstuv\n";
+
+ cl_git_pass(git_blame_buffer(&g_bufferblame, g_fileblame, buffer, strlen(buffer)));
+ check_blame_hunk_index(g_repo, g_bufferblame, 0, 1, 4, 0, "da237394", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 1, 5, 1, 1, "b99f7ac0", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 2, 6, 3, 0, "000000", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 3, 9, 4, 0, "63d671eb", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 4, 13, 3, 0, "000000", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 5, 16, 5, 0, "aa06ecca", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 6, 21, 3, 0, "000000", "b.txt");
+
+
+}
+
+void test_blame_buffer__overlapping_blocks(void)
+{
+ const char *buffer = "\
+EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\
+EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\
+EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\
+abcdefg\n\
+hijlmno\n\
+pqrstuv\n\
+BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\
+BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\
+BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\
+\n\
+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\
+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\
+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\
+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\
+\n\
+";
+
+ cl_git_pass(git_blame_buffer(&g_bufferblame, g_fileblame, buffer, strlen(buffer)));
+
+ check_blame_hunk_index(g_repo, g_bufferblame, 0, 1, 3, 0, "da237394", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 1, 4, 3, 0, "000000", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 2, 7, 4, 0, "63d671eb", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 3, 11, 5, 0, "aa06ecca", "b.txt");
+
+}
+
+void test_blame_buffer__2_add_splits_hunk(void)
+{
+ const char *buffer = "\
+EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\
+EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\
+abc\n\
+EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\
+EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\
+\n\
+BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\
+BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\
+abc\n\
+BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\
+BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\
+\n\
+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\
+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\
+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\
+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\n";
+
+ cl_git_pass(git_blame_buffer(&g_bufferblame, g_fileblame, buffer, strlen(buffer)));
+ check_blame_hunk_index(g_repo, g_bufferblame, 0, 1, 2, 0, "da237394", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 1, 3, 1, 0, "00000000", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 2, 4, 2, 0, "da237394", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 3, 6, 1, 1, "b99f7ac0", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 4, 7, 2, 0, "63d671eb", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 5, 9, 1, 0, "00000000", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 6, 10, 3, 0, "63d671eb", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 7, 13, 5, 0, "aa06ecca", "b.txt");
+}
+
void test_blame_buffer__index(void)
{
const git_blame_hunk *hunk;
const char *buffer = "Hello\nWorld!";
- /*
- * We need to open a different file from the ones used in other tests. Close
- * the one opened in test_blame_buffer__initialize() to avoid a leak.
- */
git_blame_free(g_fileblame);
g_fileblame = NULL;
cl_git_pass(git_blame_file(&g_fileblame, g_repo, "file.txt", NULL));
cl_git_pass(git_blame_buffer(&g_bufferblame, g_fileblame, buffer, strlen(buffer)));
- cl_assert_equal_i(2, git_blame_get_hunk_count(g_bufferblame));
+ cl_assert_equal_i(2, git_blame_hunkcount(g_bufferblame));
check_blame_hunk_index(g_repo, g_bufferblame, 0, 1, 1, 0, "836bc00b", "file.txt");
- hunk = git_blame_get_hunk_byline(g_bufferblame, 1);
+ hunk = git_blame_hunk_byline(g_bufferblame, 1);
cl_assert(hunk);
cl_assert_equal_s("lhchavez", hunk->final_signature->name);
check_blame_hunk_index(g_repo, g_bufferblame, 1, 2, 1, 0, "00000000", "file.txt");
- hunk = git_blame_get_hunk_byline(g_bufferblame, 2);
+ hunk = git_blame_hunk_byline(g_bufferblame, 2);
cl_assert(hunk);
cl_assert(hunk->final_signature == NULL);
}
+
+
void test_blame_buffer__added_line(void)
{
const git_blame_hunk *hunk;
@@ -65,14 +256,51 @@ CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\n";
cl_git_pass(git_blame_buffer(&g_bufferblame, g_fileblame, buffer, strlen(buffer)));
- cl_assert_equal_i(5, git_blame_get_hunk_count(g_bufferblame));
+ cl_assert_equal_i(5, git_blame_hunkcount(g_bufferblame));
check_blame_hunk_index(g_repo, g_bufferblame, 2, 6, 1, 0, "000000", "b.txt");
- hunk = git_blame_get_hunk_byline(g_bufferblame, 16);
+ hunk = git_blame_hunk_byline(g_bufferblame, 16);
cl_assert(hunk);
cl_assert_equal_s("Ben Straub", hunk->final_signature->name);
}
+void test_blame_buffer__added_lines(void)
+{
+
+ const char *buffer = "\
+EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\
+EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\
+EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\
+EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE\n\
+\n\
+\n\
+\n\
+\n\
+BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\
+BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\
+BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\
+BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n\
+\n\
+\n\
+\n\
+\n\
+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\
+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\
+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\
+CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC\n\
+\n\
+\n\
+\n\
+\n";
+
+ cl_git_pass(git_blame_buffer(&g_bufferblame, g_fileblame, buffer, strlen(buffer)));
+ cl_assert_equal_i(7, git_blame_hunkcount(g_bufferblame));
+ check_blame_hunk_index(g_repo, g_bufferblame, 2, 6, 3, 0, "000000", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 4, 14, 3, 0, "000000", "b.txt");
+ check_blame_hunk_index(g_repo, g_bufferblame, 6, 22, 3, 0, "000000", "b.txt");
+
+}
+
void test_blame_buffer__deleted_line(void)
{
const char *buffer = "\
@@ -183,7 +411,7 @@ abc\n\
def\n";
cl_git_pass(git_blame_buffer(&g_bufferblame, g_fileblame, buffer, strlen(buffer)));
- cl_assert_equal_i(5, git_blame_get_hunk_count(g_bufferblame));
+ cl_assert_equal_i(5, git_blame_hunkcount(g_bufferblame));
check_blame_hunk_index(g_repo, g_bufferblame, 0, 1, 4, 0, "da237394", "b.txt");
check_blame_hunk_index(g_repo, g_bufferblame, 1, 5, 1, 1, "b99f7ac0", "b.txt");
check_blame_hunk_index(g_repo, g_bufferblame, 2, 6, 5, 0, "63d671eb", "b.txt");
diff --git a/tests/libgit2/blame/getters.c b/tests/libgit2/blame/getters.c
index c160cd38367..fc7e4444591 100644
--- a/tests/libgit2/blame/getters.c
+++ b/tests/libgit2/blame/getters.c
@@ -10,11 +10,11 @@ void test_blame_getters__initialize(void)
git_blame_options opts = GIT_BLAME_OPTIONS_INIT;
git_blame_hunk hunks[] = {
- { 3, GIT_OID_SHA1_ZERO, 1, NULL, GIT_OID_SHA1_ZERO, "a", 0},
- { 3, GIT_OID_SHA1_ZERO, 4, NULL, GIT_OID_SHA1_ZERO, "b", 0},
- { 3, GIT_OID_SHA1_ZERO, 7, NULL, GIT_OID_SHA1_ZERO, "c", 0},
- { 3, GIT_OID_SHA1_ZERO, 10, NULL, GIT_OID_SHA1_ZERO, "d", 0},
- { 3, GIT_OID_SHA1_ZERO, 13, NULL, GIT_OID_SHA1_ZERO, "e", 0},
+ { 3, GIT_OID_SHA1_ZERO, 1, NULL, NULL, GIT_OID_SHA1_ZERO, "a", 0},
+ { 3, GIT_OID_SHA1_ZERO, 4, NULL, NULL, GIT_OID_SHA1_ZERO, "b", 0},
+ { 3, GIT_OID_SHA1_ZERO, 7, NULL, NULL, GIT_OID_SHA1_ZERO, "c", 0},
+ { 3, GIT_OID_SHA1_ZERO, 10, NULL, NULL, GIT_OID_SHA1_ZERO, "d", 0},
+ { 3, GIT_OID_SHA1_ZERO, 13, NULL, NULL, GIT_OID_SHA1_ZERO, "e", 0},
};
g_blame = git_blame__alloc(NULL, opts, "");
@@ -37,20 +37,20 @@ void test_blame_getters__cleanup(void)
void test_blame_getters__byindex(void)
{
- const git_blame_hunk *h = git_blame_get_hunk_byindex(g_blame, 2);
+ const git_blame_hunk *h = git_blame_hunk_byindex(g_blame, 2);
cl_assert(h);
cl_assert_equal_s(h->orig_path, "c");
- h = git_blame_get_hunk_byindex(g_blame, 95);
+ h = git_blame_hunk_byindex(g_blame, 95);
cl_assert_equal_p(h, NULL);
}
void test_blame_getters__byline(void)
{
- const git_blame_hunk *h = git_blame_get_hunk_byline(g_blame, 5);
+ const git_blame_hunk *h = git_blame_hunk_byline(g_blame, 5);
cl_assert(h);
cl_assert_equal_s(h->orig_path, "b");
- h = git_blame_get_hunk_byline(g_blame, 95);
+ h = git_blame_hunk_byline(g_blame, 95);
cl_assert_equal_p(h, NULL);
}
diff --git a/tests/libgit2/blame/harder.c b/tests/libgit2/blame/harder.c
index e7774172051..412949a3bb9 100644
--- a/tests/libgit2/blame/harder.c
+++ b/tests/libgit2/blame/harder.c
@@ -10,7 +10,7 @@
* |\
* | * (B) aa06ecc
* * | (C) 63d671e
- * |/
+ * |/
* * (D) da23739
* * (E) b99f7ac
*
@@ -71,7 +71,7 @@ void test_blame_harder__ccc(void)
git_blame_options opts = GIT_BLAME_OPTIONS_INIT;
GIT_UNUSED(opts);
-
+
/* Attribute the third hunk in b.txt to (E). This hunk was deleted from
* a.txt in (D), but reintroduced in (B).
*/
diff --git a/tests/libgit2/blame/simple.c b/tests/libgit2/blame/simple.c
index 6b13cccd418..ee6d5f866c0 100644
--- a/tests/libgit2/blame/simple.c
+++ b/tests/libgit2/blame/simple.c
@@ -27,7 +27,7 @@ void test_blame_simple__trivial_testrepo(void)
cl_git_pass(git_repository_open(&g_repo, cl_fixture("testrepo/.gitted")));
cl_git_pass(git_blame_file(&g_blame, g_repo, "branch_file.txt", NULL));
- cl_assert_equal_i(2, git_blame_get_hunk_count(g_blame));
+ cl_assert_equal_i(2, git_blame_hunkcount(g_blame));
check_blame_hunk_index(g_repo, g_blame, 0, 1, 1, 0, "c47800c7", "branch_file.txt");
check_blame_hunk_index(g_repo, g_blame, 1, 2, 1, 0, "a65fedf3", "branch_file.txt");
}
@@ -57,7 +57,7 @@ void test_blame_simple__trivial_blamerepo(void)
cl_git_pass(git_repository_open(&g_repo, cl_fixture("blametest.git")));
cl_git_pass(git_blame_file(&g_blame, g_repo, "b.txt", NULL));
- cl_assert_equal_i(4, git_blame_get_hunk_count(g_blame));
+ cl_assert_equal_i(4, git_blame_hunkcount(g_blame));
check_blame_hunk_index(g_repo, g_blame, 0, 1, 4, 0, "da237394", "b.txt");
check_blame_hunk_index(g_repo, g_blame, 1, 5, 1, 1, "b99f7ac0", "b.txt");
check_blame_hunk_index(g_repo, g_blame, 2, 6, 5, 0, "63d671eb", "b.txt");
@@ -233,7 +233,7 @@ void test_blame_simple__can_restrict_lines_min(void)
opts.min_line = 8;
cl_git_pass(git_blame_file(&g_blame, g_repo, "b.txt", &opts));
- cl_assert_equal_i(2, git_blame_get_hunk_count(g_blame));
+ cl_assert_equal_i(2, git_blame_hunkcount(g_blame));
check_blame_hunk_index(g_repo, g_blame, 0, 8, 3, 0, "63d671eb", "b.txt");
check_blame_hunk_index(g_repo, g_blame, 1, 11, 5, 0, "aa06ecca", "b.txt");
}
@@ -252,7 +252,7 @@ void test_blame_simple__can_ignore_whitespace_change(void)
opts.flags |= GIT_BLAME_IGNORE_WHITESPACE;
cl_git_pass(git_blame_file(&g_blame, g_repo, "c.txt", &opts));
- cl_assert_equal_i(1, git_blame_get_hunk_count(g_blame));
+ cl_assert_equal_i(1, git_blame_hunkcount(g_blame));
check_blame_hunk_index(g_repo, g_blame, 0, 1, 4, 0, "702c7aa5", "c.txt");
}
@@ -275,7 +275,7 @@ void test_blame_simple__can_restrict_lines_max(void)
opts.max_line = 6;
cl_git_pass(git_blame_file(&g_blame, g_repo, "b.txt", &opts));
- cl_assert_equal_i(3, git_blame_get_hunk_count(g_blame));
+ cl_assert_equal_i(3, git_blame_hunkcount(g_blame));
check_blame_hunk_index(g_repo, g_blame, 0, 1, 4, 0, "da237394", "b.txt");
check_blame_hunk_index(g_repo, g_blame, 1, 5, 1, 1, "b99f7ac0", "b.txt");
check_blame_hunk_index(g_repo, g_blame, 2, 6, 1, 0, "63d671eb", "b.txt");
@@ -301,7 +301,7 @@ void test_blame_simple__can_restrict_lines_both(void)
opts.min_line = 2;
opts.max_line = 7;
cl_git_pass(git_blame_file(&g_blame, g_repo, "b.txt", &opts));
- cl_assert_equal_i(3, git_blame_get_hunk_count(g_blame));
+ cl_assert_equal_i(3, git_blame_hunkcount(g_blame));
check_blame_hunk_index(g_repo, g_blame, 0, 2, 3, 0, "da237394", "b.txt");
check_blame_hunk_index(g_repo, g_blame, 1, 5, 1, 1, "b99f7ac0", "b.txt");
check_blame_hunk_index(g_repo, g_blame, 2, 6, 2, 0, "63d671eb", "b.txt");
@@ -314,7 +314,7 @@ void test_blame_simple__can_blame_huge_file(void)
cl_git_pass(git_repository_open(&g_repo, cl_fixture("blametest.git")));
cl_git_pass(git_blame_file(&g_blame, g_repo, "huge.txt", &opts));
- cl_assert_equal_i(2, git_blame_get_hunk_count(g_blame));
+ cl_assert_equal_i(2, git_blame_hunkcount(g_blame));
check_blame_hunk_index(g_repo, g_blame, 0, 1, 65536, 0, "4eecfea", "huge.txt");
check_blame_hunk_index(g_repo, g_blame, 1, 65537, 1, 0, "6653ff4", "huge.txt");
}
@@ -341,7 +341,7 @@ void test_blame_simple__can_restrict_to_newish_commits(void)
cl_git_pass(git_blame_file(&g_blame, g_repo, "branch_file.txt", &opts));
- cl_assert_equal_i(2, git_blame_get_hunk_count(g_blame));
+ cl_assert_equal_i(2, git_blame_hunkcount(g_blame));
check_blame_hunk_index(g_repo, g_blame, 0, 1, 1, 1, "be3563a", "branch_file.txt");
check_blame_hunk_index(g_repo, g_blame, 1, 2, 1, 0, "a65fedf", "branch_file.txt");
}
@@ -354,7 +354,7 @@ void test_blame_simple__can_restrict_to_first_parent_commits(void)
cl_git_pass(git_repository_open(&g_repo, cl_fixture("blametest.git")));
cl_git_pass(git_blame_file(&g_blame, g_repo, "b.txt", &opts));
- cl_assert_equal_i(4, git_blame_get_hunk_count(g_blame));
+ cl_assert_equal_i(4, git_blame_hunkcount(g_blame));
check_blame_hunk_index(g_repo, g_blame, 0, 1, 4, 0, "da237394", "b.txt");
check_blame_hunk_index(g_repo, g_blame, 1, 5, 1, 1, "b99f7ac0", "b.txt");
check_blame_hunk_index(g_repo, g_blame, 2, 6, 5, 0, "63d671eb", "b.txt");
diff --git a/tests/libgit2/checkout/binaryunicode.c b/tests/libgit2/checkout/binaryunicode.c
index b8c6c079e1f..5cefa77e2ee 100644
--- a/tests/libgit2/checkout/binaryunicode.c
+++ b/tests/libgit2/checkout/binaryunicode.c
@@ -28,20 +28,18 @@ static void execute_test(void)
cl_git_pass(git_commit_lookup(&commit, g_repo, &oid));
cl_git_pass(git_commit_tree(&tree, commit));
- opts.checkout_strategy = GIT_CHECKOUT_SAFE;
-
cl_git_pass(git_checkout_tree(g_repo, (git_object *)tree, &opts));
git_tree_free(tree);
git_commit_free(commit);
/* Verify that the lenna.jpg file was checked out correctly */
- cl_git_pass(git_oid__fromstr(&check, "8ab005d890fe53f65eda14b23672f60d9f4ec5a1", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&check, "8ab005d890fe53f65eda14b23672f60d9f4ec5a1", GIT_OID_SHA1));
cl_git_pass(git_odb__hashfile(&oid, "binaryunicode/lenna.jpg", GIT_OBJECT_BLOB, GIT_OID_SHA1));
cl_assert_equal_oid(&oid, &check);
/* Verify that the text file was checked out correctly */
- cl_git_pass(git_oid__fromstr(&check, "965b223880dd4249e2c66a0cc0b4cffe1dc40f5a", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&check, "965b223880dd4249e2c66a0cc0b4cffe1dc40f5a", GIT_OID_SHA1));
cl_git_pass(git_odb__hashfile(&oid, "binaryunicode/utf16_withbom_noeol_crlf.txt", GIT_OBJECT_BLOB, GIT_OID_SHA1));
cl_assert_equal_oid(&oid, &check);
}
diff --git a/tests/libgit2/checkout/checkout_helpers.h b/tests/libgit2/checkout/checkout_helpers.h
index 879b48b06d7..6c723ffdf59 100644
--- a/tests/libgit2/checkout/checkout_helpers.h
+++ b/tests/libgit2/checkout/checkout_helpers.h
@@ -1,5 +1,6 @@
#include "git2/object.h"
#include "git2/repository.h"
+#include "git2_features.h"
extern void assert_on_branch(git_repository *repo, const char *branch);
extern void reset_index_to_treeish(git_object *treeish);
diff --git a/tests/libgit2/checkout/conflict.c b/tests/libgit2/checkout/conflict.c
index b2eb939dcd7..4a301dc8a2f 100644
--- a/tests/libgit2/checkout/conflict.c
+++ b/tests/libgit2/checkout/conflict.c
@@ -104,7 +104,7 @@ static void create_index(struct checkout_index_entry *entries, size_t entries_le
entry.mode = entries[i].mode;
GIT_INDEX_ENTRY_STAGE_SET(&entry, entries[i].stage);
- git_oid__fromstr(&entry.id, entries[i].oid_str, GIT_OID_SHA1);
+ git_oid_from_string(&entry.id, entries[i].oid_str, GIT_OID_SHA1);
entry.path = entries[i].path;
cl_git_pass(git_index_add(g_index, &entry));
@@ -155,7 +155,7 @@ static void ensure_workdir_oid(const char *path, const char *oid_str)
{
git_oid expected, actual;
- cl_git_pass(git_oid__fromstr(&expected, oid_str, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected, oid_str, GIT_OID_SHA1));
cl_git_pass(git_repository_hashfile(&actual, g_repo, path, GIT_OBJECT_BLOB, NULL));
cl_assert_equal_oid(&expected, &actual);
}
@@ -308,8 +308,6 @@ void test_checkout_conflict__directory_file(void)
{ 0100644, CONFLICTING_THEIRS_OID, 3, "df-4/file" },
};
- opts.checkout_strategy |= GIT_CHECKOUT_SAFE;
-
create_index(checkout_index_entries, 12);
cl_git_pass(git_index_write(g_index));
@@ -347,7 +345,6 @@ void test_checkout_conflict__directory_file_with_custom_labels(void)
{ 0100644, CONFLICTING_THEIRS_OID, 3, "df-4/file" },
};
- opts.checkout_strategy |= GIT_CHECKOUT_SAFE;
opts.our_label = "HEAD";
opts.their_label = "branch";
@@ -388,8 +385,6 @@ void test_checkout_conflict__link_file(void)
{ 0100644, CONFLICTING_THEIRS_OID, 3, "link-4" },
};
- opts.checkout_strategy |= GIT_CHECKOUT_SAFE;
-
create_index(checkout_index_entries, 12);
cl_git_pass(git_index_write(g_index));
@@ -415,8 +410,6 @@ void test_checkout_conflict__links(void)
{ 0120000, LINK_THEIRS_OID, 3, "link-2" },
};
- opts.checkout_strategy |= GIT_CHECKOUT_SAFE;
-
create_index(checkout_index_entries, 5);
cl_git_pass(git_index_write(g_index));
@@ -436,8 +429,6 @@ void test_checkout_conflict__add_add(void)
{ 0100644, CONFLICTING_THEIRS_OID, 3, "conflicting.txt" },
};
- opts.checkout_strategy |= GIT_CHECKOUT_SAFE;
-
create_index(checkout_index_entries, 2);
cl_git_pass(git_index_write(g_index));
@@ -477,8 +468,6 @@ void test_checkout_conflict__mode_change(void)
{ 0100755, CONFLICTING_THEIRS_OID, 3, "executable-6" },
};
- opts.checkout_strategy |= GIT_CHECKOUT_SAFE;
-
create_index(checkout_index_entries, 18);
cl_git_pass(git_index_write(g_index));
@@ -608,8 +597,6 @@ void test_checkout_conflict__renames(void)
}
};
- opts.checkout_strategy |= GIT_CHECKOUT_SAFE;
-
create_index(checkout_index_entries, 41);
create_index_names(checkout_name_entries, 9);
cl_git_pass(git_index_write(g_index));
@@ -793,7 +780,7 @@ void test_checkout_conflict__rename_keep_ours(void)
}
};
- opts.checkout_strategy |= GIT_CHECKOUT_SAFE | GIT_CHECKOUT_USE_OURS;
+ opts.checkout_strategy |= GIT_CHECKOUT_USE_OURS;
create_index(checkout_index_entries, 41);
create_index_names(checkout_name_entries, 9);
@@ -926,8 +913,6 @@ void test_checkout_conflict__name_mangled_file_exists_in_workdir(void)
}
};
- opts.checkout_strategy |= GIT_CHECKOUT_SAFE;
-
create_index(checkout_index_entries, 24);
create_index_names(checkout_name_entries, 6);
cl_git_pass(git_index_write(g_index));
@@ -980,17 +965,17 @@ void test_checkout_conflict__name_mangled_file_exists_in_workdir(void)
0100644, "b69fe837e4cecfd4c9a40cdca7c138468687df07");
/* Name is mangled on case insensitive only */
-#if defined(GIT_WIN32) || defined(__APPLE__)
- ensure_workdir("test-three.txt~ours_0",
- 0100644, "b42712cfe99a1a500b2a51fe984e0b8a7702ba11");
- ensure_workdir("test-three.txt~theirs_0",
- 0100644, "b69fe837e4cecfd4c9a40cdca7c138468687df07");
-#else
- ensure_workdir("test-three.txt~ours",
- 0100644, "b42712cfe99a1a500b2a51fe984e0b8a7702ba11");
- ensure_workdir("test-three.txt~theirs",
- 0100644, "b69fe837e4cecfd4c9a40cdca7c138468687df07");
-#endif
+ if (cl_repo_get_bool(g_repo, "core.ignorecase")) {
+ ensure_workdir("test-three.txt~ours_0",
+ 0100644, "b42712cfe99a1a500b2a51fe984e0b8a7702ba11");
+ ensure_workdir("test-three.txt~theirs_0",
+ 0100644, "b69fe837e4cecfd4c9a40cdca7c138468687df07");
+ } else {
+ ensure_workdir("test-three.txt~ours",
+ 0100644, "b42712cfe99a1a500b2a51fe984e0b8a7702ba11");
+ ensure_workdir("test-three.txt~theirs",
+ 0100644, "b69fe837e4cecfd4c9a40cdca7c138468687df07");
+ }
ensure_workdir("directory_file-one~ours_0", 0100644, CONFLICTING_OURS_OID);
ensure_workdir("directory_file-two~theirs_0", 0100644, CONFLICTING_THEIRS_OID);
@@ -1095,7 +1080,7 @@ static void collect_progress(
if (path == NULL)
return;
- git_vector_insert(paths, strdup(path));
+ git_vector_insert(paths, git__strdup(path));
}
void test_checkout_conflict__report_progress(void)
@@ -1141,5 +1126,5 @@ void test_checkout_conflict__report_progress(void)
git_vector_foreach(&paths, i, path)
git__free(path);
- git_vector_free(&paths);
+ git_vector_dispose(&paths);
}
diff --git a/tests/libgit2/checkout/crlf.c b/tests/libgit2/checkout/crlf.c
index 21f8a852a64..2ab970cd0b8 100644
--- a/tests/libgit2/checkout/crlf.c
+++ b/tests/libgit2/checkout/crlf.c
@@ -197,7 +197,7 @@ static void empty_workdir(const char *name)
if (cmp)
cl_git_pass(p_unlink(fn));
}
- git_vector_free_deep(&contents);
+ git_vector_dispose_deep(&contents);
}
void test_checkout_crlf__matches_core_git(void)
diff --git a/tests/libgit2/checkout/head.c b/tests/libgit2/checkout/head.c
index 3b0bf472996..f67770e1fed 100644
--- a/tests/libgit2/checkout/head.c
+++ b/tests/libgit2/checkout/head.c
@@ -228,7 +228,6 @@ void test_checkout_head__workdir_filemode_is_simplified(void)
cl_git_pass(git_revparse_single(&branch, g_repo, "099fabac3a9ea935598528c27f866e34089c2eff"));
opts.checkout_strategy &= ~GIT_CHECKOUT_FORCE;
- opts.checkout_strategy |= GIT_CHECKOUT_SAFE;
cl_git_pass(git_checkout_tree(g_repo, branch, NULL));
git_object_free(branch);
@@ -256,7 +255,6 @@ void test_checkout_head__obeys_filemode_true(void)
cl_git_pass(git_revparse_single(&branch, g_repo, "099fabac3a9ea935598528c27f866e34089c2eff"));
opts.checkout_strategy &= ~GIT_CHECKOUT_FORCE;
- opts.checkout_strategy |= GIT_CHECKOUT_SAFE;
cl_git_fail_with(GIT_ECONFLICT, git_checkout_tree(g_repo, branch, NULL));
git_object_free(branch);
@@ -284,7 +282,6 @@ void test_checkout_head__obeys_filemode_false(void)
cl_git_pass(git_revparse_single(&branch, g_repo, "099fabac3a9ea935598528c27f866e34089c2eff"));
opts.checkout_strategy &= ~GIT_CHECKOUT_FORCE;
- opts.checkout_strategy |= GIT_CHECKOUT_SAFE;
cl_git_pass(git_checkout_tree(g_repo, branch, NULL));
git_object_free(branch);
diff --git a/tests/libgit2/checkout/icase.c b/tests/libgit2/checkout/icase.c
index d77c7abd514..4ff8fb28b0b 100644
--- a/tests/libgit2/checkout/icase.c
+++ b/tests/libgit2/checkout/icase.c
@@ -34,7 +34,6 @@ void test_checkout_icase__initialize(void)
cl_git_pass(git_object_lookup(&obj, repo, &id, GIT_OBJECT_ANY));
git_checkout_options_init(&checkout_opts, GIT_CHECKOUT_OPTIONS_VERSION);
- checkout_opts.checkout_strategy = GIT_CHECKOUT_NONE;
}
void test_checkout_icase__cleanup(void)
@@ -89,7 +88,7 @@ static void assert_name_is(const char *expected)
if (start)
cl_assert_equal_strn("/", actual + (start - 1), 1);
- free(actual);
+ git__free(actual);
}
static int symlink_or_fake(git_repository *repo, const char *a, const char *b)
@@ -106,7 +105,7 @@ static int symlink_or_fake(git_repository *repo, const char *a, const char *b)
void test_checkout_icase__refuses_to_overwrite_files_for_files(void)
{
- checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE|GIT_CHECKOUT_RECREATE_MISSING;
+ checkout_opts.checkout_strategy = GIT_CHECKOUT_RECREATE_MISSING;
cl_git_write2file("testrepo/BRANCH_FILE.txt", "neue file\n", 10, \
O_WRONLY | O_CREAT | O_TRUNC, 0644);
@@ -128,7 +127,7 @@ void test_checkout_icase__overwrites_files_for_files_when_forced(void)
void test_checkout_icase__refuses_to_overwrite_links_for_files(void)
{
- checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE|GIT_CHECKOUT_RECREATE_MISSING;
+ checkout_opts.checkout_strategy = GIT_CHECKOUT_RECREATE_MISSING;
cl_must_pass(symlink_or_fake(repo, "../tmp", "testrepo/BRANCH_FILE.txt"));
@@ -152,7 +151,7 @@ void test_checkout_icase__overwrites_links_for_files_when_forced(void)
void test_checkout_icase__overwrites_empty_folders_for_files(void)
{
- checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE|GIT_CHECKOUT_RECREATE_MISSING;
+ checkout_opts.checkout_strategy = GIT_CHECKOUT_RECREATE_MISSING;
cl_must_pass(p_mkdir("testrepo/NEW.txt", 0777));
@@ -164,7 +163,7 @@ void test_checkout_icase__overwrites_empty_folders_for_files(void)
void test_checkout_icase__refuses_to_overwrite_populated_folders_for_files(void)
{
- checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE|GIT_CHECKOUT_RECREATE_MISSING;
+ checkout_opts.checkout_strategy = GIT_CHECKOUT_RECREATE_MISSING;
cl_must_pass(p_mkdir("testrepo/BRANCH_FILE.txt", 0777));
cl_git_write2file("testrepo/BRANCH_FILE.txt/foobar", "neue file\n", 10, \
@@ -192,7 +191,7 @@ void test_checkout_icase__overwrites_folders_for_files_when_forced(void)
void test_checkout_icase__refuses_to_overwrite_files_for_folders(void)
{
- checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE|GIT_CHECKOUT_RECREATE_MISSING;
+ checkout_opts.checkout_strategy = GIT_CHECKOUT_RECREATE_MISSING;
cl_git_write2file("testrepo/A", "neue file\n", 10, \
O_WRONLY | O_CREAT | O_TRUNC, 0644);
@@ -216,7 +215,7 @@ void test_checkout_icase__overwrites_files_for_folders_when_forced(void)
void test_checkout_icase__refuses_to_overwrite_links_for_folders(void)
{
- checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE|GIT_CHECKOUT_RECREATE_MISSING;
+ checkout_opts.checkout_strategy = GIT_CHECKOUT_RECREATE_MISSING;
cl_must_pass(symlink_or_fake(repo, "..", "testrepo/A"));
@@ -244,8 +243,6 @@ void test_checkout_icase__ignores_unstaged_casechange(void)
git_commit *orig, *br2;
git_checkout_options checkout_opts = GIT_CHECKOUT_OPTIONS_INIT;
- checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE;
-
cl_git_pass(git_reference_lookup_resolved(&orig_ref, repo, "HEAD", 100));
cl_git_pass(git_commit_lookup(&orig, repo, git_reference_target(orig_ref)));
cl_git_pass(git_reset(repo, (git_object *)orig, GIT_RESET_HARD, NULL));
@@ -270,8 +267,6 @@ void test_checkout_icase__conflicts_with_casechanged_subtrees(void)
git_oid oid;
git_checkout_options checkout_opts = GIT_CHECKOUT_OPTIONS_INIT;
- checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE;
-
cl_git_pass(git_reference_lookup_resolved(&orig_ref, repo, "HEAD", 100));
cl_git_pass(git_object_lookup(&orig, repo, git_reference_target(orig_ref), GIT_OBJECT_COMMIT));
cl_git_pass(git_reset(repo, (git_object *)orig, GIT_RESET_HARD, NULL));
diff --git a/tests/libgit2/checkout/index.c b/tests/libgit2/checkout/index.c
index 6432cba841d..8ca72e426e6 100644
--- a/tests/libgit2/checkout/index.c
+++ b/tests/libgit2/checkout/index.c
@@ -4,6 +4,7 @@
#include "git2/checkout.h"
#include "futils.h"
#include "repository.h"
+#include "index.h"
#include "remote.h"
#include "repo/repo_helpers.h"
@@ -60,7 +61,7 @@ void test_checkout_index__can_create_missing_files(void)
cl_assert_equal_i(false, git_fs_path_isfile("./testrepo/branch_file.txt"));
cl_assert_equal_i(false, git_fs_path_isfile("./testrepo/new.txt"));
- opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_RECREATE_MISSING;
+ opts.checkout_strategy = GIT_CHECKOUT_RECREATE_MISSING;
cl_git_pass(git_checkout_index(g_repo, NULL, &opts));
@@ -80,7 +81,6 @@ void test_checkout_index__can_remove_untracked_files(void)
cl_assert_equal_i(true, git_fs_path_isdir("./testrepo/dir/subdir/subsubdir"));
opts.checkout_strategy =
- GIT_CHECKOUT_SAFE |
GIT_CHECKOUT_RECREATE_MISSING |
GIT_CHECKOUT_REMOVE_UNTRACKED;
@@ -156,7 +156,7 @@ void test_checkout_index__honor_the_specified_pathspecs(void)
cl_assert_equal_i(false, git_fs_path_isfile("./testrepo/branch_file.txt"));
cl_assert_equal_i(false, git_fs_path_isfile("./testrepo/new.txt"));
- opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_RECREATE_MISSING;
+ opts.checkout_strategy = GIT_CHECKOUT_RECREATE_MISSING;
cl_git_pass(git_checkout_index(g_repo, NULL, &opts));
@@ -175,7 +175,7 @@ void test_checkout_index__honor_the_gitattributes_directives(void)
cl_git_mkfile("./testrepo/.gitattributes", attributes);
cl_repo_set_bool(g_repo, "core.autocrlf", false);
- opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_RECREATE_MISSING;
+ opts.checkout_strategy = GIT_CHECKOUT_RECREATE_MISSING;
cl_git_pass(git_checkout_index(g_repo, NULL, &opts));
@@ -193,7 +193,7 @@ void test_checkout_index__honor_coreautocrlf_setting_set_to_true(void)
cl_git_pass(p_unlink("./testrepo/.gitattributes"));
cl_repo_set_bool(g_repo, "core.autocrlf", true);
- opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_RECREATE_MISSING;
+ opts.checkout_strategy = GIT_CHECKOUT_RECREATE_MISSING;
cl_git_pass(git_checkout_index(g_repo, NULL, &opts));
@@ -287,7 +287,7 @@ void test_checkout_index__coresymlinks_set_to_true_fails_when_unsupported(void)
cl_repo_set_bool(g_repo, "core.symlinks", true);
- opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_RECREATE_MISSING;
+ opts.checkout_strategy = GIT_CHECKOUT_RECREATE_MISSING;
cl_git_fail(git_checkout_index(g_repo, NULL, &opts));
}
@@ -303,7 +303,7 @@ void test_checkout_index__honor_coresymlinks_setting_set_to_true(void)
cl_repo_set_bool(g_repo, "core.symlinks", true);
- opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_RECREATE_MISSING;
+ opts.checkout_strategy = GIT_CHECKOUT_RECREATE_MISSING;
cl_git_pass(git_checkout_index(g_repo, NULL, &opts));
@@ -320,7 +320,7 @@ void test_checkout_index__honor_coresymlinks_setting_set_to_false(void)
cl_repo_set_bool(g_repo, "core.symlinks", false);
- opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_RECREATE_MISSING;
+ opts.checkout_strategy = GIT_CHECKOUT_RECREATE_MISSING;
cl_git_pass(git_checkout_index(g_repo, NULL, &opts));
@@ -336,7 +336,7 @@ void test_checkout_index__donot_overwrite_modified_file_by_default(void)
/* set this up to not return an error code on conflicts, but it
* still will not have permission to overwrite anything...
*/
- opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_ALLOW_CONFLICTS;
+ opts.checkout_strategy = GIT_CHECKOUT_ALLOW_CONFLICTS;
cl_git_pass(git_checkout_index(g_repo, NULL, &opts));
@@ -362,7 +362,7 @@ void test_checkout_index__options_disable_filters(void)
cl_git_mkfile("./testrepo/.gitattributes", "*.txt text eol=crlf\n");
- opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_RECREATE_MISSING;
+ opts.checkout_strategy = GIT_CHECKOUT_RECREATE_MISSING;
opts.disable_filters = false;
cl_git_pass(git_checkout_index(g_repo, NULL, &opts));
@@ -393,7 +393,7 @@ void test_checkout_index__options_dir_modes(void)
reset_index_to_treeish((git_object *)commit);
- opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_RECREATE_MISSING;
+ opts.checkout_strategy = GIT_CHECKOUT_RECREATE_MISSING;
opts.dir_mode = 0701;
cl_git_pass(git_checkout_index(g_repo, NULL, &opts));
@@ -420,7 +420,7 @@ void test_checkout_index__options_override_file_modes(void)
if (!cl_is_chmod_supported())
return;
- opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_RECREATE_MISSING;
+ opts.checkout_strategy = GIT_CHECKOUT_RECREATE_MISSING;
opts.file_mode = 0700;
cl_git_pass(git_checkout_index(g_repo, NULL, &opts));
@@ -485,7 +485,7 @@ void test_checkout_index__can_notify_of_skipped_files(void)
data.file = "new.txt";
data.sha = "a71586c1dfe8a71c6cbf6c129f404c5642ff31bd";
- opts.checkout_strategy = GIT_CHECKOUT_SAFE |
+ opts.checkout_strategy =
GIT_CHECKOUT_RECREATE_MISSING |
GIT_CHECKOUT_ALLOW_CONFLICTS;
opts.notify_flags = GIT_CHECKOUT_NOTIFY_CONFLICT;
@@ -525,7 +525,6 @@ void test_checkout_index__wont_notify_of_expected_line_ending_changes(void)
cl_git_mkfile("./testrepo/new.txt", "my new file\r\n");
opts.checkout_strategy =
- GIT_CHECKOUT_SAFE |
GIT_CHECKOUT_RECREATE_MISSING |
GIT_CHECKOUT_ALLOW_CONFLICTS;
opts.notify_flags = GIT_CHECKOUT_NOTIFY_CONFLICT;
@@ -547,7 +546,7 @@ void test_checkout_index__calls_progress_callback(void)
git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
int calls = 0;
- opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_RECREATE_MISSING;
+ opts.checkout_strategy = GIT_CHECKOUT_RECREATE_MISSING;
opts.progress_cb = checkout_progress_counter;
opts.progress_payload = &calls;
@@ -582,7 +581,6 @@ void test_checkout_index__can_overcome_name_clashes(void)
cl_assert(git_fs_path_isfile("./testrepo/path0/file0"));
opts.checkout_strategy =
- GIT_CHECKOUT_SAFE |
GIT_CHECKOUT_RECREATE_MISSING |
GIT_CHECKOUT_ALLOW_CONFLICTS;
cl_git_pass(git_checkout_index(g_repo, index, &opts));
@@ -634,7 +632,6 @@ void test_checkout_index__can_update_prefixed_files(void)
cl_git_pass(p_mkdir("./testrepo/branch_file.txt.after", 0777));
opts.checkout_strategy =
- GIT_CHECKOUT_SAFE |
GIT_CHECKOUT_RECREATE_MISSING |
GIT_CHECKOUT_REMOVE_UNTRACKED;
@@ -685,7 +682,7 @@ void test_checkout_index__target_directory(void)
checkout_counts cts;
memset(&cts, 0, sizeof(cts));
- opts.checkout_strategy = GIT_CHECKOUT_SAFE |
+ opts.checkout_strategy =
GIT_CHECKOUT_RECREATE_MISSING;
opts.target_directory = "alternative";
cl_assert(!git_fs_path_isdir("alternative"));
@@ -730,7 +727,7 @@ void test_checkout_index__target_directory_from_bare(void)
cl_git_pass(git_index_write(index));
git_index_free(index);
- opts.checkout_strategy = GIT_CHECKOUT_SAFE |
+ opts.checkout_strategy =
GIT_CHECKOUT_RECREATE_MISSING;
opts.notify_flags = GIT_CHECKOUT_NOTIFY_ALL;
@@ -769,7 +766,7 @@ void test_checkout_index__can_get_repo_from_index(void)
cl_assert_equal_i(false, git_fs_path_isfile("./testrepo/branch_file.txt"));
cl_assert_equal_i(false, git_fs_path_isfile("./testrepo/new.txt"));
- opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_RECREATE_MISSING;
+ opts.checkout_strategy = GIT_CHECKOUT_RECREATE_MISSING;
cl_git_pass(git_repository_index(&index, g_repo));
@@ -791,15 +788,15 @@ static void add_conflict(git_index *index, const char *path)
entry.mode = 0100644;
entry.path = path;
- git_oid__fromstr(&entry.id, "d427e0b2e138501a3d15cc376077a3631e15bd46", GIT_OID_SHA1);
+ git_oid_from_string(&entry.id, "d427e0b2e138501a3d15cc376077a3631e15bd46", GIT_OID_SHA1);
GIT_INDEX_ENTRY_STAGE_SET(&entry, 1);
cl_git_pass(git_index_add(index, &entry));
- git_oid__fromstr(&entry.id, "4e886e602529caa9ab11d71f86634bd1b6e0de10", GIT_OID_SHA1);
+ git_oid_from_string(&entry.id, "4e886e602529caa9ab11d71f86634bd1b6e0de10", GIT_OID_SHA1);
GIT_INDEX_ENTRY_STAGE_SET(&entry, 2);
cl_git_pass(git_index_add(index, &entry));
- git_oid__fromstr(&entry.id, "2bd0a343aeef7a2cf0d158478966a6e587ff3863", GIT_OID_SHA1);
+ git_oid_from_string(&entry.id, "2bd0a343aeef7a2cf0d158478966a6e587ff3863", GIT_OID_SHA1);
GIT_INDEX_ENTRY_STAGE_SET(&entry, 3);
cl_git_pass(git_index_add(index, &entry));
}
@@ -833,8 +830,11 @@ void test_checkout_index__adding_conflict_removes_stage_0(void)
{
git_index *new_index, *index;
git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
+ git_index_options index_opts = GIT_INDEX_OPTIONS_INIT;
+
+ index_opts.oid_type = GIT_OID_SHA1;
- cl_git_pass(git_index_new(&new_index));
+ cl_git_pass(git_index_new_ext(&new_index, &index_opts));
add_conflict(new_index, "new.txt");
cl_git_pass(git_checkout_index(g_repo, new_index, &opts));
diff --git a/tests/libgit2/checkout/tree.c b/tests/libgit2/checkout/tree.c
index 65df00cd87b..ae4c31dce83 100644
--- a/tests/libgit2/checkout/tree.c
+++ b/tests/libgit2/checkout/tree.c
@@ -139,8 +139,8 @@ void test_checkout_tree__doesnt_write_unrequested_files_to_worktree(void)
git_commit* p_chomped_commit;
git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
- git_oid__fromstr(&master_oid, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1);
- git_oid__fromstr(&chomped_oid, "e90810b8df3e80c413d903f631643c716887138d", GIT_OID_SHA1);
+ git_oid_from_string(&master_oid, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1);
+ git_oid_from_string(&chomped_oid, "e90810b8df3e80c413d903f631643c716887138d", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&p_master_commit, g_repo, &master_oid));
cl_git_pass(git_commit_lookup(&p_chomped_commit, g_repo, &chomped_oid));
@@ -186,8 +186,6 @@ void test_checkout_tree__can_switch_branches(void)
git_object_free(obj);
/* do second checkout safe because we should be clean after first */
- opts.checkout_strategy = GIT_CHECKOUT_SAFE;
-
cl_git_pass(git_reference_name_to_id(&oid, g_repo, "refs/heads/subtrees"));
cl_git_pass(git_object_lookup(&obj, g_repo, &oid, GIT_OBJECT_ANY));
@@ -213,7 +211,7 @@ void test_checkout_tree__can_remove_untracked(void)
{
git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
- opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_REMOVE_UNTRACKED;
+ opts.checkout_strategy = GIT_CHECKOUT_REMOVE_UNTRACKED;
cl_git_mkfile("testrepo/untracked_file", "as you wish");
cl_assert(git_fs_path_isfile("testrepo/untracked_file"));
@@ -228,7 +226,7 @@ void test_checkout_tree__can_remove_ignored(void)
git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
int ignored = 0;
- opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_REMOVE_IGNORED;
+ opts.checkout_strategy = GIT_CHECKOUT_REMOVE_IGNORED;
cl_git_mkfile("testrepo/ignored_file", "as you wish");
@@ -313,7 +311,7 @@ void test_checkout_tree__conflict_on_ignored_when_not_overwriting(void)
int error;
cl_git_fail(error = checkout_tree_with_blob_ignored_in_workdir(
- GIT_CHECKOUT_SAFE | GIT_CHECKOUT_DONT_OVERWRITE_IGNORED, false));
+ GIT_CHECKOUT_DONT_OVERWRITE_IGNORED, false));
cl_assert_equal_i(GIT_ECONFLICT, error);
}
@@ -334,7 +332,7 @@ void test_checkout_tree__conflict_on_ignored_folder_when_not_overwriting(void)
int error;
cl_git_fail(error = checkout_tree_with_blob_ignored_in_workdir(
- GIT_CHECKOUT_SAFE | GIT_CHECKOUT_DONT_OVERWRITE_IGNORED, true));
+ GIT_CHECKOUT_DONT_OVERWRITE_IGNORED, true));
cl_assert_equal_i(GIT_ECONFLICT, error);
}
@@ -370,7 +368,7 @@ void test_checkout_tree__can_update_only(void)
/* now checkout branch but with update only */
- opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_UPDATE_ONLY;
+ opts.checkout_strategy = GIT_CHECKOUT_UPDATE_ONLY;
cl_git_pass(git_reference_name_to_id(&oid, g_repo, "refs/heads/dir"));
cl_git_pass(git_object_lookup(&obj, g_repo, &oid, GIT_OBJECT_ANY));
@@ -417,7 +415,6 @@ void test_checkout_tree__can_checkout_with_pattern(void)
/* now to a narrow patterned checkout */
- g_opts.checkout_strategy = GIT_CHECKOUT_SAFE;
g_opts.paths.strings = entries;
g_opts.paths.count = 1;
@@ -489,7 +486,6 @@ void test_checkout_tree__can_disable_pattern_match(void)
/* now to a narrow patterned checkout, but disable pattern */
g_opts.checkout_strategy =
- GIT_CHECKOUT_SAFE |
GIT_CHECKOUT_DISABLE_PATHSPEC_MATCH;
g_opts.paths.strings = entries;
g_opts.paths.count = 1;
@@ -606,8 +602,6 @@ void test_checkout_tree__donot_update_deleted_file_by_default(void)
git_index *index = NULL;
checkout_counts ct;
- opts.checkout_strategy = GIT_CHECKOUT_SAFE;
-
memset(&ct, 0, sizeof(ct));
opts.notify_flags = GIT_CHECKOUT_NOTIFY_ALL;
opts.notify_cb = checkout_count_callback;
@@ -615,7 +609,7 @@ void test_checkout_tree__donot_update_deleted_file_by_default(void)
cl_git_pass(git_repository_index(&index, g_repo));
- cl_git_pass(git_oid__fromstr(&old_id, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&old_id, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1));
cl_git_pass(git_commit_lookup(&old_commit, g_repo, &old_id));
cl_git_pass(git_reset(g_repo, (git_object *)old_commit, GIT_RESET_HARD, NULL));
@@ -625,7 +619,7 @@ void test_checkout_tree__donot_update_deleted_file_by_default(void)
cl_assert(!git_fs_path_exists("testrepo/branch_file.txt"));
- cl_git_pass(git_oid__fromstr(&new_id, "099fabac3a9ea935598528c27f866e34089c2eff", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&new_id, "099fabac3a9ea935598528c27f866e34089c2eff", GIT_OID_SHA1));
cl_git_pass(git_commit_lookup(&new_commit, g_repo, &new_id));
@@ -883,8 +877,7 @@ void test_checkout_tree__target_directory_from_bare(void)
g_repo = cl_git_sandbox_init("testrepo.git");
cl_assert(git_repository_is_bare(g_repo));
- opts.checkout_strategy = GIT_CHECKOUT_SAFE |
- GIT_CHECKOUT_RECREATE_MISSING;
+ opts.checkout_strategy = GIT_CHECKOUT_RECREATE_MISSING;
opts.notify_flags = GIT_CHECKOUT_NOTIFY_ALL;
opts.notify_cb = checkout_count_callback;
@@ -941,16 +934,16 @@ static void create_conflict(const char *path)
memset(&entry, 0x0, sizeof(git_index_entry));
entry.mode = 0100644;
GIT_INDEX_ENTRY_STAGE_SET(&entry, 1);
- git_oid__fromstr(&entry.id, "d427e0b2e138501a3d15cc376077a3631e15bd46", GIT_OID_SHA1);
+ git_oid_from_string(&entry.id, "d427e0b2e138501a3d15cc376077a3631e15bd46", GIT_OID_SHA1);
entry.path = path;
cl_git_pass(git_index_add(index, &entry));
GIT_INDEX_ENTRY_STAGE_SET(&entry, 2);
- git_oid__fromstr(&entry.id, "ee3fa1b8c00aff7fe02065fdb50864bb0d932ccf", GIT_OID_SHA1);
+ git_oid_from_string(&entry.id, "ee3fa1b8c00aff7fe02065fdb50864bb0d932ccf", GIT_OID_SHA1);
cl_git_pass(git_index_add(index, &entry));
GIT_INDEX_ENTRY_STAGE_SET(&entry, 3);
- git_oid__fromstr(&entry.id, "2bd0a343aeef7a2cf0d158478966a6e587ff3863", GIT_OID_SHA1);
+ git_oid_from_string(&entry.id, "2bd0a343aeef7a2cf0d158478966a6e587ff3863", GIT_OID_SHA1);
cl_git_pass(git_index_add(index, &entry));
cl_git_pass(git_index_write(index));
@@ -963,8 +956,6 @@ void test_checkout_tree__fails_when_conflicts_exist_in_index(void)
git_oid oid;
git_object *obj = NULL;
- opts.checkout_strategy = GIT_CHECKOUT_SAFE;
-
cl_git_pass(git_reference_name_to_id(&oid, g_repo, "HEAD"));
cl_git_pass(git_object_lookup(&obj, g_repo, &oid, GIT_OBJECT_ANY));
@@ -988,7 +979,7 @@ void test_checkout_tree__filemode_preserved_in_index(void)
cl_git_pass(git_repository_index(&index, g_repo));
/* test a freshly added executable */
- cl_git_pass(git_oid__fromstr(&executable_oid, "afe4393b2b2a965f06acf2ca9658eaa01e0cd6b6", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&executable_oid, "afe4393b2b2a965f06acf2ca9658eaa01e0cd6b6", GIT_OID_SHA1));
cl_git_pass(git_commit_lookup(&commit, g_repo, &executable_oid));
cl_git_pass(git_checkout_tree(g_repo, (const git_object *)commit, &opts));
@@ -999,7 +990,7 @@ void test_checkout_tree__filemode_preserved_in_index(void)
/* Now start with a commit which has a text file */
- cl_git_pass(git_oid__fromstr(&executable_oid, "cf80f8de9f1185bf3a05f993f6121880dd0cfbc9", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&executable_oid, "cf80f8de9f1185bf3a05f993f6121880dd0cfbc9", GIT_OID_SHA1));
cl_git_pass(git_commit_lookup(&commit, g_repo, &executable_oid));
cl_git_pass(git_checkout_tree(g_repo, (const git_object *)commit, &opts));
@@ -1010,7 +1001,7 @@ void test_checkout_tree__filemode_preserved_in_index(void)
/* And then check out to a commit which converts the text file to an executable */
- cl_git_pass(git_oid__fromstr(&executable_oid, "144344043ba4d4a405da03de3844aa829ae8be0e", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&executable_oid, "144344043ba4d4a405da03de3844aa829ae8be0e", GIT_OID_SHA1));
cl_git_pass(git_commit_lookup(&commit, g_repo, &executable_oid));
cl_git_pass(git_checkout_tree(g_repo, (const git_object *)commit, &opts));
@@ -1021,7 +1012,7 @@ void test_checkout_tree__filemode_preserved_in_index(void)
/* Finally, check out the text file again and check that the exec bit is cleared */
- cl_git_pass(git_oid__fromstr(&executable_oid, "cf80f8de9f1185bf3a05f993f6121880dd0cfbc9", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&executable_oid, "cf80f8de9f1185bf3a05f993f6121880dd0cfbc9", GIT_OID_SHA1));
cl_git_pass(git_commit_lookup(&commit, g_repo, &executable_oid));
cl_git_pass(git_checkout_tree(g_repo, (const git_object *)commit, &opts));
@@ -1063,7 +1054,7 @@ void test_checkout_tree__filemode_preserved_in_workdir(void)
opts.checkout_strategy = GIT_CHECKOUT_FORCE;
/* test a freshly added executable */
- cl_git_pass(git_oid__fromstr(&executable_oid, "afe4393b2b2a965f06acf2ca9658eaa01e0cd6b6", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&executable_oid, "afe4393b2b2a965f06acf2ca9658eaa01e0cd6b6", GIT_OID_SHA1));
cl_git_pass(git_commit_lookup(&commit, g_repo, &executable_oid));
cl_git_pass(git_checkout_tree(g_repo, (const git_object *)commit, &opts));
@@ -1073,7 +1064,7 @@ void test_checkout_tree__filemode_preserved_in_workdir(void)
/* Now start with a commit which has a text file */
- cl_git_pass(git_oid__fromstr(&executable_oid, "cf80f8de9f1185bf3a05f993f6121880dd0cfbc9", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&executable_oid, "cf80f8de9f1185bf3a05f993f6121880dd0cfbc9", GIT_OID_SHA1));
cl_git_pass(git_commit_lookup(&commit, g_repo, &executable_oid));
cl_git_pass(git_checkout_tree(g_repo, (const git_object *)commit, &opts));
@@ -1083,7 +1074,7 @@ void test_checkout_tree__filemode_preserved_in_workdir(void)
/* And then check out to a commit which converts the text file to an executable */
- cl_git_pass(git_oid__fromstr(&executable_oid, "144344043ba4d4a405da03de3844aa829ae8be0e", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&executable_oid, "144344043ba4d4a405da03de3844aa829ae8be0e", GIT_OID_SHA1));
cl_git_pass(git_commit_lookup(&commit, g_repo, &executable_oid));
cl_git_pass(git_checkout_tree(g_repo, (const git_object *)commit, &opts));
@@ -1093,7 +1084,7 @@ void test_checkout_tree__filemode_preserved_in_workdir(void)
/* Finally, check out the text file again and check that the exec bit is cleared */
- cl_git_pass(git_oid__fromstr(&executable_oid, "cf80f8de9f1185bf3a05f993f6121880dd0cfbc9", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&executable_oid, "cf80f8de9f1185bf3a05f993f6121880dd0cfbc9", GIT_OID_SHA1));
cl_git_pass(git_commit_lookup(&commit, g_repo, &executable_oid));
cl_git_pass(git_checkout_tree(g_repo, (const git_object *)commit, &opts));
@@ -1112,7 +1103,7 @@ void test_checkout_tree__removes_conflicts(void)
git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
git_index *index;
- cl_git_pass(git_oid__fromstr(&commit_id, "afe4393b2b2a965f06acf2ca9658eaa01e0cd6b6", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&commit_id, "afe4393b2b2a965f06acf2ca9658eaa01e0cd6b6", GIT_OID_SHA1));
cl_git_pass(git_commit_lookup(&commit, g_repo, &commit_id));
opts.checkout_strategy = GIT_CHECKOUT_FORCE;
@@ -1155,7 +1146,7 @@ void test_checkout_tree__removes_conflicts_only_by_pathscope(void)
git_index *index;
const char *path = "executable.txt";
- cl_git_pass(git_oid__fromstr(&commit_id, "afe4393b2b2a965f06acf2ca9658eaa01e0cd6b6", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&commit_id, "afe4393b2b2a965f06acf2ca9658eaa01e0cd6b6", GIT_OID_SHA1));
cl_git_pass(git_commit_lookup(&commit, g_repo, &commit_id));
opts.checkout_strategy = GIT_CHECKOUT_FORCE;
@@ -1583,7 +1574,7 @@ static void modify_index_ondisk(void)
cl_git_pass(git_repository_open(&other_repo, git_repository_workdir(g_repo)));
cl_git_pass(git_repository_index(&other_index, other_repo));
- cl_git_pass(git_oid__fromstr(&entry.id, "1385f264afb75a56a5bec74243be9b367ba4ca08", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&entry.id, "1385f264afb75a56a5bec74243be9b367ba4ca08", GIT_OID_SHA1));
entry.mode = 0100644;
entry.path = "README";
@@ -1622,8 +1613,6 @@ void test_checkout_tree__retains_external_index_changes(void)
{
git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
- opts.checkout_strategy = GIT_CHECKOUT_SAFE;
-
modify_index_and_checkout_tree(&opts);
assert_status_entrycount(g_repo, 1);
}
@@ -1632,7 +1621,7 @@ void test_checkout_tree__no_index_refresh(void)
{
git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
- opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_NO_REFRESH;
+ opts.checkout_strategy = GIT_CHECKOUT_NO_REFRESH;
modify_index_and_checkout_tree(&opts);
assert_status_entrycount(g_repo, 0);
@@ -1659,7 +1648,7 @@ void test_checkout_tree__dry_run(void)
/* now checkout branch but with dry run enabled */
memset(&ct, 0, sizeof(ct));
- opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_DRY_RUN;
+ opts.checkout_strategy = GIT_CHECKOUT_DRY_RUN;
opts.notify_flags = GIT_CHECKOUT_NOTIFY_ALL;
opts.notify_cb = checkout_count_callback;
opts.notify_payload = &ct;
diff --git a/tests/libgit2/checkout/typechange.c b/tests/libgit2/checkout/typechange.c
index 1fa2d3095b4..dfdb77e9222 100644
--- a/tests/libgit2/checkout/typechange.c
+++ b/tests/libgit2/checkout/typechange.c
@@ -319,7 +319,7 @@ void test_checkout_typechange__status_char(void)
git_diff_options diffopts = GIT_DIFF_OPTIONS_INIT;
char expected[8] = {'M', 'M', 'R', 'T', 'D', 'R', 'A', 'R'};
- git_oid__fromstr(&oid, "9b19edf33a03a0c59cdfc113bfa5c06179bf9b1a", GIT_OID_SHA1);
+ git_oid_from_string(&oid, "9b19edf33a03a0c59cdfc113bfa5c06179bf9b1a", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, g_repo, &oid));
diffopts.flags |= GIT_DIFF_INCLUDE_TYPECHANGE;
cl_git_pass(git_diff__commit(&diff, g_repo, commit, &diffopts));
diff --git a/tests/libgit2/cherrypick/bare.c b/tests/libgit2/cherrypick/bare.c
index 66446889940..6c24a446561 100644
--- a/tests/libgit2/cherrypick/bare.c
+++ b/tests/libgit2/cherrypick/bare.c
@@ -32,10 +32,10 @@ void test_cherrypick_bare__automerge(void)
{ 0100644, "df6b290e0bd6a89b01d69f66687e8abf385283ca", 0, "file3.txt" },
};
- git_oid__fromstr(&head_oid, "d3d77487660ee3c0194ee01dc5eaf478782b1c7e", GIT_OID_SHA1);
+ git_oid_from_string(&head_oid, "d3d77487660ee3c0194ee01dc5eaf478782b1c7e", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
- git_oid__fromstr(&cherry_oid, "cfc4f0999a8367568e049af4f72e452d40828a15", GIT_OID_SHA1);
+ git_oid_from_string(&cherry_oid, "cfc4f0999a8367568e049af4f72e452d40828a15", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, repo, &cherry_oid));
cl_git_pass(git_cherrypick_commit(&index, repo, commit, head, 0, NULL));
@@ -62,10 +62,10 @@ void test_cherrypick_bare__conflicts(void)
{ 0100644, "e233b9ed408a95e9d4b65fec7fc34943a556deb2", 3, "file3.txt" },
};
- git_oid__fromstr(&head_oid, "bafbf6912c09505ac60575cd43d3f2aba3bd84d8", GIT_OID_SHA1);
+ git_oid_from_string(&head_oid, "bafbf6912c09505ac60575cd43d3f2aba3bd84d8", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
- git_oid__fromstr(&cherry_oid, "e9b63f3655b2ad80c0ff587389b5a9589a3a7110", GIT_OID_SHA1);
+ git_oid_from_string(&cherry_oid, "e9b63f3655b2ad80c0ff587389b5a9589a3a7110", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, repo, &cherry_oid));
cl_git_pass(git_cherrypick_commit(&index, repo, commit, head, 0, NULL));
@@ -89,10 +89,10 @@ void test_cherrypick_bare__orphan(void)
{ 0100644, "9ccb9bf50c011fd58dcbaa65df917bf79539717f", 0, "orphan.txt" },
};
- git_oid__fromstr(&head_oid, "d3d77487660ee3c0194ee01dc5eaf478782b1c7e", GIT_OID_SHA1);
+ git_oid_from_string(&head_oid, "d3d77487660ee3c0194ee01dc5eaf478782b1c7e", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
- git_oid__fromstr(&cherry_oid, "74f06b5bfec6d33d7264f73606b57a7c0b963819", GIT_OID_SHA1);
+ git_oid_from_string(&cherry_oid, "74f06b5bfec6d33d7264f73606b57a7c0b963819", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, repo, &cherry_oid));
cl_git_pass(git_cherrypick_commit(&index, repo, commit, head, 0, NULL));
diff --git a/tests/libgit2/cherrypick/workdir.c b/tests/libgit2/cherrypick/workdir.c
index c16b7814ac0..45b8349e1ed 100644
--- a/tests/libgit2/cherrypick/workdir.c
+++ b/tests/libgit2/cherrypick/workdir.c
@@ -57,7 +57,7 @@ void test_cherrypick_workdir__automerge(void)
cl_git_pass(git_signature_new(&signature, "Picker", "picker@example.org", time(NULL), 0));
- git_oid__fromstr(&head_oid, "d3d77487660ee3c0194ee01dc5eaf478782b1c7e", GIT_OID_SHA1);
+ git_oid_from_string(&head_oid, "d3d77487660ee3c0194ee01dc5eaf478782b1c7e", GIT_OID_SHA1);
for (i = 0; i < 3; ++i) {
git_commit *head = NULL, *commit = NULL;
@@ -67,7 +67,7 @@ void test_cherrypick_workdir__automerge(void)
cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL));
- git_oid__fromstr(&cherry_oid, cherrypick_oids[i], GIT_OID_SHA1);
+ git_oid_from_string(&cherry_oid, cherrypick_oids[i], GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, repo, &cherry_oid));
cl_git_pass(git_cherrypick(repo, commit, NULL));
@@ -110,7 +110,7 @@ void test_cherrypick_workdir__empty_result(void)
cl_git_pass(git_signature_new(&signature, "Picker", "picker@example.org", time(NULL), 0));
- git_oid__fromstr(&head_oid, "cfc4f0999a8367568e049af4f72e452d40828a15", GIT_OID_SHA1);
+ git_oid_from_string(&head_oid, "cfc4f0999a8367568e049af4f72e452d40828a15", GIT_OID_SHA1);
/* Create an untracked file that should not conflict */
cl_git_mkfile(TEST_REPO_PATH "/file4.txt", "");
@@ -119,7 +119,7 @@ void test_cherrypick_workdir__empty_result(void)
cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL));
- git_oid__fromstr(&cherry_oid, cherrypick_oid, GIT_OID_SHA1);
+ git_oid_from_string(&cherry_oid, cherrypick_oid, GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, repo, &cherry_oid));
cl_git_pass(git_cherrypick(repo, commit, NULL));
@@ -151,12 +151,12 @@ void test_cherrypick_workdir__conflicts(void)
{ 0100644, "e233b9ed408a95e9d4b65fec7fc34943a556deb2", 3, "file3.txt" },
};
- git_oid__fromstr(&head_oid, "bafbf6912c09505ac60575cd43d3f2aba3bd84d8", GIT_OID_SHA1);
+ git_oid_from_string(&head_oid, "bafbf6912c09505ac60575cd43d3f2aba3bd84d8", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL));
- git_oid__fromstr(&cherry_oid, "e9b63f3655b2ad80c0ff587389b5a9589a3a7110", GIT_OID_SHA1);
+ git_oid_from_string(&cherry_oid, "e9b63f3655b2ad80c0ff587389b5a9589a3a7110", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, repo, &cherry_oid));
cl_git_pass(git_cherrypick(repo, commit, NULL));
@@ -257,14 +257,14 @@ void test_cherrypick_workdir__conflict_use_ours(void)
};
/* leave the index in a conflicted state, but checkout "ours" to the workdir */
- opts.checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_USE_OURS;
+ opts.checkout_opts.checkout_strategy = GIT_CHECKOUT_USE_OURS;
- git_oid__fromstr(&head_oid, "bafbf6912c09505ac60575cd43d3f2aba3bd84d8", GIT_OID_SHA1);
+ git_oid_from_string(&head_oid, "bafbf6912c09505ac60575cd43d3f2aba3bd84d8", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL));
- git_oid__fromstr(&cherry_oid, "e9b63f3655b2ad80c0ff587389b5a9589a3a7110", GIT_OID_SHA1);
+ git_oid_from_string(&cherry_oid, "e9b63f3655b2ad80c0ff587389b5a9589a3a7110", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, repo, &cherry_oid));
cl_git_pass(git_cherrypick(repo, commit, &opts));
@@ -302,11 +302,11 @@ void test_cherrypick_workdir__rename(void)
opts.merge_opts.flags |= GIT_MERGE_FIND_RENAMES;
opts.merge_opts.rename_threshold = 50;
- git_oid__fromstr(&head_oid, "cfc4f0999a8367568e049af4f72e452d40828a15", GIT_OID_SHA1);
+ git_oid_from_string(&head_oid, "cfc4f0999a8367568e049af4f72e452d40828a15", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL));
- git_oid__fromstr(&cherry_oid, "2a26c7e88b285613b302ba76712bc998863f3cbc", GIT_OID_SHA1);
+ git_oid_from_string(&cherry_oid, "2a26c7e88b285613b302ba76712bc998863f3cbc", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, repo, &cherry_oid));
cl_git_pass(git_cherrypick(repo, commit, &opts));
@@ -337,11 +337,11 @@ void test_cherrypick_workdir__both_renamed(void)
opts.merge_opts.flags |= GIT_MERGE_FIND_RENAMES;
opts.merge_opts.rename_threshold = 50;
- git_oid__fromstr(&head_oid, "44cd2ed2052c9c68f9a439d208e9614dc2a55c70", GIT_OID_SHA1);
+ git_oid_from_string(&head_oid, "44cd2ed2052c9c68f9a439d208e9614dc2a55c70", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL));
- git_oid__fromstr(&cherry_oid, "2a26c7e88b285613b302ba76712bc998863f3cbc", GIT_OID_SHA1);
+ git_oid_from_string(&cherry_oid, "2a26c7e88b285613b302ba76712bc998863f3cbc", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, repo, &cherry_oid));
cl_git_pass(git_cherrypick(repo, commit, &opts));
@@ -388,11 +388,11 @@ void test_cherrypick_workdir__merge_fails_without_mainline_specified(void)
git_commit *head, *commit;
git_oid head_oid, cherry_oid;
- git_oid__fromstr(&head_oid, "cfc4f0999a8367568e049af4f72e452d40828a15", GIT_OID_SHA1);
+ git_oid_from_string(&head_oid, "cfc4f0999a8367568e049af4f72e452d40828a15", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL));
- git_oid__fromstr(&cherry_oid, "abe4603bc7cd5b8167a267e0e2418fd2348f8cff", GIT_OID_SHA1);
+ git_oid_from_string(&cherry_oid, "abe4603bc7cd5b8167a267e0e2418fd2348f8cff", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, repo, &cherry_oid));
cl_must_fail(git_cherrypick(repo, commit, NULL));
@@ -420,11 +420,11 @@ void test_cherrypick_workdir__merge_first_parent(void)
opts.mainline = 1;
- git_oid__fromstr(&head_oid, "cfc4f0999a8367568e049af4f72e452d40828a15", GIT_OID_SHA1);
+ git_oid_from_string(&head_oid, "cfc4f0999a8367568e049af4f72e452d40828a15", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL));
- git_oid__fromstr(&cherry_oid, "abe4603bc7cd5b8167a267e0e2418fd2348f8cff", GIT_OID_SHA1);
+ git_oid_from_string(&cherry_oid, "abe4603bc7cd5b8167a267e0e2418fd2348f8cff", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, repo, &cherry_oid));
cl_git_pass(git_cherrypick(repo, commit, &opts));
@@ -452,11 +452,11 @@ void test_cherrypick_workdir__merge_second_parent(void)
opts.mainline = 2;
- git_oid__fromstr(&head_oid, "cfc4f0999a8367568e049af4f72e452d40828a15", GIT_OID_SHA1);
+ git_oid_from_string(&head_oid, "cfc4f0999a8367568e049af4f72e452d40828a15", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL));
- git_oid__fromstr(&cherry_oid, "abe4603bc7cd5b8167a267e0e2418fd2348f8cff", GIT_OID_SHA1);
+ git_oid_from_string(&cherry_oid, "abe4603bc7cd5b8167a267e0e2418fd2348f8cff", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, repo, &cherry_oid));
cl_git_pass(git_cherrypick(repo, commit, &opts));
diff --git a/tests/libgit2/clone/local.c b/tests/libgit2/clone/local.c
index e0bd74df78a..a15e4581705 100644
--- a/tests/libgit2/clone/local.c
+++ b/tests/libgit2/clone/local.c
@@ -54,41 +54,87 @@ static int unc_path(git_str *buf, const char *host, const char *path)
void test_clone_local__should_clone_local(void)
{
git_str buf = GIT_STR_INIT;
+ bool local;
/* we use a fixture path because it needs to exist for us to want to clone */
const char *path = cl_fixture("testrepo.git");
+ /* empty string */
cl_git_pass(file_url(&buf, "", path));
- cl_assert_equal_i(0, git_clone__should_clone_local(buf.ptr, GIT_CLONE_LOCAL_AUTO));
- cl_assert_equal_i(1, git_clone__should_clone_local(buf.ptr, GIT_CLONE_LOCAL));
- cl_assert_equal_i(1, git_clone__should_clone_local(buf.ptr, GIT_CLONE_LOCAL_NO_LINKS));
- cl_assert_equal_i(0, git_clone__should_clone_local(buf.ptr, GIT_CLONE_NO_LOCAL));
+ cl_git_pass(git_clone__should_clone_local(&local, buf.ptr, GIT_CLONE_LOCAL_AUTO));
+ cl_assert_equal_i(false, local);
+ cl_git_pass(git_clone__should_clone_local(&local, buf.ptr, GIT_CLONE_LOCAL_AUTO));
+ cl_assert_equal_i(false, local);
+
+ cl_git_pass(git_clone__should_clone_local(&local, buf.ptr, GIT_CLONE_LOCAL));
+ cl_assert_equal_i(true, local);
+
+ cl_git_pass(git_clone__should_clone_local(&local, buf.ptr, GIT_CLONE_LOCAL_NO_LINKS));
+ cl_assert_equal_i(true, local);
+
+ cl_git_pass(git_clone__should_clone_local(&local, buf.ptr, GIT_CLONE_NO_LOCAL));
+ cl_assert_equal_i(false, local);
+
+ /* localhost is special */
cl_git_pass(file_url(&buf, "localhost", path));
- cl_assert_equal_i(0, git_clone__should_clone_local(buf.ptr, GIT_CLONE_LOCAL_AUTO));
- cl_assert_equal_i(1, git_clone__should_clone_local(buf.ptr, GIT_CLONE_LOCAL));
- cl_assert_equal_i(1, git_clone__should_clone_local(buf.ptr, GIT_CLONE_LOCAL_NO_LINKS));
- cl_assert_equal_i(0, git_clone__should_clone_local(buf.ptr, GIT_CLONE_NO_LOCAL));
+ cl_git_pass(git_clone__should_clone_local(&local, buf.ptr, GIT_CLONE_LOCAL_AUTO));
+ cl_assert_equal_i(false, local);
+
+ cl_git_pass(git_clone__should_clone_local(&local, buf.ptr, GIT_CLONE_LOCAL));
+ cl_assert_equal_i(true, local);
+
+ cl_git_pass(git_clone__should_clone_local(&local, buf.ptr, GIT_CLONE_LOCAL_NO_LINKS));
+ cl_assert_equal_i(true, local);
+
+ cl_git_pass(git_clone__should_clone_local(&local, buf.ptr, GIT_CLONE_NO_LOCAL));
+ cl_assert_equal_i(false, local);
+ /* a remote host */
cl_git_pass(file_url(&buf, "other-host.mycompany.com", path));
- cl_assert_equal_i(0, git_clone__should_clone_local(buf.ptr, GIT_CLONE_LOCAL_AUTO));
- cl_assert_equal_i(0, git_clone__should_clone_local(buf.ptr, GIT_CLONE_LOCAL));
- cl_assert_equal_i(0, git_clone__should_clone_local(buf.ptr, GIT_CLONE_LOCAL_NO_LINKS));
- cl_assert_equal_i(0, git_clone__should_clone_local(buf.ptr, GIT_CLONE_NO_LOCAL));
+
+ cl_git_pass(git_clone__should_clone_local(&local, buf.ptr, GIT_CLONE_LOCAL_AUTO));
+ cl_assert_equal_i(false, local);
+
+ cl_git_pass(git_clone__should_clone_local(&local, buf.ptr, GIT_CLONE_LOCAL));
+ cl_assert_equal_i(false, local);
+
+ cl_git_pass(git_clone__should_clone_local(&local, buf.ptr, GIT_CLONE_LOCAL_NO_LINKS));
+ cl_assert_equal_i(false, local);
+
+ cl_git_pass(git_clone__should_clone_local(&local, buf.ptr, GIT_CLONE_NO_LOCAL));
+ cl_assert_equal_i(false, local);
/* Ensure that file:/// urls are percent decoded: .git == %2e%67%69%74 */
cl_git_pass(file_url(&buf, "", path));
git_str_shorten(&buf, 4);
cl_git_pass(git_str_puts(&buf, "%2e%67%69%74"));
- cl_assert_equal_i(0, git_clone__should_clone_local(buf.ptr, GIT_CLONE_LOCAL_AUTO));
- cl_assert_equal_i(1, git_clone__should_clone_local(buf.ptr, GIT_CLONE_LOCAL));
- cl_assert_equal_i(1, git_clone__should_clone_local(buf.ptr, GIT_CLONE_LOCAL_NO_LINKS));
- cl_assert_equal_i(0, git_clone__should_clone_local(buf.ptr, GIT_CLONE_NO_LOCAL));
- cl_assert_equal_i(1, git_clone__should_clone_local(path, GIT_CLONE_LOCAL_AUTO));
- cl_assert_equal_i(1, git_clone__should_clone_local(path, GIT_CLONE_LOCAL));
- cl_assert_equal_i(1, git_clone__should_clone_local(path, GIT_CLONE_LOCAL_NO_LINKS));
- cl_assert_equal_i(0, git_clone__should_clone_local(path, GIT_CLONE_NO_LOCAL));
+ cl_git_pass(git_clone__should_clone_local(&local, buf.ptr, GIT_CLONE_LOCAL_AUTO));
+ cl_assert_equal_i(false, local);
+
+ cl_git_pass(git_clone__should_clone_local(&local, buf.ptr, GIT_CLONE_LOCAL));
+ cl_assert_equal_i(true, local);
+
+ cl_git_pass(git_clone__should_clone_local(&local, buf.ptr, GIT_CLONE_LOCAL_NO_LINKS));
+ cl_assert_equal_i(true, local);
+
+ cl_git_pass(git_clone__should_clone_local(&local, buf.ptr, GIT_CLONE_NO_LOCAL));
+ cl_assert_equal_i(false, local);
+
+ /* a local path on disk */
+ cl_git_pass(git_clone__should_clone_local(&local, path, GIT_CLONE_LOCAL_AUTO));
+ cl_assert_equal_i(true, local);
+
+ cl_git_pass(git_clone__should_clone_local(&local, path, GIT_CLONE_LOCAL));
+
+ cl_assert_equal_i(true, local);
+
+ cl_git_pass(git_clone__should_clone_local(&local, path, GIT_CLONE_LOCAL_NO_LINKS));
+ cl_assert_equal_i(true, local);
+
+ cl_git_pass(git_clone__should_clone_local(&local, path, GIT_CLONE_NO_LOCAL));
+ cl_assert_equal_i(false, local);
git_str_dispose(&buf);
}
@@ -210,3 +256,13 @@ void test_clone_local__git_style_unc_paths(void)
cl_git_pass(git_futils_rmdir_r("./clone.git", NULL, GIT_RMDIR_REMOVE_FILES));
#endif
}
+
+void test_clone_local__shallow_fails(void)
+{
+ git_repository *repo;
+ git_clone_options opts = GIT_CLONE_OPTIONS_INIT;
+
+ opts.fetch_opts.depth = 4;
+
+ cl_git_fail_with(GIT_ENOTSUPPORTED, git_clone(&repo, cl_fixture("testrepo.git"), "./clone.git", &opts));
+}
diff --git a/tests/libgit2/clone/nonetwork.c b/tests/libgit2/clone/nonetwork.c
index eab63363516..dfde7f291eb 100644
--- a/tests/libgit2/clone/nonetwork.c
+++ b/tests/libgit2/clone/nonetwork.c
@@ -5,6 +5,7 @@
#include "remote.h"
#include "futils.h"
#include "repository.h"
+#include "index.h"
#define LIVE_REPO_URL "git://github.com/libgit2/TestGitRepository"
@@ -23,7 +24,6 @@ void test_clone_nonetwork__initialize(void)
memset(&g_options, 0, sizeof(git_clone_options));
g_options.version = GIT_CLONE_OPTIONS_VERSION;
g_options.checkout_opts = dummy_opts;
- g_options.checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE;
g_options.fetch_opts = dummy_fetch;
}
@@ -265,13 +265,17 @@ void test_clone_nonetwork__clone_tag_to_tree(void)
git_tree *tree;
git_reference *tag;
git_tree_entry *tentry;
+ git_index_options index_opts = GIT_INDEX_OPTIONS_INIT;
+
const char *file_path = "some/deep/path.txt";
const char *file_content = "some content\n";
const char *tag_name = "refs/tags/tree-tag";
+ index_opts.oid_type = GIT_OID_SHA1;
+
stage = cl_git_sandbox_init("testrepo.git");
cl_git_pass(git_repository_odb(&odb, stage));
- cl_git_pass(git_index_new(&index));
+ cl_git_pass(git_index_new_ext(&index, &index_opts));
memset(&entry, 0, sizeof(git_index_entry));
entry.path = file_path;
diff --git a/tests/libgit2/commit/commit.c b/tests/libgit2/commit/commit.c
index 140f87d0c72..bdd08b9f7df 100644
--- a/tests/libgit2/commit/commit.c
+++ b/tests/libgit2/commit/commit.c
@@ -26,10 +26,10 @@ void test_commit_commit__create_unexisting_update_ref(void)
git_signature *s;
git_reference *ref;
- git_oid__fromstr(&oid, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1);
+ git_oid_from_string(&oid, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, _repo, &oid));
- git_oid__fromstr(&oid, "944c0f6e4dfa41595e6eb3ceecdb14f50fe18162", GIT_OID_SHA1);
+ git_oid_from_string(&oid, "944c0f6e4dfa41595e6eb3ceecdb14f50fe18162", GIT_OID_SHA1);
cl_git_pass(git_tree_lookup(&tree, _repo, &oid));
cl_git_pass(git_signature_now(&s, "alice", "alice@example.com"));
@@ -59,10 +59,10 @@ void test_commit_commit__create_initial_commit(void)
git_signature *s;
git_reference *ref;
- git_oid__fromstr(&oid, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1);
+ git_oid_from_string(&oid, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, _repo, &oid));
- git_oid__fromstr(&oid, "944c0f6e4dfa41595e6eb3ceecdb14f50fe18162", GIT_OID_SHA1);
+ git_oid_from_string(&oid, "944c0f6e4dfa41595e6eb3ceecdb14f50fe18162", GIT_OID_SHA1);
cl_git_pass(git_tree_lookup(&tree, _repo, &oid));
cl_git_pass(git_signature_now(&s, "alice", "alice@example.com"));
@@ -89,10 +89,10 @@ void test_commit_commit__create_initial_commit_parent_not_current(void)
git_commit *commit;
git_signature *s;
- git_oid__fromstr(&oid, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1);
+ git_oid_from_string(&oid, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, _repo, &oid));
- git_oid__fromstr(&oid, "944c0f6e4dfa41595e6eb3ceecdb14f50fe18162", GIT_OID_SHA1);
+ git_oid_from_string(&oid, "944c0f6e4dfa41595e6eb3ceecdb14f50fe18162", GIT_OID_SHA1);
cl_git_pass(git_tree_lookup(&tree, _repo, &oid));
cl_git_pass(git_signature_now(&s, "alice", "alice@example.com"));
diff --git a/tests/libgit2/commit/create.c b/tests/libgit2/commit/create.c
new file mode 100644
index 00000000000..9f627dc87b5
--- /dev/null
+++ b/tests/libgit2/commit/create.c
@@ -0,0 +1,112 @@
+#include "clar_libgit2.h"
+#include "repository.h"
+
+/* Fixture setup */
+static git_repository *g_repo;
+static git_signature *g_author, *g_committer;
+
+void test_commit_create__initialize(void)
+{
+ g_repo = cl_git_sandbox_init("testrepo2");
+ cl_git_pass(git_signature_new(&g_author, "Edward Thomson", "ethomson@edwardthomson.com", 123456789, 60));
+ cl_git_pass(git_signature_new(&g_committer, "libgit2 user", "nobody@noreply.libgit2.org", 987654321, 90));
+}
+
+void test_commit_create__cleanup(void)
+{
+ git_signature_free(g_committer);
+ git_signature_free(g_author);
+ cl_git_sandbox_cleanup();
+}
+
+
+void test_commit_create__from_stage_simple(void)
+{
+ git_commit_create_options opts = GIT_COMMIT_CREATE_OPTIONS_INIT;
+ git_index *index;
+ git_oid commit_id;
+ git_tree *tree;
+
+ opts.author = g_author;
+ opts.committer = g_committer;
+
+ cl_git_rewritefile("testrepo2/newfile.txt", "This is a new file.\n");
+ cl_git_rewritefile("testrepo2/newfile2.txt", "This is a new file.\n");
+ cl_git_rewritefile("testrepo2/README", "hello, world.\n");
+ cl_git_rewritefile("testrepo2/new.txt", "hi there.\n");
+
+ cl_git_pass(git_repository_index(&index, g_repo));
+ cl_git_pass(git_index_add_bypath(index, "newfile2.txt"));
+ cl_git_pass(git_index_add_bypath(index, "README"));
+ cl_git_pass(git_index_write(index));
+
+ cl_git_pass(git_commit_create_from_stage(&commit_id, g_repo, "This is the message.", &opts));
+
+ cl_git_pass(git_repository_head_tree(&tree, g_repo));
+
+ cl_assert_equal_oidstr("241b5b04e847bc38dd7b4b9f49f21e55da40f3a6", &commit_id);
+ cl_assert_equal_oidstr("b27210772d0633870b4f486d04ed3eb5ebbef5e7", git_tree_id(tree));
+
+ git_index_free(index);
+ git_tree_free(tree);
+}
+
+void test_commit_create__from_stage_nochanges(void)
+{
+ git_commit_create_options opts = GIT_COMMIT_CREATE_OPTIONS_INIT;
+ git_oid commit_id;
+ git_tree *tree;
+
+ opts.author = g_author;
+ opts.committer = g_committer;
+
+ cl_git_fail_with(GIT_EUNCHANGED, git_commit_create_from_stage(&commit_id, g_repo, "Message goes here.", &opts));
+
+ opts.allow_empty_commit = 1;
+
+ cl_git_pass(git_commit_create_from_stage(&commit_id, g_repo, "Message goes here.", &opts));
+
+ cl_git_pass(git_repository_head_tree(&tree, g_repo));
+
+ cl_assert_equal_oidstr("f776dc4c7fd8164b7127dc8e4f9b44421cb01b56", &commit_id);
+ cl_assert_equal_oidstr("c4dc1555e4d4fa0e0c9c3fc46734c7c35b3ce90b", git_tree_id(tree));
+
+ git_tree_free(tree);
+}
+
+void test_commit_create__from_stage_newrepo(void)
+{
+ git_commit_create_options opts = GIT_COMMIT_CREATE_OPTIONS_INIT;
+ git_repository *newrepo;
+ git_index *index;
+ git_commit *commit;
+ git_tree *tree;
+ git_oid commit_id;
+
+ opts.author = g_author;
+ opts.committer = g_committer;
+
+ git_repository_init(&newrepo, "newrepo", false);
+ cl_git_pass(git_repository_index(&index, newrepo));
+
+ cl_git_rewritefile("newrepo/hello.txt", "hello, world.\n");
+ cl_git_rewritefile("newrepo/hi.txt", "hi there.\n");
+ cl_git_rewritefile("newrepo/foo.txt", "bar.\n");
+
+ cl_git_pass(git_index_add_bypath(index, "hello.txt"));
+ cl_git_pass(git_index_add_bypath(index, "foo.txt"));
+ cl_git_pass(git_index_write(index));
+
+ cl_git_pass(git_commit_create_from_stage(&commit_id, newrepo, "Initial commit.", &opts));
+ cl_git_pass(git_repository_head_commit(&commit, newrepo));
+ cl_git_pass(git_repository_head_tree(&tree, newrepo));
+
+ cl_assert_equal_oid(&commit_id, git_commit_id(commit));
+ cl_assert_equal_oidstr("b2fa96a4f191c76eb172437281c66aa29609dcaa", git_commit_tree_id(commit));
+
+ git_tree_free(tree);
+ git_commit_free(commit);
+ git_index_free(index);
+ git_repository_free(newrepo);
+ cl_fixture_cleanup("newrepo");
+}
diff --git a/tests/libgit2/commit/parent.c b/tests/libgit2/commit/parent.c
index 1ec96babb1e..ddbb8a44d61 100644
--- a/tests/libgit2/commit/parent.c
+++ b/tests/libgit2/commit/parent.c
@@ -9,7 +9,7 @@ void test_commit_parent__initialize(void)
cl_git_pass(git_repository_open(&_repo, cl_fixture("testrepo.git")));
- git_oid__fromstr(&oid, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1);
+ git_oid_from_string(&oid, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, _repo, &oid));
}
diff --git a/tests/libgit2/commit/parse.c b/tests/libgit2/commit/parse.c
index 3a1fc3d26bd..6dda8a7e5a0 100644
--- a/tests/libgit2/commit/parse.c
+++ b/tests/libgit2/commit/parse.c
@@ -343,7 +343,7 @@ void test_commit_parse__details0(void) {
unsigned int parents, p;
git_commit *parent = NULL, *old_parent = NULL;
- git_oid__fromstr(&id, commit_ids[i], GIT_OID_SHA1);
+ git_oid_from_string(&id, commit_ids[i], GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, g_repo, &id));
@@ -533,7 +533,7 @@ corrupt signature\n";
git_buf_dispose(&signed_data);
/* Try to parse a tree */
- cl_git_pass(git_oid__fromstr(&commit_id, "45dd856fdd4d89b884c340ba0e047752d9b085d6", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&commit_id, "45dd856fdd4d89b884c340ba0e047752d9b085d6", GIT_OID_SHA1));
cl_git_fail_with(GIT_ENOTFOUND, git_commit_extract_signature(&signature, &signed_data, g_repo, &commit_id, NULL));
cl_assert_equal_i(GIT_ERROR_INVALID, git_error_last()->klass);
diff --git a/tests/libgit2/commit/signature.c b/tests/libgit2/commit/signature.c
index a91551415d6..3fa6646cf33 100644
--- a/tests/libgit2/commit/signature.c
+++ b/tests/libgit2/commit/signature.c
@@ -36,10 +36,17 @@ void test_commit_signature__leading_and_trailing_spaces_are_trimmed(void)
assert_name_and_email("nulltoken", "emeric.fermas@gmail.com", " \t nulltoken \n", " \n emeric.fermas@gmail.com \n");
}
+void test_commit_signature__leading_and_trailing_dots_are_supported(void)
+{
+ assert_name_and_email(".nulltoken", ".emeric.fermas@gmail.com", ".nulltoken", ".emeric.fermas@gmail.com");
+ assert_name_and_email("nulltoken.", "emeric.fermas@gmail.com.", "nulltoken.", "emeric.fermas@gmail.com.");
+ assert_name_and_email(".nulltoken.", ".emeric.fermas@gmail.com.", ".nulltoken.", ".emeric.fermas@gmail.com.");
+}
+
void test_commit_signature__leading_and_trailing_crud_is_trimmed(void)
{
assert_name_and_email("nulltoken", "emeric.fermas@gmail.com", "\"nulltoken\"", "\"emeric.fermas@gmail.com\"");
- assert_name_and_email("nulltoken w", "emeric.fermas@gmail.com", "nulltoken w.", "emeric.fermas@gmail.com");
+ assert_name_and_email("nulltoken w", "emeric.fermas@gmail.com", "nulltoken w;", "emeric.fermas@gmail.com");
assert_name_and_email("nulltoken \xe2\x98\xba", "emeric.fermas@gmail.com", "nulltoken \xe2\x98\xba", "emeric.fermas@gmail.com");
}
@@ -146,3 +153,83 @@ void test_commit_signature__pos_and_neg_zero_offsets_dont_match(void)
git_signature_free((git_signature *)with_neg_zero);
git_signature_free((git_signature *)with_pos_zero);
}
+
+static git_repository *g_repo;
+
+void test_commit_signature__initialize(void)
+{
+ g_repo = cl_git_sandbox_init("empty_standard_repo");
+}
+
+void test_commit_signature__cleanup(void)
+{
+ cl_git_sandbox_cleanup();
+ g_repo = NULL;
+}
+
+void test_commit_signature__from_env(void)
+{
+ git_signature *author_sign, *committer_sign;
+ git_config *cfg, *local;
+ cl_git_pass(git_repository_config(&cfg, g_repo));
+ cl_git_pass(git_config_open_level(&local, cfg, GIT_CONFIG_LEVEL_LOCAL));
+ /* No configuration value is set and no environment variable */
+ cl_setenv("EMAIL", NULL);
+ cl_setenv("GIT_AUTHOR_NAME", NULL);
+ cl_setenv("GIT_AUTHOR_EMAIL", NULL);
+ cl_setenv("GIT_COMMITTER_NAME", NULL);
+ cl_setenv("GIT_COMMITTER_EMAIL", NULL);
+ cl_git_fail(git_signature_default_from_env(&author_sign, &committer_sign, g_repo));
+ /* Name is read from configuration and email is read from fallback EMAIL
+ * environment variable */
+ cl_git_pass(git_config_set_string(local, "user.name", "Name (config)"));
+ cl_setenv("EMAIL", "email-envvar@example.com");
+ cl_git_pass(git_signature_default_from_env(&author_sign, &committer_sign, g_repo));
+ cl_assert_equal_s("Name (config)", author_sign->name);
+ cl_assert_equal_s("email-envvar@example.com", author_sign->email);
+ cl_assert_equal_s("Name (config)", committer_sign->name);
+ cl_assert_equal_s("email-envvar@example.com", committer_sign->email);
+ cl_setenv("EMAIL", NULL);
+ git_signature_free(author_sign);
+ git_signature_free(committer_sign);
+ /* Environment variables have precedence over configuration */
+ cl_git_pass(git_config_set_string(local, "user.email", "config@example.com"));
+ cl_setenv("GIT_AUTHOR_NAME", "Author (envvar)");
+ cl_setenv("GIT_AUTHOR_EMAIL", "author-envvar@example.com");
+ cl_setenv("GIT_COMMITTER_NAME", "Committer (envvar)");
+ cl_setenv("GIT_COMMITTER_EMAIL", "committer-envvar@example.com");
+ cl_git_pass(git_signature_default_from_env(&author_sign, &committer_sign, g_repo));
+ cl_assert_equal_s("Author (envvar)", author_sign->name);
+ cl_assert_equal_s("author-envvar@example.com", author_sign->email);
+ cl_assert_equal_s("Committer (envvar)", committer_sign->name);
+ cl_assert_equal_s("committer-envvar@example.com", committer_sign->email);
+ git_signature_free(author_sign);
+ git_signature_free(committer_sign);
+ /* When environment variables are not set we can still read from
+ * configuration */
+ cl_setenv("GIT_AUTHOR_NAME", NULL);
+ cl_setenv("GIT_AUTHOR_EMAIL", NULL);
+ cl_setenv("GIT_COMMITTER_NAME", NULL);
+ cl_setenv("GIT_COMMITTER_EMAIL", NULL);
+ cl_git_pass(git_signature_default_from_env(&author_sign, &committer_sign, g_repo));
+ cl_assert_equal_s("Name (config)", author_sign->name);
+ cl_assert_equal_s("config@example.com", author_sign->email);
+ cl_assert_equal_s("Name (config)", committer_sign->name);
+ cl_assert_equal_s("config@example.com", committer_sign->email);
+ git_signature_free(author_sign);
+ git_signature_free(committer_sign);
+ /* We can also override the timestamp with an environment variable */
+ cl_setenv("GIT_AUTHOR_DATE", "1971-02-03 04:05:06+01");
+ cl_setenv("GIT_COMMITTER_DATE", "1988-09-10 11:12:13-01");
+ cl_git_pass(git_signature_default_from_env(&author_sign, &committer_sign, g_repo));
+ cl_assert_equal_i(34398306, author_sign->when.time); /* 1971-02-03 03:05:06 UTC */
+ cl_assert_equal_i(60, author_sign->when.offset);
+ cl_assert_equal_i(589896733, committer_sign->when.time); /* 1988-09-10 12:12:13 UTC */
+ cl_assert_equal_i(-60, committer_sign->when.offset);
+ git_signature_free(author_sign);
+ git_signature_free(committer_sign);
+ cl_setenv("GIT_AUTHOR_DATE", NULL);
+ cl_setenv("GIT_COMMITTER_DATE", NULL);
+ git_config_free(local);
+ git_config_free(cfg);
+}
diff --git a/tests/libgit2/commit/write.c b/tests/libgit2/commit/write.c
index 890f7384b1a..0fd228bc883 100644
--- a/tests/libgit2/commit/write.c
+++ b/tests/libgit2/commit/write.c
@@ -51,10 +51,10 @@ void test_commit_write__from_memory(void)
git_commit *parent;
git_tree *tree;
- git_oid__fromstr(&tree_id, tree_id_str, GIT_OID_SHA1);
+ git_oid_from_string(&tree_id, tree_id_str, GIT_OID_SHA1);
cl_git_pass(git_tree_lookup(&tree, g_repo, &tree_id));
- git_oid__fromstr(&parent_id, parent_id_str, GIT_OID_SHA1);
+ git_oid_from_string(&parent_id, parent_id_str, GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&parent, g_repo, &parent_id));
/* create signatures */
@@ -107,14 +107,14 @@ void test_commit_write__into_buf(void)
git_oid parent_id;
git_buf commit = GIT_BUF_INIT;
- git_oid__fromstr(&tree_id, tree_id_str, GIT_OID_SHA1);
+ git_oid_from_string(&tree_id, tree_id_str, GIT_OID_SHA1);
cl_git_pass(git_tree_lookup(&tree, g_repo, &tree_id));
/* create signatures */
cl_git_pass(git_signature_new(&committer, committer_name, committer_email, 123456789, 60));
cl_git_pass(git_signature_new(&author, committer_name, committer_email, 987654321, 90));
- git_oid__fromstr(&parent_id, parent_id_str, GIT_OID_SHA1);
+ git_oid_from_string(&parent_id, parent_id_str, GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&parent, g_repo, &parent_id));
cl_git_pass(git_commit_create_buffer(&commit, g_repo, author, committer,
@@ -148,7 +148,7 @@ void test_commit_write__root(void)
git_reflog *log;
const git_reflog_entry *entry;
- git_oid__fromstr(&tree_id, tree_id_str, GIT_OID_SHA1);
+ git_oid_from_string(&tree_id, tree_id_str, GIT_OID_SHA1);
cl_git_pass(git_tree_lookup(&tree, g_repo, &tree_id));
/* create signatures */
@@ -242,34 +242,34 @@ void test_commit_write__can_write_invalid_objects(void)
cl_git_pass(git_libgit2_opts(GIT_OPT_ENABLE_STRICT_OBJECT_CREATION, 0));
/* this is a valid tree and parent */
- git_oid__fromstr(&tree_id, tree_id_str, GIT_OID_SHA1);
- git_oid__fromstr(&parent_id, parent_id_str, GIT_OID_SHA1);
+ git_oid_from_string(&tree_id, tree_id_str, GIT_OID_SHA1);
+ git_oid_from_string(&parent_id, parent_id_str, GIT_OID_SHA1);
- git_oid__fromstr(&expected_id, "c8571bbec3a72c4bcad31648902e5a453f1adece", GIT_OID_SHA1);
+ git_oid_from_string(&expected_id, "c8571bbec3a72c4bcad31648902e5a453f1adece", GIT_OID_SHA1);
cl_git_pass(create_commit_from_ids(&commit_id, &tree_id, &parent_id));
cl_assert_equal_oid(&expected_id, &commit_id);
/* this is a wholly invented tree id */
- git_oid__fromstr(&tree_id, "1234567890123456789012345678901234567890", GIT_OID_SHA1);
- git_oid__fromstr(&parent_id, parent_id_str, GIT_OID_SHA1);
+ git_oid_from_string(&tree_id, "1234567890123456789012345678901234567890", GIT_OID_SHA1);
+ git_oid_from_string(&parent_id, parent_id_str, GIT_OID_SHA1);
- git_oid__fromstr(&expected_id, "996008340b8e68d69bf3c28d7c57fb7ec3c8e202", GIT_OID_SHA1);
+ git_oid_from_string(&expected_id, "996008340b8e68d69bf3c28d7c57fb7ec3c8e202", GIT_OID_SHA1);
cl_git_pass(create_commit_from_ids(&commit_id, &tree_id, &parent_id));
cl_assert_equal_oid(&expected_id, &commit_id);
/* this is a wholly invented parent id */
- git_oid__fromstr(&tree_id, tree_id_str, GIT_OID_SHA1);
- git_oid__fromstr(&parent_id, "1234567890123456789012345678901234567890", GIT_OID_SHA1);
+ git_oid_from_string(&tree_id, tree_id_str, GIT_OID_SHA1);
+ git_oid_from_string(&parent_id, "1234567890123456789012345678901234567890", GIT_OID_SHA1);
- git_oid__fromstr(&expected_id, "d78f660cab89d9791ca6714b57978bf2a7e709fd", GIT_OID_SHA1);
+ git_oid_from_string(&expected_id, "d78f660cab89d9791ca6714b57978bf2a7e709fd", GIT_OID_SHA1);
cl_git_pass(create_commit_from_ids(&commit_id, &tree_id, &parent_id));
cl_assert_equal_oid(&expected_id, &commit_id);
/* these are legitimate objects, but of the wrong type */
- git_oid__fromstr(&tree_id, parent_id_str, GIT_OID_SHA1);
- git_oid__fromstr(&parent_id, tree_id_str, GIT_OID_SHA1);
+ git_oid_from_string(&tree_id, parent_id_str, GIT_OID_SHA1);
+ git_oid_from_string(&parent_id, tree_id_str, GIT_OID_SHA1);
- git_oid__fromstr(&expected_id, "5d80c07414e3f18792949699dfcacadf7748f361", GIT_OID_SHA1);
+ git_oid_from_string(&expected_id, "5d80c07414e3f18792949699dfcacadf7748f361", GIT_OID_SHA1);
cl_git_pass(create_commit_from_ids(&commit_id, &tree_id, &parent_id));
cl_assert_equal_oid(&expected_id, &commit_id);
}
@@ -279,23 +279,23 @@ void test_commit_write__can_validate_objects(void)
git_oid tree_id, parent_id, commit_id;
/* this is a valid tree and parent */
- git_oid__fromstr(&tree_id, tree_id_str, GIT_OID_SHA1);
- git_oid__fromstr(&parent_id, parent_id_str, GIT_OID_SHA1);
+ git_oid_from_string(&tree_id, tree_id_str, GIT_OID_SHA1);
+ git_oid_from_string(&parent_id, parent_id_str, GIT_OID_SHA1);
cl_git_pass(create_commit_from_ids(&commit_id, &tree_id, &parent_id));
/* this is a wholly invented tree id */
- git_oid__fromstr(&tree_id, "1234567890123456789012345678901234567890", GIT_OID_SHA1);
- git_oid__fromstr(&parent_id, parent_id_str, GIT_OID_SHA1);
+ git_oid_from_string(&tree_id, "1234567890123456789012345678901234567890", GIT_OID_SHA1);
+ git_oid_from_string(&parent_id, parent_id_str, GIT_OID_SHA1);
cl_git_fail(create_commit_from_ids(&commit_id, &tree_id, &parent_id));
/* this is a wholly invented parent id */
- git_oid__fromstr(&tree_id, tree_id_str, GIT_OID_SHA1);
- git_oid__fromstr(&parent_id, "1234567890123456789012345678901234567890", GIT_OID_SHA1);
+ git_oid_from_string(&tree_id, tree_id_str, GIT_OID_SHA1);
+ git_oid_from_string(&parent_id, "1234567890123456789012345678901234567890", GIT_OID_SHA1);
cl_git_fail(create_commit_from_ids(&commit_id, &tree_id, &parent_id));
/* these are legitimate objects, but of the wrong type */
- git_oid__fromstr(&tree_id, parent_id_str, GIT_OID_SHA1);
- git_oid__fromstr(&parent_id, tree_id_str, GIT_OID_SHA1);
+ git_oid_from_string(&tree_id, parent_id_str, GIT_OID_SHA1);
+ git_oid_from_string(&parent_id, tree_id_str, GIT_OID_SHA1);
cl_git_fail(create_commit_from_ids(&commit_id, &tree_id, &parent_id));
}
diff --git a/tests/libgit2/config/configlevel.c b/tests/libgit2/config/configlevel.c
index 8422d32c944..0e31268b0c6 100644
--- a/tests/libgit2/config/configlevel.c
+++ b/tests/libgit2/config/configlevel.c
@@ -71,3 +71,44 @@ void test_config_configlevel__fetching_a_level_from_an_empty_compound_config_ret
git_config_free(cfg);
}
+
+void test_config_configlevel__can_fetch_highest_level(void)
+{
+ git_config *cfg;
+ git_config *single_level_cfg;
+ git_buf buf = {0};
+
+ cl_git_pass(git_config_new(&cfg));
+ cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config18"),
+ GIT_CONFIG_LEVEL_GLOBAL, NULL, 0));
+ cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config19"),
+ GIT_CONFIG_LEVEL_LOCAL, NULL, 0));
+
+ cl_git_pass(git_config_open_level(&single_level_cfg, cfg, GIT_CONFIG_HIGHEST_LEVEL));
+
+ git_config_free(cfg);
+
+ cl_git_pass(git_config_get_string_buf(&buf, single_level_cfg, "core.stringglobal"));
+ cl_assert_equal_s("don't find me!", buf.ptr);
+
+ git_buf_dispose(&buf);
+ git_config_free(single_level_cfg);
+}
+
+void test_config_configlevel__can_override_local_with_worktree(void)
+{
+ git_config *cfg;
+ git_buf buf = GIT_BUF_INIT;
+
+ cl_git_pass(git_config_new(&cfg));
+ cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config19"),
+ GIT_CONFIG_LEVEL_WORKTREE, NULL, 1));
+ cl_git_pass(git_config_add_file_ondisk(cfg, cl_fixture("config/config18"),
+ GIT_CONFIG_LEVEL_LOCAL, NULL, 1));
+
+ cl_git_pass(git_config_get_string_buf(&buf, cfg, "core.stringglobal"));
+ cl_assert_equal_s("don't find me!", buf.ptr);
+
+ git_buf_dispose(&buf);
+ git_config_free(cfg);
+}
diff --git a/tests/libgit2/config/find.c b/tests/libgit2/config/find.c
new file mode 100644
index 00000000000..7ca8ec767e1
--- /dev/null
+++ b/tests/libgit2/config/find.c
@@ -0,0 +1,11 @@
+#include "clar_libgit2.h"
+
+void test_config_find__one(void)
+{
+ git_buf buf = GIT_BUF_INIT;
+
+ cl_git_fail_with(GIT_ENOTFOUND, git_config_find_global(&buf));
+ cl_git_fail_with(GIT_ENOTFOUND, git_config_find_xdg(&buf));
+ cl_git_fail_with(GIT_ENOTFOUND, git_config_find_system(&buf));
+ cl_git_fail_with(GIT_ENOTFOUND, git_config_find_programdata(&buf));
+}
diff --git a/tests/libgit2/config/global.c b/tests/libgit2/config/global.c
index 5aba4eec69e..d382f970eee 100644
--- a/tests/libgit2/config/global.c
+++ b/tests/libgit2/config/global.c
@@ -20,6 +20,11 @@ void test_config_global__initialize(void)
cl_git_pass(git_libgit2_opts(
GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_SYSTEM, path.ptr));
+ cl_git_pass(git_futils_mkdir_r("programdata", 0777));
+ cl_git_pass(git_fs_path_prettify(&path, "programdata", NULL));
+ cl_git_pass(git_libgit2_opts(
+ GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_PROGRAMDATA, path.ptr));
+
git_str_dispose(&path);
}
diff --git a/tests/libgit2/config/include.c b/tests/libgit2/config/include.c
index 1b55fdc86fd..ba8bcad4387 100644
--- a/tests/libgit2/config/include.c
+++ b/tests/libgit2/config/include.c
@@ -111,7 +111,7 @@ void test_config_include__missing(void)
git_error_clear();
cl_git_pass(git_config_open_ondisk(&cfg, "including"));
- cl_assert(git_error_last() == NULL);
+ cl_assert_equal_i(GIT_ERROR_NONE, git_error_last()->klass);
cl_git_pass(git_config_get_string_buf(&buf, cfg, "foo.bar"));
cl_assert_equal_s("baz", buf.ptr);
@@ -126,7 +126,7 @@ void test_config_include__missing_homedir(void)
git_error_clear();
cl_git_pass(git_config_open_ondisk(&cfg, "including"));
- cl_assert(git_error_last() == NULL);
+ cl_assert_equal_i(GIT_ERROR_NONE, git_error_last()->klass);
cl_git_pass(git_config_get_string_buf(&buf, cfg, "foo.bar"));
cl_assert_equal_s("baz", buf.ptr);
diff --git a/tests/libgit2/config/memory.c b/tests/libgit2/config/memory.c
index ae661899da7..9f533e282fd 100644
--- a/tests/libgit2/config/memory.c
+++ b/tests/libgit2/config/memory.c
@@ -34,8 +34,13 @@ static int contains_all_cb(const git_config_entry *entry, void *payload)
int i;
for (i = 0; entries[i].name; i++) {
- if (strcmp(entries[i].name, entry->name) ||
- strcmp(entries[i].value , entry->value))
+ if (strcmp(entries[i].name, entry->name))
+ continue;
+
+ if ((entries[i].value == NULL) ^ (entry->value == NULL))
+ continue;
+
+ if (entry->value && strcmp(entries[i].value , entry->value))
continue;
if (entries[i].seen)
@@ -61,7 +66,23 @@ static void assert_config_contains_all(git_config_backend *backend,
static void setup_backend(const char *cfg)
{
- cl_git_pass(git_config_backend_from_string(&backend, cfg, strlen(cfg)));
+ git_config_backend_memory_options opts =
+ GIT_CONFIG_BACKEND_MEMORY_OPTIONS_INIT;
+
+ opts.backend_type = "test";
+
+ cl_git_pass(git_config_backend_from_string(&backend, cfg, strlen(cfg), &opts));
+ cl_git_pass(git_config_backend_open(backend, 0, NULL));
+}
+
+static void setup_values_backend(const char **values, size_t len)
+{
+ git_config_backend_memory_options opts =
+ GIT_CONFIG_BACKEND_MEMORY_OPTIONS_INIT;
+
+ opts.backend_type = "test";
+
+ cl_git_pass(git_config_backend_from_values(&backend, values, len, &opts));
cl_git_pass(git_config_backend_open(backend, 0, NULL));
}
@@ -88,7 +109,13 @@ void test_config_memory__malformed_fails_to_open(void)
const char *cfg =
"[general\n"
"foo=bar\n";
- cl_git_pass(git_config_backend_from_string(&backend, cfg, strlen(cfg)));
+
+ git_config_backend_memory_options opts =
+ GIT_CONFIG_BACKEND_MEMORY_OPTIONS_INIT;
+
+ opts.backend_type = "test";
+
+ cl_git_pass(git_config_backend_from_string(&backend, cfg, strlen(cfg), &opts));
cl_git_fail(git_config_backend_open(backend, 0, NULL));
}
@@ -137,3 +164,43 @@ void test_config_memory__foreach_sees_multivar(void)
"foo=bar2\n");
assert_config_contains_all(backend, entries);
}
+
+void test_config_memory__values(void)
+{
+ const char *values[] = {
+ "general.foo=bar1",
+ "general.foo=bar2",
+ "other.key=value",
+ "empty.value=",
+ "no.value",
+ };
+
+ struct expected_entry entries[] = {
+ { "general.foo", "bar1", 0 },
+ { "general.foo", "bar2", 0 },
+ { "other.key", "value", 0 },
+ { "empty.value", "", 0 },
+ { "no.value", NULL, 0 },
+ { NULL, NULL, 0 }
+ };
+
+ setup_values_backend(values, 5);
+ assert_config_contains_all(backend, entries);
+}
+
+void test_config_memory__valid_values(void)
+{
+ const char *values[] = {
+ "general.foo=bar1",
+ "=bar2",
+ "other.key=value"
+ };
+
+ git_config_backend_memory_options opts =
+ GIT_CONFIG_BACKEND_MEMORY_OPTIONS_INIT;
+
+ opts.backend_type = "test";
+
+ cl_git_pass(git_config_backend_from_values(&backend, values, 3, &opts));
+ cl_git_fail(git_config_backend_open(backend, 0, NULL));
+}
diff --git a/tests/libgit2/config/multivar.c b/tests/libgit2/config/multivar.c
index 244e3755965..3ed846012fa 100644
--- a/tests/libgit2/config/multivar.c
+++ b/tests/libgit2/config/multivar.c
@@ -1,4 +1,6 @@
#include "clar_libgit2.h"
+#include "config.h"
+#include "config/config_helpers.h"
static const char *_name = "remote.ab.url";
@@ -286,3 +288,32 @@ void test_config_multivar__delete_notfound(void)
git_config_free(cfg);
}
+
+void test_config_multivar__rename_section(void)
+{
+ git_repository *repo;
+ git_config *cfg;
+ int n;
+
+ repo = cl_git_sandbox_init("testrepo");
+ cl_git_pass(git_repository_config(&cfg, repo));
+
+ cl_git_pass(git_config_set_multivar(cfg, "branch.foo.name", "^$", "bar"));
+ cl_git_pass(git_config_set_multivar(cfg, "branch.foo.name", "^$", "xyzzy"));
+ n = 0;
+ cl_git_pass(git_config_get_multivar_foreach(
+ cfg, "branch.foo.name", NULL, cb, &n));
+ cl_assert(n == 2);
+
+ cl_git_pass(
+ git_config_rename_section(repo, "branch.foo", "branch.foobar"));
+
+ assert_config_entry_existence(repo, "branch.foo.name", false);
+ n = 0;
+ cl_git_pass(git_config_get_multivar_foreach(
+ cfg, "branch.foobar.name", NULL, cb, &n));
+ cl_assert(n == 2);
+
+ git_config_free(cfg);
+ cl_git_sandbox_cleanup();
+}
diff --git a/tests/libgit2/config/read.c b/tests/libgit2/config/read.c
index ac6459b9ea6..25e7b963c4d 100644
--- a/tests/libgit2/config/read.c
+++ b/tests/libgit2/config/read.c
@@ -495,6 +495,8 @@ void test_config_read__read_git_config_entry(void)
cl_assert_equal_s("core.dummy2", entry->name);
cl_assert_equal_s("42", entry->value);
cl_assert_equal_i(GIT_CONFIG_LEVEL_SYSTEM, entry->level);
+ cl_assert_equal_s("file", entry->backend_type);
+ cl_assert_equal_s(cl_fixture("config/config9"), entry->origin_path);
git_config_entry_free(entry);
git_config_free(cfg);
diff --git a/tests/libgit2/config/readonly.c b/tests/libgit2/config/readonly.c
index a8901e394c0..483f83a85fd 100644
--- a/tests/libgit2/config/readonly.c
+++ b/tests/libgit2/config/readonly.c
@@ -24,7 +24,7 @@ void test_config_readonly__writing_to_readonly_fails(void)
backend->readonly = 1;
cl_git_pass(git_config_add_backend(cfg, backend, GIT_CONFIG_LEVEL_GLOBAL, NULL, 0));
- cl_git_fail_with(GIT_ENOTFOUND, git_config_set_string(cfg, "foo.bar", "baz"));
+ cl_git_fail_with(GIT_EREADONLY, git_config_set_string(cfg, "foo.bar", "baz"));
cl_assert(!git_fs_path_exists("global"));
}
diff --git a/tests/libgit2/config/snapshot.c b/tests/libgit2/config/snapshot.c
index 5cc08a721ac..cc877063c08 100644
--- a/tests/libgit2/config/snapshot.c
+++ b/tests/libgit2/config/snapshot.c
@@ -79,6 +79,7 @@ void test_config_snapshot__multivar(void)
void test_config_snapshot__includes(void)
{
+ git_config_entry *entry;
int i;
cl_git_mkfile("including", "[include]\npath = included");
@@ -99,6 +100,16 @@ void test_config_snapshot__includes(void)
cl_git_pass(git_config_get_int32(&i, snapshot, "section.key"));
cl_assert_equal_i(i, 1);
+ /* Ensure that the config entry is populated with origin */
+ cl_git_pass(git_config_get_entry(&entry, snapshot, "section.key"));
+
+ cl_assert_equal_s("section.key", entry->name);
+ cl_assert_equal_s("1", entry->value);
+ cl_assert_equal_s("file", entry->backend_type);
+ cl_assert_equal_s("./included", entry->origin_path);
+
+ git_config_entry_free(entry);
+
cl_git_pass(p_unlink("including"));
cl_git_pass(p_unlink("included"));
}
@@ -106,6 +117,7 @@ void test_config_snapshot__includes(void)
void test_config_snapshot__snapshot(void)
{
git_config *snapshot_snapshot;
+ git_config_entry *entry;
int i;
cl_git_mkfile("configfile", "[section]\nkey = 1\n");
@@ -118,22 +130,49 @@ void test_config_snapshot__snapshot(void)
cl_git_pass(git_config_get_int32(&i, snapshot_snapshot, "section.key"));
cl_assert_equal_i(i, 1);
+ /* Ensure that the config entry is populated with origin */
+ cl_git_pass(git_config_get_entry(&entry, snapshot_snapshot, "section.key"));
+
+ cl_assert_equal_s("section.key", entry->name);
+ cl_assert_equal_s("1", entry->value);
+ cl_assert_equal_s("file", entry->backend_type);
+ cl_assert_equal_s("configfile", entry->origin_path);
+
+ git_config_entry_free(entry);
+
git_config_free(snapshot_snapshot);
cl_git_pass(p_unlink("configfile"));
}
-void test_config_snapshot__snapshot_from_in_memony(void)
+void test_config_snapshot__snapshot_from_in_memory(void)
{
const char *configuration = "[section]\nkey = 1\n";
git_config_backend *backend;
+ git_config_entry *entry;
int i;
+ git_config_backend_memory_options opts =
+ GIT_CONFIG_BACKEND_MEMORY_OPTIONS_INIT;
+
+ opts.backend_type = "test";
+ opts.origin_path = "hello";
+
cl_git_pass(git_config_new(&cfg));
- cl_git_pass(git_config_backend_from_string(&backend, configuration, strlen(configuration)));
+ cl_git_pass(git_config_backend_from_string(&backend, configuration, strlen(configuration), &opts));
cl_git_pass(git_config_add_backend(cfg, backend, 0, NULL, 0));
cl_git_pass(git_config_snapshot(&snapshot, cfg));
cl_git_pass(git_config_get_int32(&i, snapshot, "section.key"));
cl_assert_equal_i(i, 1);
+
+ /* Ensure that the config entry is populated with origin */
+ cl_git_pass(git_config_get_entry(&entry, snapshot, "section.key"));
+
+ cl_assert_equal_s("section.key", entry->name);
+ cl_assert_equal_s("1", entry->value);
+ cl_assert_equal_s("test", entry->backend_type);
+ cl_assert_equal_s("hello", entry->origin_path);
+
+ git_config_entry_free(entry);
}
diff --git a/tests/libgit2/config/write.c b/tests/libgit2/config/write.c
index 9d8c3fe9495..c71d4f6dc86 100644
--- a/tests/libgit2/config/write.c
+++ b/tests/libgit2/config/write.c
@@ -696,6 +696,36 @@ void test_config_write__locking(void)
git_config_free(cfg);
}
+void test_config_write__abort_lock(void)
+{
+ git_config *cfg;
+ git_config_entry *entry;
+ git_transaction *tx;
+ const char *filename = "locked-file";
+
+ /* Open the config and lock it */
+ cl_git_mkfile(filename, "[section]\n\tname = value\n");
+ cl_git_pass(git_config_open_ondisk(&cfg, filename));
+ cl_git_pass(git_config_get_entry(&entry, cfg, "section.name"));
+ cl_assert_equal_s("value", entry->value);
+ git_config_entry_free(entry);
+ cl_git_pass(git_config_lock(&tx, cfg));
+
+ /* Change entries in the locked backend */
+ cl_git_pass(git_config_set_string(cfg, "section.name", "other value"));
+ cl_git_pass(git_config_set_string(cfg, "section2.name3", "more value"));
+
+ git_transaction_free(tx);
+
+ /* Now that we've unlocked it, we should see no changes */
+ cl_git_pass(git_config_get_entry(&entry, cfg, "section.name"));
+ cl_assert_equal_s("value", entry->value);
+ git_config_entry_free(entry);
+ cl_git_fail_with(GIT_ENOTFOUND, git_config_get_entry(&entry, cfg, "section2.name3"));
+
+ git_config_free(cfg);
+}
+
void test_config_write__repeated(void)
{
const char *filename = "config-repeated";
diff --git a/tests/libgit2/core/features.c b/tests/libgit2/core/features.c
index 7b28cc0cb41..f8c6679c2fb 100644
--- a/tests/libgit2/core/features.c
+++ b/tests/libgit2/core/features.c
@@ -1,15 +1,8 @@
#include "clar_libgit2.h"
-void test_core_features__0(void)
+void test_core_features__basic(void)
{
- int major, minor, rev, caps;
-
- git_libgit2_version(&major, &minor, &rev);
- cl_assert_equal_i(LIBGIT2_VER_MAJOR, major);
- cl_assert_equal_i(LIBGIT2_VER_MINOR, minor);
- cl_assert_equal_i(LIBGIT2_VER_REVISION, rev);
-
- caps = git_libgit2_features();
+ int caps = git_libgit2_features();
#ifdef GIT_THREADS
cl_assert((caps & GIT_FEATURE_THREADS) != 0);
@@ -27,9 +20,217 @@ void test_core_features__0(void)
cl_assert((caps & GIT_FEATURE_SSH) == 0);
#endif
-#if defined(GIT_USE_NSEC)
+#if defined(GIT_NSEC)
cl_assert((caps & GIT_FEATURE_NSEC) != 0);
#else
cl_assert((caps & GIT_FEATURE_NSEC) == 0);
#endif
+
+ cl_assert((caps & GIT_FEATURE_HTTP_PARSER) != 0);
+ cl_assert((caps & GIT_FEATURE_REGEX) != 0);
+
+#if defined(GIT_I18N_ICONV)
+ cl_assert((caps & GIT_FEATURE_I18N) != 0);
+#endif
+
+#if defined(GIT_AUTH_NTLM)
+ cl_assert((caps & GIT_FEATURE_AUTH_NTLM) != 0);
+#endif
+#if defined(GIT_AUTH_NEGOTIATE)
+ cl_assert((caps & GIT_FEATURE_AUTH_NEGOTIATE) != 0);
+#endif
+
+ cl_assert((caps & GIT_FEATURE_COMPRESSION) != 0);
+ cl_assert((caps & GIT_FEATURE_SHA1) != 0);
+
+#if defined(GIT_EXPERIMENTAL_SHA256)
+ cl_assert((caps & GIT_FEATURE_SHA256) != 0);
+#endif
+
+ /*
+ * Ensure that our tests understand all the features;
+ * this test tries to ensure that if there's a new feature
+ * added that the backends test (below) is updated as well.
+ */
+ cl_assert((caps & ~(GIT_FEATURE_THREADS |
+ GIT_FEATURE_HTTPS |
+ GIT_FEATURE_SSH |
+ GIT_FEATURE_NSEC |
+ GIT_FEATURE_HTTP_PARSER |
+ GIT_FEATURE_REGEX |
+ GIT_FEATURE_I18N |
+ GIT_FEATURE_AUTH_NTLM |
+ GIT_FEATURE_AUTH_NEGOTIATE |
+ GIT_FEATURE_COMPRESSION |
+ GIT_FEATURE_SHA1 |
+ GIT_FEATURE_SHA256
+ )) == 0);
+}
+
+void test_core_features__backends(void)
+{
+ const char *threads = git_libgit2_feature_backend(GIT_FEATURE_THREADS);
+ const char *https = git_libgit2_feature_backend(GIT_FEATURE_HTTPS);
+ const char *ssh = git_libgit2_feature_backend(GIT_FEATURE_SSH);
+ const char *nsec = git_libgit2_feature_backend(GIT_FEATURE_NSEC);
+ const char *http_parser = git_libgit2_feature_backend(GIT_FEATURE_HTTP_PARSER);
+ const char *regex = git_libgit2_feature_backend(GIT_FEATURE_REGEX);
+ const char *i18n = git_libgit2_feature_backend(GIT_FEATURE_I18N);
+ const char *ntlm = git_libgit2_feature_backend(GIT_FEATURE_AUTH_NTLM);
+ const char *negotiate = git_libgit2_feature_backend(GIT_FEATURE_AUTH_NEGOTIATE);
+ const char *compression = git_libgit2_feature_backend(GIT_FEATURE_COMPRESSION);
+ const char *sha1 = git_libgit2_feature_backend(GIT_FEATURE_SHA1);
+ const char *sha256 = git_libgit2_feature_backend(GIT_FEATURE_SHA256);
+
+#if defined(GIT_THREADS_WIN32)
+ cl_assert_equal_s("win32", threads);
+#elif defined(GIT_THREADS_PTHREADS)
+ cl_assert_equal_s("pthread", threads);
+#elif defined(GIT_THREADS)
+ cl_assert(0);
+#else
+ cl_assert(threads == NULL);
+#endif
+
+#if defined(GIT_HTTPS_OPENSSL)
+ cl_assert_equal_s("openssl", https);
+#elif defined(GIT_HTTPS_OPENSSL_DYNAMIC)
+ cl_assert_equal_s("openssl-dynamic", https);
+#elif defined(GIT_HTTPS_MBEDTLS)
+ cl_assert_equal_s("mbedtls", https);
+#elif defined(GIT_HTTPS_SECURETRANSPORT)
+ cl_assert_equal_s("securetransport", https);
+#elif defined(GIT_HTTPS_SCHANNEL)
+ cl_assert_equal_s("schannel", https);
+#elif defined(GIT_HTTPS_WINHTTP)
+ cl_assert_equal_s("winhttp", https);
+#elif defined(GIT_HTTPS)
+ cl_assert(0);
+#else
+ cl_assert(https == NULL);
+#endif
+
+#if defined(GIT_SSH) && defined(GIT_SSH_EXEC)
+ cl_assert_equal_s("exec", ssh);
+#elif defined(GIT_SSH) && defined(GIT_SSH_LIBSSH2)
+ cl_assert_equal_s("libssh2", ssh);
+#elif defined(GIT_SSH)
+ cl_assert(0);
+#else
+ cl_assert(ssh == NULL);
+#endif
+
+#if defined(GIT_NSEC_MTIMESPEC)
+ cl_assert_equal_s("mtimespec", nsec);
+#elif defined(GIT_NSEC_MTIM)
+ cl_assert_equal_s("mtim", nsec);
+#elif defined(GIT_NSEC_MTIME_NSEC)
+ cl_assert_equal_s("mtime_nsec", nsec);
+#elif defined(GIT_NSEC_WIN32)
+ cl_assert_equal_s("win32", nsec);
+#elif defined(GIT_NSEC)
+ cl_assert(0);
+#else
+ cl_assert(nsec == NULL);
+#endif
+
+#if defined(GIT_HTTPPARSER_HTTPPARSER)
+ cl_assert_equal_s("httpparser", http_parser);
+#elif defined(GIT_HTTPPARSER_LLHTTP)
+ cl_assert_equal_s("llhttp", http_parser);
+#elif defined(GIT_HTTPPARSER_BUILTIN)
+ cl_assert_equal_s("builtin", http_parser);
+#else
+ cl_assert(0);
+#endif
+
+#if defined(GIT_REGEX_REGCOMP_L)
+ cl_assert_equal_s("regcomp_l", regex);
+#elif defined(GIT_REGEX_REGCOMP)
+ cl_assert_equal_s("regcomp", regex);
+#elif defined(GIT_REGEX_PCRE)
+ cl_assert_equal_s("pcre", regex);
+#elif defined(GIT_REGEX_PCRE2)
+ cl_assert_equal_s("pcre2", regex);
+#elif defined(GIT_REGEX_BUILTIN)
+ cl_assert_equal_s("builtin", regex);
+#else
+ cl_assert(0);
+#endif
+
+#if defined(GIT_I18N_ICONV)
+ cl_assert_equal_s("iconv", i18n);
+#elif defined(GIT_I18N)
+ cl_assert(0);
+#else
+ cl_assert(i18n == NULL);
+#endif
+
+#if defined(GIT_AUTH_NTLM_BUILTIN)
+ cl_assert_equal_s("builtin", ntlm);
+#elif defined(GIT_AUTH_NTLM_SSPI)
+ cl_assert_equal_s("sspi", ntlm);
+#elif defined(GIT_AUTH_NTLM)
+ cl_assert(0);
+#else
+ cl_assert(ntlm == NULL);
+#endif
+
+#if defined(GIT_AUTH_NEGOTIATE_GSSFRAMEWORK)
+ cl_assert_equal_s("gssframework", negotiate);
+#elif defined(GIT_AUTH_NEGOTIATE_GSSAPI)
+ cl_assert_equal_s("gssapi", negotiate);
+#elif defined(GIT_AUTH_NEGOTIATE_SSPI)
+ cl_assert_equal_s("sspi", negotiate);
+#elif defined(GIT_AUTH_NEGOTIATE)
+ cl_assert(0);
+#else
+ cl_assert(negotiate == NULL);
+#endif
+
+#if defined(GIT_COMPRESSION_BUILTIN)
+ cl_assert_equal_s("builtin", compression);
+#elif defined(GIT_COMPRESSION_ZLIB)
+ cl_assert_equal_s("zlib", compression);
+#else
+ cl_assert(0);
+#endif
+
+#if defined(GIT_SHA1_BUILTIN)
+ cl_assert_equal_s("builtin", sha1);
+#elif defined(GIT_SHA1_OPENSSL)
+ cl_assert_equal_s("openssl", sha1);
+#elif defined(GIT_SHA1_OPENSSL_FIPS)
+ cl_assert_equal_s("openssl-fips", sha1);
+#elif defined(GIT_SHA1_OPENSSL_DYNAMIC)
+ cl_assert_equal_s("openssl-dynamic", sha1);
+#elif defined(GIT_SHA1_MBEDTLS)
+ cl_assert_equal_s("mbedtls", sha1);
+#elif defined(GIT_SHA1_COMMON_CRYPTO)
+ cl_assert_equal_s("commoncrypto", sha1);
+#elif defined(GIT_SHA1_WIN32)
+ cl_assert_equal_s("win32", sha1);
+#else
+ cl_assert(0);
+#endif
+
+#if defined(GIT_EXPERIMENTAL_SHA256) && defined(GIT_SHA256_BUILTIN)
+ cl_assert_equal_s("builtin", sha256);
+#elif defined(GIT_EXPERIMENTAL_SHA256) && defined(GIT_SHA256_OPENSSL)
+ cl_assert_equal_s("openssl", sha256);
+#elif defined(GIT_EXPERIMENTAL_SHA256) && defined(GIT_SHA256_OPENSSL_FIPS)
+ cl_assert_equal_s("openssl-fips", sha256);
+#elif defined(GIT_EXPERIMENTAL_SHA256) && defined(GIT_SHA256_OPENSSL_DYNAMIC)
+ cl_assert_equal_s("openssl-dynamic", sha256);
+#elif defined(GIT_EXPERIMENTAL_SHA256) && defined(GIT_SHA256_MBEDTLS)
+ cl_assert_equal_s("mbedtls", sha256);
+#elif defined(GIT_EXPERIMENTAL_SHA256) && defined(GIT_SHA256_COMMON_CRYPTO)
+ cl_assert_equal_s("commoncrypto", sha256);
+#elif defined(GIT_EXPERIMENTAL_SHA256) && defined(GIT_SHA256_WIN32)
+ cl_assert_equal_s("win32", sha256);
+#elif defined(GIT_EXPERIMENTAL_SHA256)
+ cl_assert(0);
+#else
+ cl_assert(sha256 == NULL);
+#endif
}
diff --git a/tests/libgit2/core/oid.c b/tests/libgit2/core/oid.c
index a405b3344d7..3b20061cbfb 100644
--- a/tests/libgit2/core/oid.c
+++ b/tests/libgit2/core/oid.c
@@ -21,14 +21,14 @@ const char *str_oid_sha256_m = "d3e63d2f2e43d1fee23a74bf19a0ede156cba2d1bd602eba
void test_core_oid__initialize(void)
{
- cl_git_pass(git_oid__fromstr(&id_sha1, str_oid_sha1, GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstrp(&idp_sha1, str_oid_sha1_p, GIT_OID_SHA1));
- cl_git_fail(git_oid__fromstrp(&idm_sha1, str_oid_sha1_m, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id_sha1, str_oid_sha1, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&idp_sha1, str_oid_sha1_p, strlen(str_oid_sha1_p), GIT_OID_SHA1));
+ cl_git_fail(git_oid_from_prefix(&idm_sha1, str_oid_sha1_m, strlen(str_oid_sha1_m), GIT_OID_SHA1));
#ifdef GIT_EXPERIMENTAL_SHA256
- cl_git_pass(git_oid__fromstr(&id_sha256, str_oid_sha256, GIT_OID_SHA256));
- cl_git_pass(git_oid__fromstrp(&idp_sha256, str_oid_sha256_p, GIT_OID_SHA256));
- cl_git_fail(git_oid__fromstrp(&idm_sha256, str_oid_sha256_m, GIT_OID_SHA256));
+ cl_git_pass(git_oid_from_string(&id_sha256, str_oid_sha256, GIT_OID_SHA256));
+ cl_git_pass(git_oid_from_prefix(&idp_sha256, str_oid_sha256_p, strlen(str_oid_sha256_p), GIT_OID_SHA256));
+ cl_git_fail(git_oid_from_prefix(&idm_sha256, str_oid_sha256_m, strlen(str_oid_sha256_m), GIT_OID_SHA256));
#endif
}
diff --git a/tests/libgit2/core/oidarray.c b/tests/libgit2/core/oidarray.c
new file mode 100644
index 00000000000..6f607c85be0
--- /dev/null
+++ b/tests/libgit2/core/oidarray.c
@@ -0,0 +1,98 @@
+#include "clar_libgit2.h"
+
+#include "git2/oid.h"
+#include "git2/transport.h"
+
+#include "common.h"
+#include "transports/smart.h"
+#include "oid.h"
+#include "oidarray.h"
+
+#include <assert.h>
+
+#define oid_0 "c070ad8c08840c8116da865b2d65593a6bb9cd2a"
+#define oid_1 "0966a434eb1a025db6b71485ab63a3bfbea520b6"
+#define oid_2 "83834a7afdaa1a1260568567f6ad90020389f664"
+#define oid_3 "746fb4c91a7b6190bc4761adf7410afc4b59812c"
+
+void test_core_oidarray__add_and_remove_oid_from_shallowarray(void)
+{
+ git_oid oid_0_obj, oid_1_obj, oid_2_obj, oid_3_obj;
+ git_array_oid_t array = GIT_ARRAY_INIT;
+
+ git_oid_from_string(&oid_0_obj, oid_0, GIT_OID_SHA1);
+ git_oid_from_string(&oid_1_obj, oid_1, GIT_OID_SHA1);
+ git_oid_from_string(&oid_2_obj, oid_2, GIT_OID_SHA1);
+ git_oid_from_string(&oid_3_obj, oid_3, GIT_OID_SHA1);
+
+ /* add some initial ids */
+ git_oidarray__add(&array, &oid_0_obj);
+ git_oidarray__add(&array, &oid_1_obj);
+ git_oidarray__add(&array, &oid_2_obj);
+
+ cl_assert_equal_i(3, array.size);
+ cl_assert_equal_s("c070ad8c08840c8116da865b2d65593a6bb9cd2a", git_oid_tostr_s(&array.ptr[0]));
+ cl_assert_equal_s("0966a434eb1a025db6b71485ab63a3bfbea520b6", git_oid_tostr_s(&array.ptr[1]));
+ cl_assert_equal_s("83834a7afdaa1a1260568567f6ad90020389f664", git_oid_tostr_s(&array.ptr[2]));
+
+ /* don't duplicate existing ids */
+ git_oidarray__add(&array, &oid_1_obj);
+
+ cl_assert_equal_i(3, array.size);
+ cl_assert_equal_s("c070ad8c08840c8116da865b2d65593a6bb9cd2a", git_oid_tostr_s(&array.ptr[0]));
+ cl_assert_equal_s("0966a434eb1a025db6b71485ab63a3bfbea520b6", git_oid_tostr_s(&array.ptr[1]));
+ cl_assert_equal_s("83834a7afdaa1a1260568567f6ad90020389f664", git_oid_tostr_s(&array.ptr[2]));
+
+ /* remove the last id */
+ cl_assert_equal_i(1, git_oidarray__remove(&array, &oid_2_obj));
+
+ cl_assert_equal_i(2, array.size);
+ cl_assert_equal_s("c070ad8c08840c8116da865b2d65593a6bb9cd2a", git_oid_tostr_s(&array.ptr[0]));
+ cl_assert_equal_s("0966a434eb1a025db6b71485ab63a3bfbea520b6", git_oid_tostr_s(&array.ptr[1]));
+
+ /* add another id */
+ git_oidarray__add(&array, &oid_3_obj);
+
+ cl_assert_equal_i(3, array.size);
+ cl_assert_equal_s("c070ad8c08840c8116da865b2d65593a6bb9cd2a", git_oid_tostr_s(&array.ptr[0]));
+ cl_assert_equal_s("0966a434eb1a025db6b71485ab63a3bfbea520b6", git_oid_tostr_s(&array.ptr[1]));
+ cl_assert_equal_s("746fb4c91a7b6190bc4761adf7410afc4b59812c", git_oid_tostr_s(&array.ptr[2]));
+
+ /* remove the first id */
+ cl_assert_equal_i(1, git_oidarray__remove(&array, &oid_0_obj));
+
+ cl_assert_equal_i(2, array.size);
+ cl_assert_equal_s("0966a434eb1a025db6b71485ab63a3bfbea520b6", git_oid_tostr_s(&array.ptr[0]));
+ cl_assert_equal_s("746fb4c91a7b6190bc4761adf7410afc4b59812c", git_oid_tostr_s(&array.ptr[1]));
+
+ /* removing a nonexistent oid does nothing */
+ cl_assert_equal_i(0, git_oidarray__remove(&array, &oid_2_obj));
+
+ /* add another id */
+ git_oidarray__add(&array, &oid_0_obj);
+
+ cl_assert_equal_i(3, array.size);
+ cl_assert_equal_s("0966a434eb1a025db6b71485ab63a3bfbea520b6", git_oid_tostr_s(&array.ptr[0]));
+ cl_assert_equal_s("746fb4c91a7b6190bc4761adf7410afc4b59812c", git_oid_tostr_s(&array.ptr[1]));
+ cl_assert_equal_s("c070ad8c08840c8116da865b2d65593a6bb9cd2a", git_oid_tostr_s(&array.ptr[2]));
+
+ /* remove another id */
+ cl_assert_equal_i(1, git_oidarray__remove(&array, &oid_3_obj));
+
+ cl_assert_equal_i(2, array.size);
+ cl_assert_equal_s("0966a434eb1a025db6b71485ab63a3bfbea520b6", git_oid_tostr_s(&array.ptr[0]));
+ cl_assert_equal_s("c070ad8c08840c8116da865b2d65593a6bb9cd2a", git_oid_tostr_s(&array.ptr[1]));
+
+ /* remove another id */
+ cl_assert_equal_i(1, git_oidarray__remove(&array, &oid_1_obj));
+
+ cl_assert_equal_i(1, array.size);
+ cl_assert_equal_s("c070ad8c08840c8116da865b2d65593a6bb9cd2a", git_oid_tostr_s(&array.ptr[0]));
+
+ /* remove the final id */
+ cl_assert_equal_i(1, git_oidarray__remove(&array, &oid_0_obj));
+
+ cl_assert_equal_i(0, array.size);
+
+ git_array_clear(array);
+}
diff --git a/tests/libgit2/core/oidmap.c b/tests/libgit2/core/oidmap.c
deleted file mode 100644
index 34374ceefa4..00000000000
--- a/tests/libgit2/core/oidmap.c
+++ /dev/null
@@ -1,130 +0,0 @@
-#include "clar_libgit2.h"
-#include "oidmap.h"
-
-static struct {
- git_oid oid;
- size_t extra;
-} test_oids[0x0FFF];
-
-static git_oidmap *g_map;
-
-void test_core_oidmap__initialize(void)
-{
- uint32_t i, j;
- for (i = 0; i < ARRAY_SIZE(test_oids); ++i) {
- uint32_t segment = i / 8;
- int modi = i - (segment * 8);
-
- test_oids[i].extra = i;
-
- for (j = 0; j < GIT_OID_SHA1_SIZE / 4; ++j) {
- test_oids[i].oid.id[j * 4 ] = (unsigned char)modi;
- test_oids[i].oid.id[j * 4 + 1] = (unsigned char)(modi >> 8);
- test_oids[i].oid.id[j * 4 + 2] = (unsigned char)(modi >> 16);
- test_oids[i].oid.id[j * 4 + 3] = (unsigned char)(modi >> 24);
- }
-
- test_oids[i].oid.id[ 8] = (unsigned char)i;
- test_oids[i].oid.id[ 9] = (unsigned char)(i >> 8);
- test_oids[i].oid.id[10] = (unsigned char)(i >> 16);
- test_oids[i].oid.id[11] = (unsigned char)(i >> 24);
-#ifdef GIT_EXPERIMENTAL_SHA256
- test_oids[i].oid.type = GIT_OID_SHA1;
-#endif
- }
-
- cl_git_pass(git_oidmap_new(&g_map));
-}
-
-void test_core_oidmap__cleanup(void)
-{
- git_oidmap_free(g_map);
-}
-
-void test_core_oidmap__basic(void)
-{
- size_t i;
-
- for (i = 0; i < ARRAY_SIZE(test_oids); ++i) {
- cl_assert(!git_oidmap_exists(g_map, &test_oids[i].oid));
- cl_git_pass(git_oidmap_set(g_map, &test_oids[i].oid, &test_oids[i]));
- }
-
- for (i = 0; i < ARRAY_SIZE(test_oids); ++i) {
- cl_assert(git_oidmap_exists(g_map, &test_oids[i].oid));
- cl_assert_equal_p(git_oidmap_get(g_map, &test_oids[i].oid), &test_oids[i]);
- }
-}
-
-void test_core_oidmap__hash_collision(void)
-{
- size_t i;
-
- for (i = 0; i < ARRAY_SIZE(test_oids); ++i) {
- cl_assert(!git_oidmap_exists(g_map, &test_oids[i].oid));
- cl_git_pass(git_oidmap_set(g_map, &test_oids[i].oid, &test_oids[i]));
- }
-
- for (i = 0; i < ARRAY_SIZE(test_oids); ++i) {
- cl_assert(git_oidmap_exists(g_map, &test_oids[i].oid));
- cl_assert_equal_p(git_oidmap_get(g_map, &test_oids[i].oid), &test_oids[i]);
- }
-}
-
-void test_core_oidmap__get_succeeds_with_existing_keys(void)
-{
- size_t i;
-
- for (i = 0; i < ARRAY_SIZE(test_oids); ++i)
- cl_git_pass(git_oidmap_set(g_map, &test_oids[i].oid, &test_oids[i]));
-
- for (i = 0; i < ARRAY_SIZE(test_oids); ++i)
- cl_assert_equal_p(git_oidmap_get(g_map, &test_oids[i].oid), &test_oids[i]);
-}
-
-void test_core_oidmap__get_fails_with_nonexisting_key(void)
-{
- size_t i;
-
- /* Do _not_ add last OID to verify that we cannot look it up */
- for (i = 0; i < ARRAY_SIZE(test_oids) - 1; ++i)
- cl_git_pass(git_oidmap_set(g_map, &test_oids[i].oid, &test_oids[i]));
-
- cl_assert_equal_p(git_oidmap_get(g_map, &test_oids[ARRAY_SIZE(test_oids) - 1].oid), NULL);
-}
-
-void test_core_oidmap__setting_oid_persists(void)
-{
- git_oid oids[] = {
- GIT_OID_INIT(GIT_OID_SHA1, { 0x01 }),
- GIT_OID_INIT(GIT_OID_SHA1, { 0x02 }),
- GIT_OID_INIT(GIT_OID_SHA1, { 0x03 })
- };
-
- cl_git_pass(git_oidmap_set(g_map, &oids[0], "one"));
- cl_git_pass(git_oidmap_set(g_map, &oids[1], "two"));
- cl_git_pass(git_oidmap_set(g_map, &oids[2], "three"));
-
- cl_assert_equal_s(git_oidmap_get(g_map, &oids[0]), "one");
- cl_assert_equal_s(git_oidmap_get(g_map, &oids[1]), "two");
- cl_assert_equal_s(git_oidmap_get(g_map, &oids[2]), "three");
-}
-
-void test_core_oidmap__setting_existing_key_updates(void)
-{
- git_oid oids[] = {
- GIT_OID_INIT(GIT_OID_SHA1, { 0x01 }),
- GIT_OID_INIT(GIT_OID_SHA1, { 0x02 }),
- GIT_OID_INIT(GIT_OID_SHA1, { 0x03 })
- };
-
- cl_git_pass(git_oidmap_set(g_map, &oids[0], "one"));
- cl_git_pass(git_oidmap_set(g_map, &oids[1], "two"));
- cl_git_pass(git_oidmap_set(g_map, &oids[2], "three"));
- cl_assert_equal_i(git_oidmap_size(g_map), 3);
-
- cl_git_pass(git_oidmap_set(g_map, &oids[1], "other"));
- cl_assert_equal_i(git_oidmap_size(g_map), 3);
-
- cl_assert_equal_s(git_oidmap_get(g_map, &oids[1]), "other");
-}
diff --git a/tests/libgit2/core/opts.c b/tests/libgit2/core/opts.c
index 486ff58c6e7..1580fb2f5dc 100644
--- a/tests/libgit2/core/opts.c
+++ b/tests/libgit2/core/opts.c
@@ -34,9 +34,11 @@ void test_core_opts__extensions_query(void)
cl_git_pass(git_libgit2_opts(GIT_OPT_GET_EXTENSIONS, &out));
- cl_assert_equal_sz(out.count, 2);
+ cl_assert_equal_sz(out.count, 4);
cl_assert_equal_s("noop", out.strings[0]);
cl_assert_equal_s("objectformat", out.strings[1]);
+ cl_assert_equal_s("preciousobjects", out.strings[2]);
+ cl_assert_equal_s("worktreeconfig", out.strings[3]);
git_strarray_dispose(&out);
}
@@ -49,10 +51,12 @@ void test_core_opts__extensions_add(void)
cl_git_pass(git_libgit2_opts(GIT_OPT_SET_EXTENSIONS, in, ARRAY_SIZE(in)));
cl_git_pass(git_libgit2_opts(GIT_OPT_GET_EXTENSIONS, &out));
- cl_assert_equal_sz(out.count, 3);
- cl_assert_equal_s("noop", out.strings[0]);
- cl_assert_equal_s("objectformat", out.strings[1]);
- cl_assert_equal_s("foo", out.strings[2]);
+ cl_assert_equal_sz(out.count, 5);
+ cl_assert_equal_s("foo", out.strings[0]);
+ cl_assert_equal_s("noop", out.strings[1]);
+ cl_assert_equal_s("objectformat", out.strings[2]);
+ cl_assert_equal_s("preciousobjects", out.strings[3]);
+ cl_assert_equal_s("worktreeconfig", out.strings[4]);
git_strarray_dispose(&out);
}
@@ -65,10 +69,31 @@ void test_core_opts__extensions_remove(void)
cl_git_pass(git_libgit2_opts(GIT_OPT_SET_EXTENSIONS, in, ARRAY_SIZE(in)));
cl_git_pass(git_libgit2_opts(GIT_OPT_GET_EXTENSIONS, &out));
- cl_assert_equal_sz(out.count, 3);
- cl_assert_equal_s("objectformat", out.strings[0]);
- cl_assert_equal_s("bar", out.strings[1]);
- cl_assert_equal_s("baz", out.strings[2]);
+ cl_assert_equal_sz(out.count, 5);
+ cl_assert_equal_s("bar", out.strings[0]);
+ cl_assert_equal_s("baz", out.strings[1]);
+ cl_assert_equal_s("objectformat", out.strings[2]);
+ cl_assert_equal_s("preciousobjects", out.strings[3]);
+ cl_assert_equal_s("worktreeconfig", out.strings[4]);
+
+ git_strarray_dispose(&out);
+}
+
+void test_core_opts__extensions_uniq(void)
+{
+ const char *in[] = { "foo", "noop", "bar", "bar", "foo", "objectformat" };
+ git_strarray out = { 0 };
+
+ cl_git_pass(git_libgit2_opts(GIT_OPT_SET_EXTENSIONS, in, ARRAY_SIZE(in)));
+ cl_git_pass(git_libgit2_opts(GIT_OPT_GET_EXTENSIONS, &out));
+
+ cl_assert_equal_sz(out.count, 6);
+ cl_assert_equal_s("bar", out.strings[0]);
+ cl_assert_equal_s("foo", out.strings[1]);
+ cl_assert_equal_s("noop", out.strings[2]);
+ cl_assert_equal_s("objectformat", out.strings[3]);
+ cl_assert_equal_s("preciousobjects", out.strings[4]);
+ cl_assert_equal_s("worktreeconfig", out.strings[5]);
git_strarray_dispose(&out);
}
diff --git a/tests/libgit2/core/pool.c b/tests/libgit2/core/pool.c
index cf01cb9d182..83332f2d08d 100644
--- a/tests/libgit2/core/pool.c
+++ b/tests/libgit2/core/pool.c
@@ -22,7 +22,7 @@ void test_core_pool__oid(void)
for (j = 0; j < 8; j++)
oid_hex[j] = to_hex[(i >> (4 * j)) & 0x0f];
- cl_git_pass(git_oid__fromstr(oid, oid_hex, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(oid, oid_hex, GIT_OID_SHA1_HEXSIZE, GIT_OID_SHA1));
}
#ifndef GIT_DEBUG_POOL
diff --git a/tests/libgit2/core/useragent.c b/tests/libgit2/core/useragent.c
index a4ece902fd9..2e119de4490 100644
--- a/tests/libgit2/core/useragent.c
+++ b/tests/libgit2/core/useragent.c
@@ -1,17 +1,52 @@
#include "clar_libgit2.h"
#include "settings.h"
-void test_core_useragent__get(void)
+static git_buf default_ua = GIT_BUF_INIT;
+static git_buf default_product = GIT_BUF_INIT;
+
+void test_core_useragent__initialize(void)
+{
+ cl_git_pass(git_libgit2_opts(GIT_OPT_GET_USER_AGENT, &default_ua));
+ cl_git_pass(git_libgit2_opts(GIT_OPT_GET_USER_AGENT_PRODUCT, &default_product));
+}
+
+void test_core_useragent__cleanup(void)
+{
+ git_libgit2_opts(GIT_OPT_SET_USER_AGENT, NULL);
+ git_libgit2_opts(GIT_OPT_SET_USER_AGENT_PRODUCT, NULL);
+
+ git_buf_dispose(&default_ua);
+ git_buf_dispose(&default_product);
+}
+
+void test_core_useragent__get_default(void)
+{
+ cl_assert(default_ua.size);
+ cl_assert(default_ua.ptr);
+ cl_assert(git__prefixcmp(default_ua.ptr, "libgit2 ") == 0);
+
+ cl_assert(default_product.size);
+ cl_assert(default_product.ptr);
+ cl_assert(git__prefixcmp(default_product.ptr, "git/") == 0);
+}
+
+void test_core_useragent__set(void)
{
- const char *custom_name = "super duper git";
- git_str buf = GIT_STR_INIT;
+ cl_git_pass(git_libgit2_opts(GIT_OPT_SET_USER_AGENT, "foo bar 4.24"));
+ cl_assert_equal_s("foo bar 4.24", git_settings__user_agent());
+ cl_assert_equal_s(default_product.ptr, git_settings__user_agent_product());
- cl_assert_equal_p(NULL, git_libgit2__user_agent());
- cl_git_pass(git_libgit2_opts(GIT_OPT_SET_USER_AGENT, custom_name));
- cl_assert_equal_s(custom_name, git_libgit2__user_agent());
+ cl_git_pass(git_libgit2_opts(GIT_OPT_SET_USER_AGENT_PRODUCT, "baz/2.2.3"));
+ cl_assert_equal_s("foo bar 4.24", git_settings__user_agent());
+ cl_assert_equal_s("baz/2.2.3", git_settings__user_agent_product());
- cl_git_pass(git_libgit2_opts(GIT_OPT_GET_USER_AGENT, &buf));
- cl_assert_equal_s(custom_name, buf.ptr);
+ cl_git_pass(git_libgit2_opts(GIT_OPT_SET_USER_AGENT, ""));
+ cl_git_pass(git_libgit2_opts(GIT_OPT_SET_USER_AGENT_PRODUCT, ""));
+ cl_assert_equal_s("", git_settings__user_agent());
+ cl_assert_equal_s("", git_settings__user_agent_product());
- git_str_dispose(&buf);
+ cl_git_pass(git_libgit2_opts(GIT_OPT_SET_USER_AGENT, NULL));
+ cl_git_pass(git_libgit2_opts(GIT_OPT_SET_USER_AGENT_PRODUCT, NULL));
+ cl_assert_equal_s(default_ua.ptr, git_settings__user_agent());
+ cl_assert_equal_s(default_product.ptr, git_settings__user_agent_product());
}
diff --git a/tests/libgit2/core/version.c b/tests/libgit2/core/version.c
new file mode 100644
index 00000000000..9fd375c69b8
--- /dev/null
+++ b/tests/libgit2/core/version.c
@@ -0,0 +1,22 @@
+#include "clar_libgit2.h"
+
+void test_core_version__query(void)
+{
+ int major, minor, rev;
+
+ git_libgit2_version(&major, &minor, &rev);
+ cl_assert_equal_i(LIBGIT2_VERSION_MAJOR, major);
+ cl_assert_equal_i(LIBGIT2_VERSION_MINOR, minor);
+ cl_assert_equal_i(LIBGIT2_VERSION_REVISION, rev);
+}
+
+void test_core_version__check(void)
+{
+#if !LIBGIT2_VERSION_CHECK(1,6,3)
+ cl_fail("version check");
+#endif
+
+#if LIBGIT2_VERSION_CHECK(99,99,99)
+ cl_fail("version check");
+#endif
+}
diff --git a/tests/libgit2/date/date.c b/tests/libgit2/date/date.c
index 82b5c67282e..b5796861ce4 100644
--- a/tests/libgit2/date/date.c
+++ b/tests/libgit2/date/date.c
@@ -20,3 +20,11 @@ void test_date_date__invalid_date(void)
cl_git_fail(git_date_parse(&d, ""));
cl_git_fail(git_date_parse(&d, "NEITHER_INTEGER_NOR_DATETIME"));
}
+
+void test_date_date__offset(void)
+{
+ git_time_t d;
+ int offset;
+ cl_git_pass(git_date_offset_parse(&d, &offset, "1970-1-1 01:00:00+03"));
+ cl_assert_equal_i(offset, 3*60);
+}
diff --git a/tests/libgit2/diff/binary.c b/tests/libgit2/diff/binary.c
index 3bf39f34ad7..11061788d68 100644
--- a/tests/libgit2/diff/binary.c
+++ b/tests/libgit2/diff/binary.c
@@ -31,12 +31,12 @@ static void test_patch(
git_patch *patch;
git_buf actual = GIT_BUF_INIT;
- cl_git_pass(git_oid__fromstr(&id_one, one, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id_one, one, GIT_OID_SHA1));
cl_git_pass(git_commit_lookup(&commit_one, repo, &id_one));
cl_git_pass(git_commit_tree(&tree_one, commit_one));
if (two) {
- cl_git_pass(git_oid__fromstr(&id_two, two, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id_two, two, GIT_OID_SHA1));
cl_git_pass(git_commit_lookup(&commit_two, repo, &id_two));
cl_git_pass(git_commit_tree(&tree_two, commit_two));
} else {
@@ -289,7 +289,7 @@ void test_diff_binary__empty_for_no_diff(void)
repo = cl_git_sandbox_init("renames");
- cl_git_pass(git_oid__fromstr(&id, "19dd32dfb1520a64e5bbaae8dce6ef423dfa2f13", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, "19dd32dfb1520a64e5bbaae8dce6ef423dfa2f13", GIT_OID_SHA1));
cl_git_pass(git_commit_lookup(&commit, repo, &id));
cl_git_pass(git_commit_tree(&tree, commit));
@@ -510,8 +510,8 @@ void test_diff_binary__blob_to_blob(void)
cl_git_pass(git_index_add_bypath(index, "untimely.txt"));
cl_git_pass(git_index_write(index));
- git_oid__fromstr(&old_id, "9a69d960ae94b060f56c2a8702545e2bb1abb935", GIT_OID_SHA1);
- git_oid__fromstr(&new_id, "1111d4f11f4b35bf6759e0fb714fe09731ef0840", GIT_OID_SHA1);
+ git_oid_from_string(&old_id, "9a69d960ae94b060f56c2a8702545e2bb1abb935", GIT_OID_SHA1);
+ git_oid_from_string(&new_id, "1111d4f11f4b35bf6759e0fb714fe09731ef0840", GIT_OID_SHA1);
cl_git_pass(git_blob_lookup(&old_blob, repo, &old_id));
cl_git_pass(git_blob_lookup(&new_blob, repo, &new_id));
diff --git a/tests/libgit2/diff/blob.c b/tests/libgit2/diff/blob.c
index cb7e48b8d7d..235407512e1 100644
--- a/tests/libgit2/diff/blob.c
+++ b/tests/libgit2/diff/blob.c
@@ -45,11 +45,11 @@ void test_diff_blob__initialize(void)
memset(&expected, 0, sizeof(expected));
/* tests/resources/attr/root_test4.txt */
- cl_git_pass(git_oid__fromstrn(&oid, "a0f7217a", 8, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&oid, "a0f7217a", 8, GIT_OID_SHA1));
cl_git_pass(git_blob_lookup_prefix(&d, g_repo, &oid, 8));
/* alien.png */
- cl_git_pass(git_oid__fromstrn(&oid, "edf3dcee", 8, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&oid, "edf3dcee", 8, GIT_OID_SHA1));
cl_git_pass(git_blob_lookup_prefix(&alien, g_repo, &oid, 8));
}
@@ -86,10 +86,10 @@ void test_diff_blob__patch_with_freed_blobs(void)
git_buf buf = GIT_BUF_INIT;
/* tests/resources/attr/root_test1 */
- cl_git_pass(git_oid__fromstrn(&a_oid, "45141a79", 8, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&a_oid, "45141a79", 8, GIT_OID_SHA1));
cl_git_pass(git_blob_lookup_prefix(&a, g_repo, &a_oid, 4));
/* tests/resources/attr/root_test2 */
- cl_git_pass(git_oid__fromstrn(&b_oid, "4d713dc4", 8, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&b_oid, "4d713dc4", 8, GIT_OID_SHA1));
cl_git_pass(git_blob_lookup_prefix(&b, g_repo, &b_oid, 4));
cl_git_pass(git_patch_from_blobs(&p, a, NULL, b, NULL, NULL));
@@ -110,15 +110,15 @@ void test_diff_blob__can_compare_text_blobs(void)
git_oid a_oid, b_oid, c_oid;
/* tests/resources/attr/root_test1 */
- cl_git_pass(git_oid__fromstrn(&a_oid, "45141a79", 8, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&a_oid, "45141a79", 8, GIT_OID_SHA1));
cl_git_pass(git_blob_lookup_prefix(&a, g_repo, &a_oid, 4));
/* tests/resources/attr/root_test2 */
- cl_git_pass(git_oid__fromstrn(&b_oid, "4d713dc4", 8, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&b_oid, "4d713dc4", 8, GIT_OID_SHA1));
cl_git_pass(git_blob_lookup_prefix(&b, g_repo, &b_oid, 4));
/* tests/resources/attr/root_test3 */
- cl_git_pass(git_oid__fromstrn(&c_oid, "c96bbb2c2557a832", 16, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&c_oid, "c96bbb2c2557a832", 16, GIT_OID_SHA1));
cl_git_pass(git_blob_lookup_prefix(&c, g_repo, &c_oid, 16));
/* Doing the equivalent of a `git diff -U1` on these files */
@@ -201,15 +201,15 @@ void test_diff_blob__can_compare_text_blobs_with_patch(void)
git_patch *p;
/* tests/resources/attr/root_test1 */
- cl_git_pass(git_oid__fromstrn(&a_oid, "45141a79", 8, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&a_oid, "45141a79", 8, GIT_OID_SHA1));
cl_git_pass(git_blob_lookup_prefix(&a, g_repo, &a_oid, 8));
/* tests/resources/attr/root_test2 */
- cl_git_pass(git_oid__fromstrn(&b_oid, "4d713dc4", 8, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&b_oid, "4d713dc4", 8, GIT_OID_SHA1));
cl_git_pass(git_blob_lookup_prefix(&b, g_repo, &b_oid, 8));
/* tests/resources/attr/root_test3 */
- cl_git_pass(git_oid__fromstrn(&c_oid, "c96bbb2c2557a832", 16, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&c_oid, "c96bbb2c2557a832", 16, GIT_OID_SHA1));
cl_git_pass(git_blob_lookup_prefix(&c, g_repo, &c_oid, 16));
/* Doing the equivalent of a `git diff -U1` on these files */
@@ -475,7 +475,7 @@ void test_diff_blob__can_compare_two_binary_blobs(void)
git_oid h_oid;
/* heart.png */
- cl_git_pass(git_oid__fromstrn(&h_oid, "de863bff", 8, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&h_oid, "de863bff", 8, GIT_OID_SHA1));
cl_git_pass(git_blob_lookup_prefix(&heart, g_repo, &h_oid, 8));
cl_git_pass(git_diff_blobs(
@@ -543,7 +543,7 @@ void test_diff_blob__comparing_two_text_blobs_honors_interhunkcontext(void)
opts.context_lines = 3;
/* tests/resources/attr/root_test1 from commit f5b0af1 */
- cl_git_pass(git_oid__fromstrn(&old_d_oid, "fe773770", 8, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&old_d_oid, "fe773770", 8, GIT_OID_SHA1));
cl_git_pass(git_blob_lookup_prefix(&old_d, g_repo, &old_d_oid, 8));
/* Test with default inter-hunk-context (not set) => default is 0 */
@@ -652,7 +652,7 @@ void test_diff_blob__can_compare_blob_to_buffer(void)
const char *b_content = "Hello from the root\n\nSome additional lines\n\nDown here below\n\n";
/* tests/resources/attr/root_test1 */
- cl_git_pass(git_oid__fromstrn(&a_oid, "45141a79", 8, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&a_oid, "45141a79", 8, GIT_OID_SHA1));
cl_git_pass(git_blob_lookup_prefix(&a, g_repo, &a_oid, 8));
/* diff from blob a to content of b */
@@ -694,7 +694,7 @@ void test_diff_blob__can_compare_blob_to_buffer_with_patch(void)
size_t tc, ta, td;
/* tests/resources/attr/root_test1 */
- cl_git_pass(git_oid__fromstrn(&a_oid, "45141a79", 8, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&a_oid, "45141a79", 8, GIT_OID_SHA1));
cl_git_pass(git_blob_lookup_prefix(&a, g_repo, &a_oid, 8));
/* diff from blob a to content of b */
@@ -773,10 +773,10 @@ void test_diff_blob__binary_data_comparisons(void)
opts.flags |= GIT_DIFF_INCLUDE_UNMODIFIED;
- cl_git_pass(git_oid__fromstrn(&oid, "45141a79", 8, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&oid, "45141a79", 8, GIT_OID_SHA1));
cl_git_pass(git_blob_lookup_prefix(&nonbin, g_repo, &oid, 8));
- cl_git_pass(git_oid__fromstrn(&oid, "b435cd56", 8, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&oid, "b435cd56", 8, GIT_OID_SHA1));
cl_git_pass(git_blob_lookup_prefix(&bin, g_repo, &oid, 8));
/* non-binary to reference content */
@@ -879,11 +879,11 @@ void test_diff_blob__using_path_and_attributes(void)
opts.context_lines = 0;
opts.flags |= GIT_DIFF_INCLUDE_UNMODIFIED;
- cl_git_pass(git_oid__fromstrn(&oid, "45141a79", 8, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&oid, "45141a79", 8, GIT_OID_SHA1));
cl_git_pass(git_blob_lookup_prefix(&nonbin, g_repo, &oid, 8));
/* 20b: "Hello from the root\n" */
- cl_git_pass(git_oid__fromstrn(&oid, "b435cd56", 8, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&oid, "b435cd56", 8, GIT_OID_SHA1));
cl_git_pass(git_blob_lookup_prefix(&bin, g_repo, &oid, 8));
/* 33b: "0123456789\n\x01\x02\x03\x04\x05\x06\x07\x08\x09\n0123456789\n" */
diff --git a/tests/libgit2/diff/diff_helpers.c b/tests/libgit2/diff/diff_helpers.c
index 341b0a448a3..79148f42c95 100644
--- a/tests/libgit2/diff/diff_helpers.c
+++ b/tests/libgit2/diff/diff_helpers.c
@@ -11,7 +11,7 @@ git_tree *resolve_commit_oid_to_tree(
git_object *obj = NULL;
git_tree *tree = NULL;
- if (git_oid__fromstrn(&oid, partial_oid, len, GIT_OID_SHA1) == 0)
+ if (git_oid_from_prefix(&oid, partial_oid, len, GIT_OID_SHA1) == 0)
cl_git_pass(git_object_lookup_prefix(&obj, repo, &oid, len, GIT_OBJECT_ANY));
cl_git_pass(git_object_peel((git_object **) &tree, obj, GIT_OBJECT_TREE));
@@ -314,3 +314,10 @@ void diff_assert_equal(git_diff *a, git_diff *b)
}
}
+int diff_from_buffer(
+ git_diff **out,
+ const char *content,
+ size_t content_len)
+{
+ return git_diff_from_buffer(out, content, content_len);
+}
diff --git a/tests/libgit2/diff/diff_helpers.h b/tests/libgit2/diff/diff_helpers.h
index af855ce684f..1be4b47801c 100644
--- a/tests/libgit2/diff/diff_helpers.h
+++ b/tests/libgit2/diff/diff_helpers.h
@@ -71,3 +71,7 @@ extern void diff_print_raw(FILE *fp, git_diff *diff);
extern void diff_assert_equal(git_diff *a, git_diff *b);
+extern int diff_from_buffer(
+ git_diff **out,
+ const char *content,
+ size_t content_len);
diff --git a/tests/libgit2/diff/drivers.c b/tests/libgit2/diff/drivers.c
index 304a54b56dc..0dc2879800b 100644
--- a/tests/libgit2/diff/drivers.c
+++ b/tests/libgit2/diff/drivers.c
@@ -249,7 +249,7 @@ void test_diff_drivers__builtins(void)
git_buf_dispose(&actual);
git_str_dispose(&file);
git_str_dispose(&expected);
- git_vector_free(&files);
+ git_vector_dispose(&files);
}
void test_diff_drivers__invalid_pattern(void)
diff --git a/tests/libgit2/diff/format_email.c b/tests/libgit2/diff/format_email.c
index 2726edb0ddd..614fcbc114c 100644
--- a/tests/libgit2/diff/format_email.c
+++ b/tests/libgit2/diff/format_email.c
@@ -28,7 +28,7 @@ static void assert_email_match(
git_diff *diff = NULL;
git_buf buf = GIT_BUF_INIT;
- git_oid__fromstr(&oid, oidstr, GIT_OID_SHA1);
+ git_oid_from_string(&oid, oidstr, GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, repo, &oid));
@@ -228,7 +228,7 @@ void test_diff_format_email__multiple(void)
"\n";
- git_oid__fromstr(&oid, "10808fe9c9be5a190c0ba68d1a002233fb363508", GIT_OID_SHA1);
+ git_oid_from_string(&oid, "10808fe9c9be5a190c0ba68d1a002233fb363508", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, repo, &oid));
opts.id = git_commit_id(commit);
@@ -245,7 +245,7 @@ void test_diff_format_email__multiple(void)
diff = NULL;
commit = NULL;
- git_oid__fromstr(&oid, "873806f6f27e631eb0b23e4b56bea2bfac14a373", GIT_OID_SHA1);
+ git_oid_from_string(&oid, "873806f6f27e631eb0b23e4b56bea2bfac14a373", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, repo, &oid));
opts.id = git_commit_id(commit);
@@ -324,7 +324,7 @@ void test_diff_format_email__invalid_no(void)
git_diff_format_email_options opts = GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT;
git_buf buf = GIT_BUF_INIT;
- git_oid__fromstr(&oid, "9264b96c6d104d0e07ae33d3007b6a48246c6f92", GIT_OID_SHA1);
+ git_oid_from_string(&oid, "9264b96c6d104d0e07ae33d3007b6a48246c6f92", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, repo, &oid));
diff --git a/tests/libgit2/diff/header.c b/tests/libgit2/diff/header.c
new file mode 100644
index 00000000000..b5b73698c32
--- /dev/null
+++ b/tests/libgit2/diff/header.c
@@ -0,0 +1,69 @@
+#include "clar_libgit2.h"
+#include "git2/sys/repository.h"
+
+#include "diff_helpers.h"
+#include "diff.h"
+#include "repository.h"
+
+static git_repository *g_repo = NULL;
+
+void test_diff_header__initialize(void)
+{
+}
+
+void test_diff_header__cleanup(void)
+{
+ cl_git_sandbox_cleanup();
+}
+
+#define EXPECTED_HEADER "diff --git a/subdir.txt b/subdir.txt\n" \
+ "deleted file mode 100644\n" \
+ "index e8ee89e..0000000\n" \
+ "--- a/subdir.txt\n" \
+ "+++ /dev/null\n"
+
+static int check_header_cb(
+ const git_diff_delta *delta,
+ const git_diff_hunk *hunk,
+ const git_diff_line *line,
+ void *payload)
+{
+ int *counter = (int *) payload;
+
+ GIT_UNUSED(delta);
+
+ switch (line->origin) {
+ case GIT_DIFF_LINE_FILE_HDR:
+ cl_assert(hunk == NULL);
+ (*counter)++;
+ break;
+ default:
+ /* unexpected code path */
+ return -1;
+ }
+
+ return 0;
+}
+
+void test_diff_header__can_print_just_headers(void)
+{
+ const char *one_sha = "26a125e";
+ git_tree *one;
+ git_diff *diff;
+ int counter = 0;
+
+ g_repo = cl_git_sandbox_init("status");
+
+ one = resolve_commit_oid_to_tree(g_repo, one_sha);
+
+ cl_git_pass(git_diff_tree_to_index(&diff, g_repo, one, NULL, NULL));
+
+ cl_git_pass(git_diff_print(
+ diff, GIT_DIFF_FORMAT_PATCH_HEADER, check_header_cb, &counter));
+
+ cl_assert_equal_i(8, counter);
+
+ git_diff_free(diff);
+
+ git_tree_free(one);
+}
diff --git a/tests/libgit2/diff/index.c b/tests/libgit2/diff/index.c
index 5773b748e10..de2280070f6 100644
--- a/tests/libgit2/diff/index.c
+++ b/tests/libgit2/diff/index.c
@@ -1,5 +1,6 @@
#include "clar_libgit2.h"
#include "diff_helpers.h"
+#include "index.h"
static git_repository *g_repo = NULL;
@@ -185,9 +186,9 @@ static void do_conflicted_diff(diff_expects *exp, unsigned long flags)
ancestor.path = ours.path = theirs.path = "staged_changes";
ancestor.mode = ours.mode = theirs.mode = GIT_FILEMODE_BLOB;
- git_oid__fromstr(&ancestor.id, "d427e0b2e138501a3d15cc376077a3631e15bd46", GIT_OID_SHA1);
- git_oid__fromstr(&ours.id, "ee3fa1b8c00aff7fe02065fdb50864bb0d932ccf", GIT_OID_SHA1);
- git_oid__fromstr(&theirs.id, "2bd0a343aeef7a2cf0d158478966a6e587ff3863", GIT_OID_SHA1);
+ git_oid_from_string(&ancestor.id, "d427e0b2e138501a3d15cc376077a3631e15bd46", GIT_OID_SHA1);
+ git_oid_from_string(&ours.id, "ee3fa1b8c00aff7fe02065fdb50864bb0d932ccf", GIT_OID_SHA1);
+ git_oid_from_string(&theirs.id, "2bd0a343aeef7a2cf0d158478966a6e587ff3863", GIT_OID_SHA1);
cl_git_pass(git_index_conflict_add(index, &ancestor, &ours, &theirs));
cl_git_pass(git_diff_tree_to_index(&diff, g_repo, a, index, &opts));
@@ -255,7 +256,7 @@ void test_diff_index__not_in_head_conflicted(void)
theirs.path = "file_not_in_head";
theirs.mode = GIT_FILEMODE_BLOB;
- git_oid__fromstr(&theirs.id, "2bd0a343aeef7a2cf0d158478966a6e587ff3863", GIT_OID_SHA1);
+ git_oid_from_string(&theirs.id, "2bd0a343aeef7a2cf0d158478966a6e587ff3863", GIT_OID_SHA1);
cl_git_pass(git_index_conflict_add(index, NULL, NULL, &theirs));
cl_git_pass(git_diff_tree_to_index(&diff, g_repo, a, index, NULL));
@@ -275,10 +276,13 @@ void test_diff_index__to_index(void)
git_tree *old_tree;
git_index *old_index;
git_index *new_index;
+ git_index_options index_opts = GIT_INDEX_OPTIONS_INIT;
git_diff *diff;
diff_expects exp;
- cl_git_pass(git_index_new(&old_index));
+ index_opts.oid_type = GIT_OID_SHA1;
+
+ cl_git_pass(git_index_new_ext(&old_index, &index_opts));
old_tree = resolve_commit_oid_to_tree(g_repo, a_commit);
cl_git_pass(git_index_read_tree(old_index, old_tree));
diff --git a/tests/libgit2/diff/parse.c b/tests/libgit2/diff/parse.c
index cae843cc836..59fc0280ed6 100644
--- a/tests/libgit2/diff/parse.c
+++ b/tests/libgit2/diff/parse.c
@@ -19,19 +19,19 @@ void test_diff_parse__nonpatches_fail_with_notfound(void)
const char *not_with_both = "Lead.\n" PATCH_NOT_A_PATCH "Trail.\n";
cl_git_fail_with(GIT_ENOTFOUND,
- git_diff_from_buffer(&diff,
+ diff_from_buffer(&diff,
not,
strlen(not)));
cl_git_fail_with(GIT_ENOTFOUND,
- git_diff_from_buffer(&diff,
+ diff_from_buffer(&diff,
not_with_leading,
strlen(not_with_leading)));
cl_git_fail_with(GIT_ENOTFOUND,
- git_diff_from_buffer(&diff,
+ diff_from_buffer(&diff,
not_with_trailing,
strlen(not_with_trailing)));
cl_git_fail_with(GIT_ENOTFOUND,
- git_diff_from_buffer(&diff,
+ diff_from_buffer(&diff,
not_with_both,
strlen(not_with_both)));
}
@@ -51,7 +51,7 @@ static void test_parse_invalid_diff(const char *invalid_diff)
git_str_puts(&buf, PATCH_BINARY_LITERAL);
cl_git_fail_with(GIT_ERROR,
- git_diff_from_buffer(&diff, buf.ptr, buf.size));
+ diff_from_buffer(&diff, buf.ptr, buf.size));
git_str_dispose(&buf);
}
@@ -72,7 +72,7 @@ void test_diff_parse__exact_rename(void)
"2.9.3\n";
git_diff *diff;
- cl_git_pass(git_diff_from_buffer(
+ cl_git_pass(diff_from_buffer(
&diff, content, strlen(content)));
git_diff_free(diff);
}
@@ -92,7 +92,7 @@ void test_diff_parse__empty_file(void)
"2.20.1\n";
git_diff *diff;
- cl_git_pass(git_diff_from_buffer(
+ cl_git_pass(diff_from_buffer(
&diff, content, strlen(content)));
git_diff_free(diff);
}
@@ -102,7 +102,7 @@ void test_diff_parse__no_extended_headers(void)
const char *content = PATCH_NO_EXTENDED_HEADERS;
git_diff *diff;
- cl_git_pass(git_diff_from_buffer(
+ cl_git_pass(diff_from_buffer(
&diff, content, strlen(content)));
git_diff_free(diff);
}
@@ -125,7 +125,7 @@ void test_diff_parse__add_delete_no_index(void)
"-three\n";
git_diff *diff;
- cl_git_pass(git_diff_from_buffer(
+ cl_git_pass(diff_from_buffer(
&diff, content, strlen(content)));
git_diff_free(diff);
}
@@ -166,7 +166,7 @@ static void test_tree_to_tree_computed_to_parsed(
cl_git_pass(git_diff_to_buf(&computed_buf,
computed, GIT_DIFF_FORMAT_PATCH));
- cl_git_pass(git_diff_from_buffer(&parsed,
+ cl_git_pass(diff_from_buffer(&parsed,
computed_buf.ptr, computed_buf.size));
diff_assert_equal(computed, parsed);
@@ -248,7 +248,7 @@ void test_diff_parse__get_patch_from_diff(void)
computed, GIT_DIFF_FORMAT_PATCH));
cl_git_pass(git_patch_from_diff(&patch_computed, computed, 0));
- cl_git_pass(git_diff_from_buffer(&parsed,
+ cl_git_pass(diff_from_buffer(&parsed,
computed_buf.ptr, computed_buf.size));
cl_git_pass(git_patch_from_diff(&patch_parsed, parsed, 0));
@@ -279,6 +279,31 @@ static int file_cb(const git_diff_delta *delta, float progress, void *payload)
return 0;
}
+void test_diff_parse__eof_nl_missing(void)
+{
+ const char patch[] =
+ "diff --git a/.env b/.env\n"
+ "index f89e4c0..7c56eb7 100644\n"
+ "--- a/.env\n"
+ "+++ b/.env\n"
+ "@@ -1 +1 @@\n"
+ "-hello=12345\n"
+ "+hello=123456\n"
+ "\\ No newline at end of file\n";
+ git_diff *diff;
+ git_patch *ret_patch;
+ git_diff_line *line;
+
+ cl_git_pass(diff_from_buffer(&diff, patch, strlen(patch)));
+ cl_git_pass(git_patch_from_diff(&ret_patch, diff, 0));
+
+ cl_assert((line = git_array_get(ret_patch->lines, 2)) != NULL);
+ cl_assert(line->origin == GIT_DIFF_LINE_DEL_EOFNL);
+
+ git_diff_free(diff);
+ git_patch_free(ret_patch);
+}
+
void test_diff_parse__foreach_works_with_parsed_patch(void)
{
const char patch[] =
@@ -292,7 +317,7 @@ void test_diff_parse__foreach_works_with_parsed_patch(void)
int called = 0;
git_diff *diff;
- cl_git_pass(git_diff_from_buffer(&diff, patch, strlen(patch)));
+ cl_git_pass(diff_from_buffer(&diff, patch, strlen(patch)));
cl_git_pass(git_diff_foreach(diff, file_cb, NULL, NULL, NULL, &called));
cl_assert_equal_i(called, 1);
@@ -312,7 +337,7 @@ void test_diff_parse__parsing_minimal_patch_succeeds(void)
git_buf buf = GIT_BUF_INIT;
git_diff *diff;
- cl_git_pass(git_diff_from_buffer(&diff, patch, strlen(patch)));
+ cl_git_pass(diff_from_buffer(&diff, patch, strlen(patch)));
cl_git_pass(git_diff_to_buf(&buf, diff, GIT_DIFF_FORMAT_PATCH));
cl_assert_equal_s(patch, buf.ptr);
@@ -330,7 +355,7 @@ void test_diff_parse__patch_roundtrip_succeeds(void)
cl_git_pass(git_patch_from_buffers(&patch, buf1, strlen(buf1), "obj1", buf2, strlen(buf2), "obj2", NULL));
cl_git_pass(git_patch_to_buf(&patchbuf, patch));
- cl_git_pass(git_diff_from_buffer(&diff, patchbuf.ptr, patchbuf.size));
+ cl_git_pass(diff_from_buffer(&diff, patchbuf.ptr, patchbuf.size));
cl_git_pass(git_diff_to_buf(&diffbuf, diff, GIT_DIFF_FORMAT_PATCH));
cl_assert_equal_s(patchbuf.ptr, diffbuf.ptr);
@@ -372,7 +397,7 @@ void test_diff_parse__issue4672(void)
const git_diff_hunk *hunk;
size_t n, l = 0;
- cl_git_pass(git_diff_from_buffer(&diff, text, strlen(text)));
+ cl_git_pass(diff_from_buffer(&diff, text, strlen(text)));
cl_git_pass(git_patch_from_diff(&patch, diff, 0));
cl_git_pass(git_patch_get_hunk(&hunk, &n, patch, 0));
@@ -393,7 +418,7 @@ void test_diff_parse__lineinfo(void)
const git_diff_hunk *hunk;
size_t n, l = 0;
- cl_git_pass(git_diff_from_buffer(&diff, text, strlen(text)));
+ cl_git_pass(diff_from_buffer(&diff, text, strlen(text)));
cl_git_pass(git_patch_from_diff(&patch, diff, 0));
cl_git_pass(git_patch_get_hunk(&hunk, &n, patch, 0));
@@ -419,7 +444,7 @@ void test_diff_parse__new_file_with_space(void)
git_patch *patch;
git_diff *diff;
- cl_git_pass(git_diff_from_buffer(&diff, content, strlen(content)));
+ cl_git_pass(diff_from_buffer(&diff, content, strlen(content)));
cl_git_pass(git_patch_from_diff((git_patch **) &patch, diff, 0));
cl_assert_equal_p(patch->diff_opts.old_prefix, NULL);
@@ -437,7 +462,7 @@ void test_diff_parse__new_file_with_space_and_regenerate_patch(void)
git_diff *diff = NULL;
git_buf buf = GIT_BUF_INIT;
- cl_git_pass(git_diff_from_buffer(&diff, content, strlen(content)));
+ cl_git_pass(diff_from_buffer(&diff, content, strlen(content)));
cl_git_pass(git_diff_to_buf(&buf, diff, GIT_DIFF_FORMAT_PATCH));
git_buf_dispose(&buf);
@@ -450,7 +475,7 @@ void test_diff_parse__delete_file_with_space_and_regenerate_patch(void)
git_diff *diff = NULL;
git_buf buf = GIT_BUF_INIT;
- cl_git_pass(git_diff_from_buffer(&diff, content, strlen(content)));
+ cl_git_pass(diff_from_buffer(&diff, content, strlen(content)));
cl_git_pass(git_diff_to_buf(&buf, diff, GIT_DIFF_FORMAT_PATCH));
git_buf_dispose(&buf);
@@ -464,7 +489,7 @@ void test_diff_parse__crlf(void)
git_patch *patch;
const git_diff_delta *delta;
- cl_git_pass(git_diff_from_buffer(&diff, text, strlen(text)));
+ cl_git_pass(diff_from_buffer(&diff, text, strlen(text)));
cl_git_pass(git_patch_from_diff(&patch, diff, 0));
delta = git_patch_get_delta(patch);
diff --git a/tests/libgit2/diff/patchid.c b/tests/libgit2/diff/patchid.c
index 1cc368e2193..2cd9473f247 100644
--- a/tests/libgit2/diff/patchid.c
+++ b/tests/libgit2/diff/patchid.c
@@ -1,13 +1,14 @@
#include "clar_libgit2.h"
#include "patch/patch_common.h"
+#include "diff_helpers.h"
static void verify_patch_id(const char *diff_content, const char *expected_id)
{
git_oid expected_oid, actual_oid;
git_diff *diff;
- cl_git_pass(git_oid__fromstr(&expected_oid, expected_id, GIT_OID_SHA1));
- cl_git_pass(git_diff_from_buffer(&diff, diff_content, strlen(diff_content)));
+ cl_git_pass(git_oid_from_string(&expected_oid, expected_id, GIT_OID_SHA1));
+ cl_git_pass(diff_from_buffer(&diff, diff_content, strlen(diff_content)));
cl_git_pass(git_diff_patchid(&actual_oid, diff, NULL));
cl_assert_equal_oid(&expected_oid, &actual_oid);
diff --git a/tests/libgit2/diff/rename.c b/tests/libgit2/diff/rename.c
index 9d44394624d..a5bbfe447bc 100644
--- a/tests/libgit2/diff/rename.c
+++ b/tests/libgit2/diff/rename.c
@@ -574,7 +574,7 @@ void test_diff_rename__working_directory_changes(void)
/* again with exact match blob */
- cl_git_pass(git_oid__fromstr(&id, blobsha, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, blobsha, GIT_OID_SHA1));
cl_git_pass(git_blob_lookup(&blob, g_repo, &id));
cl_git_pass(git_str_set(
&content, git_blob_rawcontent(blob), (size_t)git_blob_rawsize(blob)));
@@ -1441,6 +1441,52 @@ void test_diff_rename__can_delete_unmodified_deltas(void)
git_str_dispose(&c1);
}
+void test_diff_rename__can_delete_unmodified_deltas_including_submodule(void)
+{
+ git_repository *repo; /* "submodules" */
+ git_index *index;
+ git_tree *tree;
+ git_diff *diff;
+ git_diff_options diffopts = GIT_DIFF_OPTIONS_INIT;
+ git_diff_find_options opts = GIT_DIFF_FIND_OPTIONS_INIT;
+ diff_expects exp;
+
+ cl_git_sandbox_cleanup(); /* Don't use "renames" for this test */
+ repo = cl_git_sandbox_init("submodules");
+
+ cl_repo_set_bool(repo, "core.autocrlf", false);
+
+ cl_git_pass(
+ git_revparse_single((git_object **)&tree, repo, "HEAD^{tree}"));
+
+ cl_git_pass(git_repository_index(&index, repo));
+ cl_git_pass(git_index_read_tree(index, tree));
+
+ diffopts.flags = GIT_DIFF_INCLUDE_UNMODIFIED;
+
+ cl_git_pass(git_diff_tree_to_index(&diff, repo, tree, index, &diffopts));
+
+ memset(&exp, 0, sizeof(exp));
+ cl_git_pass(git_diff_foreach(
+ diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
+ cl_assert_equal_i(5, exp.files);
+ cl_assert_equal_i(5, exp.file_status[GIT_DELTA_UNMODIFIED]);
+
+ opts.flags = GIT_DIFF_FIND_ALL | GIT_DIFF_FIND_REMOVE_UNMODIFIED;
+ cl_git_pass(git_diff_find_similar(diff, &opts));
+
+ memset(&exp, 0, sizeof(exp));
+ cl_git_pass(git_diff_foreach(
+ diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
+ cl_assert_equal_i(0, exp.files);
+
+ git_diff_free(diff);
+ git_tree_free(tree);
+ git_index_free(index);
+
+ cl_git_sandbox_cleanup();
+}
+
void test_diff_rename__matches_config_behavior(void)
{
const char *sha0 = INITIAL_COMMIT;
diff --git a/tests/libgit2/diff/stats.c b/tests/libgit2/diff/stats.c
index b076ad5a93d..f808136220a 100644
--- a/tests/libgit2/diff/stats.c
+++ b/tests/libgit2/diff/stats.c
@@ -4,6 +4,7 @@
#include "commit.h"
#include "diff.h"
#include "diff_generate.h"
+#include "diff_helpers.h"
static git_repository *_repo;
static git_diff_stats *_stats;
@@ -26,7 +27,7 @@ static void diff_stats_from_commit_oid(
git_commit *commit;
git_diff *diff;
- git_oid__fromstr(&oid, oidstr, GIT_OID_SHA1);
+ git_oid_from_string(&oid, oidstr, GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, _repo, &oid));
cl_git_pass(git_diff__commit(&diff, _repo, commit, NULL));
if (rename)
@@ -368,7 +369,7 @@ void test_diff_stats__new_file(void)
" 1 file changed, 1 insertion(+)\n"
" create mode 100644 Gurjeet Singh\n";
- cl_git_pass(git_diff_from_buffer(&diff, input, strlen(input)));
+ cl_git_pass(diff_from_buffer(&diff, input, strlen(input)));
cl_git_pass(git_diff_get_stats(&_stats, diff));
cl_git_pass(git_diff_stats_to_buf(&buf, _stats, GIT_DIFF_STATS_FULL | GIT_DIFF_STATS_INCLUDE_SUMMARY, 0));
cl_assert_equal_s(stat, buf.ptr);
diff --git a/tests/libgit2/diff/workdir.c b/tests/libgit2/diff/workdir.c
index 21c5b0de9a2..602460908bb 100644
--- a/tests/libgit2/diff/workdir.c
+++ b/tests/libgit2/diff/workdir.c
@@ -86,11 +86,11 @@ void test_diff_workdir__to_index_with_conflicts(void)
/* Adding an entry that represents a rename gets two files in conflict */
our_entry.path = "subdir/modified_file";
our_entry.mode = 0100644;
- git_oid__fromstr(&our_entry.id, "ee3fa1b8c00aff7fe02065fdb50864bb0d932ccf", GIT_OID_SHA1);
+ git_oid_from_string(&our_entry.id, "ee3fa1b8c00aff7fe02065fdb50864bb0d932ccf", GIT_OID_SHA1);
their_entry.path = "subdir/rename_conflict";
their_entry.mode = 0100644;
- git_oid__fromstr(&their_entry.id, "2bd0a343aeef7a2cf0d158478966a6e587ff3863", GIT_OID_SHA1);
+ git_oid_from_string(&their_entry.id, "2bd0a343aeef7a2cf0d158478966a6e587ff3863", GIT_OID_SHA1);
cl_git_pass(git_repository_index(&index, g_repo));
cl_git_pass(git_index_conflict_add(index, NULL, &our_entry, &their_entry));
@@ -2015,9 +2015,9 @@ void test_diff_workdir__to_index_conflicted(void) {
ancestor.path = ours.path = theirs.path = "_file";
ancestor.mode = ours.mode = theirs.mode = 0100644;
- git_oid__fromstr(&ancestor.id, "d427e0b2e138501a3d15cc376077a3631e15bd46", GIT_OID_SHA1);
- git_oid__fromstr(&ours.id, "ee3fa1b8c00aff7fe02065fdb50864bb0d932ccf", GIT_OID_SHA1);
- git_oid__fromstr(&theirs.id, "2bd0a343aeef7a2cf0d158478966a6e587ff3863", GIT_OID_SHA1);
+ git_oid_from_string(&ancestor.id, "d427e0b2e138501a3d15cc376077a3631e15bd46", GIT_OID_SHA1);
+ git_oid_from_string(&ours.id, "ee3fa1b8c00aff7fe02065fdb50864bb0d932ccf", GIT_OID_SHA1);
+ git_oid_from_string(&theirs.id, "2bd0a343aeef7a2cf0d158478966a6e587ff3863", GIT_OID_SHA1);
cl_git_pass(git_index_conflict_add(index, &ancestor, &ours, &theirs));
cl_git_pass(git_diff_tree_to_index(&diff1, g_repo, a, index, NULL));
@@ -2136,7 +2136,7 @@ void test_diff_workdir__to_index_pathlist(void)
git_diff_free(diff);
git_index_free(index);
- git_vector_free(&pathlist);
+ git_vector_dispose(&pathlist);
}
void test_diff_workdir__symlink_changed_on_non_symlink_platform(void)
@@ -2198,7 +2198,7 @@ void test_diff_workdir__symlink_changed_on_non_symlink_platform(void)
cl_git_pass(git_futils_rmdir_r("symlink", NULL, GIT_RMDIR_REMOVE_FILES));
git_tree_free(tree);
- git_vector_free(&pathlist);
+ git_vector_dispose(&pathlist);
}
void test_diff_workdir__order(void)
@@ -2278,3 +2278,89 @@ void test_diff_workdir__ignore_blank_lines(void)
git_patch_free(patch);
git_diff_free(diff);
}
+
+void test_diff_workdir__to_index_reversed_content_loads(void)
+{
+ git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
+ git_diff *diff = NULL;
+ diff_expects exp;
+ int use_iterator;
+ char *pathspec = "new_file";
+
+ g_repo = cl_git_sandbox_init("status");
+
+ opts.context_lines = 3;
+ opts.interhunk_lines = 1;
+ opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED |
+ GIT_DIFF_SHOW_UNTRACKED_CONTENT | GIT_DIFF_REVERSE;
+ opts.pathspec.strings = &pathspec;
+ opts.pathspec.count = 1;
+
+ cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
+
+ for (use_iterator = 0; use_iterator <= 1; use_iterator++) {
+ memset(&exp, 0, sizeof(exp));
+
+ if (use_iterator)
+ cl_git_pass(diff_foreach_via_iterator(
+ diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
+ else
+ cl_git_pass(git_diff_foreach(
+ diff, diff_file_cb, diff_binary_cb, diff_hunk_cb, diff_line_cb, &exp));
+
+ cl_assert_equal_i(1, exp.files);
+ cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
+ cl_assert_equal_i(0, exp.file_status[GIT_DELTA_DELETED]);
+ cl_assert_equal_i(0, exp.file_status[GIT_DELTA_MODIFIED]);
+ cl_assert_equal_i(0, exp.file_status[GIT_DELTA_IGNORED]);
+ cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNTRACKED]);
+
+ cl_assert_equal_i(1, exp.hunks);
+
+ cl_assert_equal_i(1, exp.lines);
+ cl_assert_equal_i(0, exp.line_ctxt);
+ cl_assert_equal_i(0, exp.line_adds);
+ cl_assert_equal_i(1, exp.line_dels);
+ }
+
+ git_diff_free(diff);
+}
+
+void test_diff_workdir__completely_ignored_shows_empty_diff(void)
+{
+ git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
+ git_diff *diff;
+ git_patch *patch;
+ git_buf buf = GIT_BUF_INIT;
+ char *pathspec = "subdir.txt";
+
+ opts.pathspec.strings = &pathspec;
+ opts.pathspec.count = 1;
+
+ g_repo = cl_git_sandbox_init("status");
+ cl_git_rewritefile("status/subdir.txt", "Is it a bird?\n\nIs it a plane?\n");
+
+ /* Perform the diff normally */
+ cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
+ cl_git_pass(git_patch_from_diff(&patch, diff, 0));
+ cl_git_pass(git_patch_to_buf(&buf, patch));
+
+ cl_assert_equal_s("diff --git a/subdir.txt b/subdir.txt\nindex e8ee89e..53c8db5 100644\n--- a/subdir.txt\n+++ b/subdir.txt\n@@ -1,2 +1,3 @@\n Is it a bird?\n+\n Is it a plane?\n", buf.ptr);
+
+ git_buf_dispose(&buf);
+ git_patch_free(patch);
+ git_diff_free(diff);
+
+ /* Perform the diff ignoring blank lines */
+ opts.flags |= GIT_DIFF_IGNORE_BLANK_LINES;
+
+ cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
+ cl_git_pass(git_patch_from_diff(&patch, diff, 0));
+ cl_git_pass(git_patch_to_buf(&buf, patch));
+
+ cl_assert_equal_s("", buf.ptr);
+
+ git_buf_dispose(&buf);
+ git_patch_free(patch);
+ git_diff_free(diff);
+}
diff --git a/tests/libgit2/email/create.c b/tests/libgit2/email/create.c
index cf40ff552e0..1a69dc4f267 100644
--- a/tests/libgit2/email/create.c
+++ b/tests/libgit2/email/create.c
@@ -1,5 +1,6 @@
#include "clar.h"
#include "clar_libgit2.h"
+#include "git2/sys/email.h"
#include "diff_generate.h"
@@ -24,7 +25,7 @@ static void email_for_commit(
git_commit *commit = NULL;
git_diff *diff = NULL;
- git_oid__fromstr(&oid, commit_id, GIT_OID_SHA1);
+ git_oid_from_string(&oid, commit_id, GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, repo, &oid));
@@ -323,7 +324,7 @@ void test_email_create__custom_summary_and_body(void)
opts.subject_prefix = "PPPPPATCH";
- git_oid__fromstr(&oid, "627e7e12d87e07a83fad5b6bfa25e86ead4a5270", GIT_OID_SHA1);
+ git_oid_from_string(&oid, "627e7e12d87e07a83fad5b6bfa25e86ead4a5270", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, repo, &oid));
cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
cl_git_pass(git_email_create_from_diff(&buf, diff, 2, 4, &oid, summary, body, git_commit_author(commit), &opts));
diff --git a/tests/libgit2/fetch/local.c b/tests/libgit2/fetch/local.c
index 5d2417f1cd3..ca307a881e8 100644
--- a/tests/libgit2/fetch/local.c
+++ b/tests/libgit2/fetch/local.c
@@ -26,7 +26,7 @@ void test_fetch_local__defaults(void)
cl_fixture("testrepo.git")));
cl_git_pass(git_remote_fetch(remote, NULL, NULL, NULL));
- git_oid__fromstr(&expected_id, "258f0e2a959a364e40ed6603d5d44fbb24765b10", GIT_OID_SHA1);
+ git_oid_from_string(&expected_id, "258f0e2a959a364e40ed6603d5d44fbb24765b10", GIT_OID_SHA1);
cl_git_pass(git_revparse_single(&obj, repo, "refs/remotes/test/haacked"));
cl_assert_equal_oid(&expected_id, git_object_id(obj));
@@ -47,7 +47,7 @@ void test_fetch_local__reachable_commit(void)
refspecs.strings = &refspec;
refspecs.count = 1;
- git_oid__fromstr(&expected_id, "5b5b025afb0b4c913b4c338a42934a3863bf3644", GIT_OID_SHA1);
+ git_oid_from_string(&expected_id, "5b5b025afb0b4c913b4c338a42934a3863bf3644", GIT_OID_SHA1);
cl_git_pass(git_remote_create(&remote, repo, "test",
cl_fixture("testrepo.git")));
diff --git a/tests/libgit2/fetchhead/nonetwork.c b/tests/libgit2/fetchhead/nonetwork.c
index 2519d895e29..ac86d611af4 100644
--- a/tests/libgit2/fetchhead/nonetwork.c
+++ b/tests/libgit2/fetchhead/nonetwork.c
@@ -29,7 +29,7 @@ static void populate_fetchhead(git_vector *out, git_repository *repo)
git_fetchhead_ref *fetchhead_ref;
git_oid oid;
- cl_git_pass(git_oid__fromstr(&oid,
+ cl_git_pass(git_oid_from_string(&oid,
"49322bb17d3acc9146f98c97d078513228bbf3c0",
GIT_OID_SHA1));
cl_git_pass(git_fetchhead_ref_create(&fetchhead_ref, &oid, 1,
@@ -37,7 +37,7 @@ static void populate_fetchhead(git_vector *out, git_repository *repo)
"https://github.com/libgit2/TestGitRepository"));
cl_git_pass(git_vector_insert(out, fetchhead_ref));
- cl_git_pass(git_oid__fromstr(&oid,
+ cl_git_pass(git_oid_from_string(&oid,
"0966a434eb1a025db6b71485ab63a3bfbea520b6",
GIT_OID_SHA1));
cl_git_pass(git_fetchhead_ref_create(&fetchhead_ref, &oid, 0,
@@ -45,7 +45,7 @@ static void populate_fetchhead(git_vector *out, git_repository *repo)
"https://github.com/libgit2/TestGitRepository"));
cl_git_pass(git_vector_insert(out, fetchhead_ref));
- cl_git_pass(git_oid__fromstr(&oid,
+ cl_git_pass(git_oid_from_string(&oid,
"42e4e7c5e507e113ebbb7801b16b52cf867b7ce1",
GIT_OID_SHA1));
cl_git_pass(git_fetchhead_ref_create(&fetchhead_ref, &oid, 0,
@@ -53,7 +53,7 @@ static void populate_fetchhead(git_vector *out, git_repository *repo)
"https://github.com/libgit2/TestGitRepository"));
cl_git_pass(git_vector_insert(out, fetchhead_ref));
- cl_git_pass(git_oid__fromstr(&oid,
+ cl_git_pass(git_oid_from_string(&oid,
"d96c4e80345534eccee5ac7b07fc7603b56124cb",
GIT_OID_SHA1));
cl_git_pass(git_fetchhead_ref_create(&fetchhead_ref, &oid, 0,
@@ -61,7 +61,7 @@ static void populate_fetchhead(git_vector *out, git_repository *repo)
"https://github.com/libgit2/TestGitRepository"));
cl_git_pass(git_vector_insert(out, fetchhead_ref));
- cl_git_pass(git_oid__fromstr(&oid,
+ cl_git_pass(git_oid_from_string(&oid,
"55a1a760df4b86a02094a904dfa511deb5655905",
GIT_OID_SHA1));
cl_git_pass(git_fetchhead_ref_create(&fetchhead_ref, &oid, 0,
@@ -69,7 +69,7 @@ static void populate_fetchhead(git_vector *out, git_repository *repo)
"https://github.com/libgit2/TestGitRepository"));
cl_git_pass(git_vector_insert(out, fetchhead_ref));
- cl_git_pass(git_oid__fromstr(&oid,
+ cl_git_pass(git_oid_from_string(&oid,
"8f50ba15d49353813cc6e20298002c0d17b0a9ee",
GIT_OID_SHA1));
cl_git_pass(git_fetchhead_ref_create(&fetchhead_ref, &oid, 0,
@@ -106,7 +106,7 @@ void test_fetchhead_nonetwork__write(void)
git_fetchhead_ref_free(fetchhead_ref);
}
- git_vector_free(&fetchhead_vector);
+ git_vector_dispose(&fetchhead_vector);
cl_assert(equals);
}
@@ -166,7 +166,7 @@ void test_fetchhead_nonetwork__read(void)
git_fetchhead_ref_free(fetchhead_ref);
}
- git_vector_free(&fetchhead_vector);
+ git_vector_dispose(&fetchhead_vector);
}
static int read_old_style_cb(const char *name, const char *url,
@@ -176,7 +176,7 @@ static int read_old_style_cb(const char *name, const char *url,
GIT_UNUSED(payload);
- git_oid__fromstr(&expected, "49322bb17d3acc9146f98c97d078513228bbf3c0", GIT_OID_SHA1);
+ git_oid_from_string(&expected, "49322bb17d3acc9146f98c97d078513228bbf3c0", GIT_OID_SHA1);
cl_assert(name == NULL);
cl_assert(url == NULL);
@@ -203,7 +203,7 @@ static int read_type_missing(const char *ref_name, const char *remote_url,
GIT_UNUSED(payload);
- git_oid__fromstr(&expected, "49322bb17d3acc9146f98c97d078513228bbf3c0", GIT_OID_SHA1);
+ git_oid_from_string(&expected, "49322bb17d3acc9146f98c97d078513228bbf3c0", GIT_OID_SHA1);
cl_assert_equal_s("name", ref_name);
cl_assert_equal_s("remote_url", remote_url);
@@ -230,7 +230,7 @@ static int read_name_missing(const char *ref_name, const char *remote_url,
GIT_UNUSED(payload);
- git_oid__fromstr(&expected, "49322bb17d3acc9146f98c97d078513228bbf3c0", GIT_OID_SHA1);
+ git_oid_from_string(&expected, "49322bb17d3acc9146f98c97d078513228bbf3c0", GIT_OID_SHA1);
cl_assert(ref_name == NULL);
cl_assert_equal_s("remote_url", remote_url);
@@ -534,13 +534,13 @@ void test_fetchhead_nonetwork__credentials_are_stripped(void)
git_fetchhead_ref *ref;
git_oid oid;
- cl_git_pass(git_oid__fromstr(&oid, "49322bb17d3acc9146f98c97d078513228bbf3c0", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, "49322bb17d3acc9146f98c97d078513228bbf3c0", GIT_OID_SHA1));
cl_git_pass(git_fetchhead_ref_create(&ref, &oid, 0,
"refs/tags/commit_tree", "http://foo:bar@github.com/libgit2/TestGitRepository"));
cl_assert_equal_s(ref->remote_url, "http://github.com/libgit2/TestGitRepository");
git_fetchhead_ref_free(ref);
- cl_git_pass(git_oid__fromstr(&oid, "49322bb17d3acc9146f98c97d078513228bbf3c0", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, "49322bb17d3acc9146f98c97d078513228bbf3c0", GIT_OID_SHA1));
cl_git_pass(git_fetchhead_ref_create(&ref, &oid, 0,
"refs/tags/commit_tree", "https://foo:bar@github.com/libgit2/TestGitRepository"));
cl_assert_equal_s(ref->remote_url, "https://github.com/libgit2/TestGitRepository");
diff --git a/tests/libgit2/filter/bare.c b/tests/libgit2/filter/bare.c
index f53cfcb4919..afbccd73228 100644
--- a/tests/libgit2/filter/bare.c
+++ b/tests/libgit2/filter/bare.c
@@ -140,7 +140,7 @@ void test_filter_bare__from_specific_commit_one(void)
opts.flags |= GIT_BLOB_FILTER_NO_SYSTEM_ATTRIBUTES;
opts.flags |= GIT_BLOB_FILTER_ATTRIBUTES_FROM_COMMIT;
- cl_git_pass(git_oid__fromstr(&opts.attr_commit_id, "b8986fec0f7bde90f78ac72706e782d82f24f2f0", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&opts.attr_commit_id, "b8986fec0f7bde90f78ac72706e782d82f24f2f0", GIT_OID_SHA1));
cl_git_pass(git_revparse_single(
(git_object **)&blob, g_repo, "055c872")); /* ident */
@@ -165,7 +165,7 @@ void test_filter_bare__from_specific_commit_with_no_attributes_file(void)
opts.flags |= GIT_BLOB_FILTER_NO_SYSTEM_ATTRIBUTES;
opts.flags |= GIT_BLOB_FILTER_ATTRIBUTES_FROM_COMMIT;
- cl_git_pass(git_oid__fromstr(&opts.attr_commit_id, "5afb6a14a864e30787857dd92af837e8cdd2cb1b", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&opts.attr_commit_id, "5afb6a14a864e30787857dd92af837e8cdd2cb1b", GIT_OID_SHA1));
cl_git_pass(git_revparse_single(
(git_object **)&blob, g_repo, "799770d")); /* all-lf */
diff --git a/tests/libgit2/filter/query.c b/tests/libgit2/filter/query.c
index 429c1044324..d57b808cd9b 100644
--- a/tests/libgit2/filter/query.c
+++ b/tests/libgit2/filter/query.c
@@ -53,6 +53,18 @@ void test_filter_query__filters(void)
cl_assert_equal_i(1, filter_for("id.binident", "ident"));
}
+void test_filter_query__filters_ignorecase(void)
+{
+ if (!cl_repo_get_bool(g_repo, "core.ignorecase"))
+ cl_skip();
+
+ cl_assert_equal_i(1, filter_for("TEXT.TXT", "crlf"));
+ cl_assert_equal_i(0, filter_for("Binary.bin", "crlf"));
+
+ cl_assert_equal_i(1, filter_for("id.Ident", "crlf"));
+ cl_assert_equal_i(1, filter_for("ID.IdEnT", "ident"));
+}
+
void test_filter_query__autocrlf_true_implies_crlf(void)
{
cl_repo_set_bool(g_repo, "core.autocrlf", true);
diff --git a/tests/libgit2/filter/systemattrs.c b/tests/libgit2/filter/systemattrs.c
index b687b4b44cd..5f669e35124 100644
--- a/tests/libgit2/filter/systemattrs.c
+++ b/tests/libgit2/filter/systemattrs.c
@@ -1,21 +1,30 @@
#include "clar_libgit2.h"
#include "crlf.h"
#include "path.h"
+#include "futils.h"
static git_repository *g_repo = NULL;
+static git_str orig_system_path = GIT_STR_INIT;
static git_str system_attr_path = GIT_STR_INIT;
void test_filter_systemattrs__initialize(void)
{
- git_buf system_path = GIT_BUF_INIT;
+ git_str new_system_path = GIT_BUF_INIT;
g_repo = cl_git_sandbox_init("crlf");
cl_must_pass(p_unlink("crlf/.gitattributes"));
cl_git_pass(git_libgit2_opts(
- GIT_OPT_GET_SEARCH_PATH, GIT_CONFIG_LEVEL_SYSTEM, &system_path));
+ GIT_OPT_GET_SEARCH_PATH, GIT_CONFIG_LEVEL_SYSTEM, &orig_system_path));
+
+ cl_git_pass(git_str_joinpath(&new_system_path,
+ clar_sandbox_path(), "_system_path"));
+ cl_git_pass(git_futils_mkdir_r(new_system_path.ptr, 0777));
+ cl_git_pass(git_libgit2_opts(
+ GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_SYSTEM, new_system_path.ptr));
+
cl_git_pass(git_str_joinpath(&system_attr_path,
- system_path.ptr, "gitattributes"));
+ new_system_path.ptr, "gitattributes"));
cl_git_mkfile(system_attr_path.ptr,
"*.txt text\n"
@@ -23,13 +32,17 @@ void test_filter_systemattrs__initialize(void)
"*.crlf text eol=crlf\n"
"*.lf text eol=lf\n");
- git_buf_dispose(&system_path);
+ git_str_dispose(&new_system_path);
}
void test_filter_systemattrs__cleanup(void)
{
+ cl_git_pass(git_libgit2_opts(
+ GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_SYSTEM, orig_system_path.ptr));
+
cl_must_pass(p_unlink(system_attr_path.ptr));
git_str_dispose(&system_attr_path);
+ git_str_dispose(&orig_system_path);
cl_git_sandbox_cleanup();
}
diff --git a/tests/libgit2/grafts/basic.c b/tests/libgit2/grafts/basic.c
new file mode 100644
index 00000000000..ad208b7f2a1
--- /dev/null
+++ b/tests/libgit2/grafts/basic.c
@@ -0,0 +1,121 @@
+#include "clar_libgit2.h"
+
+#include "futils.h"
+#include "grafts.h"
+
+static git_repository *g_repo;
+
+void test_grafts_basic__initialize(void)
+{
+ g_repo = cl_git_sandbox_init("grafted.git");
+}
+
+void test_grafts_basic__cleanup(void)
+{
+ cl_git_sandbox_cleanup();
+}
+
+void test_grafts_basic__graft_add(void)
+{
+ git_array_oid_t parents = GIT_ARRAY_INIT;
+ git_oid oid_src, *oid1;
+ git_commit_graft *graft;
+ git_grafts *grafts;
+
+ cl_git_pass(git_grafts_new(&grafts, GIT_OID_SHA1));
+
+ cl_assert(oid1 = git_array_alloc(parents));
+ cl_git_pass(git_oid_from_string(&oid_src, "2f3053cbff8a4ca2f0666de364ddb734a28a31a9", GIT_OID_SHA1));
+ git_oid_cpy(oid1, &oid_src);
+
+ git_oid_from_string(&oid_src, "f503807ffa920e407a600cfaee96b7152259acc7", GIT_OID_SHA1);
+ cl_git_pass(git_grafts_add(grafts, &oid_src, parents));
+ git_array_clear(parents);
+
+ cl_assert_equal_i(1, git_grafts_size(grafts));
+ cl_git_pass(git_grafts_get(&graft, grafts, &oid_src));
+ cl_assert_equal_s("f503807ffa920e407a600cfaee96b7152259acc7", git_oid_tostr_s(&graft->oid));
+ cl_assert_equal_i(1, git_array_size(graft->parents));
+ cl_assert_equal_s("2f3053cbff8a4ca2f0666de364ddb734a28a31a9", git_oid_tostr_s(git_array_get(graft->parents, 0)));
+
+ git_grafts_free(grafts);
+}
+
+void test_grafts_basic__grafted_revwalk(void)
+{
+ git_revwalk *w;
+ git_oid oids[10];
+ size_t i = 0;
+ git_commit *commit;
+
+ cl_git_pass(git_revwalk_new(&w, g_repo));
+ cl_git_pass(git_revwalk_push_ref(w, "refs/heads/branch"));
+
+ cl_git_pass(git_revwalk_next(&oids[i++], w));
+ cl_assert_equal_s(git_oid_tostr_s(&oids[0]), "8a00e91619098618be97c0d2ceabb05a2c58edd9");
+ cl_git_pass(git_revwalk_next(&oids[i++], w));
+ cl_assert_equal_s(git_oid_tostr_s(&oids[1]), "f503807ffa920e407a600cfaee96b7152259acc7");
+ cl_git_pass(git_revwalk_next(&oids[i++], w));
+ cl_assert_equal_s(git_oid_tostr_s(&oids[2]), "2f3053cbff8a4ca2f0666de364ddb734a28a31a9");
+
+ cl_git_fail_with(GIT_ITEROVER, git_revwalk_next(&oids[i++], w));
+
+ cl_git_pass(git_commit_lookup(&commit, g_repo, &oids[0]));
+
+ cl_assert_equal_i(1, git_commit_parentcount(commit));
+
+ git_commit_free(commit);
+ git_revwalk_free(w);
+}
+
+void test_grafts_basic__grafted_objects(void)
+{
+ git_oid oid;
+ git_commit *commit;
+
+ cl_git_pass(git_oid_from_string(&oid, "f503807ffa920e407a600cfaee96b7152259acc7", GIT_OID_SHA1));
+ cl_git_pass(git_commit_lookup(&commit, g_repo, &oid));
+ cl_assert_equal_i(1, git_commit_parentcount(commit));
+ git_commit_free(commit);
+
+ cl_git_pass(git_oid_from_string(&oid, "0512adebd3782157f0d5c9b22b043f87b4aaff9e", GIT_OID_SHA1));
+ cl_git_pass(git_commit_lookup(&commit, g_repo, &oid));
+ cl_assert_equal_i(1, git_commit_parentcount(commit));
+ git_commit_free(commit);
+
+ cl_git_pass(git_oid_from_string(&oid, "66cc22a015f6ca75b34c82d28f78ba663876bade", GIT_OID_SHA1));
+ cl_git_pass(git_commit_lookup(&commit, g_repo, &oid));
+ cl_assert_equal_i(4, git_commit_parentcount(commit));
+ git_commit_free(commit);
+}
+
+void test_grafts_basic__grafted_merge_revwalk(void)
+{
+ git_revwalk *w;
+ git_oid oids[10];
+ size_t i = 0;
+
+ cl_git_pass(git_revwalk_new(&w, g_repo));
+ cl_git_pass(git_revwalk_push_ref(w, "refs/heads/bottom"));
+
+ cl_git_pass(git_revwalk_next(&oids[i++], w));
+ cl_assert_equal_s(git_oid_tostr_s(&oids[i - 1]), "66cc22a015f6ca75b34c82d28f78ba663876bade");
+ cl_git_pass(git_revwalk_next(&oids[i++], w));
+ cl_assert_equal_s(git_oid_tostr_s(&oids[i - 1]), "e414f42f4e6bc6934563a2349a8600f0ab68618e");
+ cl_git_pass(git_revwalk_next(&oids[i++], w));
+ cl_assert_equal_s(git_oid_tostr_s(&oids[i - 1]), "8a00e91619098618be97c0d2ceabb05a2c58edd9");
+ cl_git_pass(git_revwalk_next(&oids[i++], w));
+ cl_assert_equal_s(git_oid_tostr_s(&oids[i - 1]), "1c18e80a276611bb9b146590616bbc5aebdf2945");
+ cl_git_pass(git_revwalk_next(&oids[i++], w));
+ cl_assert_equal_s(git_oid_tostr_s(&oids[i - 1]), "d7224d49d6d5aff6ade596ed74f4bcd4f77b29e2");
+ cl_git_pass(git_revwalk_next(&oids[i++], w));
+ cl_assert_equal_s(git_oid_tostr_s(&oids[i - 1]), "0512adebd3782157f0d5c9b22b043f87b4aaff9e");
+ cl_git_pass(git_revwalk_next(&oids[i++], w));
+ cl_assert_equal_s(git_oid_tostr_s(&oids[i - 1]), "f503807ffa920e407a600cfaee96b7152259acc7");
+ cl_git_pass(git_revwalk_next(&oids[i++], w));
+ cl_assert_equal_s(git_oid_tostr_s(&oids[i - 1]), "2f3053cbff8a4ca2f0666de364ddb734a28a31a9");
+
+ cl_git_fail_with(GIT_ITEROVER, git_revwalk_next(&oids[i++], w));
+
+ git_revwalk_free(w);
+}
diff --git a/tests/libgit2/grafts/parse.c b/tests/libgit2/grafts/parse.c
new file mode 100644
index 00000000000..f268a2a1712
--- /dev/null
+++ b/tests/libgit2/grafts/parse.c
@@ -0,0 +1,149 @@
+#include "clar_libgit2.h"
+
+#include "grafts.h"
+
+#define OID0 "c0368f9f9743e950e6cfe1f45a649f8a9dfcd97e"
+#define OID1 "cfc50a0db87ce908fb8a8c5b8f7b4ab96eee8643"
+#define OID2 "6914d97cd08b9edf5e855fca211c750fa82fd80a"
+#define OID3 "516521937d0e9ce9d0d836149a0702671f326b4a"
+#define OID4 "e2c29d67ef2f217650196f94c796f0532b8caad6"
+#define OID5 "79bcb936596cb50353fe7be28b7444e66e4a2842"
+#define OID6 "b9c54107d57c17dbcaf646c4d52f66eb9e69d23d"
+#define OID7 "9f8a746e9ad7b58cc840016bc3944d5ad262acb5"
+#define OID8 "392f4beef7d0d15b2bc5b1abe1a754eba0ec36da"
+
+#define OID_TRUNCATED "392f4beef7d0d15b2bc5b1abe1a754eba0ec36d"
+#define OID_NONHEX "9f8a746e9ax7b58cc840016bc3944d5ad262acb5"
+
+static git_grafts *grafts;
+
+void test_grafts_parse__initialize(void)
+{
+ cl_git_pass(git_grafts_new(&grafts, GIT_OID_SHA1));
+}
+
+void test_grafts_parse__cleanup(void)
+{
+ git_grafts_free(grafts);
+ grafts = NULL;
+}
+
+static void assert_parse_succeeds(git_grafts *grafts, const char *string, size_t n)
+{
+ cl_git_pass(git_grafts_parse(grafts, string, strlen(string)));
+ cl_assert_equal_i(git_grafts_size(grafts), n);
+}
+
+static void assert_parse_fails(git_grafts *grafts, const char *string)
+{
+ cl_git_fail(git_grafts_parse(grafts, string, strlen(string)));
+}
+
+static void assert_graft_contains(git_grafts *grafts, const char *graft, size_t n, ...)
+{
+ git_commit_graft *commit;
+ git_oid oid;
+ va_list ap;
+ size_t i = 0;
+
+ cl_git_pass(git_oid_from_string(&oid, graft, GIT_OID_SHA1));
+ cl_git_pass(git_grafts_get(&commit, grafts, &oid));
+ cl_assert_equal_oid(&commit->oid, &oid);
+ cl_assert_equal_i(commit->parents.size, n);
+
+ va_start(ap, n);
+ while (i < n) {
+ cl_git_pass(git_oid_from_string(&oid, va_arg(ap, const char *), GIT_OID_SHA1));
+ cl_assert_equal_oid(&commit->parents.ptr[i], &oid);
+ i++;
+ }
+ va_end(ap);
+}
+
+void test_grafts_parse__single_oid(void)
+{
+ assert_parse_succeeds(grafts, OID1, 1);
+ assert_graft_contains(grafts, OID1, 0);
+}
+
+void test_grafts_parse__single_oid_with_newline(void)
+{
+ assert_parse_succeeds(grafts, OID1 "\n", 1);
+ assert_graft_contains(grafts, OID1, 0);
+}
+
+void test_grafts_parse__multiple_oids(void)
+{
+ assert_parse_succeeds(grafts, OID1 "\n" OID2 "\n" OID3, 3);
+ assert_graft_contains(grafts, OID1, 0);
+ assert_graft_contains(grafts, OID2, 0);
+ assert_graft_contains(grafts, OID3, 0);
+}
+
+void test_grafts_parse__same_oid(void)
+{
+ assert_parse_succeeds(grafts, OID1 "\n" OID1, 1);
+ assert_graft_contains(grafts, OID1, 0);
+}
+
+void test_grafts_parse__oid_with_parent(void)
+{
+ assert_parse_succeeds(grafts, OID1 " " OID2, 1);
+ assert_graft_contains(grafts, OID1, 1, OID2);
+}
+
+void test_grafts_parse__oid_with_parent_and_newline(void)
+{
+ assert_parse_succeeds(grafts, OID1 " " OID2 "\n", 1);
+ assert_graft_contains(grafts, OID1, 1, OID2);
+}
+
+void test_grafts_parse__oid_with_multiple_parents(void)
+{
+ assert_parse_succeeds(grafts, OID1 " " OID2 " " OID3 " " OID4 " " OID5, 1);
+ assert_graft_contains(grafts, OID1, 4, OID2, OID3, OID4, OID5);
+}
+
+void test_grafts_parse__multiple_oids_with_multiple_parents(void)
+{
+ assert_parse_succeeds(grafts,
+ OID1 " " OID2 " " OID3 " " OID4 " " OID5 "\n"
+ OID6 " " OID7 " " OID8 "\n" , 2);
+ assert_graft_contains(grafts, OID1, 4, OID2, OID3, OID4, OID5);
+ assert_graft_contains(grafts, OID6, 2, OID7, OID8);
+}
+
+void test_grafts_parse__multiple_spaces_fails(void)
+{
+ assert_parse_fails(grafts, OID1 " " OID2);
+}
+
+void test_grafts_parse__trailing_space_fails(void)
+{
+ assert_parse_fails(grafts, OID1 " " OID2 " ");
+}
+
+void test_grafts_parse__invalid_character_inbetween_fails(void)
+{
+ assert_parse_fails(grafts, OID1 " x " OID2);
+}
+
+void test_grafts_parse__truncated_oid_fails(void)
+{
+ assert_parse_fails(grafts, OID_TRUNCATED);
+}
+
+void test_grafts_parse__truncated_parent_fails(void)
+{
+ assert_parse_fails(grafts, OID1 " " OID_TRUNCATED);
+}
+
+void test_grafts_parse__invalid_oid_fails(void)
+{
+ assert_parse_fails(grafts, OID_NONHEX);
+}
+
+void test_grafts_parse__invalid_parent_fails(void)
+{
+ assert_parse_fails(grafts, OID1 " " OID_NONHEX);
+}
diff --git a/tests/libgit2/grafts/shallow.c b/tests/libgit2/grafts/shallow.c
new file mode 100644
index 00000000000..ceb56ed5a7c
--- /dev/null
+++ b/tests/libgit2/grafts/shallow.c
@@ -0,0 +1,134 @@
+#include "clar_libgit2.h"
+
+#include "futils.h"
+#include "grafts.h"
+#include "repository.h"
+
+static git_repository *g_repo;
+static git_oid g_shallow_oid;
+
+void test_grafts_shallow__initialize(void)
+{
+ cl_git_pass(git_oid_from_string(&g_shallow_oid, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1));
+}
+
+void test_grafts_shallow__cleanup(void)
+{
+ cl_git_sandbox_cleanup();
+}
+
+void test_grafts_shallow__no_shallow_file(void)
+{
+ g_repo = cl_git_sandbox_init("testrepo.git");
+ cl_assert_equal_i(0, git_repository_is_shallow(g_repo));
+}
+
+void test_grafts_shallow__empty_shallow_file(void)
+{
+ g_repo = cl_git_sandbox_init("testrepo.git");
+ cl_git_mkfile("testrepo.git/shallow", "");
+ cl_assert_equal_i(0, git_repository_is_shallow(g_repo));
+}
+
+void test_grafts_shallow__shallow_repo(void)
+{
+ g_repo = cl_git_sandbox_init("shallow.git");
+ cl_assert_equal_i(1, git_repository_is_shallow(g_repo));
+}
+
+void test_grafts_shallow__clears_errors(void)
+{
+ g_repo = cl_git_sandbox_init("testrepo.git");
+ cl_assert_equal_i(0, git_repository_is_shallow(g_repo));
+ cl_assert_equal_i(GIT_ERROR_NONE, git_error_last()->klass);
+}
+
+void test_grafts_shallow__shallow_oids(void)
+{
+ git_commit_graft *graft;
+ git_grafts *grafts;
+
+ g_repo = cl_git_sandbox_init("shallow.git");
+
+ cl_git_pass(git_repository_shallow_grafts__weakptr(&grafts, g_repo));
+ cl_assert_equal_i(1, git_grafts_size(grafts));
+ cl_git_pass(git_grafts_get(&graft, grafts, &g_shallow_oid));
+}
+
+void test_grafts_shallow__cache_clearing(void)
+{
+ git_commit_graft *graft;
+ git_grafts *grafts;
+ git_oid tmp_oid;
+
+ cl_git_pass(git_oid_from_string(&tmp_oid, "0000000000000000000000000000000000000000", GIT_OID_SHA1));
+ g_repo = cl_git_sandbox_init("shallow.git");
+ cl_git_pass(git_repository_shallow_grafts__weakptr(&grafts, g_repo));
+
+ cl_assert_equal_i(1, git_grafts_size(grafts));
+ cl_git_pass(git_grafts_get(&graft, grafts, &g_shallow_oid));
+
+ cl_git_mkfile("shallow.git/shallow",
+ "be3563ae3f795b2b4353bcce3a527ad0a4f7f644\n"
+ "0000000000000000000000000000000000000000\n"
+ );
+
+ cl_git_pass(git_grafts_refresh(grafts));
+ cl_assert_equal_i(2, git_grafts_size(grafts));
+ cl_git_pass(git_grafts_get(&graft, grafts, &g_shallow_oid));
+ cl_git_pass(git_grafts_get(&graft, grafts, &tmp_oid));
+
+ cl_git_pass(p_unlink("shallow.git/shallow"));
+ cl_git_pass(git_grafts_refresh(grafts));
+ cl_assert_equal_i(0, git_grafts_size(grafts));
+}
+
+void test_grafts_shallow__errors_on_borked(void)
+{
+ git_grafts *grafts;
+
+ g_repo = cl_git_sandbox_init("shallow.git");
+
+ cl_git_mkfile("shallow.git/shallow", "lolno");
+ cl_git_pass(git_repository_shallow_grafts__weakptr(&grafts, g_repo));
+ cl_git_fail(git_grafts_refresh(grafts));
+ cl_assert_equal_i(0, git_grafts_size(grafts));
+
+ cl_git_mkfile("shallow.git/shallow", "lolno\n");
+ cl_git_pass(git_repository_shallow_grafts__weakptr(&grafts, g_repo));
+ cl_git_fail(git_grafts_refresh(grafts));
+ cl_assert_equal_i(0, git_grafts_size(grafts));
+}
+
+void test_grafts_shallow__revwalk_behavior(void)
+{
+ git_revwalk *w;
+ git_oid oid_1, oid_2, oid_3;
+
+ g_repo = cl_git_sandbox_init("shallow.git");
+
+ cl_git_pass(git_revwalk_new(&w, g_repo));
+ cl_git_pass(git_revwalk_push_head(w));
+
+ cl_git_pass(git_revwalk_next(&oid_1, w)); /* a65fedf39aefe402d3bb6e24df4d4f5fe4547750 */
+ cl_git_pass(git_revwalk_next(&oid_2, w)); /* be3563ae3f795b2b4353bcce3a527ad0a4f7f644 */
+ cl_git_fail_with(GIT_ITEROVER, git_revwalk_next(&oid_3, w));
+
+ cl_assert_equal_s(git_oid_tostr_s(&oid_1), "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
+ cl_assert_equal_s(git_oid_tostr_s(&oid_2), "be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
+
+ git_revwalk_free(w);
+}
+
+void test_grafts_shallow__grafted_object(void)
+{
+ git_commit *commit;
+
+ g_repo = cl_git_sandbox_init("shallow.git");
+
+ cl_git_pass(git_commit_lookup(&commit, g_repo, &g_shallow_oid));
+
+ cl_assert_equal_i(0, git_commit_parentcount(commit));
+
+ git_commit_free(commit);
+}
diff --git a/tests/libgit2/graph/ahead_behind.c b/tests/libgit2/graph/ahead_behind.c
index dd828c5f37b..66db34b0f55 100644
--- a/tests/libgit2/graph/ahead_behind.c
+++ b/tests/libgit2/graph/ahead_behind.c
@@ -10,7 +10,7 @@ void test_graph_ahead_behind__initialize(void)
git_oid oid;
cl_git_pass(git_repository_open(&_repo, cl_fixture("testrepo.git")));
- cl_git_pass(git_oid__fromstr(&oid, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1));
cl_git_pass(git_commit_lookup(&commit, _repo, &oid));
}
@@ -29,8 +29,8 @@ void test_graph_ahead_behind__returns_correct_result(void)
git_oid oid2;
git_commit *other;
- cl_git_pass(git_oid__fromstr(&oid, "e90810b8df3e80c413d903f631643c716887138d", GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&oid2, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, "e90810b8df3e80c413d903f631643c716887138d", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid2, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1));
cl_git_pass(git_graph_ahead_behind(&ahead, &behind, _repo, &oid, &oid2));
cl_assert_equal_sz(2, ahead);
diff --git a/tests/libgit2/graph/commitgraph.c b/tests/libgit2/graph/commitgraph.c
index 82f7f936f97..4000882d713 100644
--- a/tests/libgit2/graph/commitgraph.c
+++ b/tests/libgit2/graph/commitgraph.c
@@ -16,31 +16,31 @@ void test_graph_commitgraph__parse(void)
cl_git_pass(git_repository_open(&repo, cl_fixture("testrepo.git")));
cl_git_pass(git_str_joinpath(&commit_graph_path, git_repository_path(repo), "objects/info/commit-graph"));
- cl_git_pass(git_commit_graph_file_open(&file, git_str_cstr(&commit_graph_path)));
+ cl_git_pass(git_commit_graph_file_open(&file, git_str_cstr(&commit_graph_path), GIT_OID_SHA1));
cl_assert_equal_i(git_commit_graph_file_needs_refresh(file, git_str_cstr(&commit_graph_path)), 0);
- cl_git_pass(git_oid__fromstr(&id, "5001298e0c09ad9c34e4249bc5801c75e9754fa5", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, "5001298e0c09ad9c34e4249bc5801c75e9754fa5", GIT_OID_SHA1));
cl_git_pass(git_commit_graph_entry_find(&e, file, &id, GIT_OID_SHA1_HEXSIZE));
cl_assert_equal_oid(&e.sha1, &id);
- cl_git_pass(git_oid__fromstr(&id, "418382dff1ffb8bdfba833f4d8bbcde58b1e7f47", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, "418382dff1ffb8bdfba833f4d8bbcde58b1e7f47", GIT_OID_SHA1));
cl_assert_equal_oid(&e.tree_oid, &id);
cl_assert_equal_i(e.generation, 1);
cl_assert_equal_i(e.commit_time, UINT64_C(1273610423));
cl_assert_equal_i(e.parent_count, 0);
- cl_git_pass(git_oid__fromstr(&id, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1));
cl_git_pass(git_commit_graph_entry_find(&e, file, &id, GIT_OID_SHA1_HEXSIZE));
cl_assert_equal_oid(&e.sha1, &id);
cl_assert_equal_i(e.generation, 5);
cl_assert_equal_i(e.commit_time, UINT64_C(1274813907));
cl_assert_equal_i(e.parent_count, 2);
- cl_git_pass(git_oid__fromstr(&id, "9fd738e8f7967c078dceed8190330fc8648ee56a", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, "9fd738e8f7967c078dceed8190330fc8648ee56a", GIT_OID_SHA1));
cl_git_pass(git_commit_graph_entry_parent(&parent, file, &e, 0));
cl_assert_equal_oid(&parent.sha1, &id);
cl_assert_equal_i(parent.generation, 4);
- cl_git_pass(git_oid__fromstr(&id, "c47800c7266a2be04c571c04d5a6614691ea99bd", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, "c47800c7266a2be04c571c04d5a6614691ea99bd", GIT_OID_SHA1));
cl_git_pass(git_commit_graph_entry_parent(&parent, file, &e, 1));
cl_assert_equal_oid(&parent.sha1, &id);
cl_assert_equal_i(parent.generation, 3);
@@ -60,28 +60,28 @@ void test_graph_commitgraph__parse_octopus_merge(void)
cl_git_pass(git_repository_open(&repo, cl_fixture("merge-recursive/.gitted")));
cl_git_pass(git_str_joinpath(&commit_graph_path, git_repository_path(repo), "objects/info/commit-graph"));
- cl_git_pass(git_commit_graph_file_open(&file, git_str_cstr(&commit_graph_path)));
+ cl_git_pass(git_commit_graph_file_open(&file, git_str_cstr(&commit_graph_path), GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&id, "d71c24b3b113fd1d1909998c5bfe33b86a65ee03", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, "d71c24b3b113fd1d1909998c5bfe33b86a65ee03", GIT_OID_SHA1));
cl_git_pass(git_commit_graph_entry_find(&e, file, &id, GIT_OID_SHA1_HEXSIZE));
cl_assert_equal_oid(&e.sha1, &id);
- cl_git_pass(git_oid__fromstr(&id, "348f16ffaeb73f319a75cec5b16a0a47d2d5e27c", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, "348f16ffaeb73f319a75cec5b16a0a47d2d5e27c", GIT_OID_SHA1));
cl_assert_equal_oid(&e.tree_oid, &id);
cl_assert_equal_i(e.generation, 7);
cl_assert_equal_i(e.commit_time, UINT64_C(1447083009));
cl_assert_equal_i(e.parent_count, 3);
- cl_git_pass(git_oid__fromstr(&id, "ad2ace9e15f66b3d1138922e6ffdc3ea3f967fa6", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, "ad2ace9e15f66b3d1138922e6ffdc3ea3f967fa6", GIT_OID_SHA1));
cl_git_pass(git_commit_graph_entry_parent(&parent, file, &e, 0));
cl_assert_equal_oid(&parent.sha1, &id);
cl_assert_equal_i(parent.generation, 6);
- cl_git_pass(git_oid__fromstr(&id, "483065df53c0f4a02cdc6b2910b05d388fc17ffb", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, "483065df53c0f4a02cdc6b2910b05d388fc17ffb", GIT_OID_SHA1));
cl_git_pass(git_commit_graph_entry_parent(&parent, file, &e, 1));
cl_assert_equal_oid(&parent.sha1, &id);
cl_assert_equal_i(parent.generation, 2);
- cl_git_pass(git_oid__fromstr(&id, "815b5a1c80ca749d705c7aa0cb294a00cbedd340", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, "815b5a1c80ca749d705c7aa0cb294a00cbedd340", GIT_OID_SHA1));
cl_git_pass(git_commit_graph_entry_parent(&parent, file, &e, 2));
cl_assert_equal_oid(&parent.sha1, &id);
cl_assert_equal_i(parent.generation, 6);
@@ -103,7 +103,12 @@ void test_graph_commitgraph__writer(void)
cl_git_pass(git_repository_open(&repo, cl_fixture("testrepo.git")));
cl_git_pass(git_str_joinpath(&path, git_repository_path(repo), "objects/info"));
- cl_git_pass(git_commit_graph_writer_new(&w, git_str_cstr(&path)));
+
+#ifdef GIT_EXPERIMENTAL_SHA256
+ opts.oid_type = GIT_OID_SHA1;
+#endif
+
+ cl_git_pass(git_commit_graph_writer_new(&w, git_str_cstr(&path), &opts));
/* This is equivalent to `git commit-graph write --reachable`. */
cl_git_pass(git_revwalk_new(&walk, repo));
@@ -111,7 +116,8 @@ void test_graph_commitgraph__writer(void)
cl_git_pass(git_commit_graph_writer_add_revwalk(w, walk));
git_revwalk_free(walk);
- cl_git_pass(git_commit_graph_writer_dump(&cgraph, w, &opts));
+ cl_git_pass(git_commit_graph_writer_dump(&cgraph, w));
+
cl_git_pass(git_str_joinpath(&path, git_repository_path(repo), "objects/info/commit-graph"));
cl_git_pass(git_futils_readbuffer(&expected_cgraph, git_str_cstr(&path)));
@@ -131,11 +137,19 @@ void test_graph_commitgraph__validate(void)
struct git_commit_graph *cgraph;
git_str objects_dir = GIT_STR_INIT;
+#ifdef GIT_EXPERIMENTAL_SHA256
+ git_commit_graph_open_options opts = GIT_COMMIT_GRAPH_OPEN_OPTIONS_INIT;
+#endif
+
cl_git_pass(git_repository_open(&repo, cl_fixture("testrepo.git")));
cl_git_pass(git_str_joinpath(&objects_dir, git_repository_path(repo), "objects"));
/* git_commit_graph_open() calls git_commit_graph_validate() */
+#ifdef GIT_EXPERIMENTAL_SHA256
+ cl_git_pass(git_commit_graph_open(&cgraph, git_str_cstr(&objects_dir), &opts));
+#else
cl_git_pass(git_commit_graph_open(&cgraph, git_str_cstr(&objects_dir)));
+#endif
git_commit_graph_free(cgraph);
git_str_dispose(&objects_dir);
@@ -148,6 +162,10 @@ void test_graph_commitgraph__validate_corrupt(void)
struct git_commit_graph *cgraph;
int fd = -1;
+#ifdef GIT_EXPERIMENTAL_SHA256
+ git_commit_graph_open_options opts = GIT_COMMIT_GRAPH_OPEN_OPTIONS_INIT;
+#endif
+
cl_fixture_sandbox("testrepo.git");
cl_git_pass(git_repository_open(&repo, cl_git_sandbox_path(1, "testrepo.git", NULL)));
@@ -158,7 +176,11 @@ void test_graph_commitgraph__validate_corrupt(void)
cl_must_pass(p_close(fd));
/* git_commit_graph_open() calls git_commit_graph_validate() */
+#ifdef GIT_EXPERIMENTAL_SHA256
+ cl_git_fail(git_commit_graph_open(&cgraph, cl_git_sandbox_path(1, "testrepo.git", "objects", NULL), &opts));
+#else
cl_git_fail(git_commit_graph_open(&cgraph, cl_git_sandbox_path(1, "testrepo.git", "objects", NULL)));
+#endif
git_commit_graph_free(cgraph);
git_repository_free(repo);
diff --git a/tests/libgit2/graph/descendant_of.c b/tests/libgit2/graph/descendant_of.c
index b6dffae0671..594066c42b6 100644
--- a/tests/libgit2/graph/descendant_of.c
+++ b/tests/libgit2/graph/descendant_of.c
@@ -9,7 +9,7 @@ void test_graph_descendant_of__initialize(void)
cl_git_pass(git_repository_open(&_repo, cl_fixture("testrepo.git")));
- git_oid__fromstr(&oid, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1);
+ git_oid_from_string(&oid, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, _repo, &oid));
}
@@ -50,6 +50,6 @@ void test_graph_descendant_of__nopath(void)
{
git_oid oid;
- git_oid__fromstr(&oid, "e90810b8df3e80c413d903f631643c716887138d", GIT_OID_SHA1);
+ git_oid_from_string(&oid, "e90810b8df3e80c413d903f631643c716887138d", GIT_OID_SHA1);
cl_assert_equal_i(0, git_graph_descendant_of(_repo, git_commit_id(commit), &oid));
}
diff --git a/tests/libgit2/graph/reachable_from_any.c b/tests/libgit2/graph/reachable_from_any.c
index 8e1c23874d9..161b640020f 100644
--- a/tests/libgit2/graph/reachable_from_any.c
+++ b/tests/libgit2/graph/reachable_from_any.c
@@ -17,7 +17,7 @@ void test_graph_reachable_from_any__initialize(void)
repo = cl_git_sandbox_init(TEST_REPO_PATH);
- git_oid__fromstr(&oid, "539bd011c4822c560c1d17cab095006b7a10f707", GIT_OID_SHA1);
+ git_oid_from_string(&oid, "539bd011c4822c560c1d17cab095006b7a10f707", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, repo, &oid));
cl_git_pass(git_reset(repo, (git_object *)commit, GIT_RESET_HARD, NULL));
git_commit_free(commit);
@@ -231,6 +231,6 @@ void test_graph_reachable_from_any__exhaustive(void)
git_vector_foreach (&mc.commits, child_idx, child_commit)
git_commit_free(child_commit);
git_bitvec_free(&reachable);
- git_vector_free(&mc.commits);
+ git_vector_dispose(&mc.commits);
git_odb_free(mc.db);
}
diff --git a/tests/libgit2/index/add.c b/tests/libgit2/index/add.c
index b0c3bd2b7ae..d4290019b6a 100644
--- a/tests/libgit2/index/add.c
+++ b/tests/libgit2/index/add.c
@@ -28,7 +28,7 @@ static void test_add_entry(
{
git_index_entry entry = {{0}};
- cl_git_pass(git_oid__fromstr(&entry.id, idstr, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&entry.id, idstr, GIT_OID_SHA1));
entry.path = mode == GIT_FILEMODE_TREE ? "test_folder" : "test_file";
entry.mode = mode;
@@ -82,3 +82,27 @@ void test_index_add__invalid_entries_succeeds_by_default(void)
test_add_entry(true, valid_commit_id, GIT_FILEMODE_LINK);
}
+void test_index_add__two_slash_prefixed(void)
+{
+ git_index_entry one = {{0}}, two = {{0}};
+ const git_index_entry *result;
+ size_t orig_count;
+
+ orig_count = git_index_entrycount(g_index);
+
+ cl_git_pass(git_oid_from_string(&one.id, "fa49b077972391ad58037050f2a75f74e3671e92", GIT_OID_SHA1));
+ one.path = "/a";
+ one.mode = GIT_FILEMODE_BLOB;
+
+ cl_git_pass(git_oid_from_string(&two.id, "3697d64be941a53d4ae8f6a271e4e3fa56b022cc", GIT_OID_SHA1));
+ two.path = "/a";
+ two.mode = GIT_FILEMODE_BLOB;
+
+ cl_git_pass(git_index_add(g_index, &one));
+ cl_git_pass(git_index_add(g_index, &two));
+
+ cl_assert_equal_i(orig_count + 1, git_index_entrycount(g_index));
+
+ cl_assert(result = git_index_get_bypath(g_index, "/a", 0));
+ cl_assert_equal_oid(&two.id, &result->id);
+}
diff --git a/tests/libgit2/index/addall.c b/tests/libgit2/index/addall.c
index 6f95f6386f4..e76b6e81d89 100644
--- a/tests/libgit2/index/addall.c
+++ b/tests/libgit2/index/addall.c
@@ -441,6 +441,52 @@ void test_index_addall__callback_filtering(void)
git_index_free(index);
}
+void test_index_addall__handles_ignored_files_in_directory(void)
+{
+ git_index *index;
+
+ g_repo = cl_git_sandbox_init_new(TEST_DIR);
+
+ cl_git_mkfile(TEST_DIR "/file.foo", "a file");
+ cl_git_mkfile(TEST_DIR "/file.bar", "another file");
+ cl_must_pass(p_mkdir(TEST_DIR "/folder", 0777));
+ cl_git_mkfile(TEST_DIR "/folder/asdf", "yet another file");
+
+ cl_git_mkfile(TEST_DIR "/.gitignore", "folder/\n");
+
+ check_status(g_repo, 0, 0, 0, 3, 0, 0, 1, 0);
+
+ cl_git_pass(git_repository_index(&index, g_repo));
+ cl_git_pass(git_index_add_all(index, NULL, 0, NULL, NULL));
+
+ check_status(g_repo, 3, 0, 0, 0, 0, 0, 1, 0);
+
+ git_index_free(index);
+}
+
+void test_index_addall__force_adds_ignored_directories(void)
+{
+ git_index *index;
+
+ g_repo = cl_git_sandbox_init_new(TEST_DIR);
+
+ cl_git_mkfile(TEST_DIR "/file.foo", "a file");
+ cl_git_mkfile(TEST_DIR "/file.bar", "another file");
+ cl_must_pass(p_mkdir(TEST_DIR "/folder", 0777));
+ cl_git_mkfile(TEST_DIR "/folder/asdf", "yet another file");
+
+ cl_git_mkfile(TEST_DIR "/.gitignore", "folder/\n");
+
+ check_status(g_repo, 0, 0, 0, 3, 0, 0, 1, 0);
+
+ cl_git_pass(git_repository_index(&index, g_repo));
+ cl_git_pass(git_index_add_all(index, NULL, GIT_INDEX_ADD_FORCE, NULL, NULL));
+
+ check_status(g_repo, 4, 0, 0, 0, 0, 0, 0, 0);
+
+ git_index_free(index);
+}
+
void test_index_addall__adds_conflicts(void)
{
git_index *index;
diff --git a/tests/libgit2/index/bypath.c b/tests/libgit2/index/bypath.c
index 15c11af5f0b..ef105462d49 100644
--- a/tests/libgit2/index/bypath.c
+++ b/tests/libgit2/index/bypath.c
@@ -131,7 +131,7 @@ void test_index_bypath__add_honors_existing_case_2(void)
clar__skip();
dummy.mode = GIT_FILEMODE_BLOB;
- cl_git_pass(git_oid__fromstr(&dummy.id, "f990a25a74d1a8281ce2ab018ea8df66795cd60b", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&dummy.id, "f990a25a74d1a8281ce2ab018ea8df66795cd60b", GIT_OID_SHA1));
/* note that `git_index_add` does no checking to canonical directories */
dummy.path = "Just_a_dir/file0.txt";
@@ -187,7 +187,7 @@ void test_index_bypath__add_honors_existing_case_3(void)
clar__skip();
dummy.mode = GIT_FILEMODE_BLOB;
- cl_git_pass(git_oid__fromstr(&dummy.id, "f990a25a74d1a8281ce2ab018ea8df66795cd60b", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&dummy.id, "f990a25a74d1a8281ce2ab018ea8df66795cd60b", GIT_OID_SHA1));
dummy.path = "just_a_dir/filea.txt";
cl_git_pass(git_index_add(g_idx, &dummy));
@@ -218,7 +218,7 @@ void test_index_bypath__add_honors_existing_case_4(void)
clar__skip();
dummy.mode = GIT_FILEMODE_BLOB;
- cl_git_pass(git_oid__fromstr(&dummy.id, "f990a25a74d1a8281ce2ab018ea8df66795cd60b", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&dummy.id, "f990a25a74d1a8281ce2ab018ea8df66795cd60b", GIT_OID_SHA1));
dummy.path = "just_a_dir/a/b/c/d/e/file1.txt";
cl_git_pass(git_index_add(g_idx, &dummy));
diff --git a/tests/libgit2/index/cache.c b/tests/libgit2/index/cache.c
index 7576331b014..7207308414c 100644
--- a/tests/libgit2/index/cache.c
+++ b/tests/libgit2/index/cache.c
@@ -24,9 +24,9 @@ void test_index_cache__write_extension_at_root(void)
const char *tree_id_str = "45dd856fdd4d89b884c340ba0e047752d9b085d6";
const char *index_file = "index-tree";
- cl_git_pass(git_index_open(&index, index_file));
+ cl_git_pass(git_index_open_ext(&index, index_file, NULL));
cl_assert(index->tree == NULL);
- cl_git_pass(git_oid__fromstr(&id, tree_id_str, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, tree_id_str, GIT_OID_SHA1));
cl_git_pass(git_tree_lookup(&tree, g_repo, &id));
cl_git_pass(git_index_read_tree(index, tree));
git_tree_free(tree);
@@ -35,7 +35,7 @@ void test_index_cache__write_extension_at_root(void)
cl_git_pass(git_index_write(index));
git_index_free(index);
- cl_git_pass(git_index_open(&index, index_file));
+ cl_git_pass(git_index_open_ext(&index, index_file, NULL));
cl_assert(index->tree);
cl_assert_equal_i(git_index_entrycount(index), index->tree->entry_count);
@@ -52,13 +52,14 @@ void test_index_cache__write_extension_invalidated_root(void)
git_index *index;
git_tree *tree;
git_oid id;
+ git_index_options index_opts = GIT_INDEX_OPTIONS_INIT;
const char *tree_id_str = "45dd856fdd4d89b884c340ba0e047752d9b085d6";
const char *index_file = "index-tree-invalidated";
git_index_entry entry;
- cl_git_pass(git_index_open(&index, index_file));
+ cl_git_pass(git_index_open_ext(&index, index_file, &index_opts));
cl_assert(index->tree == NULL);
- cl_git_pass(git_oid__fromstr(&id, tree_id_str, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, tree_id_str, GIT_OID_SHA1));
cl_git_pass(git_tree_lookup(&tree, g_repo, &id));
cl_git_pass(git_index_read_tree(index, tree));
git_tree_free(tree);
@@ -77,7 +78,9 @@ void test_index_cache__write_extension_invalidated_root(void)
cl_git_pass(git_index_write(index));
git_index_free(index);
- cl_git_pass(git_index_open(&index, index_file));
+ index_opts.oid_type = GIT_OID_SHA1;
+
+ cl_git_pass(git_index_open_ext(&index, index_file, &index_opts));
cl_assert(index->tree);
cl_assert_equal_i(-1, index->tree->entry_count);
@@ -98,7 +101,7 @@ void test_index_cache__read_tree_no_children(void)
cl_git_pass(git_index_new(&index));
cl_assert(index->tree == NULL);
- cl_git_pass(git_oid__fromstr(&id, "45dd856fdd4d89b884c340ba0e047752d9b085d6", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, "45dd856fdd4d89b884c340ba0e047752d9b085d6", GIT_OID_SHA1));
cl_git_pass(git_tree_lookup(&tree, g_repo, &id));
cl_git_pass(git_index_read_tree(index, tree));
git_tree_free(tree);
@@ -111,7 +114,7 @@ void test_index_cache__read_tree_no_children(void)
memset(&entry, 0x0, sizeof(git_index_entry));
entry.path = "new.txt";
entry.mode = GIT_FILEMODE_BLOB;
- git_oid__fromstr(&entry.id, "d4bcc68acd4410bf836a39f20afb2c2ece09584e", GIT_OID_SHA1);
+ git_oid_from_string(&entry.id, "d4bcc68acd4410bf836a39f20afb2c2ece09584e", GIT_OID_SHA1);
cl_git_pass(git_index_add(index, &entry));
cl_assert_equal_i(-1, index->tree->entry_count);
@@ -132,7 +135,7 @@ void test_index_cache__two_levels(void)
memset(&entry, 0x0, sizeof(entry));
entry.mode = GIT_FILEMODE_BLOB;
- cl_git_pass(git_oid__fromstr(&entry.id, "a8233120f6ad708f843d861ce2b7228ec4e3dec6", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&entry.id, "a8233120f6ad708f843d861ce2b7228ec4e3dec6", GIT_OID_SHA1));
entry.path = "top-level.txt";
cl_git_pass(git_index_add(index, &entry));
@@ -156,7 +159,7 @@ void test_index_cache__two_levels(void)
cl_assert(git_tree_cache_get(index->tree, "subdir"));
entry.path = "top-level.txt";
- cl_git_pass(git_oid__fromstr(&entry.id, "3697d64be941a53d4ae8f6a271e4e3fa56b022cc", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&entry.id, "3697d64be941a53d4ae8f6a271e4e3fa56b022cc", GIT_OID_SHA1));
cl_git_pass(git_index_add(index, &entry));
/* writ out the index after we invalidate the root */
@@ -191,7 +194,7 @@ void test_index_cache__read_tree_children(void)
memset(&entry, 0x0, sizeof(git_index_entry));
entry.path = "top-level";
entry.mode = GIT_FILEMODE_BLOB;
- git_oid__fromstr(&entry.id, "ee3fa1b8c00aff7fe02065fdb50864bb0d932ccf", GIT_OID_SHA1);
+ git_oid_from_string(&entry.id, "ee3fa1b8c00aff7fe02065fdb50864bb0d932ccf", GIT_OID_SHA1);
cl_git_pass(git_index_add(index, &entry));
@@ -217,7 +220,7 @@ void test_index_cache__read_tree_children(void)
/* override with a slightly different id, also dummy */
entry.path = "subdir/some-file";
- git_oid__fromstr(&entry.id, "ee3fa1b8c00aff7fe02065fdb50864bb0d932ccf", GIT_OID_SHA1);
+ git_oid_from_string(&entry.id, "ee3fa1b8c00aff7fe02065fdb50864bb0d932ccf", GIT_OID_SHA1);
cl_git_pass(git_index_add(index, &entry));
cl_assert_equal_i(-1, index->tree->entry_count);
diff --git a/tests/libgit2/index/conflicts.c b/tests/libgit2/index/conflicts.c
index 353886f7b53..cecdc5d3303 100644
--- a/tests/libgit2/index/conflicts.c
+++ b/tests/libgit2/index/conflicts.c
@@ -37,17 +37,17 @@ void test_index_conflicts__add(void)
ancestor_entry.path = "test-one.txt";
ancestor_entry.mode = 0100644;
GIT_INDEX_ENTRY_STAGE_SET(&ancestor_entry, 1);
- git_oid__fromstr(&ancestor_entry.id, CONFLICTS_ONE_ANCESTOR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&ancestor_entry.id, CONFLICTS_ONE_ANCESTOR_OID, GIT_OID_SHA1);
our_entry.path = "test-one.txt";
our_entry.mode = 0100644;
GIT_INDEX_ENTRY_STAGE_SET(&our_entry, 2);
- git_oid__fromstr(&our_entry.id, CONFLICTS_ONE_OUR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&our_entry.id, CONFLICTS_ONE_OUR_OID, GIT_OID_SHA1);
their_entry.path = "test-one.txt";
their_entry.mode = 0100644;
GIT_INDEX_ENTRY_STAGE_SET(&ancestor_entry, 2);
- git_oid__fromstr(&their_entry.id, CONFLICTS_ONE_THEIR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&their_entry.id, CONFLICTS_ONE_THEIR_OID, GIT_OID_SHA1);
cl_git_pass(git_index_conflict_add(repo_index, &ancestor_entry, &our_entry, &their_entry));
@@ -68,17 +68,17 @@ void test_index_conflicts__add_fixes_incorrect_stage(void)
ancestor_entry.path = "test-one.txt";
ancestor_entry.mode = 0100644;
GIT_INDEX_ENTRY_STAGE_SET(&ancestor_entry, 3);
- git_oid__fromstr(&ancestor_entry.id, CONFLICTS_ONE_ANCESTOR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&ancestor_entry.id, CONFLICTS_ONE_ANCESTOR_OID, GIT_OID_SHA1);
our_entry.path = "test-one.txt";
our_entry.mode = 0100644;
GIT_INDEX_ENTRY_STAGE_SET(&our_entry, 1);
- git_oid__fromstr(&our_entry.id, CONFLICTS_ONE_OUR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&our_entry.id, CONFLICTS_ONE_OUR_OID, GIT_OID_SHA1);
their_entry.path = "test-one.txt";
their_entry.mode = 0100644;
GIT_INDEX_ENTRY_STAGE_SET(&their_entry, 2);
- git_oid__fromstr(&their_entry.id, CONFLICTS_ONE_THEIR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&their_entry.id, CONFLICTS_ONE_THEIR_OID, GIT_OID_SHA1);
cl_git_pass(git_index_conflict_add(repo_index, &ancestor_entry, &our_entry, &their_entry));
@@ -111,17 +111,17 @@ void test_index_conflicts__add_detects_invalid_filemode(void)
ancestor_entry.path = "test-one.txt";
ancestor_entry.mode = 0100644;
GIT_INDEX_ENTRY_STAGE_SET(&ancestor_entry, 3);
- git_oid__fromstr(&ancestor_entry.id, CONFLICTS_ONE_ANCESTOR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&ancestor_entry.id, CONFLICTS_ONE_ANCESTOR_OID, GIT_OID_SHA1);
our_entry.path = "test-one.txt";
our_entry.mode = 0100644;
GIT_INDEX_ENTRY_STAGE_SET(&our_entry, 1);
- git_oid__fromstr(&our_entry.id, CONFLICTS_ONE_OUR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&our_entry.id, CONFLICTS_ONE_OUR_OID, GIT_OID_SHA1);
their_entry.path = "test-one.txt";
their_entry.mode = 0100644;
GIT_INDEX_ENTRY_STAGE_SET(&their_entry, 2);
- git_oid__fromstr(&their_entry.id, CONFLICTS_ONE_THEIR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&their_entry.id, CONFLICTS_ONE_THEIR_OID, GIT_OID_SHA1);
/* Corrupt the conflict entry's mode */
conflict_entry[i]->mode = 027431745;
@@ -151,17 +151,17 @@ void test_index_conflicts__add_removes_stage_zero(void)
ancestor_entry.path = "test-one.txt";
ancestor_entry.mode = 0100644;
GIT_INDEX_ENTRY_STAGE_SET(&ancestor_entry, 3);
- git_oid__fromstr(&ancestor_entry.id, CONFLICTS_ONE_ANCESTOR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&ancestor_entry.id, CONFLICTS_ONE_ANCESTOR_OID, GIT_OID_SHA1);
our_entry.path = "test-one.txt";
our_entry.mode = 0100644;
GIT_INDEX_ENTRY_STAGE_SET(&our_entry, 1);
- git_oid__fromstr(&our_entry.id, CONFLICTS_ONE_OUR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&our_entry.id, CONFLICTS_ONE_OUR_OID, GIT_OID_SHA1);
their_entry.path = "test-one.txt";
their_entry.mode = 0100644;
GIT_INDEX_ENTRY_STAGE_SET(&their_entry, 2);
- git_oid__fromstr(&their_entry.id, CONFLICTS_ONE_THEIR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&their_entry.id, CONFLICTS_ONE_THEIR_OID, GIT_OID_SHA1);
cl_git_pass(git_index_conflict_add(repo_index, &ancestor_entry, &our_entry, &their_entry));
@@ -189,13 +189,13 @@ void test_index_conflicts__get(void)
cl_assert_equal_s("conflicts-one.txt", conflict_entry[0]->path);
- git_oid__fromstr(&oid, CONFLICTS_ONE_ANCESTOR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, CONFLICTS_ONE_ANCESTOR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&oid, &conflict_entry[0]->id);
- git_oid__fromstr(&oid, CONFLICTS_ONE_OUR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, CONFLICTS_ONE_OUR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&oid, &conflict_entry[1]->id);
- git_oid__fromstr(&oid, CONFLICTS_ONE_THEIR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, CONFLICTS_ONE_THEIR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&oid, &conflict_entry[2]->id);
cl_git_pass(git_index_conflict_get(&conflict_entry[0], &conflict_entry[1],
@@ -203,13 +203,13 @@ void test_index_conflicts__get(void)
cl_assert_equal_s("conflicts-two.txt", conflict_entry[0]->path);
- git_oid__fromstr(&oid, CONFLICTS_TWO_ANCESTOR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, CONFLICTS_TWO_ANCESTOR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&oid, &conflict_entry[0]->id);
- git_oid__fromstr(&oid, CONFLICTS_TWO_OUR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, CONFLICTS_TWO_OUR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&oid, &conflict_entry[1]->id);
- git_oid__fromstr(&oid, CONFLICTS_TWO_THEIR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, CONFLICTS_TWO_THEIR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&oid, &conflict_entry[2]->id);
}
@@ -223,29 +223,29 @@ void test_index_conflicts__iterate(void)
cl_git_pass(git_index_conflict_next(&conflict_entry[0], &conflict_entry[1], &conflict_entry[2], iterator));
- git_oid__fromstr(&oid, CONFLICTS_ONE_ANCESTOR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, CONFLICTS_ONE_ANCESTOR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&oid, &conflict_entry[0]->id);
cl_assert(git__strcmp(conflict_entry[0]->path, "conflicts-one.txt") == 0);
- git_oid__fromstr(&oid, CONFLICTS_ONE_OUR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, CONFLICTS_ONE_OUR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&oid, &conflict_entry[1]->id);
cl_assert(git__strcmp(conflict_entry[0]->path, "conflicts-one.txt") == 0);
- git_oid__fromstr(&oid, CONFLICTS_ONE_THEIR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, CONFLICTS_ONE_THEIR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&oid, &conflict_entry[2]->id);
cl_assert(git__strcmp(conflict_entry[0]->path, "conflicts-one.txt") == 0);
cl_git_pass(git_index_conflict_next(&conflict_entry[0], &conflict_entry[1], &conflict_entry[2], iterator));
- git_oid__fromstr(&oid, CONFLICTS_TWO_ANCESTOR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, CONFLICTS_TWO_ANCESTOR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&oid, &conflict_entry[0]->id);
cl_assert(git__strcmp(conflict_entry[0]->path, "conflicts-two.txt") == 0);
- git_oid__fromstr(&oid, CONFLICTS_TWO_OUR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, CONFLICTS_TWO_OUR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&oid, &conflict_entry[1]->id);
cl_assert(git__strcmp(conflict_entry[0]->path, "conflicts-two.txt") == 0);
- git_oid__fromstr(&oid, CONFLICTS_TWO_THEIR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, CONFLICTS_TWO_THEIR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&oid, &conflict_entry[2]->id);
cl_assert(git__strcmp(conflict_entry[0]->path, "conflicts-two.txt") == 0);
@@ -357,7 +357,7 @@ void test_index_conflicts__partial(void)
ancestor_entry.path = "test-one.txt";
ancestor_entry.mode = 0100644;
GIT_INDEX_ENTRY_STAGE_SET(&ancestor_entry, 1);
- git_oid__fromstr(&ancestor_entry.id, CONFLICTS_ONE_ANCESTOR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&ancestor_entry.id, CONFLICTS_ONE_ANCESTOR_OID, GIT_OID_SHA1);
cl_git_pass(git_index_conflict_add(repo_index, &ancestor_entry, NULL, NULL));
cl_assert(git_index_entrycount(repo_index) == 9);
@@ -387,17 +387,17 @@ void test_index_conflicts__case_matters(void)
ancestor_entry.path = upper_case;
GIT_INDEX_ENTRY_STAGE_SET(&ancestor_entry, GIT_INDEX_STAGE_ANCESTOR);
- git_oid__fromstr(&ancestor_entry.id, CONFLICTS_ONE_ANCESTOR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&ancestor_entry.id, CONFLICTS_ONE_ANCESTOR_OID, GIT_OID_SHA1);
ancestor_entry.mode = GIT_FILEMODE_BLOB;
our_entry.path = upper_case;
GIT_INDEX_ENTRY_STAGE_SET(&our_entry, GIT_INDEX_STAGE_OURS);
- git_oid__fromstr(&our_entry.id, CONFLICTS_ONE_OUR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&our_entry.id, CONFLICTS_ONE_OUR_OID, GIT_OID_SHA1);
our_entry.mode = GIT_FILEMODE_BLOB;
their_entry.path = upper_case;
GIT_INDEX_ENTRY_STAGE_SET(&their_entry, GIT_INDEX_STAGE_THEIRS);
- git_oid__fromstr(&their_entry.id, CONFLICTS_ONE_THEIR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&their_entry.id, CONFLICTS_ONE_THEIR_OID, GIT_OID_SHA1);
their_entry.mode = GIT_FILEMODE_BLOB;
cl_git_pass(git_index_conflict_add(repo_index,
@@ -405,17 +405,17 @@ void test_index_conflicts__case_matters(void)
ancestor_entry.path = mixed_case;
GIT_INDEX_ENTRY_STAGE_SET(&ancestor_entry, GIT_INDEX_STAGE_ANCESTOR);
- git_oid__fromstr(&ancestor_entry.id, CONFLICTS_TWO_ANCESTOR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&ancestor_entry.id, CONFLICTS_TWO_ANCESTOR_OID, GIT_OID_SHA1);
ancestor_entry.mode = GIT_FILEMODE_BLOB;
our_entry.path = mixed_case;
GIT_INDEX_ENTRY_STAGE_SET(&ancestor_entry, GIT_INDEX_STAGE_ANCESTOR);
- git_oid__fromstr(&our_entry.id, CONFLICTS_TWO_OUR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&our_entry.id, CONFLICTS_TWO_OUR_OID, GIT_OID_SHA1);
ancestor_entry.mode = GIT_FILEMODE_BLOB;
their_entry.path = mixed_case;
GIT_INDEX_ENTRY_STAGE_SET(&their_entry, GIT_INDEX_STAGE_THEIRS);
- git_oid__fromstr(&their_entry.id, CONFLICTS_TWO_THEIR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&their_entry.id, CONFLICTS_TWO_THEIR_OID, GIT_OID_SHA1);
their_entry.mode = GIT_FILEMODE_BLOB;
cl_git_pass(git_index_conflict_add(repo_index,
@@ -434,29 +434,29 @@ void test_index_conflicts__case_matters(void)
correct_case = upper_case;
cl_assert_equal_s(correct_case, conflict_entry[0]->path);
- git_oid__fromstr(&oid, ignorecase ? CONFLICTS_TWO_ANCESTOR_OID : CONFLICTS_ONE_ANCESTOR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, ignorecase ? CONFLICTS_TWO_ANCESTOR_OID : CONFLICTS_ONE_ANCESTOR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&oid, &conflict_entry[0]->id);
cl_assert_equal_s(correct_case, conflict_entry[1]->path);
- git_oid__fromstr(&oid, ignorecase ? CONFLICTS_TWO_OUR_OID : CONFLICTS_ONE_OUR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, ignorecase ? CONFLICTS_TWO_OUR_OID : CONFLICTS_ONE_OUR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&oid, &conflict_entry[1]->id);
cl_assert_equal_s(correct_case, conflict_entry[2]->path);
- git_oid__fromstr(&oid, ignorecase ? CONFLICTS_TWO_THEIR_OID : CONFLICTS_ONE_THEIR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, ignorecase ? CONFLICTS_TWO_THEIR_OID : CONFLICTS_ONE_THEIR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&oid, &conflict_entry[2]->id);
cl_git_pass(git_index_conflict_get(&conflict_entry[0], &conflict_entry[1],
&conflict_entry[2], repo_index, mixed_case));
cl_assert_equal_s(mixed_case, conflict_entry[0]->path);
- git_oid__fromstr(&oid, CONFLICTS_TWO_ANCESTOR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, CONFLICTS_TWO_ANCESTOR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&oid, &conflict_entry[0]->id);
cl_assert_equal_s(mixed_case, conflict_entry[1]->path);
- git_oid__fromstr(&oid, CONFLICTS_TWO_OUR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, CONFLICTS_TWO_OUR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&oid, &conflict_entry[1]->id);
cl_assert_equal_s(mixed_case, conflict_entry[2]->path);
- git_oid__fromstr(&oid, CONFLICTS_TWO_THEIR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, CONFLICTS_TWO_THEIR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&oid, &conflict_entry[2]->id);
}
diff --git a/tests/libgit2/index/crlf.c b/tests/libgit2/index/crlf.c
index 666ac1a0c4c..e1788f18a7c 100644
--- a/tests/libgit2/index/crlf.c
+++ b/tests/libgit2/index/crlf.c
@@ -190,7 +190,7 @@ static void set_up_workingdir(const char *name)
continue;
p_unlink(fn);
}
- git_vector_free_deep(&contents);
+ git_vector_dispose_deep(&contents);
/* copy input files */
git_fs_path_dirload(&contents, cl_fixture("crlf"), 0, 0);
@@ -207,7 +207,7 @@ static void set_up_workingdir(const char *name)
git__free(basename);
git_str_dispose(&dest_filename);
}
- git_vector_free_deep(&contents);
+ git_vector_dispose_deep(&contents);
}
void test_index_crlf__matches_core_git(void)
@@ -243,7 +243,7 @@ void test_index_crlf__autocrlf_false_no_attrs(void)
cl_git_pass(git_index_add_bypath(g_index, "newfile.txt"));
entry = git_index_get_bypath(g_index, "newfile.txt", 0);
- cl_git_pass(git_oid__fromstr(&oid,
+ cl_git_pass(git_oid_from_string(&oid,
(GIT_EOL_NATIVE == GIT_EOL_CRLF) ? FILE_OID_CRLF : FILE_OID_LF,
GIT_OID_SHA1));
cl_assert_equal_oid(&oid, &entry->id);
@@ -262,7 +262,7 @@ void test_index_crlf__autocrlf_true_no_attrs(void)
cl_git_pass(git_index_add_bypath(g_index, "newfile.txt"));
entry = git_index_get_bypath(g_index, "newfile.txt", 0);
- cl_git_pass(git_oid__fromstr(&oid, FILE_OID_LF, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, FILE_OID_LF, GIT_OID_SHA1));
cl_assert_equal_oid(&oid, &entry->id);
}
@@ -279,7 +279,7 @@ void test_index_crlf__autocrlf_input_no_attrs(void)
cl_git_pass(git_index_add_bypath(g_index, "newfile.txt"));
entry = git_index_get_bypath(g_index, "newfile.txt", 0);
- cl_git_pass(git_oid__fromstr(&oid, FILE_OID_LF, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, FILE_OID_LF, GIT_OID_SHA1));
cl_assert_equal_oid(&oid, &entry->id);
}
@@ -298,7 +298,7 @@ void test_index_crlf__autocrlf_false_text_auto_attr(void)
cl_git_pass(git_index_add_bypath(g_index, "newfile.txt"));
entry = git_index_get_bypath(g_index, "newfile.txt", 0);
- cl_git_pass(git_oid__fromstr(&oid, FILE_OID_LF, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, FILE_OID_LF, GIT_OID_SHA1));
cl_assert_equal_oid(&oid, &entry->id);
}
@@ -317,7 +317,7 @@ void test_index_crlf__autocrlf_true_text_auto_attr(void)
cl_git_pass(git_index_add_bypath(g_index, "newfile.txt"));
entry = git_index_get_bypath(g_index, "newfile.txt", 0);
- cl_git_pass(git_oid__fromstr(&oid, FILE_OID_LF, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, FILE_OID_LF, GIT_OID_SHA1));
cl_assert_equal_oid(&oid, &entry->id);
}
@@ -336,7 +336,7 @@ void test_index_crlf__autocrlf_input_text_auto_attr(void)
cl_git_pass(git_index_add_bypath(g_index, "newfile.txt"));
entry = git_index_get_bypath(g_index, "newfile.txt", 0);
- cl_git_pass(git_oid__fromstr(&oid, FILE_OID_LF, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, FILE_OID_LF, GIT_OID_SHA1));
cl_assert_equal_oid(&oid, &entry->id);
}
@@ -356,7 +356,7 @@ void test_index_crlf__safecrlf_true_autocrlf_input_text_auto_attr(void)
entry = git_index_get_bypath(g_index, "newfile.txt", 0);
cl_assert(entry);
- cl_git_pass(git_oid__fromstr(&oid, FILE_OID_LF, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, FILE_OID_LF, GIT_OID_SHA1));
cl_assert_equal_oid(&oid, &entry->id);
cl_git_mkfile("./crlf/newfile2.txt", FILE_CONTENTS_CRLF);
@@ -377,7 +377,7 @@ void test_index_crlf__safecrlf_true_autocrlf_input_text__no_attr(void)
entry = git_index_get_bypath(g_index, "newfile.txt", 0);
cl_assert(entry);
- cl_git_pass(git_oid__fromstr(&oid, FILE_OID_LF, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, FILE_OID_LF, GIT_OID_SHA1));
cl_assert_equal_oid(&oid, &entry->id);
cl_git_mkfile("./crlf/newfile2.txt", FILE_CONTENTS_CRLF);
diff --git a/tests/libgit2/index/inmemory.c b/tests/libgit2/index/inmemory.c
index 38e91e0fd94..2b4ea994877 100644
--- a/tests/libgit2/index/inmemory.c
+++ b/tests/libgit2/index/inmemory.c
@@ -1,4 +1,5 @@
#include "clar_libgit2.h"
+#include "index.h"
void test_index_inmemory__can_create_an_inmemory_index(void)
{
@@ -14,7 +15,7 @@ void test_index_inmemory__cannot_add_bypath_to_an_inmemory_index(void)
{
git_index *index;
- cl_git_pass(git_index_new(&index));
+ cl_git_pass(git_index_new_ext(&index, NULL));
cl_assert_equal_i(GIT_ERROR, git_index_add_bypath(index, "test.txt"));
diff --git a/tests/libgit2/index/names.c b/tests/libgit2/index/names.c
index 2a41100aac2..1121021e462 100644
--- a/tests/libgit2/index/names.c
+++ b/tests/libgit2/index/names.c
@@ -42,21 +42,21 @@ static void index_add_conflicts(void)
entry.path = conflict[0];
entry.mode = GIT_FILEMODE_BLOB;
GIT_INDEX_ENTRY_STAGE_SET(&entry, GIT_INDEX_STAGE_ANCESTOR);
- git_oid__fromstr(&entry.id, "1f85ca51b8e0aac893a621b61a9c2661d6aa6d81", GIT_OID_SHA1);
+ git_oid_from_string(&entry.id, "1f85ca51b8e0aac893a621b61a9c2661d6aa6d81", GIT_OID_SHA1);
cl_git_pass(git_index_add(repo_index, &entry));
/* ours */
entry.path = conflict[1];
entry.mode = GIT_FILEMODE_BLOB;
GIT_INDEX_ENTRY_STAGE_SET(&entry, GIT_INDEX_STAGE_OURS);
- git_oid__fromstr(&entry.id, "1f85ca51b8e0aac893a621b61a9c2661d6aa6d81", GIT_OID_SHA1);
+ git_oid_from_string(&entry.id, "1f85ca51b8e0aac893a621b61a9c2661d6aa6d81", GIT_OID_SHA1);
cl_git_pass(git_index_add(repo_index, &entry));
/* theirs */
entry.path = conflict[2];
entry.mode = GIT_FILEMODE_BLOB;
GIT_INDEX_ENTRY_STAGE_SET(&entry, GIT_INDEX_STAGE_THEIRS);
- git_oid__fromstr(&entry.id, "1f85ca51b8e0aac893a621b61a9c2661d6aa6d81", GIT_OID_SHA1);
+ git_oid_from_string(&entry.id, "1f85ca51b8e0aac893a621b61a9c2661d6aa6d81", GIT_OID_SHA1);
cl_git_pass(git_index_add(repo_index, &entry));
}
}
diff --git a/tests/libgit2/index/racy.c b/tests/libgit2/index/racy.c
index 07b3b73d429..bbac7a6df3b 100644
--- a/tests/libgit2/index/racy.c
+++ b/tests/libgit2/index/racy.c
@@ -279,6 +279,7 @@ void test_index_racy__read_index_smudges(void)
{
git_index *index, *newindex;
const git_index_entry *entry;
+ git_index_options index_opts = GIT_INDEX_OPTIONS_INIT;
/* if we are reading an index into our new index, ensure that any
* racy entries in the index that we're reading are smudged so that
@@ -287,7 +288,7 @@ void test_index_racy__read_index_smudges(void)
setup_race();
cl_git_pass(git_repository_index(&index, g_repo));
- cl_git_pass(git_index_new(&newindex));
+ cl_git_pass(git_index_new_ext(&newindex, &index_opts));
cl_git_pass(git_index_read_index(newindex, index));
cl_assert(entry = git_index_get_bypath(newindex, "A", 0));
diff --git a/tests/libgit2/index/read_index.c b/tests/libgit2/index/read_index.c
index ac03cf1773e..fbd671c2fe1 100644
--- a/tests/libgit2/index/read_index.c
+++ b/tests/libgit2/index/read_index.c
@@ -33,8 +33,11 @@ void test_index_read_index__maintains_stat_cache(void)
git_index_entry new_entry;
const git_index_entry *e;
git_tree *tree;
+ git_index_options index_opts = GIT_INDEX_OPTIONS_INIT;
size_t i;
+ index_opts.oid_type = GIT_OID_SHA1;
+
cl_assert_equal_i(4, git_index_entrycount(_index));
/* write-tree */
@@ -42,14 +45,14 @@ void test_index_read_index__maintains_stat_cache(void)
/* read-tree, then read index */
git_tree_lookup(&tree, _repo, &index_id);
- cl_git_pass(git_index_new(&new_index));
+ cl_git_pass(git_index_new_ext(&new_index, &index_opts));
cl_git_pass(git_index_read_tree(new_index, tree));
git_tree_free(tree);
/* add a new entry that will not have stat data */
memset(&new_entry, 0, sizeof(git_index_entry));
new_entry.path = "Hello";
- git_oid__fromstr(&new_entry.id, "0123456789012345678901234567890123456789", GIT_OID_SHA1);
+ git_oid_from_string(&new_entry.id, "0123456789012345678901234567890123456789", GIT_OID_SHA1);
new_entry.file_size = 1234;
new_entry.mode = 0100644;
cl_git_pass(git_index_add(new_index, &new_entry));
@@ -79,7 +82,7 @@ static bool roundtrip_with_read_index(const char *tree_idstr)
git_tree *tree;
git_index *tree_index;
- cl_git_pass(git_oid__fromstr(&tree_id, tree_idstr, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&tree_id, tree_idstr, GIT_OID_SHA1));
cl_git_pass(git_tree_lookup(&tree, _repo, &tree_id));
cl_git_pass(git_index_new(&tree_index));
cl_git_pass(git_index_read_tree(tree_index, tree));
@@ -110,15 +113,18 @@ void test_index_read_index__read_and_writes(void)
git_oid tree_id, new_tree_id;
git_tree *tree;
git_index *tree_index, *new_index;
+ git_index_options index_opts = GIT_INDEX_OPTIONS_INIT;
+
+ index_opts.oid_type = GIT_OID_SHA1;
- cl_git_pass(git_oid__fromstr(&tree_id, "ae90f12eea699729ed24555e40b9fd669da12a12", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&tree_id, "ae90f12eea699729ed24555e40b9fd669da12a12", GIT_OID_SHA1));
cl_git_pass(git_tree_lookup(&tree, _repo, &tree_id));
- cl_git_pass(git_index_new(&tree_index));
+ cl_git_pass(git_index_new_ext(&tree_index, &index_opts));
cl_git_pass(git_index_read_tree(tree_index, tree));
cl_git_pass(git_index_read_index(_index, tree_index));
cl_git_pass(git_index_write(_index));
- cl_git_pass(git_index_open(&new_index, git_index_path(_index)));
+ cl_git_pass(git_index_open_ext(&new_index, git_index_path(_index), &index_opts));
cl_git_pass(git_index_write_tree_to(&new_tree_id, new_index, _repo));
cl_assert_equal_oid(&tree_id, &new_tree_id);
@@ -148,17 +154,17 @@ static void add_conflicts(git_index *index, const char *filename)
ancestor_entry.path = filename;
ancestor_entry.mode = 0100644;
GIT_INDEX_ENTRY_STAGE_SET(&ancestor_entry, 1);
- git_oid__fromstr(&ancestor_entry.id, ancestor_ids[conflict_idx], GIT_OID_SHA1);
+ git_oid_from_string(&ancestor_entry.id, ancestor_ids[conflict_idx], GIT_OID_SHA1);
our_entry.path = filename;
our_entry.mode = 0100644;
GIT_INDEX_ENTRY_STAGE_SET(&our_entry, 2);
- git_oid__fromstr(&our_entry.id, our_ids[conflict_idx], GIT_OID_SHA1);
+ git_oid_from_string(&our_entry.id, our_ids[conflict_idx], GIT_OID_SHA1);
their_entry.path = filename;
their_entry.mode = 0100644;
GIT_INDEX_ENTRY_STAGE_SET(&ancestor_entry, 2);
- git_oid__fromstr(&their_entry.id, their_ids[conflict_idx], GIT_OID_SHA1);
+ git_oid_from_string(&their_entry.id, their_ids[conflict_idx], GIT_OID_SHA1);
cl_git_pass(git_index_conflict_add(index, &ancestor_entry,
&our_entry, &their_entry));
@@ -172,10 +178,10 @@ void test_index_read_index__handles_conflicts(void)
git_index_conflict_iterator *conflict_iterator;
const git_index_entry *ancestor, *ours, *theirs;
- cl_git_pass(git_oid__fromstr(&tree_id, "ae90f12eea699729ed24555e40b9fd669da12a12", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&tree_id, "ae90f12eea699729ed24555e40b9fd669da12a12", GIT_OID_SHA1));
cl_git_pass(git_tree_lookup(&tree, _repo, &tree_id));
- cl_git_pass(git_index_new(&index));
- cl_git_pass(git_index_new(&new_index));
+ cl_git_pass(git_index_new_ext(&index, NULL));
+ cl_git_pass(git_index_new_ext(&new_index, NULL));
cl_git_pass(git_index_read_tree(index, tree));
cl_git_pass(git_index_read_tree(new_index, tree));
diff --git a/tests/libgit2/index/rename.c b/tests/libgit2/index/rename.c
index 9b132cb61b0..509601357f0 100644
--- a/tests/libgit2/index/rename.c
+++ b/tests/libgit2/index/rename.c
@@ -22,7 +22,7 @@ void test_index_rename__single_file(void)
cl_git_pass(git_index_add_bypath(index, "lame.name.txt"));
cl_assert(git_index_entrycount(index) == 1);
- cl_git_pass(git_oid__fromstr(&expected, "d4fa8600b4f37d7516bef4816ae2c64dbf029e3a", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected, "d4fa8600b4f37d7516bef4816ae2c64dbf029e3a", GIT_OID_SHA1));
cl_assert(!git_index_find(&position, index, "lame.name.txt"));
diff --git a/tests/libgit2/index/reuc.c b/tests/libgit2/index/reuc.c
index 7d8766c57f7..6c7923d2ed5 100644
--- a/tests/libgit2/index/reuc.c
+++ b/tests/libgit2/index/reuc.c
@@ -38,9 +38,9 @@ void test_index_reuc__add(void)
git_oid ancestor_oid, our_oid, their_oid;
const git_index_reuc_entry *reuc;
- git_oid__fromstr(&ancestor_oid, ONE_ANCESTOR_OID, GIT_OID_SHA1);
- git_oid__fromstr(&our_oid, ONE_OUR_OID, GIT_OID_SHA1);
- git_oid__fromstr(&their_oid, ONE_THEIR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&ancestor_oid, ONE_ANCESTOR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&our_oid, ONE_OUR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&their_oid, ONE_THEIR_OID, GIT_OID_SHA1);
cl_git_pass(git_index_reuc_add(repo_index, "newfile.txt",
0100644, &ancestor_oid,
@@ -66,8 +66,8 @@ void test_index_reuc__add_no_ancestor(void)
const git_index_reuc_entry *reuc;
memset(&ancestor_oid, 0x0, sizeof(git_oid));
- git_oid__fromstr(&our_oid, ONE_OUR_OID, GIT_OID_SHA1);
- git_oid__fromstr(&their_oid, ONE_THEIR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&our_oid, ONE_OUR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&their_oid, ONE_THEIR_OID, GIT_OID_SHA1);
cl_git_pass(git_index_reuc_add(repo_index, "newfile.txt",
0, NULL,
@@ -100,11 +100,11 @@ void test_index_reuc__read_bypath(void)
cl_assert(reuc->mode[0] == 0100644);
cl_assert(reuc->mode[1] == 0100644);
cl_assert(reuc->mode[2] == 0100644);
- git_oid__fromstr(&oid, TWO_ANCESTOR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, TWO_ANCESTOR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&reuc->oid[0], &oid);
- git_oid__fromstr(&oid, TWO_OUR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, TWO_OUR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&reuc->oid[1], &oid);
- git_oid__fromstr(&oid, TWO_THEIR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, TWO_THEIR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&reuc->oid[2], &oid);
cl_assert(reuc = git_index_reuc_get_bypath(repo_index, "one.txt"));
@@ -113,11 +113,11 @@ void test_index_reuc__read_bypath(void)
cl_assert(reuc->mode[0] == 0100644);
cl_assert(reuc->mode[1] == 0100644);
cl_assert(reuc->mode[2] == 0100644);
- git_oid__fromstr(&oid, ONE_ANCESTOR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, ONE_ANCESTOR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&reuc->oid[0], &oid);
- git_oid__fromstr(&oid, ONE_OUR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, ONE_OUR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&reuc->oid[1], &oid);
- git_oid__fromstr(&oid, ONE_THEIR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, ONE_THEIR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&reuc->oid[2], &oid);
}
@@ -145,11 +145,11 @@ void test_index_reuc__ignore_case(void)
cl_assert(reuc->mode[0] == 0100644);
cl_assert(reuc->mode[1] == 0100644);
cl_assert(reuc->mode[2] == 0100644);
- git_oid__fromstr(&oid, TWO_ANCESTOR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, TWO_ANCESTOR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&reuc->oid[0], &oid);
- git_oid__fromstr(&oid, TWO_OUR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, TWO_OUR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&reuc->oid[1], &oid);
- git_oid__fromstr(&oid, TWO_THEIR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, TWO_THEIR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&reuc->oid[2], &oid);
}
@@ -166,11 +166,11 @@ void test_index_reuc__read_byindex(void)
cl_assert(reuc->mode[0] == 0100644);
cl_assert(reuc->mode[1] == 0100644);
cl_assert(reuc->mode[2] == 0100644);
- git_oid__fromstr(&oid, ONE_ANCESTOR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, ONE_ANCESTOR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&reuc->oid[0], &oid);
- git_oid__fromstr(&oid, ONE_OUR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, ONE_OUR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&reuc->oid[1], &oid);
- git_oid__fromstr(&oid, ONE_THEIR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, ONE_THEIR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&reuc->oid[2], &oid);
cl_assert(reuc = git_index_reuc_get_byindex(repo_index, 1));
@@ -179,11 +179,11 @@ void test_index_reuc__read_byindex(void)
cl_assert(reuc->mode[0] == 0100644);
cl_assert(reuc->mode[1] == 0100644);
cl_assert(reuc->mode[2] == 0100644);
- git_oid__fromstr(&oid, TWO_ANCESTOR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, TWO_ANCESTOR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&reuc->oid[0], &oid);
- git_oid__fromstr(&oid, TWO_OUR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, TWO_OUR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&reuc->oid[1], &oid);
- git_oid__fromstr(&oid, TWO_THEIR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, TWO_THEIR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&reuc->oid[2], &oid);
}
@@ -200,9 +200,9 @@ void test_index_reuc__updates_existing(void)
index_caps |= GIT_INDEX_CAPABILITY_IGNORE_CASE;
cl_git_pass(git_index_set_caps(repo_index, index_caps));
- git_oid__fromstr(&ancestor_oid, TWO_ANCESTOR_OID, GIT_OID_SHA1);
- git_oid__fromstr(&our_oid, TWO_OUR_OID, GIT_OID_SHA1);
- git_oid__fromstr(&their_oid, TWO_THEIR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&ancestor_oid, TWO_ANCESTOR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&our_oid, TWO_OUR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&their_oid, TWO_THEIR_OID, GIT_OID_SHA1);
cl_git_pass(git_index_reuc_add(repo_index, "two.txt",
0100644, &ancestor_oid,
@@ -219,11 +219,11 @@ void test_index_reuc__updates_existing(void)
cl_assert(reuc = git_index_reuc_get_byindex(repo_index, 0));
cl_assert_equal_s("TWO.txt", reuc->path);
- git_oid__fromstr(&oid, TWO_OUR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, TWO_OUR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&reuc->oid[0], &oid);
- git_oid__fromstr(&oid, TWO_THEIR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, TWO_THEIR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&reuc->oid[1], &oid);
- git_oid__fromstr(&oid, TWO_ANCESTOR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, TWO_ANCESTOR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&reuc->oid[2], &oid);
}
@@ -245,11 +245,11 @@ void test_index_reuc__remove(void)
cl_assert(reuc->mode[0] == 0100644);
cl_assert(reuc->mode[1] == 0100644);
cl_assert(reuc->mode[2] == 0100644);
- git_oid__fromstr(&oid, TWO_ANCESTOR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, TWO_ANCESTOR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&reuc->oid[0], &oid);
- git_oid__fromstr(&oid, TWO_OUR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, TWO_OUR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&reuc->oid[1], &oid);
- git_oid__fromstr(&oid, TWO_THEIR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&oid, TWO_THEIR_OID, GIT_OID_SHA1);
cl_assert_equal_oid(&reuc->oid[2], &oid);
}
@@ -261,18 +261,18 @@ void test_index_reuc__write(void)
git_index_clear(repo_index);
/* Write out of order to ensure sorting is correct */
- git_oid__fromstr(&ancestor_oid, TWO_ANCESTOR_OID, GIT_OID_SHA1);
- git_oid__fromstr(&our_oid, TWO_OUR_OID, GIT_OID_SHA1);
- git_oid__fromstr(&their_oid, TWO_THEIR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&ancestor_oid, TWO_ANCESTOR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&our_oid, TWO_OUR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&their_oid, TWO_THEIR_OID, GIT_OID_SHA1);
cl_git_pass(git_index_reuc_add(repo_index, "two.txt",
0100644, &ancestor_oid,
0100644, &our_oid,
0100644, &their_oid));
- git_oid__fromstr(&ancestor_oid, ONE_ANCESTOR_OID, GIT_OID_SHA1);
- git_oid__fromstr(&our_oid, ONE_OUR_OID, GIT_OID_SHA1);
- git_oid__fromstr(&their_oid, ONE_THEIR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&ancestor_oid, ONE_ANCESTOR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&our_oid, ONE_OUR_OID, GIT_OID_SHA1);
+ git_oid_from_string(&their_oid, ONE_THEIR_OID, GIT_OID_SHA1);
cl_git_pass(git_index_reuc_add(repo_index, "one.txt",
0100644, &ancestor_oid,
diff --git a/tests/libgit2/index/tests.c b/tests/libgit2/index/tests.c
index da3ff6dd7b5..63486ff54a5 100644
--- a/tests/libgit2/index/tests.c
+++ b/tests/libgit2/index/tests.c
@@ -259,7 +259,7 @@ void test_index_tests__add(void)
* This has been generated by executing the following
* $ echo "hey there" | git hash-object --stdin
*/
- cl_git_pass(git_oid__fromstr(&id1, "a8233120f6ad708f843d861ce2b7228ec4e3dec6", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id1, "a8233120f6ad708f843d861ce2b7228ec4e3dec6", GIT_OID_SHA1));
/* Add the new file to the index */
cl_git_pass(git_index_add_bypath(index, "test.txt"));
@@ -304,7 +304,7 @@ void test_index_tests__add_frombuffer(void)
* This has been generated by executing the following
* $ echo "hey there" | git hash-object --stdin
*/
- cl_git_pass(git_oid__fromstr(&id1, "a8233120f6ad708f843d861ce2b7228ec4e3dec6", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id1, "a8233120f6ad708f843d861ce2b7228ec4e3dec6", GIT_OID_SHA1));
/* Add the new file to the index */
memset(&entry, 0x0, sizeof(git_index_entry));
@@ -447,7 +447,7 @@ void test_index_tests__add_frombuffer_reset_entry(void)
* This has been generated by executing the following
* $ echo "hey there" | git hash-object --stdin
*/
- cl_git_pass(git_oid__fromstr(&id1, "a8233120f6ad708f843d861ce2b7228ec4e3dec6", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id1, "a8233120f6ad708f843d861ce2b7228ec4e3dec6", GIT_OID_SHA1));
cl_git_pass(git_index_add_bypath(index, "test.txt"));
@@ -511,7 +511,7 @@ void test_index_tests__add_issue_1397(void)
* This has been generated by executing the following
* $ git hash-object crlf_file.txt
*/
- cl_git_pass(git_oid__fromstr(&id1, "8312e0889a9cbab77c732b6bc39b51a683e3a318", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id1, "8312e0889a9cbab77c732b6bc39b51a683e3a318", GIT_OID_SHA1));
/* Make sure the initial SHA-1 is correct */
cl_assert((entry = git_index_get_bypath(index, "crlf_file.txt", 0)) != NULL);
@@ -600,7 +600,7 @@ static void assert_add_fails(git_repository *repo, const char *fn)
entry.path = fn;
entry.mode = GIT_FILEMODE_BLOB;
- cl_git_pass(git_oid__fromstr(&entry.id, "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&entry.id, "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", GIT_OID_SHA1));
cl_git_fail(git_index_add(index, &entry));
@@ -702,10 +702,13 @@ void test_index_tests__write_tree_invalid_unowned_index(void)
git_repository *repo;
git_index_entry entry = {{0}};
git_oid tree_id;
+ git_index_options index_opts = GIT_INDEX_OPTIONS_INIT;
- cl_git_pass(git_index_new(&idx));
+ index_opts.oid_type = GIT_OID_SHA1;
- cl_git_pass(git_oid__fromstr(&entry.id, "8312e0a89a9cbab77c732b6bc39b51a783e3a318", GIT_OID_SHA1));
+ cl_git_pass(git_index_new_ext(&idx, &index_opts));
+
+ cl_git_pass(git_oid_from_string(&entry.id, "8312e0a89a9cbab77c732b6bc39b51a783e3a318", GIT_OID_SHA1));
entry.path = "foo";
entry.mode = GIT_FILEMODE_BLOB;
cl_git_pass(git_index_add(idx, &entry));
@@ -1147,12 +1150,12 @@ void test_index_tests__can_modify_while_iterating(void)
* ensure that our iterator is backed by a snapshot and thus returns
* the number of entries from when the iterator was created.
*/
- cl_git_pass(git_oid__fromstr(&new_entry.id, "8312e0a89a9cbab77c732b6bc39b51a783e3a318", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&new_entry.id, "8312e0a89a9cbab77c732b6bc39b51a783e3a318", GIT_OID_SHA1));
new_entry.path = "newfile";
new_entry.mode = GIT_FILEMODE_BLOB;
cl_git_pass(git_index_add(index, &new_entry));
- cl_git_pass(git_oid__fromstr(&new_entry.id, "4141414141414141414141414141414141414141", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&new_entry.id, "4141414141414141414141414141414141414141", GIT_OID_SHA1));
new_entry.path = "Makefile";
new_entry.mode = GIT_FILEMODE_BLOB;
cl_git_pass(git_index_add(index, &new_entry));
diff --git a/tests/libgit2/index/tests256.c b/tests/libgit2/index/tests256.c
new file mode 100644
index 00000000000..7f94ab23fff
--- /dev/null
+++ b/tests/libgit2/index/tests256.c
@@ -0,0 +1,1208 @@
+#include "clar_libgit2.h"
+#include "index.h"
+
+#ifdef GIT_EXPERIMENTAL_SHA256
+
+static const size_t index_entry_count = 4344;
+#define TEST_INDEX_PATH cl_fixture("git-sha256.index")
+
+static git_repository_init_options repo_init_opts =
+ GIT_REPOSITORY_INIT_OPTIONS_INIT;
+
+/* Suite data */
+struct test_entry {
+ size_t index;
+ char path[128];
+ off64_t file_size;
+ git_time_t mtime;
+};
+
+static struct test_entry test_entries[] = {
+ { 892, "Makefile", 120084, 0x642c3a6e },
+ { 1542, "git.c", 27432, 0x642c3a6e },
+ { 1737, "perl/Git.pm", 48084, 0x642c3a6e },
+ { 1961, "t/Makefile", 4711, 0x642c3a6e },
+ { 4343, "zlib.c", 6271, 0x642c3a6f }
+};
+
+/* Helpers */
+static void copy_file(const char *src, const char *dst)
+{
+ git_str source_buf = GIT_STR_INIT;
+ git_file dst_fd;
+
+ cl_git_pass(git_futils_readbuffer(&source_buf, src));
+
+ dst_fd = git_futils_creat_withpath(dst, 0777, 0666); /* -V536 */
+ if (dst_fd < 0)
+ goto cleanup;
+
+ cl_git_pass(p_write(dst_fd, source_buf.ptr, source_buf.size));
+
+cleanup:
+ git_str_dispose(&source_buf);
+ p_close(dst_fd);
+}
+
+static void files_are_equal(const char *a, const char *b)
+{
+ git_str buf_a = GIT_STR_INIT;
+ git_str buf_b = GIT_STR_INIT;
+
+ if (git_futils_readbuffer(&buf_a, a) < 0)
+ cl_assert(0);
+
+ if (git_futils_readbuffer(&buf_b, b) < 0) {
+ git_str_dispose(&buf_a);
+ cl_assert(0);
+ }
+
+ cl_assert_equal_sz(buf_a.size, buf_b.size);
+ cl_assert(!memcmp(buf_a.ptr, buf_b.ptr, buf_a.size));
+
+ git_str_dispose(&buf_a);
+ git_str_dispose(&buf_b);
+}
+
+#endif
+
+/* Fixture setup and teardown */
+void test_index_tests256__initialize(void)
+{
+#ifdef GIT_EXPERIMENTAL_SHA256
+ repo_init_opts.flags |= GIT_REPOSITORY_INIT_MKPATH;
+ repo_init_opts.oid_type = GIT_OID_SHA256;
+#endif
+}
+
+void test_index_tests256__cleanup(void)
+{
+#ifdef GIT_EXPERIMENTAL_SHA256
+ cl_git_pass(git_libgit2_opts(GIT_OPT_ENABLE_UNSAVED_INDEX_SAFETY, 0));
+#endif
+}
+
+void test_index_tests256__empty_index(void)
+{
+#ifdef GIT_EXPERIMENTAL_SHA256
+ git_index *index;
+ git_index_options index_opts = GIT_INDEX_OPTIONS_INIT;
+
+ index_opts.oid_type = GIT_OID_SHA256;
+
+ cl_git_pass(git_index_open_ext(&index, "in-memory-index", &index_opts));
+ cl_assert(index->on_disk == 0);
+
+ cl_assert(git_index_entrycount(index) == 0);
+ cl_assert(git_vector_is_sorted(&index->entries));
+
+ git_index_free(index);
+#endif
+}
+
+void test_index_tests256__default_test_index(void)
+{
+#ifdef GIT_EXPERIMENTAL_SHA256
+ git_index *index;
+ unsigned int i;
+ git_index_entry **entries;
+ git_index_options index_opts = GIT_INDEX_OPTIONS_INIT;
+
+ index_opts.oid_type = GIT_OID_SHA256;
+
+ cl_git_pass(git_index_open_ext(&index, TEST_INDEX_PATH, &index_opts));
+ cl_assert(index->on_disk);
+
+ cl_assert_equal_sz(git_index_entrycount(index), index_entry_count);
+ cl_assert(git_vector_is_sorted(&index->entries));
+
+ entries = (git_index_entry **)index->entries.contents;
+
+ for (i = 0; i < ARRAY_SIZE(test_entries); ++i) {
+ git_index_entry *e = entries[test_entries[i].index];
+
+ cl_assert_equal_s(e->path, test_entries[i].path);
+ cl_assert_equal_i(e->mtime.seconds, test_entries[i].mtime);
+ cl_assert_equal_i(e->file_size, test_entries[i].file_size);
+ }
+
+ git_index_free(index);
+#endif
+}
+
+void test_index_tests256__find_in_existing(void)
+{
+#ifdef GIT_EXPERIMENTAL_SHA256
+ git_index *index;
+ unsigned int i;
+ git_index_options index_opts = GIT_INDEX_OPTIONS_INIT;
+
+ index_opts.oid_type = GIT_OID_SHA256;
+
+ cl_git_pass(git_index_open_ext(&index, TEST_INDEX_PATH, &index_opts));
+
+ for (i = 0; i < ARRAY_SIZE(test_entries); ++i) {
+ size_t idx;
+
+ cl_assert(!git_index_find(&idx, index, test_entries[i].path));
+ cl_assert(idx == test_entries[i].index);
+ }
+
+ git_index_free(index);
+#endif
+}
+
+void test_index_tests256__find_in_empty(void)
+{
+#ifdef GIT_EXPERIMENTAL_SHA256
+ git_index *index;
+ unsigned int i;
+ git_index_options index_opts = GIT_INDEX_OPTIONS_INIT;
+
+ index_opts.oid_type = GIT_OID_SHA256;
+
+ cl_git_pass(git_index_open_ext(&index, "fake-index", &index_opts));
+
+ for (i = 0; i < ARRAY_SIZE(test_entries); ++i) {
+ cl_assert(GIT_ENOTFOUND == git_index_find(NULL, index, test_entries[i].path));
+ }
+
+ git_index_free(index);
+#endif
+}
+
+void test_index_tests256__find_prefix(void)
+{
+#ifdef GIT_EXPERIMENTAL_SHA256
+ git_index *index;
+ const git_index_entry *entry;
+ size_t pos;
+ git_index_options index_opts = GIT_INDEX_OPTIONS_INIT;
+
+ index_opts.oid_type = GIT_OID_SHA256;
+
+ cl_git_pass(git_index_open_ext(&index, TEST_INDEX_PATH, &index_opts));
+
+ cl_git_pass(git_index_find_prefix(&pos, index, "Documentation"));
+ entry = git_index_get_byindex(index, pos);
+ cl_assert(git__strcmp(entry->path, "Documentation/.gitattributes") == 0);
+
+ cl_git_pass(git_index_find_prefix(&pos, index, "contrib/RE"));
+ entry = git_index_get_byindex(index, pos);
+ cl_assert(git__strcmp(entry->path, "contrib/README") == 0);
+
+ cl_assert(GIT_ENOTFOUND == git_index_find_prefix(NULL, index, "blah"));
+
+ git_index_free(index);
+#endif
+}
+
+void test_index_tests256__write(void)
+{
+#ifdef GIT_EXPERIMENTAL_SHA256
+ git_index *index;
+ git_index_options index_opts = GIT_INDEX_OPTIONS_INIT;
+
+ index_opts.oid_type = GIT_OID_SHA256;
+
+ copy_file(TEST_INDEX_PATH, "index_rewrite");
+
+ cl_git_pass(git_index_open_ext(&index, "index_rewrite", &index_opts));
+ cl_assert(index->on_disk);
+
+ cl_git_pass(git_index_write(index));
+ files_are_equal(TEST_INDEX_PATH, "index_rewrite");
+
+ git_index_free(index);
+
+ p_unlink("index_rewrite");
+#endif
+}
+
+void test_index_tests256__sort1(void)
+{
+#ifdef GIT_EXPERIMENTAL_SHA256
+ /* sort the entries in an empty index */
+ git_index *index;
+ git_index_options index_opts = GIT_INDEX_OPTIONS_INIT;
+
+ index_opts.oid_type = GIT_OID_SHA256;
+
+ cl_git_pass(git_index_open_ext(&index, "fake-index", &index_opts));
+
+ /* FIXME: this test is slightly dumb */
+ cl_assert(git_vector_is_sorted(&index->entries));
+
+ git_index_free(index);
+#endif
+}
+
+#ifdef GIT_EXPERIMENTAL_SHA256
+static void cleanup_myrepo(void *opaque)
+{
+ GIT_UNUSED(opaque);
+ cl_fixture_cleanup("myrepo");
+}
+#endif
+
+void test_index_tests256__add(void)
+{
+#ifdef GIT_EXPERIMENTAL_SHA256
+ git_index *index;
+ git_filebuf file = GIT_FILEBUF_INIT;
+ git_repository *repo;
+ const git_index_entry *entry;
+ git_oid id1;
+
+ cl_set_cleanup(&cleanup_myrepo, NULL);
+
+ /* Initialize a new repository */
+ cl_git_pass(git_repository_init_ext(&repo, "./myrepo", &repo_init_opts));
+
+ /* Ensure we're the only guy in the room */
+ cl_git_pass(git_repository_index(&index, repo));
+ cl_assert(git_index_entrycount(index) == 0);
+
+ /* Create a new file in the working directory */
+ cl_git_pass(git_futils_mkpath2file("myrepo/test.txt", 0777));
+ cl_git_pass(git_filebuf_open(&file, "myrepo/test.txt", 0, 0666));
+ cl_git_pass(git_filebuf_write(&file, "hey there\n", 10));
+ cl_git_pass(git_filebuf_commit(&file));
+
+ /* Store the expected hash of the file/blob
+ * This has been generated by executing the following
+ * $ echo "hey there" | git hash-object --stdin
+ */
+ cl_git_pass(git_oid_from_string(&id1, "aea29dc305d40e362df25c3fdeed5502fd56b182af01b7740d297a24459333c5", GIT_OID_SHA256));
+
+ /* Add the new file to the index */
+ cl_git_pass(git_index_add_bypath(index, "test.txt"));
+
+ /* Wow... it worked! */
+ cl_assert(git_index_entrycount(index) == 1);
+ entry = git_index_get_byindex(index, 0);
+
+ /* And the built-in hashing mechanism worked as expected */
+ cl_assert_equal_oid(&id1, &entry->id);
+
+ /* Test access by path instead of index */
+ cl_assert((entry = git_index_get_bypath(index, "test.txt", 0)) != NULL);
+ cl_assert_equal_oid(&id1, &entry->id);
+
+ git_index_free(index);
+ git_repository_free(repo);
+#endif
+}
+
+void test_index_tests256__add_frombuffer(void)
+{
+#ifdef GIT_EXPERIMENTAL_SHA256
+ git_index *index;
+ git_repository *repo;
+ git_index_entry entry;
+ const git_index_entry *returned_entry;
+
+ git_oid id1;
+ git_blob *blob;
+
+ const char *content = "hey there\n";
+
+ cl_set_cleanup(&cleanup_myrepo, NULL);
+
+ /* Initialize a new repository */
+ cl_git_pass(git_repository_init_ext(&repo, "./myrepo", &repo_init_opts));
+
+ /* Ensure we're the only guy in the room */
+ cl_git_pass(git_repository_index(&index, repo));
+ cl_assert(git_index_entrycount(index) == 0);
+
+ /* Store the expected hash of the file/blob
+ * This has been generated by executing the following
+ * $ echo "hey there" | git hash-object --stdin
+ */
+ cl_git_pass(git_oid_from_string(&id1, "aea29dc305d40e362df25c3fdeed5502fd56b182af01b7740d297a24459333c5", GIT_OID_SHA256));
+
+ /* Add the new file to the index */
+ memset(&entry, 0x0, sizeof(git_index_entry));
+ entry.mode = GIT_FILEMODE_BLOB;
+ entry.path = "test.txt";
+ cl_git_pass(git_index_add_from_buffer(index, &entry,
+ content, strlen(content)));
+
+ /* Wow... it worked! */
+ cl_assert(git_index_entrycount(index) == 1);
+ returned_entry = git_index_get_byindex(index, 0);
+
+ /* And the built-in hashing mechanism worked as expected */
+ cl_assert_equal_oid(&id1, &returned_entry->id);
+ /* And mode is the one asked */
+ cl_assert_equal_i(GIT_FILEMODE_BLOB, returned_entry->mode);
+
+ /* Test access by path instead of index */
+ cl_assert((returned_entry = git_index_get_bypath(index, "test.txt", 0)) != NULL);
+ cl_assert_equal_oid(&id1, &returned_entry->id);
+
+ /* Test the blob is in the repository */
+ cl_git_pass(git_blob_lookup(&blob, repo, &id1));
+ cl_assert_equal_s(
+ content, git_blob_rawcontent(blob));
+ git_blob_free(blob);
+
+ git_index_free(index);
+ git_repository_free(repo);
+#endif
+}
+
+void test_index_tests256__dirty_and_clean(void)
+{
+#ifdef GIT_EXPERIMENTAL_SHA256
+ git_repository *repo;
+ git_index *index;
+ git_index_entry entry = {{0}};
+
+ /* Index is not dirty after opening */
+ cl_git_pass(git_repository_init_ext(&repo, "./myrepo", &repo_init_opts));
+ cl_git_pass(git_repository_index(&index, repo));
+
+ cl_assert(git_index_entrycount(index) == 0);
+ cl_assert(!git_index_is_dirty(index));
+
+ /* Index is dirty after adding an entry */
+ entry.mode = GIT_FILEMODE_BLOB;
+ entry.path = "test.txt";
+ cl_git_pass(git_index_add_from_buffer(index, &entry, "Hi.\n", 4));
+ cl_assert(git_index_entrycount(index) == 1);
+ cl_assert(git_index_is_dirty(index));
+
+ /* Index is not dirty after write */
+ cl_git_pass(git_index_write(index));
+ cl_assert(!git_index_is_dirty(index));
+
+ /* Index is dirty after removing an entry */
+ cl_git_pass(git_index_remove_bypath(index, "test.txt"));
+ cl_assert(git_index_entrycount(index) == 0);
+ cl_assert(git_index_is_dirty(index));
+
+ /* Index is not dirty after write */
+ cl_git_pass(git_index_write(index));
+ cl_assert(!git_index_is_dirty(index));
+
+ /* Index remains not dirty after read */
+ cl_git_pass(git_index_read(index, 0));
+ cl_assert(!git_index_is_dirty(index));
+
+ /* Index is dirty when we do an unforced read with dirty content */
+ cl_git_pass(git_index_add_from_buffer(index, &entry, "Hi.\n", 4));
+ cl_assert(git_index_entrycount(index) == 1);
+ cl_assert(git_index_is_dirty(index));
+
+ cl_git_pass(git_index_read(index, 0));
+ cl_assert(git_index_is_dirty(index));
+
+ /* Index is clean when we force a read with dirty content */
+ cl_git_pass(git_index_read(index, 1));
+ cl_assert(!git_index_is_dirty(index));
+
+ git_index_free(index);
+ git_repository_free(repo);
+#endif
+}
+
+void test_index_tests256__dirty_fails_optionally(void)
+{
+#ifdef GIT_EXPERIMENTAL_SHA256
+ git_repository *repo;
+ git_index *index;
+ git_index_entry entry = {{0}};
+
+ /* Index is not dirty after opening */
+ repo = cl_git_sandbox_init("testrepo");
+ cl_git_pass(git_repository_index(&index, repo));
+
+ /* Index is dirty after adding an entry */
+ entry.mode = GIT_FILEMODE_BLOB;
+ entry.path = "test.txt";
+ cl_git_pass(git_index_add_from_buffer(index, &entry, "Hi.\n", 4));
+ cl_assert(git_index_is_dirty(index));
+
+ cl_git_pass(git_checkout_head(repo, NULL));
+
+ /* Index is dirty (again) after adding an entry */
+ entry.mode = GIT_FILEMODE_BLOB;
+ entry.path = "test.txt";
+ cl_git_pass(git_index_add_from_buffer(index, &entry, "Hi.\n", 4));
+ cl_assert(git_index_is_dirty(index));
+
+ cl_git_pass(git_libgit2_opts(GIT_OPT_ENABLE_UNSAVED_INDEX_SAFETY, 1));
+ cl_git_fail_with(GIT_EINDEXDIRTY, git_checkout_head(repo, NULL));
+
+ git_index_free(index);
+ cl_git_sandbox_cleanup();
+#endif
+}
+
+void test_index_tests256__add_frombuffer_reset_entry(void)
+{
+#ifdef GIT_EXPERIMENTAL_SHA256
+ git_index *index;
+ git_repository *repo;
+ git_index_entry entry;
+ const git_index_entry *returned_entry;
+ git_filebuf file = GIT_FILEBUF_INIT;
+
+ git_oid id1;
+ git_blob *blob;
+ const char *old_content = "here\n";
+ const char *content = "hey there\n";
+
+ cl_set_cleanup(&cleanup_myrepo, NULL);
+
+ /* Initialize a new repository */
+ cl_git_pass(git_repository_init_ext(&repo, "./myrepo", &repo_init_opts));
+ cl_git_pass(git_repository_index(&index, repo));
+ cl_git_pass(git_futils_mkpath2file("myrepo/test.txt", 0777));
+ cl_git_pass(git_filebuf_open(&file, "myrepo/test.txt", 0, 0666));
+ cl_git_pass(git_filebuf_write(&file, old_content, strlen(old_content)));
+ cl_git_pass(git_filebuf_commit(&file));
+
+ /* Store the expected hash of the file/blob
+ * This has been generated by executing the following
+ * $ echo "hey there" | git hash-object --stdin
+ */
+ cl_git_pass(git_oid_from_string(&id1, "aea29dc305d40e362df25c3fdeed5502fd56b182af01b7740d297a24459333c5", GIT_OID_SHA256));
+
+ cl_git_pass(git_index_add_bypath(index, "test.txt"));
+
+ /* Add the new file to the index */
+ memset(&entry, 0x0, sizeof(git_index_entry));
+ entry.mode = GIT_FILEMODE_BLOB;
+ entry.path = "test.txt";
+ cl_git_pass(git_index_add_from_buffer(index, &entry,
+ content, strlen(content)));
+
+ /* Wow... it worked! */
+ cl_assert(git_index_entrycount(index) == 1);
+ returned_entry = git_index_get_byindex(index, 0);
+
+ /* And the built-in hashing mechanism worked as expected */
+ cl_assert_equal_oid(&id1, &returned_entry->id);
+ /* And mode is the one asked */
+ cl_assert_equal_i(GIT_FILEMODE_BLOB, returned_entry->mode);
+
+ /* Test access by path instead of index */
+ cl_assert((returned_entry = git_index_get_bypath(index, "test.txt", 0)) != NULL);
+ cl_assert_equal_oid(&id1, &returned_entry->id);
+ cl_assert_equal_i(0, returned_entry->dev);
+ cl_assert_equal_i(0, returned_entry->ino);
+ cl_assert_equal_i(0, returned_entry->uid);
+ cl_assert_equal_i(0, returned_entry->uid);
+ cl_assert_equal_i(10, returned_entry->file_size);
+
+ /* Test the blob is in the repository */
+ cl_git_pass(git_blob_lookup(&blob, repo, &id1));
+ cl_assert_equal_s(content, git_blob_rawcontent(blob));
+ git_blob_free(blob);
+
+ git_index_free(index);
+ git_repository_free(repo);
+#endif
+}
+
+void test_index_tests256__add_bypath_to_a_bare_repository_returns_EBAREPO(void)
+{
+#ifdef GIT_EXPERIMENTAL_SHA256
+ git_repository *bare_repo;
+ git_index *index;
+
+ cl_git_pass(git_repository_open(&bare_repo, cl_fixture("testrepo.git")));
+ cl_git_pass(git_repository_index(&index, bare_repo));
+
+ cl_assert_equal_i(GIT_EBAREREPO, git_index_add_bypath(index, "test.txt"));
+
+ git_index_free(index);
+ git_repository_free(bare_repo);
+#endif
+}
+
+#ifdef GIT_EXPERIMENTAL_SHA256
+static void assert_add_bypath_fails(git_repository *repo, const char *fn)
+{
+ git_index *index;
+ git_str path = GIT_STR_INIT;
+
+ cl_git_pass(git_repository_index(&index, repo));
+ cl_assert(git_index_entrycount(index) == 0);
+
+ git_str_joinpath(&path, "./invalid", fn);
+
+ cl_git_mkfile(path.ptr, NULL);
+ cl_git_fail(git_index_add_bypath(index, fn));
+ cl_must_pass(p_unlink(path.ptr));
+
+ cl_assert(git_index_entrycount(index) == 0);
+
+ git_str_dispose(&path);
+ git_index_free(index);
+}
+#endif
+
+/* Test that writing an invalid filename fails */
+void test_index_tests256__cannot_add_invalid_filename(void)
+{
+#ifdef GIT_EXPERIMENTAL_SHA256
+ git_repository *repo;
+
+ cl_must_pass(p_mkdir("invalid", 0700));
+ cl_git_pass(git_repository_init_ext(&repo, "./invalid", &repo_init_opts));
+ cl_must_pass(p_mkdir("./invalid/subdir", 0777));
+
+ /* cl_git_mkfile() needs the dir to exist */
+ if (!git_fs_path_exists("./invalid/.GIT"))
+ cl_must_pass(p_mkdir("./invalid/.GIT", 0777));
+ if (!git_fs_path_exists("./invalid/.GiT"))
+ cl_must_pass(p_mkdir("./invalid/.GiT", 0777));
+
+ assert_add_bypath_fails(repo, ".git/hello");
+ assert_add_bypath_fails(repo, ".GIT/hello");
+ assert_add_bypath_fails(repo, ".GiT/hello");
+ assert_add_bypath_fails(repo, "./.git/hello");
+ assert_add_bypath_fails(repo, "./foo");
+ assert_add_bypath_fails(repo, "./bar");
+ assert_add_bypath_fails(repo, "subdir/../bar");
+
+ git_repository_free(repo);
+
+ cl_fixture_cleanup("invalid");
+#endif
+}
+
+#ifdef GIT_EXPERIMENTAL_SHA256
+static void assert_add_fails(git_repository *repo, const char *fn)
+{
+ git_index *index;
+ git_str path = GIT_STR_INIT;
+ git_index_entry entry = {{0}};
+
+ cl_git_pass(git_repository_index(&index, repo));
+ cl_assert(git_index_entrycount(index) == 0);
+
+ entry.path = fn;
+ entry.mode = GIT_FILEMODE_BLOB;
+ cl_git_pass(git_oid_from_string(&entry.id, "aea29dc305d40e362df25c3fdeed5502fd56b182af01b7740d297a24459333c5", GIT_OID_SHA256));
+
+ cl_git_fail(git_index_add(index, &entry));
+
+ cl_assert(git_index_entrycount(index) == 0);
+
+ git_str_dispose(&path);
+ git_index_free(index);
+}
+#endif
+
+/*
+ * Test that writing an invalid filename fails on filesystem
+ * specific protected names
+ */
+void test_index_tests256__cannot_add_protected_invalid_filename(void)
+{
+#ifdef GIT_EXPERIMENTAL_SHA256
+ git_repository *repo;
+ git_index *index;
+
+ cl_must_pass(p_mkdir("invalid", 0700));
+
+ cl_git_pass(git_repository_init(&repo, "./invalid", 0));
+
+ /* add a file to the repository so we can reference it later */
+ cl_git_pass(git_repository_index(&index, repo));
+ cl_git_mkfile("invalid/dummy.txt", "");
+ cl_git_pass(git_index_add_bypath(index, "dummy.txt"));
+ cl_must_pass(p_unlink("invalid/dummy.txt"));
+ cl_git_pass(git_index_remove_bypath(index, "dummy.txt"));
+ git_index_free(index);
+
+ cl_repo_set_bool(repo, "core.protectHFS", true);
+ cl_repo_set_bool(repo, "core.protectNTFS", true);
+
+ assert_add_fails(repo, ".git./hello");
+ assert_add_fails(repo, ".git\xe2\x80\xad/hello");
+ assert_add_fails(repo, "git~1/hello");
+ assert_add_fails(repo, ".git\xe2\x81\xaf/hello");
+ assert_add_fails(repo, ".git::$INDEX_ALLOCATION/dummy-file");
+
+ git_repository_free(repo);
+
+ cl_fixture_cleanup("invalid");
+#endif
+}
+
+#ifdef GIT_EXPERIMENTAL_SHA256
+static void replace_char(char *str, char in, char out)
+{
+ char *c = str;
+
+ while (*c++)
+ if (*c == in)
+ *c = out;
+}
+
+static void assert_write_fails(git_repository *repo, const char *fn_orig)
+{
+ git_index *index;
+ git_oid expected;
+ const git_index_entry *entry;
+ git_str path = GIT_STR_INIT;
+ char *fn;
+
+ cl_git_pass(git_repository_index(&index, repo));
+ cl_assert(git_index_entrycount(index) == 0);
+
+ /*
+ * Sneak a valid path into the index, we'll update it
+ * to an invalid path when we try to write the index.
+ */
+ fn = git__strdup(fn_orig);
+ replace_char(fn, '/', '_');
+ replace_char(fn, ':', '!');
+
+ git_str_joinpath(&path, "./invalid", fn);
+
+ cl_git_mkfile(path.ptr, NULL);
+
+ cl_git_pass(git_index_add_bypath(index, fn));
+
+ cl_assert(entry = git_index_get_bypath(index, fn, 0));
+
+ /* kids, don't try this at home */
+ replace_char((char *)entry->path, '_', '/');
+ replace_char((char *)entry->path, '!', ':');
+
+ /* write-tree */
+ cl_git_fail(git_index_write_tree(&expected, index));
+
+ p_unlink(path.ptr);
+
+ cl_git_pass(git_index_remove_all(index, NULL, NULL, NULL));
+ git_str_dispose(&path);
+ git_index_free(index);
+ git__free(fn);
+}
+#endif
+
+void test_index_tests256__write_tree_invalid_unowned_index(void)
+{
+#ifdef GIT_EXPERIMENTAL_SHA256
+ git_index *idx;
+ git_repository *repo;
+ git_index_entry entry = {{0}};
+ git_oid tree_id;
+ git_index_options index_opts = GIT_INDEX_OPTIONS_INIT;
+
+ index_opts.oid_type = GIT_OID_SHA256;
+
+ cl_git_pass(git_index_new_ext(&idx, &index_opts));
+
+ /* TODO: this one is failing */
+ cl_git_pass(git_oid_from_string(&entry.id, "a8c2e0a89a9cbab77c732b6bc39b51a783e3a318a847f46cba7614cac9814291", GIT_OID_SHA256));
+ entry.path = "foo";
+ entry.mode = GIT_FILEMODE_BLOB;
+ cl_git_pass(git_index_add(idx, &entry));
+
+ cl_git_pass(git_repository_init_ext(&repo, "./invalid-id", &repo_init_opts));
+
+ cl_git_fail(git_index_write_tree_to(&tree_id, idx, repo));
+
+ git_index_free(idx);
+ git_repository_free(repo);
+
+ cl_fixture_cleanup("invalid-id");
+#endif
+}
+
+/* Test that writing an invalid filename fails */
+void test_index_tests256__write_invalid_filename(void)
+{
+#ifdef GIT_EXPERIMENTAL_SHA256
+ git_repository *repo;
+
+ p_mkdir("invalid", 0700);
+
+ cl_git_pass(git_repository_init(&repo, "./invalid", 0));
+
+ assert_write_fails(repo, ".git/hello");
+ assert_write_fails(repo, ".GIT/hello");
+ assert_write_fails(repo, ".GiT/hello");
+ assert_write_fails(repo, "./.git/hello");
+ assert_write_fails(repo, "./foo");
+ assert_write_fails(repo, "./bar");
+ assert_write_fails(repo, "foo/../bar");
+
+ git_repository_free(repo);
+
+ cl_fixture_cleanup("invalid");
+#endif
+}
+
+void test_index_tests256__honors_protect_filesystems(void)
+{
+#ifdef GIT_EXPERIMENTAL_SHA256
+ git_repository *repo;
+
+ p_mkdir("invalid", 0700);
+
+ cl_git_pass(git_repository_init(&repo, "./invalid", 0));
+
+ cl_repo_set_bool(repo, "core.protectHFS", true);
+ cl_repo_set_bool(repo, "core.protectNTFS", true);
+
+ assert_write_fails(repo, ".git./hello");
+ assert_write_fails(repo, ".git\xe2\x80\xad/hello");
+ assert_write_fails(repo, "git~1/hello");
+ assert_write_fails(repo, ".git\xe2\x81\xaf/hello");
+ assert_write_fails(repo, ".git::$INDEX_ALLOCATION/dummy-file");
+
+ git_repository_free(repo);
+
+ cl_fixture_cleanup("invalid");
+#endif
+}
+
+void test_index_tests256__protectntfs_on_by_default(void)
+{
+#ifdef GIT_EXPERIMENTAL_SHA256
+ git_repository *repo;
+
+ p_mkdir("invalid", 0700);
+
+ cl_git_pass(git_repository_init(&repo, "./invalid", 0));
+ assert_write_fails(repo, ".git./hello");
+ assert_write_fails(repo, "git~1/hello");
+
+ git_repository_free(repo);
+
+ cl_fixture_cleanup("invalid");
+#endif
+}
+
+void test_index_tests256__can_disable_protectntfs(void)
+{
+#ifdef GIT_EXPERIMENTAL_SHA256
+ git_repository *repo;
+ git_index *index;
+
+ cl_must_pass(p_mkdir("valid", 0700));
+ cl_git_rewritefile("valid/git~1", "steal the shortname");
+
+ cl_git_pass(git_repository_init(&repo, "./valid", 0));
+ cl_git_pass(git_repository_index(&index, repo));
+ cl_repo_set_bool(repo, "core.protectNTFS", false);
+
+ cl_git_pass(git_index_add_bypath(index, "git~1"));
+
+ git_index_free(index);
+ git_repository_free(repo);
+
+ cl_fixture_cleanup("valid");
+#endif
+}
+
+void test_index_tests256__remove_entry(void)
+{
+#ifdef GIT_EXPERIMENTAL_SHA256
+ git_repository *repo;
+ git_index *index;
+
+ p_mkdir("index_test", 0770);
+
+ cl_git_pass(git_repository_init(&repo, "index_test", 0));
+ cl_git_pass(git_repository_index(&index, repo));
+ cl_assert(git_index_entrycount(index) == 0);
+
+ cl_git_mkfile("index_test/hello", NULL);
+ cl_git_pass(git_index_add_bypath(index, "hello"));
+ cl_git_pass(git_index_write(index));
+
+ cl_git_pass(git_index_read(index, true)); /* reload */
+ cl_assert(git_index_entrycount(index) == 1);
+ cl_assert(git_index_get_bypath(index, "hello", 0) != NULL);
+
+ cl_git_pass(git_index_remove(index, "hello", 0));
+ cl_git_pass(git_index_write(index));
+
+ cl_git_pass(git_index_read(index, true)); /* reload */
+ cl_assert(git_index_entrycount(index) == 0);
+ cl_assert(git_index_get_bypath(index, "hello", 0) == NULL);
+
+ git_index_free(index);
+ git_repository_free(repo);
+ cl_fixture_cleanup("index_test");
+#endif
+}
+
+void test_index_tests256__remove_directory(void)
+{
+#ifdef GIT_EXPERIMENTAL_SHA256
+ git_repository *repo;
+ git_index *index;
+
+ p_mkdir("index_test", 0770);
+
+ cl_git_pass(git_repository_init(&repo, "index_test", 0));
+ cl_git_pass(git_repository_index(&index, repo));
+ cl_assert_equal_i(0, (int)git_index_entrycount(index));
+
+ p_mkdir("index_test/a", 0770);
+ cl_git_mkfile("index_test/a/1.txt", NULL);
+ cl_git_mkfile("index_test/a/2.txt", NULL);
+ cl_git_mkfile("index_test/a/3.txt", NULL);
+ cl_git_mkfile("index_test/b.txt", NULL);
+
+ cl_git_pass(git_index_add_bypath(index, "a/1.txt"));
+ cl_git_pass(git_index_add_bypath(index, "a/2.txt"));
+ cl_git_pass(git_index_add_bypath(index, "a/3.txt"));
+ cl_git_pass(git_index_add_bypath(index, "b.txt"));
+ cl_git_pass(git_index_write(index));
+
+ cl_git_pass(git_index_read(index, true)); /* reload */
+ cl_assert_equal_i(4, (int)git_index_entrycount(index));
+ cl_assert(git_index_get_bypath(index, "a/1.txt", 0) != NULL);
+ cl_assert(git_index_get_bypath(index, "a/2.txt", 0) != NULL);
+ cl_assert(git_index_get_bypath(index, "b.txt", 0) != NULL);
+
+ cl_git_pass(git_index_remove(index, "a/1.txt", 0));
+ cl_git_pass(git_index_write(index));
+
+ cl_git_pass(git_index_read(index, true)); /* reload */
+ cl_assert_equal_i(3, (int)git_index_entrycount(index));
+ cl_assert(git_index_get_bypath(index, "a/1.txt", 0) == NULL);
+ cl_assert(git_index_get_bypath(index, "a/2.txt", 0) != NULL);
+ cl_assert(git_index_get_bypath(index, "b.txt", 0) != NULL);
+
+ cl_git_pass(git_index_remove_directory(index, "a", 0));
+ cl_git_pass(git_index_write(index));
+
+ cl_git_pass(git_index_read(index, true)); /* reload */
+ cl_assert_equal_i(1, (int)git_index_entrycount(index));
+ cl_assert(git_index_get_bypath(index, "a/1.txt", 0) == NULL);
+ cl_assert(git_index_get_bypath(index, "a/2.txt", 0) == NULL);
+ cl_assert(git_index_get_bypath(index, "b.txt", 0) != NULL);
+
+ git_index_free(index);
+ git_repository_free(repo);
+ cl_fixture_cleanup("index_test");
+#endif
+}
+
+void test_index_tests256__preserves_case(void)
+{
+#ifdef GIT_EXPERIMENTAL_SHA256
+ git_repository *repo;
+ git_index *index;
+ const git_index_entry *entry;
+ int index_caps;
+
+ cl_set_cleanup(&cleanup_myrepo, NULL);
+
+ cl_git_pass(git_repository_init_ext(&repo, "./myrepo", &repo_init_opts));
+ cl_git_pass(git_repository_index(&index, repo));
+
+ index_caps = git_index_caps(index);
+
+ cl_git_rewritefile("myrepo/test.txt", "hey there\n");
+ cl_git_pass(git_index_add_bypath(index, "test.txt"));
+
+ cl_git_pass(p_rename("myrepo/test.txt", "myrepo/TEST.txt"));
+ cl_git_rewritefile("myrepo/TEST.txt", "hello again\n");
+ cl_git_pass(git_index_add_bypath(index, "TEST.txt"));
+
+ if (index_caps & GIT_INDEX_CAPABILITY_IGNORE_CASE)
+ cl_assert_equal_i(1, (int)git_index_entrycount(index));
+ else
+ cl_assert_equal_i(2, (int)git_index_entrycount(index));
+
+ /* Test access by path instead of index */
+ cl_assert((entry = git_index_get_bypath(index, "test.txt", 0)) != NULL);
+ /* The path should *not* have changed without an explicit remove */
+ cl_assert(git__strcmp(entry->path, "test.txt") == 0);
+
+ cl_assert((entry = git_index_get_bypath(index, "TEST.txt", 0)) != NULL);
+ if (index_caps & GIT_INDEX_CAPABILITY_IGNORE_CASE)
+ /* The path should *not* have changed without an explicit remove */
+ cl_assert(git__strcmp(entry->path, "test.txt") == 0);
+ else
+ cl_assert(git__strcmp(entry->path, "TEST.txt") == 0);
+
+ git_index_free(index);
+ git_repository_free(repo);
+#endif
+}
+
+void test_index_tests256__elocked(void)
+{
+#ifdef GIT_EXPERIMENTAL_SHA256
+ git_repository *repo;
+ git_index *index;
+ git_filebuf file = GIT_FILEBUF_INIT;
+ const git_error *err;
+ int error;
+
+ cl_set_cleanup(&cleanup_myrepo, NULL);
+
+ cl_git_pass(git_repository_init_ext(&repo, "./myrepo", &repo_init_opts));
+ cl_git_pass(git_repository_index(&index, repo));
+
+ /* Lock the index file so we fail to lock it */
+ cl_git_pass(git_filebuf_open(&file, index->index_file_path, 0, 0666));
+ error = git_index_write(index);
+ cl_assert_equal_i(GIT_ELOCKED, error);
+
+ err = git_error_last();
+ cl_assert_equal_i(err->klass, GIT_ERROR_INDEX);
+
+ git_filebuf_cleanup(&file);
+ git_index_free(index);
+ git_repository_free(repo);
+#endif
+}
+
+void test_index_tests256__reload_from_disk(void)
+{
+#ifdef GIT_EXPERIMENTAL_SHA256
+ git_repository *repo;
+ git_index *read_index;
+ git_index *write_index;
+ git_index_options index_opts = GIT_INDEX_OPTIONS_INIT;
+
+ index_opts.oid_type = GIT_OID_SHA256;
+
+ cl_set_cleanup(&cleanup_myrepo, NULL);
+
+ cl_git_pass(git_futils_mkdir("./myrepo", 0777, GIT_MKDIR_PATH));
+ cl_git_mkfile("./myrepo/a.txt", "a\n");
+ cl_git_mkfile("./myrepo/b.txt", "b\n");
+
+ cl_git_pass(git_repository_init_ext(&repo, "./myrepo", &repo_init_opts));
+ cl_git_pass(git_repository_index(&write_index, repo));
+ cl_assert_equal_i(false, write_index->on_disk);
+
+ cl_git_pass(git_index_open_ext(&read_index, write_index->index_file_path, &index_opts));
+ cl_assert_equal_i(false, read_index->on_disk);
+
+ /* Stage two new files against the write_index */
+ cl_git_pass(git_index_add_bypath(write_index, "a.txt"));
+ cl_git_pass(git_index_add_bypath(write_index, "b.txt"));
+
+ cl_assert_equal_sz(2, git_index_entrycount(write_index));
+
+ /* Persist the index changes to disk */
+ cl_git_pass(git_index_write(write_index));
+ cl_assert_equal_i(true, write_index->on_disk);
+
+ /* Sync the changes back into the read_index */
+ cl_assert_equal_sz(0, git_index_entrycount(read_index));
+
+ cl_git_pass(git_index_read(read_index, true));
+ cl_assert_equal_i(true, read_index->on_disk);
+
+ cl_assert_equal_sz(2, git_index_entrycount(read_index));
+
+ /* Remove the index file from the filesystem */
+ cl_git_pass(p_unlink(write_index->index_file_path));
+
+ /* Sync the changes back into the read_index */
+ cl_git_pass(git_index_read(read_index, true));
+ cl_assert_equal_i(false, read_index->on_disk);
+ cl_assert_equal_sz(0, git_index_entrycount(read_index));
+
+ git_index_free(read_index);
+ git_index_free(write_index);
+ git_repository_free(repo);
+#endif
+}
+
+void test_index_tests256__reload_while_ignoring_case(void)
+{
+#ifdef GIT_EXPERIMENTAL_SHA256
+ git_index *index;
+ unsigned int caps;
+ git_index_options index_opts = GIT_INDEX_OPTIONS_INIT;
+
+ index_opts.oid_type = GIT_OID_SHA256;
+
+ cl_git_pass(git_index_open_ext(&index, TEST_INDEX_PATH, &index_opts));
+ cl_git_pass(git_vector_verify_sorted(&index->entries));
+
+ caps = git_index_caps(index);
+ cl_git_pass(git_index_set_caps(index, caps &= ~GIT_INDEX_CAPABILITY_IGNORE_CASE));
+ cl_git_pass(git_index_read(index, true));
+ cl_git_pass(git_vector_verify_sorted(&index->entries));
+ cl_assert(git_index_get_bypath(index, "contrib/README", 0));
+ cl_assert_equal_p(NULL, git_index_get_bypath(index, "CONTRIB/readme", 0));
+
+ cl_git_pass(git_index_set_caps(index, caps | GIT_INDEX_CAPABILITY_IGNORE_CASE));
+ cl_git_pass(git_index_read(index, true));
+ cl_git_pass(git_vector_verify_sorted(&index->entries));
+ cl_assert(git_index_get_bypath(index, "contrib/README", 0));
+ cl_assert(git_index_get_bypath(index, "CONTRIB/readme", 0));
+
+ git_index_free(index);
+#endif
+}
+
+void test_index_tests256__change_icase_on_instance(void)
+{
+#ifdef GIT_EXPERIMENTAL_SHA256
+ git_index *index;
+ unsigned int caps;
+ const git_index_entry *e;
+ git_index_options index_opts = GIT_INDEX_OPTIONS_INIT;
+
+ index_opts.oid_type = GIT_OID_SHA256;
+
+ cl_git_pass(git_index_open_ext(&index, TEST_INDEX_PATH, &index_opts));
+ cl_git_pass(git_vector_verify_sorted(&index->entries));
+
+ caps = git_index_caps(index);
+ cl_git_pass(git_index_set_caps(index, caps &= ~GIT_INDEX_CAPABILITY_IGNORE_CASE));
+ cl_assert_equal_i(false, index->ignore_case);
+ cl_git_pass(git_vector_verify_sorted(&index->entries));
+ cl_assert(e = git_index_get_bypath(index, "contrib/README", 0));
+ cl_assert_equal_p(NULL, e = git_index_get_bypath(index, "CONTRIB/readme", 0));
+ cl_assert(e = git_index_get_bypath(index, "config.h", 0));
+ cl_assert_equal_p(NULL, e = git_index_get_bypath(index, "CONFIG.H", 0));
+
+ cl_git_pass(git_index_set_caps(index, caps | GIT_INDEX_CAPABILITY_IGNORE_CASE));
+ cl_assert_equal_i(true, index->ignore_case);
+ cl_git_pass(git_vector_verify_sorted(&index->entries));
+ cl_assert(e = git_index_get_bypath(index, "config.h", 0));
+ cl_assert_equal_s("config.h", e->path);
+ cl_assert(e = git_index_get_bypath(index, "CONFIG.H", 0));
+ cl_assert_equal_s("config.h", e->path);
+
+ git_index_free(index);
+#endif
+}
+
+void test_index_tests256__can_lock_index(void)
+{
+#ifdef GIT_EXPERIMENTAL_SHA256
+ git_repository *repo;
+ git_index *index;
+ git_indexwriter one = GIT_INDEXWRITER_INIT,
+ two = GIT_INDEXWRITER_INIT;
+
+ repo = cl_git_sandbox_init("testrepo.git");
+
+ cl_git_pass(git_repository_index(&index, repo));
+ cl_git_pass(git_indexwriter_init(&one, index));
+
+ cl_git_fail_with(GIT_ELOCKED, git_indexwriter_init(&two, index));
+ cl_git_fail_with(GIT_ELOCKED, git_index_write(index));
+
+ cl_git_pass(git_indexwriter_commit(&one));
+
+ cl_git_pass(git_index_write(index));
+
+ git_indexwriter_cleanup(&one);
+ git_indexwriter_cleanup(&two);
+ git_index_free(index);
+ cl_git_sandbox_cleanup();
+#endif
+}
+
+void test_index_tests256__can_iterate(void)
+{
+#ifdef GIT_EXPERIMENTAL_SHA256
+ git_index *index;
+ git_index_iterator *iterator;
+ const git_index_entry *entry;
+ size_t i, iterator_idx = 0, found = 0;
+ int ret;
+ git_index_options index_opts = GIT_INDEX_OPTIONS_INIT;
+
+ index_opts.oid_type = GIT_OID_SHA256;
+
+ cl_git_pass(git_index_open_ext(&index, TEST_INDEX_PATH, &index_opts));
+ cl_git_pass(git_index_iterator_new(&iterator, index));
+
+ cl_assert(git_vector_is_sorted(&iterator->snap));
+
+ for (i = 0; i < ARRAY_SIZE(test_entries); i++) {
+ /* Advance iterator to next test entry index */
+ do {
+ ret = git_index_iterator_next(&entry, iterator);
+
+ if (ret == GIT_ITEROVER)
+ cl_fail("iterator did not contain all test entries");
+
+ cl_git_pass(ret);
+ } while (iterator_idx++ < test_entries[i].index);
+
+ cl_assert_equal_s(entry->path, test_entries[i].path);
+ cl_assert_equal_i(entry->mtime.seconds, test_entries[i].mtime);
+ cl_assert_equal_i(entry->file_size, test_entries[i].file_size);
+ found++;
+ }
+
+ while ((ret = git_index_iterator_next(&entry, iterator)) == 0)
+ ;
+
+ if (ret != GIT_ITEROVER)
+ cl_git_fail(ret);
+
+ cl_assert_equal_i(found, ARRAY_SIZE(test_entries));
+
+ git_index_iterator_free(iterator);
+ git_index_free(index);
+#endif
+}
+
+void test_index_tests256__can_modify_while_iterating(void)
+{
+#ifdef GIT_EXPERIMENTAL_SHA256
+ git_index *index;
+ git_index_iterator *iterator;
+ const git_index_entry *entry;
+ git_index_entry new_entry = {{0}};
+ size_t expected = 0, seen = 0;
+ int ret;
+ git_index_options index_opts = GIT_INDEX_OPTIONS_INIT;
+
+ index_opts.oid_type = GIT_OID_SHA256;
+
+ cl_git_pass(git_index_open_ext(&index, TEST_INDEX_PATH, &index_opts));
+ cl_git_pass(git_index_iterator_new(&iterator, index));
+
+ expected = git_index_entrycount(index);
+ cl_assert(git_vector_is_sorted(&iterator->snap));
+
+ /*
+ * After we've counted the entries, add a new one and change another;
+ * ensure that our iterator is backed by a snapshot and thus returns
+ * the number of entries from when the iterator was created.
+ */
+ cl_git_pass(git_oid_from_string(&new_entry.id, "8312e0a89a9cbab77c732b6bc39b51a783e3a318a847f46cba7614cac9814291", GIT_OID_SHA256));
+ new_entry.path = "newfile";
+ new_entry.mode = GIT_FILEMODE_BLOB;
+ cl_git_pass(git_index_add(index, &new_entry));
+
+ cl_git_pass(git_oid_from_string(&new_entry.id, "4141414141414141414141414141414141414141414141414141414141414141", GIT_OID_SHA256));
+ new_entry.path = "Makefile";
+ new_entry.mode = GIT_FILEMODE_BLOB;
+ cl_git_pass(git_index_add(index, &new_entry));
+
+ while (true) {
+ ret = git_index_iterator_next(&entry, iterator);
+
+ if (ret == GIT_ITEROVER)
+ break;
+
+ seen++;
+ }
+
+ cl_assert_equal_i(expected, seen);
+
+ git_index_iterator_free(iterator);
+ git_index_free(index);
+#endif
+}
diff --git a/tests/libgit2/iterator/index.c b/tests/libgit2/iterator/index.c
index a0083479d39..2f50bfab022 100644
--- a/tests/libgit2/iterator/index.c
+++ b/tests/libgit2/iterator/index.c
@@ -52,7 +52,7 @@ static void index_iterator_test(
if (expected_oids != NULL) {
git_oid oid;
- cl_git_pass(git_oid__fromstr(&oid, expected_oids[count], GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, expected_oids[count], GIT_OID_SHA1));
cl_assert_equal_oid(&oid, &entry->id);
}
@@ -627,7 +627,7 @@ void test_iterator_index__pathlist(void)
}
git_index_free(index);
- git_vector_free(&filelist);
+ git_vector_dispose(&filelist);
}
void test_iterator_index__pathlist_with_dirs(void)
@@ -728,7 +728,7 @@ void test_iterator_index__pathlist_with_dirs(void)
}
git_index_free(index);
- git_vector_free(&filelist);
+ git_vector_dispose(&filelist);
}
void test_iterator_index__pathlist_with_dirs_include_trees(void)
@@ -759,7 +759,7 @@ void test_iterator_index__pathlist_with_dirs_include_trees(void)
git_iterator_free(i);
git_index_free(index);
- git_vector_free(&filelist);
+ git_vector_dispose(&filelist);
}
void test_iterator_index__pathlist_1(void)
@@ -799,7 +799,7 @@ void test_iterator_index__pathlist_1(void)
git_iterator_free(i);
git_index_free(index);
- git_vector_free(&filelist);
+ git_vector_dispose(&filelist);
}
void test_iterator_index__pathlist_2(void)
@@ -841,7 +841,7 @@ void test_iterator_index__pathlist_2(void)
git_iterator_free(i);
git_index_free(index);
- git_vector_free(&filelist);
+ git_vector_dispose(&filelist);
}
void test_iterator_index__pathlist_four(void)
@@ -883,7 +883,7 @@ void test_iterator_index__pathlist_four(void)
git_iterator_free(i);
git_index_free(index);
- git_vector_free(&filelist);
+ git_vector_dispose(&filelist);
}
void test_iterator_index__pathlist_icase(void)
@@ -946,7 +946,7 @@ void test_iterator_index__pathlist_icase(void)
cl_git_pass(git_index_set_caps(index, caps));
git_index_free(index);
- git_vector_free(&filelist);
+ git_vector_dispose(&filelist);
}
void test_iterator_index__pathlist_with_directory(void)
@@ -973,7 +973,7 @@ void test_iterator_index__pathlist_with_directory(void)
git_index_free(index);
git_tree_free(tree);
- git_vector_free(&filelist);
+ git_vector_dispose(&filelist);
}
static void create_paths(git_index *index, const char *root, int depth)
@@ -999,7 +999,7 @@ static void create_paths(git_index *index, const char *root, int depth)
memset(&entry, 0, sizeof(git_index_entry));
entry.path = fullpath.ptr;
entry.mode = GIT_FILEMODE_BLOB;
- git_oid__fromstr(&entry.id, "d44e18fb93b7107b5cd1b95d601591d77869a1b6", GIT_OID_SHA1);
+ git_oid_from_string(&entry.id, "d44e18fb93b7107b5cd1b95d601591d77869a1b6", GIT_OID_SHA1);
cl_git_pass(git_index_add(index, &entry));
} else if (depth > 0) {
@@ -1131,7 +1131,7 @@ void test_iterator_index__pathlist_for_deeply_nested_item(void)
}
git_index_free(index);
- git_vector_free(&filelist);
+ git_vector_dispose(&filelist);
}
void test_iterator_index__advance_over(void)
@@ -1296,17 +1296,17 @@ static void add_conflict(
ancestor.path = ancestor_path;
ancestor.mode = GIT_FILEMODE_BLOB;
- git_oid__fromstr(&ancestor.id, "d44e18fb93b7107b5cd1b95d601591d77869a1b6", GIT_OID_SHA1);
+ git_oid_from_string(&ancestor.id, "d44e18fb93b7107b5cd1b95d601591d77869a1b6", GIT_OID_SHA1);
GIT_INDEX_ENTRY_STAGE_SET(&ancestor, 1);
ours.path = our_path;
ours.mode = GIT_FILEMODE_BLOB;
- git_oid__fromstr(&ours.id, "d44e18fb93b7107b5cd1b95d601591d77869a1b6", GIT_OID_SHA1);
+ git_oid_from_string(&ours.id, "d44e18fb93b7107b5cd1b95d601591d77869a1b6", GIT_OID_SHA1);
GIT_INDEX_ENTRY_STAGE_SET(&ours, 2);
theirs.path = their_path;
theirs.mode = GIT_FILEMODE_BLOB;
- git_oid__fromstr(&theirs.id, "d44e18fb93b7107b5cd1b95d601591d77869a1b6", GIT_OID_SHA1);
+ git_oid_from_string(&theirs.id, "d44e18fb93b7107b5cd1b95d601591d77869a1b6", GIT_OID_SHA1);
GIT_INDEX_ENTRY_STAGE_SET(&theirs, 3);
cl_git_pass(git_index_conflict_add(index, &ancestor, &ours, &theirs));
diff --git a/tests/libgit2/iterator/tree.c b/tests/libgit2/iterator/tree.c
index 7dfee28be51..3ebf49d4091 100644
--- a/tests/libgit2/iterator/tree.c
+++ b/tests/libgit2/iterator/tree.c
@@ -675,7 +675,7 @@ void test_iterator_tree__case_conflicts_0(void)
g_repo = cl_git_sandbox_init("icase");
- cl_git_pass(git_oid__fromstr(&blob_id, blob_sha, GIT_OID_SHA1)); /* lookup blob */
+ cl_git_pass(git_oid_from_string(&blob_id, blob_sha, GIT_OID_SHA1)); /* lookup blob */
/* create tree with: A/1.file, A/3.file, a/2.file, a/4.file */
build_test_tree(
@@ -729,7 +729,7 @@ void test_iterator_tree__case_conflicts_1(void)
g_repo = cl_git_sandbox_init("icase");
- cl_git_pass(git_oid__fromstr(&blob_id, blob_sha, GIT_OID_SHA1)); /* lookup blob */
+ cl_git_pass(git_oid_from_string(&blob_id, blob_sha, GIT_OID_SHA1)); /* lookup blob */
/* create: A/a A/b/1 A/c a/a a/b a/C */
build_test_tree(&Ab_id, g_repo, "b|1|", &blob_id);
@@ -798,7 +798,7 @@ void test_iterator_tree__case_conflicts_2(void)
g_repo = cl_git_sandbox_init("icase");
- cl_git_pass(git_oid__fromstr(&blob_id, blob_sha, GIT_OID_SHA1)); /* lookup blob */
+ cl_git_pass(git_oid_from_string(&blob_id, blob_sha, GIT_OID_SHA1)); /* lookup blob */
build_test_tree(&d1, g_repo, "b|16|,b|foo|", &blob_id, &blob_id);
build_test_tree(&d2, g_repo, "b|15|,b|FOO|", &blob_id, &blob_id);
@@ -911,7 +911,7 @@ void test_iterator_tree__pathlist(void)
expect_iterator_items(i, expect, NULL, expect, NULL);
git_iterator_free(i);
- git_vector_free(&filelist);
+ git_vector_dispose(&filelist);
git_tree_free(tree);
}
@@ -968,7 +968,7 @@ void test_iterator_tree__pathlist_icase(void)
expect_iterator_items(i, 2, NULL, 2, NULL);
git_iterator_free(i);
- git_vector_free(&filelist);
+ git_vector_dispose(&filelist);
git_tree_free(tree);
}
@@ -1021,7 +1021,7 @@ void test_iterator_tree__pathlist_with_directory(void)
git_iterator_free(i);
git_tree_free(tree);
- git_vector_free(&filelist);
+ git_vector_dispose(&filelist);
}
void test_iterator_tree__pathlist_with_directory_include_tree_nodes(void)
@@ -1050,7 +1050,7 @@ void test_iterator_tree__pathlist_with_directory_include_tree_nodes(void)
git_iterator_free(i);
git_tree_free(tree);
- git_vector_free(&filelist);
+ git_vector_dispose(&filelist);
}
void test_iterator_tree__pathlist_no_match(void)
@@ -1075,6 +1075,6 @@ void test_iterator_tree__pathlist_no_match(void)
git_iterator_free(i);
git_tree_free(tree);
- git_vector_free(&filelist);
+ git_vector_dispose(&filelist);
}
diff --git a/tests/libgit2/iterator/workdir.c b/tests/libgit2/iterator/workdir.c
index 7634997e1e5..59feb4546c8 100644
--- a/tests/libgit2/iterator/workdir.c
+++ b/tests/libgit2/iterator/workdir.c
@@ -585,9 +585,9 @@ void test_iterator_workdir__filesystem(void)
expect_iterator_items(i, 5, expect_noauto, 18, expect_trees);
git_iterator_free(i);
- git__tsort((void **)expect_base, 8, (git__tsort_cmp)git__strcasecmp);
- git__tsort((void **)expect_trees, 18, (git__tsort_cmp)git__strcasecmp);
- git__tsort((void **)expect_noauto, 5, (git__tsort_cmp)git__strcasecmp);
+ git__tsort((void **)expect_base, 8, git__strcasecmp_cb);
+ git__tsort((void **)expect_trees, 18, git__strcasecmp_cb);
+ git__tsort((void **)expect_noauto, 5, git__strcasecmp_cb);
i_opts.flags = GIT_ITERATOR_IGNORE_CASE;
cl_git_pass(git_iterator_for_filesystem(&i, "status/subdir", &i_opts));
@@ -917,7 +917,7 @@ void test_iterator_workdir__pathlist(void)
git_iterator_free(i);
}
- git_vector_free(&filelist);
+ git_vector_dispose(&filelist);
}
void test_iterator_workdir__pathlist_with_dirs(void)
@@ -1014,7 +1014,7 @@ void test_iterator_workdir__pathlist_with_dirs(void)
git_iterator_free(i);
}
- git_vector_free(&filelist);
+ git_vector_dispose(&filelist);
}
static void create_paths(const char *root, int depth)
@@ -1175,7 +1175,7 @@ void test_iterator_workdir__pathlist_for_deeply_nested_item(void)
git_iterator_free(i);
}
- git_vector_free(&filelist);
+ git_vector_dispose(&filelist);
}
void test_iterator_workdir__bounded_submodules(void)
@@ -1258,7 +1258,7 @@ void test_iterator_workdir__bounded_submodules(void)
git_iterator_free(i);
}
- git_vector_free(&filelist);
+ git_vector_dispose(&filelist);
git_index_free(index);
git_tree_free(head);
}
@@ -1380,7 +1380,7 @@ void test_iterator_workdir__advance_over_with_pathlist(void)
cl_git_fail_with(GIT_ITEROVER, git_iterator_advance(NULL, i));
git_iterator_free(i);
- git_vector_free(&pathlist);
+ git_vector_dispose(&pathlist);
}
void test_iterator_workdir__advance_into(void)
@@ -1447,7 +1447,7 @@ void test_iterator_workdir__pathlist_with_directory(void)
expect_iterator_items(i, expected_len, expected, expected_len, expected);
git_iterator_free(i);
- git_vector_free(&filelist);
+ git_vector_dispose(&filelist);
}
void test_iterator_workdir__pathlist_with_directory_include_trees(void)
@@ -1473,7 +1473,7 @@ void test_iterator_workdir__pathlist_with_directory_include_trees(void)
expect_iterator_items(i, expected_len, expected, expected_len, expected);
git_iterator_free(i);
- git_vector_free(&filelist);
+ git_vector_dispose(&filelist);
}
void test_iterator_workdir__hash_when_requested(void)
@@ -1514,7 +1514,7 @@ void test_iterator_workdir__hash_when_requested(void)
for (i = 0; i < sizeof(expected) / sizeof(struct merge_index_entry); i++) {
cl_git_pass(git_iterator_advance(&entry, iter));
- cl_git_pass(git_oid__fromstr(&expected_id, expected[i].oid_str, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected_id, expected[i].oid_str, GIT_OID_SHA1));
cl_assert_equal_oid(&expected_id, &entry->id);
cl_assert_equal_s(expected[i].path, entry->path);
}
diff --git a/tests/libgit2/mailmap/blame.c b/tests/libgit2/mailmap/blame.c
index e6bc1a41f43..ce2c9d48a00 100644
--- a/tests/libgit2/mailmap/blame.c
+++ b/tests/libgit2/mailmap/blame.c
@@ -33,7 +33,7 @@ void test_mailmap_blame__hunks(void)
cl_assert(g_blame);
for (idx = 0; idx < ARRAY_SIZE(resolved); ++idx) {
- hunk = git_blame_get_hunk_byline(g_blame, idx + 1);
+ hunk = git_blame_hunk_byline(g_blame, idx + 1);
cl_assert(hunk->final_signature != NULL);
cl_assert(hunk->orig_signature != NULL);
@@ -54,7 +54,7 @@ void test_mailmap_blame__hunks_no_mailmap(void)
cl_assert(g_blame);
for (idx = 0; idx < ARRAY_SIZE(resolved); ++idx) {
- hunk = git_blame_get_hunk_byline(g_blame, idx + 1);
+ hunk = git_blame_hunk_byline(g_blame, idx + 1);
cl_assert(hunk->final_signature != NULL);
cl_assert(hunk->orig_signature != NULL);
diff --git a/tests/libgit2/merge/driver.c b/tests/libgit2/merge/driver.c
index fd73c3770a9..16780afba57 100644
--- a/tests/libgit2/merge/driver.c
+++ b/tests/libgit2/merge/driver.c
@@ -22,7 +22,7 @@ void test_merge_driver__initialize(void)
repo = cl_git_sandbox_init(TEST_REPO_PATH);
git_repository_index(&repo_index, repo);
- git_oid__fromstr(&automergeable_id, AUTOMERGEABLE_IDSTR, GIT_OID_SHA1);
+ git_oid_from_string(&automergeable_id, AUTOMERGEABLE_IDSTR, GIT_OID_SHA1);
/* Ensure that the user's merge.conflictstyle doesn't interfere */
cl_git_pass(git_repository_config(&cfg, repo));
@@ -145,7 +145,7 @@ static void merge_branch(void)
git_oid their_id;
git_annotated_commit *their_head;
- cl_git_pass(git_oid__fromstr(&their_id, BRANCH_ID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&their_id, BRANCH_ID, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&their_head, repo, &their_id));
cl_git_pass(git_merge(repo, (const git_annotated_commit **)&their_head,
@@ -299,7 +299,7 @@ void test_merge_driver__default_can_be_specified(void)
merge_opts.default_driver = "custom";
- cl_git_pass(git_oid__fromstr(&their_id, BRANCH_ID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&their_id, BRANCH_ID, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&their_head, repo, &their_id));
cl_git_pass(git_merge(repo, (const git_annotated_commit **)&their_head,
diff --git a/tests/libgit2/merge/files.c b/tests/libgit2/merge/files.c
index 6c1c2e13f78..0f2dfbdf428 100644
--- a/tests/libgit2/merge/files.c
+++ b/tests/libgit2/merge/files.c
@@ -149,15 +149,15 @@ void test_merge_files__automerge_from_index(void)
git_merge_file_result result = {0};
git_index_entry ancestor, ours, theirs;
- git_oid__fromstr(&ancestor.id, "6212c31dab5e482247d7977e4f0dd3601decf13b", GIT_OID_SHA1);
+ git_oid_from_string(&ancestor.id, "6212c31dab5e482247d7977e4f0dd3601decf13b", GIT_OID_SHA1);
ancestor.path = "automergeable.txt";
ancestor.mode = 0100644;
- git_oid__fromstr(&ours.id, "ee3fa1b8c00aff7fe02065fdb50864bb0d932ccf", GIT_OID_SHA1);
+ git_oid_from_string(&ours.id, "ee3fa1b8c00aff7fe02065fdb50864bb0d932ccf", GIT_OID_SHA1);
ours.path = "automergeable.txt";
ours.mode = 0100755;
- git_oid__fromstr(&theirs.id, "058541fc37114bfc1dddf6bd6bffc7fae5c2e6fe", GIT_OID_SHA1);
+ git_oid_from_string(&theirs.id, "058541fc37114bfc1dddf6bd6bffc7fae5c2e6fe", GIT_OID_SHA1);
theirs.path = "newname.txt";
theirs.mode = 0100644;
diff --git a/tests/libgit2/merge/merge_helpers.c b/tests/libgit2/merge/merge_helpers.c
index 1406987e53f..3746c191ae4 100644
--- a/tests/libgit2/merge/merge_helpers.c
+++ b/tests/libgit2/merge/merge_helpers.c
@@ -165,7 +165,7 @@ static int index_entry_eq_merge_index_entry(const struct merge_index_entry *expe
bool test_oid;
if (strlen(expected->oid_str) != 0) {
- cl_git_pass(git_oid__fromstr(&expected_oid, expected->oid_str, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected_oid, expected->oid_str, GIT_OID_SHA1));
test_oid = 1;
} else
test_oid = 0;
@@ -304,21 +304,21 @@ int merge_test_reuc(git_index *index, const struct merge_reuc_entry expected[],
return 0;
if (expected[i].ancestor_mode > 0) {
- cl_git_pass(git_oid__fromstr(&expected_oid, expected[i].ancestor_oid_str, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected_oid, expected[i].ancestor_oid_str, GIT_OID_SHA1));
if (git_oid_cmp(&reuc_entry->oid[0], &expected_oid) != 0)
return 0;
}
if (expected[i].our_mode > 0) {
- cl_git_pass(git_oid__fromstr(&expected_oid, expected[i].our_oid_str, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected_oid, expected[i].our_oid_str, GIT_OID_SHA1));
if (git_oid_cmp(&reuc_entry->oid[1], &expected_oid) != 0)
return 0;
}
if (expected[i].their_mode > 0) {
- cl_git_pass(git_oid__fromstr(&expected_oid, expected[i].their_oid_str, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected_oid, expected[i].their_oid_str, GIT_OID_SHA1));
if (git_oid_cmp(&reuc_entry->oid[2], &expected_oid) != 0)
return 0;
@@ -353,7 +353,7 @@ int merge_test_workdir(git_repository *repo, const struct merge_index_entry expe
for (i = 0; i < expected_len; i++) {
git_blob_create_from_workdir(&actual_oid, repo, expected[i].path);
- git_oid__fromstr(&expected_oid, expected[i].oid_str, GIT_OID_SHA1);
+ git_oid_from_string(&expected_oid, expected[i].oid_str, GIT_OID_SHA1);
if (git_oid_cmp(&actual_oid, &expected_oid) != 0)
return 0;
diff --git a/tests/libgit2/merge/trees/renames.c b/tests/libgit2/merge/trees/renames.c
index a27945ee071..a93d4751756 100644
--- a/tests/libgit2/merge/trees/renames.c
+++ b/tests/libgit2/merge/trees/renames.c
@@ -286,7 +286,7 @@ void test_merge_trees_renames__cache_recomputation(void)
void *data;
size_t i;
- cl_git_pass(git_oid__fromstr(&blob, "a2d8d1824c68541cca94ffb90f79291eba495921", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&blob, "a2d8d1824c68541cca94ffb90f79291eba495921", GIT_OID_SHA1));
/*
* Create a 50MB blob that consists of NUL bytes only. It is important
@@ -350,3 +350,22 @@ void test_merge_trees_renames__cache_recomputation(void)
git_tree_free(our_tree);
git__free(data);
}
+
+void test_merge_trees_renames__emptyfile_renames(void)
+{
+ git_index *index;
+ git_merge_options *opts = NULL;
+
+ struct merge_index_entry merge_index_entries[] = {
+ { 0100644, "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", 1, "bar" },
+ { 0100644, "60b12be2d2f57977ce83d8dfd32e2394ac1ba1a2", 3, "bar" },
+ { 0100644, "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", 0, "boo" },
+ { 0100644, "e50a49f9558d09d4d3bfc108363bb24c127ed263", 0, "foo" },
+ };
+
+ cl_git_pass(merge_trees_from_branches(&index, repo,
+ "emptyfile_renames", "emptyfile_renames-branch",
+ opts));
+ cl_assert(merge_test_index(index, merge_index_entries, 4));
+ git_index_free(index);
+}
diff --git a/tests/libgit2/merge/trees/treediff.c b/tests/libgit2/merge/trees/treediff.c
index 094018d3cf6..5c786f12250 100644
--- a/tests/libgit2/merge/trees/treediff.c
+++ b/tests/libgit2/merge/trees/treediff.c
@@ -61,9 +61,9 @@ static void test_find_differences(
opts.metric->similarity = git_diff_find_similar__calc_similarity;
opts.metric->payload = (void *)GIT_HASHSIG_SMART_WHITESPACE;
- cl_git_pass(git_oid__fromstr(&ancestor_oid, ancestor_oidstr, GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&ours_oid, ours_oidstr, GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&theirs_oid, theirs_oidstr, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&ancestor_oid, ancestor_oidstr, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&ours_oid, ours_oidstr, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&theirs_oid, theirs_oidstr, GIT_OID_SHA1));
cl_git_pass(git_tree_lookup(&ancestor_tree, repo, &ancestor_oid));
cl_git_pass(git_tree_lookup(&ours_tree, repo, &ours_oid));
diff --git a/tests/libgit2/merge/trees/trivial.c b/tests/libgit2/merge/trees/trivial.c
index 287a53cfe7a..41c2408d52f 100644
--- a/tests/libgit2/merge/trees/trivial.c
+++ b/tests/libgit2/merge/trees/trivial.c
@@ -258,7 +258,7 @@ void test_merge_trees_trivial__13(void)
cl_git_pass(merge_trivial(&result, "trivial-13", "trivial-13-branch"));
cl_assert(entry = git_index_get_bypath(result, "modified-in-13.txt", 0));
- cl_git_pass(git_oid__fromstr(&expected_oid, "1cff9ec6a47a537380dedfdd17c9e76d74259a2b", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected_oid, "1cff9ec6a47a537380dedfdd17c9e76d74259a2b", GIT_OID_SHA1));
cl_assert_equal_oid(&expected_oid, &entry->id);
cl_assert(git_index_reuc_entrycount(result) == 0);
@@ -277,7 +277,7 @@ void test_merge_trees_trivial__14(void)
cl_git_pass(merge_trivial(&result, "trivial-14", "trivial-14-branch"));
cl_assert(entry = git_index_get_bypath(result, "modified-in-14-branch.txt", 0));
- cl_git_pass(git_oid__fromstr(&expected_oid, "26153a3ff3649b6c2bb652d3f06878c6e0a172f9", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected_oid, "26153a3ff3649b6c2bb652d3f06878c6e0a172f9", GIT_OID_SHA1));
cl_assert(git_oid_cmp(&entry->id, &expected_oid) == 0);
cl_assert(git_index_reuc_entrycount(result) == 0);
diff --git a/tests/libgit2/merge/workdir/dirty.c b/tests/libgit2/merge/workdir/dirty.c
index 36b42a10353..27d35742987 100644
--- a/tests/libgit2/merge/workdir/dirty.c
+++ b/tests/libgit2/merge/workdir/dirty.c
@@ -94,10 +94,9 @@ static int merge_branch(void)
git_checkout_options checkout_opts = GIT_CHECKOUT_OPTIONS_INIT;
int error;
- cl_git_pass(git_oid__fromstr(&their_oids[0], MERGE_BRANCH_OID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&their_oids[0], MERGE_BRANCH_OID, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&their_head, repo, &their_oids[0]));
- checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE;
error = git_merge(repo, (const git_annotated_commit **)&their_head, 1, &merge_opts, &checkout_opts);
git_annotated_commit_free(their_head);
@@ -163,7 +162,7 @@ static void hack_index(char *files[])
entry->ctime.seconds = (int32_t)statbuf.st_ctime;
entry->mtime.seconds = (int32_t)statbuf.st_mtime;
-#if defined(GIT_USE_NSEC)
+#if defined(GIT_NSEC)
entry->ctime.nanoseconds = statbuf.st_ctime_nsec;
entry->mtime.nanoseconds = statbuf.st_mtime_nsec;
#else
diff --git a/tests/libgit2/merge/workdir/renames.c b/tests/libgit2/merge/workdir/renames.c
index 1b5128cf1b7..90f4b6910e1 100644
--- a/tests/libgit2/merge/workdir/renames.c
+++ b/tests/libgit2/merge/workdir/renames.c
@@ -100,7 +100,7 @@ void test_merge_workdir_renames__ours(void)
merge_opts.flags |= GIT_MERGE_FIND_RENAMES;
merge_opts.rename_threshold = 50;
- checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_USE_OURS;
+ checkout_opts.checkout_strategy = GIT_CHECKOUT_USE_OURS;
cl_git_pass(merge_branches(repo, GIT_REFS_HEADS_DIR BRANCH_RENAME_OURS, GIT_REFS_HEADS_DIR BRANCH_RENAME_THEIRS, &merge_opts, &checkout_opts));
cl_git_pass(git_repository_index(&index, repo));
diff --git a/tests/libgit2/merge/workdir/setup.c b/tests/libgit2/merge/workdir/setup.c
index 98ccdf700e0..84496c436e1 100644
--- a/tests/libgit2/merge/workdir/setup.c
+++ b/tests/libgit2/merge/workdir/setup.c
@@ -78,7 +78,7 @@ void test_merge_workdir_setup__one_branch(void)
git_reference *octo1_ref;
git_annotated_commit *our_head, *their_heads[1];
- cl_git_pass(git_oid__fromstr(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&our_head, repo, &our_oid));
cl_git_pass(git_reference_lookup(&octo1_ref, repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH));
@@ -104,10 +104,10 @@ void test_merge_workdir_setup__one_oid(void)
git_oid octo1_oid;
git_annotated_commit *our_head, *their_heads[1];
- cl_git_pass(git_oid__fromstr(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&our_head, repo, &our_oid));
- cl_git_pass(git_oid__fromstr(&octo1_oid, OCTO1_OID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&octo1_oid, OCTO1_OID, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&their_heads[0], repo, &octo1_oid));
cl_git_pass(git_merge__setup(repo, our_head, (const git_annotated_commit **)their_heads, 1));
@@ -129,7 +129,7 @@ void test_merge_workdir_setup__two_branches(void)
git_reference *octo2_ref;
git_annotated_commit *our_head, *their_heads[2];
- cl_git_pass(git_oid__fromstr(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&our_head, repo, &our_oid));
cl_git_pass(git_reference_lookup(&octo1_ref, repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH));
@@ -162,7 +162,7 @@ void test_merge_workdir_setup__three_branches(void)
git_reference *octo3_ref;
git_annotated_commit *our_head, *their_heads[3];
- cl_git_pass(git_oid__fromstr(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&our_head, repo, &our_oid));
cl_git_pass(git_reference_lookup(&octo1_ref, repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH));
@@ -200,16 +200,16 @@ void test_merge_workdir_setup__three_oids(void)
git_oid octo3_oid;
git_annotated_commit *our_head, *their_heads[3];
- cl_git_pass(git_oid__fromstr(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&our_head, repo, &our_oid));
- cl_git_pass(git_oid__fromstr(&octo1_oid, OCTO1_OID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&octo1_oid, OCTO1_OID, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&their_heads[0], repo, &octo1_oid));
- cl_git_pass(git_oid__fromstr(&octo2_oid, OCTO2_OID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&octo2_oid, OCTO2_OID, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&their_heads[1], repo, &octo2_oid));
- cl_git_pass(git_oid__fromstr(&octo3_oid, OCTO3_OID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&octo3_oid, OCTO3_OID, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&their_heads[2], repo, &octo3_oid));
cl_git_pass(git_merge__setup(repo, our_head, (const git_annotated_commit **)their_heads, 3));
@@ -233,13 +233,13 @@ void test_merge_workdir_setup__branches_and_oids_1(void)
git_oid octo2_oid;
git_annotated_commit *our_head, *their_heads[2];
- cl_git_pass(git_oid__fromstr(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&our_head, repo, &our_oid));
cl_git_pass(git_reference_lookup(&octo1_ref, repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH));
cl_git_pass(git_annotated_commit_from_ref(&their_heads[0], repo, octo1_ref));
- cl_git_pass(git_oid__fromstr(&octo2_oid, OCTO2_OID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&octo2_oid, OCTO2_OID, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&their_heads[1], repo, &octo2_oid));
cl_git_pass(git_merge__setup(repo, our_head, (const git_annotated_commit **)their_heads, 2));
@@ -266,19 +266,19 @@ void test_merge_workdir_setup__branches_and_oids_2(void)
git_oid octo4_oid;
git_annotated_commit *our_head, *their_heads[4];
- cl_git_pass(git_oid__fromstr(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&our_head, repo, &our_oid));
cl_git_pass(git_reference_lookup(&octo1_ref, repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH));
cl_git_pass(git_annotated_commit_from_ref(&their_heads[0], repo, octo1_ref));
- cl_git_pass(git_oid__fromstr(&octo2_oid, OCTO2_OID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&octo2_oid, OCTO2_OID, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&their_heads[1], repo, &octo2_oid));
cl_git_pass(git_reference_lookup(&octo3_ref, repo, GIT_REFS_HEADS_DIR OCTO3_BRANCH));
cl_git_pass(git_annotated_commit_from_ref(&their_heads[2], repo, octo3_ref));
- cl_git_pass(git_oid__fromstr(&octo4_oid, OCTO4_OID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&octo4_oid, OCTO4_OID, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&their_heads[3], repo, &octo4_oid));
cl_git_pass(git_merge__setup(repo, our_head, (const git_annotated_commit **)their_heads, 4));
@@ -308,16 +308,16 @@ void test_merge_workdir_setup__branches_and_oids_3(void)
git_reference *octo4_ref;
git_annotated_commit *our_head, *their_heads[4];
- cl_git_pass(git_oid__fromstr(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&our_head, repo, &our_oid));
- cl_git_pass(git_oid__fromstr(&octo1_oid, OCTO1_OID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&octo1_oid, OCTO1_OID, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&their_heads[0], repo, &octo1_oid));
cl_git_pass(git_reference_lookup(&octo2_ref, repo, GIT_REFS_HEADS_DIR OCTO2_BRANCH));
cl_git_pass(git_annotated_commit_from_ref(&their_heads[1], repo, octo2_ref));
- cl_git_pass(git_oid__fromstr(&octo3_oid, OCTO3_OID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&octo3_oid, OCTO3_OID, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&their_heads[2], repo, &octo3_oid));
cl_git_pass(git_reference_lookup(&octo4_ref, repo, GIT_REFS_HEADS_DIR OCTO4_BRANCH));
@@ -351,16 +351,16 @@ void test_merge_workdir_setup__branches_and_oids_4(void)
git_reference *octo5_ref;
git_annotated_commit *our_head, *their_heads[5];
- cl_git_pass(git_oid__fromstr(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&our_head, repo, &our_oid));
- cl_git_pass(git_oid__fromstr(&octo1_oid, OCTO1_OID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&octo1_oid, OCTO1_OID, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&their_heads[0], repo, &octo1_oid));
cl_git_pass(git_reference_lookup(&octo2_ref, repo, GIT_REFS_HEADS_DIR OCTO2_BRANCH));
cl_git_pass(git_annotated_commit_from_ref(&their_heads[1], repo, octo2_ref));
- cl_git_pass(git_oid__fromstr(&octo3_oid, OCTO3_OID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&octo3_oid, OCTO3_OID, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&their_heads[2], repo, &octo3_oid));
cl_git_pass(git_reference_lookup(&octo4_ref, repo, GIT_REFS_HEADS_DIR OCTO4_BRANCH));
@@ -397,7 +397,7 @@ void test_merge_workdir_setup__three_same_branches(void)
git_reference *octo1_3_ref;
git_annotated_commit *our_head, *their_heads[3];
- cl_git_pass(git_oid__fromstr(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&our_head, repo, &our_oid));
cl_git_pass(git_reference_lookup(&octo1_1_ref, repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH));
@@ -435,16 +435,16 @@ void test_merge_workdir_setup__three_same_oids(void)
git_oid octo1_3_oid;
git_annotated_commit *our_head, *their_heads[3];
- cl_git_pass(git_oid__fromstr(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&our_head, repo, &our_oid));
- cl_git_pass(git_oid__fromstr(&octo1_1_oid, OCTO1_OID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&octo1_1_oid, OCTO1_OID, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&their_heads[0], repo, &octo1_1_oid));
- cl_git_pass(git_oid__fromstr(&octo1_2_oid, OCTO1_OID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&octo1_2_oid, OCTO1_OID, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&their_heads[1], repo, &octo1_2_oid));
- cl_git_pass(git_oid__fromstr(&octo1_3_oid, OCTO1_OID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&octo1_3_oid, OCTO1_OID, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&their_heads[2], repo, &octo1_3_oid));
cl_git_pass(git_merge__setup(repo, our_head, (const git_annotated_commit **)their_heads, 3));
@@ -512,7 +512,7 @@ void test_merge_workdir_setup__remote_tracking_one_branch(void)
cl_git_pass(create_remote_tracking_branch(OCTO1_BRANCH, OCTO1_OID));
- cl_git_pass(git_oid__fromstr(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&our_head, repo, &our_oid));
cl_git_pass(git_reference_lookup(&octo1_ref, repo, GIT_REFS_REMOTES_DIR "origin/" OCTO1_BRANCH));
@@ -542,7 +542,7 @@ void test_merge_workdir_setup__remote_tracking_two_branches(void)
cl_git_pass(create_remote_tracking_branch(OCTO1_BRANCH, OCTO1_OID));
cl_git_pass(create_remote_tracking_branch(OCTO2_BRANCH, OCTO2_OID));
- cl_git_pass(git_oid__fromstr(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&our_head, repo, &our_oid));
cl_git_pass(git_reference_lookup(&octo1_ref, repo, GIT_REFS_REMOTES_DIR "origin/" OCTO1_BRANCH));
@@ -579,7 +579,7 @@ void test_merge_workdir_setup__remote_tracking_three_branches(void)
cl_git_pass(create_remote_tracking_branch(OCTO2_BRANCH, OCTO2_OID));
cl_git_pass(create_remote_tracking_branch(OCTO3_BRANCH, OCTO3_OID));
- cl_git_pass(git_oid__fromstr(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&our_head, repo, &our_oid));
cl_git_pass(git_reference_lookup(&octo1_ref, repo, GIT_REFS_REMOTES_DIR "origin/" OCTO1_BRANCH));
@@ -618,7 +618,7 @@ void test_merge_workdir_setup__normal_branch_and_remote_tracking_branch(void)
cl_git_pass(create_remote_tracking_branch(OCTO2_BRANCH, OCTO2_OID));
- cl_git_pass(git_oid__fromstr(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&our_head, repo, &our_oid));
cl_git_pass(git_reference_lookup(&octo1_ref, repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH));
@@ -652,7 +652,7 @@ void test_merge_workdir_setup__remote_tracking_branch_and_normal_branch(void)
cl_git_pass(create_remote_tracking_branch(OCTO1_BRANCH, OCTO1_OID));
- cl_git_pass(git_oid__fromstr(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&our_head, repo, &our_oid));
cl_git_pass(git_reference_lookup(&octo1_ref, repo, GIT_REFS_REMOTES_DIR "origin/" OCTO1_BRANCH));
@@ -689,7 +689,7 @@ void test_merge_workdir_setup__two_remote_tracking_branch_and_two_normal_branche
cl_git_pass(create_remote_tracking_branch(OCTO2_BRANCH, OCTO2_OID));
cl_git_pass(create_remote_tracking_branch(OCTO4_BRANCH, OCTO4_OID));
- cl_git_pass(git_oid__fromstr(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&our_head, repo, &our_oid));
cl_git_pass(git_reference_lookup(&octo1_ref, repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH));
@@ -730,10 +730,10 @@ void test_merge_workdir_setup__pull_one(void)
git_oid octo1_1_oid;
git_annotated_commit *our_head, *their_heads[1];
- cl_git_pass(git_oid__fromstr(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&our_head, repo, &our_oid));
- cl_git_pass(git_oid__fromstr(&octo1_1_oid, OCTO1_OID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&octo1_1_oid, OCTO1_OID, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_from_fetchhead(&their_heads[0], repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH, "http://remote.url/repo.git", &octo1_1_oid));
cl_git_pass(git_merge__setup(repo, our_head, (const git_annotated_commit **)their_heads, 1));
@@ -755,13 +755,13 @@ void test_merge_workdir_setup__pull_two(void)
git_oid octo2_oid;
git_annotated_commit *our_head, *their_heads[2];
- cl_git_pass(git_oid__fromstr(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&our_head, repo, &our_oid));
- cl_git_pass(git_oid__fromstr(&octo1_oid, OCTO1_OID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&octo1_oid, OCTO1_OID, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_from_fetchhead(&their_heads[0], repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH, "http://remote.url/repo.git", &octo1_oid));
- cl_git_pass(git_oid__fromstr(&octo2_oid, OCTO2_OID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&octo2_oid, OCTO2_OID, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_from_fetchhead(&their_heads[1], repo, GIT_REFS_HEADS_DIR OCTO2_BRANCH, "http://remote.url/repo.git", &octo2_oid));
cl_git_pass(git_merge__setup(repo, our_head, (const git_annotated_commit **)their_heads, 2));
@@ -785,16 +785,16 @@ void test_merge_workdir_setup__pull_three(void)
git_oid octo3_oid;
git_annotated_commit *our_head, *their_heads[3];
- cl_git_pass(git_oid__fromstr(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&our_head, repo, &our_oid));
- cl_git_pass(git_oid__fromstr(&octo1_oid, OCTO1_OID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&octo1_oid, OCTO1_OID, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_from_fetchhead(&their_heads[0], repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH, "http://remote.url/repo.git", &octo1_oid));
- cl_git_pass(git_oid__fromstr(&octo2_oid, OCTO2_OID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&octo2_oid, OCTO2_OID, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_from_fetchhead(&their_heads[1], repo, GIT_REFS_HEADS_DIR OCTO2_BRANCH, "http://remote.url/repo.git", &octo2_oid));
- cl_git_pass(git_oid__fromstr(&octo3_oid, OCTO3_OID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&octo3_oid, OCTO3_OID, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_from_fetchhead(&their_heads[2], repo, GIT_REFS_HEADS_DIR OCTO3_BRANCH, "http://remote.url/repo.git", &octo3_oid));
cl_git_pass(git_merge__setup(repo, our_head, (const git_annotated_commit **)their_heads, 3));
@@ -818,16 +818,16 @@ void test_merge_workdir_setup__three_remotes(void)
git_oid octo3_oid;
git_annotated_commit *our_head, *their_heads[3];
- cl_git_pass(git_oid__fromstr(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&our_head, repo, &our_oid));
- cl_git_pass(git_oid__fromstr(&octo1_oid, OCTO1_OID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&octo1_oid, OCTO1_OID, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_from_fetchhead(&their_heads[0], repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH, "http://remote.first/repo.git", &octo1_oid));
- cl_git_pass(git_oid__fromstr(&octo2_oid, OCTO2_OID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&octo2_oid, OCTO2_OID, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_from_fetchhead(&their_heads[1], repo, GIT_REFS_HEADS_DIR OCTO2_BRANCH, "http://remote.second/repo.git", &octo2_oid));
- cl_git_pass(git_oid__fromstr(&octo3_oid, OCTO3_OID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&octo3_oid, OCTO3_OID, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_from_fetchhead(&their_heads[2], repo, GIT_REFS_HEADS_DIR OCTO3_BRANCH, "http://remote.third/repo.git", &octo3_oid));
cl_git_pass(git_merge__setup(repo, our_head, (const git_annotated_commit **)their_heads, 3));
@@ -852,19 +852,19 @@ void test_merge_workdir_setup__two_remotes(void)
git_oid octo4_oid;
git_annotated_commit *our_head, *their_heads[4];
- cl_git_pass(git_oid__fromstr(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&our_head, repo, &our_oid));
- cl_git_pass(git_oid__fromstr(&octo1_oid, OCTO1_OID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&octo1_oid, OCTO1_OID, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_from_fetchhead(&their_heads[0], repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH, "http://remote.first/repo.git", &octo1_oid));
- cl_git_pass(git_oid__fromstr(&octo2_oid, OCTO2_OID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&octo2_oid, OCTO2_OID, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_from_fetchhead(&their_heads[1], repo, GIT_REFS_HEADS_DIR OCTO2_BRANCH, "http://remote.second/repo.git", &octo2_oid));
- cl_git_pass(git_oid__fromstr(&octo3_oid, OCTO3_OID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&octo3_oid, OCTO3_OID, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_from_fetchhead(&their_heads[2], repo, GIT_REFS_HEADS_DIR OCTO3_BRANCH, "http://remote.first/repo.git", &octo3_oid));
- cl_git_pass(git_oid__fromstr(&octo4_oid, OCTO4_OID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&octo4_oid, OCTO4_OID, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_from_fetchhead(&their_heads[3], repo, GIT_REFS_HEADS_DIR OCTO4_BRANCH, "http://remote.second/repo.git", &octo4_oid));
cl_git_pass(git_merge__setup(repo, our_head, (const git_annotated_commit **)their_heads, 4));
@@ -888,7 +888,7 @@ void test_merge_workdir_setup__id_from_head(void)
git_reference *ref;
git_annotated_commit *heads[3];
- cl_git_pass(git_oid__fromstr(&expected_id, OCTO1_OID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected_id, OCTO1_OID, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_from_fetchhead(&heads[0], repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH, "http://remote.url/repo.git", &expected_id));
id = git_annotated_commit_id(heads[0]);
cl_assert_equal_i(1, git_oid_equal(id, &expected_id));
@@ -920,7 +920,7 @@ static int annotated_commit_foreach_cb(const git_oid *oid, void *payload)
git_oid expected_oid;
struct annotated_commit_cb_data *cb_data = payload;
- git_oid__fromstr(&expected_oid, cb_data->oid_str[cb_data->i], GIT_OID_SHA1);
+ git_oid_from_string(&expected_oid, cb_data->oid_str[cb_data->i], GIT_OID_SHA1);
cl_assert(git_oid_cmp(&expected_oid, oid) == 0);
cb_data->i++;
return 0;
@@ -998,7 +998,7 @@ void test_merge_workdir_setup__retained_after_success(void)
git_reference *octo1_ref;
git_annotated_commit *our_head, *their_heads[1];
- cl_git_pass(git_oid__fromstr(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&our_head, repo, &our_oid));
cl_git_pass(git_reference_lookup(&octo1_ref, repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH));
@@ -1025,7 +1025,7 @@ void test_merge_workdir_setup__removed_after_failure(void)
git_reference *octo1_ref;
git_annotated_commit *our_head, *their_heads[1];
- cl_git_pass(git_oid__fromstr(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&our_head, repo, &our_oid));
cl_git_pass(git_reference_lookup(&octo1_ref, repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH));
@@ -1052,7 +1052,7 @@ void test_merge_workdir_setup__unlocked_after_success(void)
git_reference *octo1_ref;
git_annotated_commit *our_head, *their_heads[1];
- cl_git_pass(git_oid__fromstr(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&our_head, repo, &our_oid));
cl_git_pass(git_reference_lookup(&octo1_ref, repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH));
@@ -1075,7 +1075,7 @@ void test_merge_workdir_setup__unlocked_after_conflict(void)
git_reference *octo1_ref;
git_annotated_commit *our_head, *their_heads[1];
- cl_git_pass(git_oid__fromstr(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&our_oid, ORIG_HEAD, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&our_head, repo, &our_oid));
cl_git_pass(git_reference_lookup(&octo1_ref, repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH));
diff --git a/tests/libgit2/merge/workdir/simple.c b/tests/libgit2/merge/workdir/simple.c
index e9cffeea822..c92277d8599 100644
--- a/tests/libgit2/merge/workdir/simple.c
+++ b/tests/libgit2/merge/workdir/simple.c
@@ -99,11 +99,11 @@ static void merge_simple_branch(int merge_file_favor, int addl_checkout_strategy
git_merge_options merge_opts = GIT_MERGE_OPTIONS_INIT;
git_checkout_options checkout_opts = GIT_CHECKOUT_OPTIONS_INIT;
- cl_git_pass(git_oid__fromstr(&their_oids[0], THEIRS_SIMPLE_OID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&their_oids[0], THEIRS_SIMPLE_OID, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&their_heads[0], repo, &their_oids[0]));
merge_opts.file_favor = merge_file_favor;
- checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_ALLOW_CONFLICTS |
+ checkout_opts.checkout_strategy = GIT_CHECKOUT_ALLOW_CONFLICTS |
addl_checkout_strategy;
cl_git_pass(git_merge(repo, (const git_annotated_commit **)their_heads, 1, &merge_opts, &checkout_opts));
@@ -180,14 +180,14 @@ void test_merge_workdir_simple__index_reload(void)
cl_git_pass(git_index_read(repo_index, 0));
entry.mode = GIT_FILEMODE_BLOB;
- cl_git_pass(git_oid__fromstr(&entry.id, "11deab00b2d3a6f5a3073988ac050c2d7b6655e2", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&entry.id, "11deab00b2d3a6f5a3073988ac050c2d7b6655e2", GIT_OID_SHA1));
entry.path = "automergeable.txt";
cl_git_pass(git_index_add(repo_index, &entry));
cl_git_pass(git_index_add_bypath(tmp_index, "automergeable.txt"));
cl_git_pass(git_index_write(tmp_index));
- cl_git_pass(git_oid__fromstr(&their_oid, THEIRS_SIMPLE_OID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&their_oid, THEIRS_SIMPLE_OID, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&their_heads[0], repo, &their_oid));
cl_git_pass(git_merge(repo, (const git_annotated_commit **)their_heads, 1, NULL, NULL));
@@ -577,7 +577,7 @@ void test_merge_workdir_simple__checkout_ours(void)
REMOVED_IN_MASTER_REUC_ENTRY
};
- merge_simple_branch(0, GIT_CHECKOUT_SAFE | GIT_CHECKOUT_USE_OURS);
+ merge_simple_branch(0, GIT_CHECKOUT_USE_OURS);
cl_assert(merge_test_index(repo_index, merge_index_entries, 8));
cl_assert(merge_test_reuc(repo_index, merge_reuc_entries, 3));
@@ -669,7 +669,7 @@ void test_merge_workdir_simple__directory_file(void)
cl_git_pass(git_commit_lookup(&head_commit, repo, &head_commit_id));
cl_git_pass(git_reset(repo, (git_object *)head_commit, GIT_RESET_HARD, NULL));
- cl_git_pass(git_oid__fromstr(&their_oids[0], THEIRS_DIRECTORY_FILE, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&their_oids[0], THEIRS_DIRECTORY_FILE, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&their_heads[0], repo, &their_oids[0]));
merge_opts.file_favor = 0;
@@ -700,7 +700,7 @@ void test_merge_workdir_simple__unrelated(void)
{ 0100644, "c8f06f2e3bb2964174677e91f0abead0e43c9e5d", 0, "unchanged.txt" },
};
- cl_git_pass(git_oid__fromstr(&their_oids[0], THEIRS_UNRELATED_PARENT, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&their_oids[0], THEIRS_UNRELATED_PARENT, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&their_heads[0], repo, &their_oids[0]));
merge_opts.file_favor = 0;
@@ -731,7 +731,7 @@ void test_merge_workdir_simple__unrelated_with_conflicts(void)
{ 0100644, "c8f06f2e3bb2964174677e91f0abead0e43c9e5d", 0, "unchanged.txt" },
};
- cl_git_pass(git_oid__fromstr(&their_oids[0], THEIRS_UNRELATED_OID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&their_oids[0], THEIRS_UNRELATED_OID, GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&their_heads[0], repo, &their_oids[0]));
merge_opts.file_favor = 0;
@@ -755,8 +755,8 @@ void test_merge_workdir_simple__binary(void)
{ 0100644, "836b8b82b26cab22eaaed8820877c76d6c8bca19", 3, "binary" },
};
- cl_git_pass(git_oid__fromstr(&our_oid, "cc338e4710c9b257106b8d16d82f86458d5beaf1", GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&their_oid, "ad01aebfdf2ac13145efafe3f9fcf798882f1730", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&our_oid, "cc338e4710c9b257106b8d16d82f86458d5beaf1", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&their_oid, "ad01aebfdf2ac13145efafe3f9fcf798882f1730", GIT_OID_SHA1));
cl_git_pass(git_commit_lookup(&our_commit, repo, &our_oid));
cl_git_pass(git_reset(repo, (git_object *)our_commit, GIT_RESET_HARD, NULL));
@@ -770,7 +770,7 @@ void test_merge_workdir_simple__binary(void)
cl_git_pass(git_index_add_bypath(repo_index, "binary"));
cl_assert((binary_entry = git_index_get_bypath(repo_index, "binary", 0)) != NULL);
- cl_git_pass(git_oid__fromstr(&our_file_oid, "23ed141a6ae1e798b2f721afedbe947c119111ba", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&our_file_oid, "23ed141a6ae1e798b2f721afedbe947c119111ba", GIT_OID_SHA1));
cl_assert(git_oid_cmp(&binary_entry->id, &our_file_oid) == 0);
git_annotated_commit_free(their_head);
diff --git a/tests/libgit2/merge/workdir/trivial.c b/tests/libgit2/merge/workdir/trivial.c
index 364182c8993..88ce033329a 100644
--- a/tests/libgit2/merge/workdir/trivial.c
+++ b/tests/libgit2/merge/workdir/trivial.c
@@ -222,7 +222,7 @@ void test_merge_workdir_trivial__13(void)
cl_git_pass(merge_trivial("trivial-13", "trivial-13-branch"));
cl_assert(entry = git_index_get_bypath(repo_index, "modified-in-13.txt", 0));
- cl_git_pass(git_oid__fromstr(&expected_oid, "1cff9ec6a47a537380dedfdd17c9e76d74259a2b", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected_oid, "1cff9ec6a47a537380dedfdd17c9e76d74259a2b", GIT_OID_SHA1));
cl_assert(git_oid_cmp(&entry->id, &expected_oid) == 0);
cl_assert(git_index_reuc_entrycount(repo_index) == 0);
@@ -238,7 +238,7 @@ void test_merge_workdir_trivial__14(void)
cl_git_pass(merge_trivial("trivial-14", "trivial-14-branch"));
cl_assert(entry = git_index_get_bypath(repo_index, "modified-in-14-branch.txt", 0));
- cl_git_pass(git_oid__fromstr(&expected_oid, "26153a3ff3649b6c2bb652d3f06878c6e0a172f9", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected_oid, "26153a3ff3649b6c2bb652d3f06878c6e0a172f9", GIT_OID_SHA1));
cl_assert(git_oid_cmp(&entry->id, &expected_oid) == 0);
cl_assert(git_index_reuc_entrycount(repo_index) == 0);
diff --git a/tests/libgit2/message/trailer.c b/tests/libgit2/message/trailer.c
index 919e10a499c..09e8f6115a7 100644
--- a/tests/libgit2/message/trailer.c
+++ b/tests/libgit2/message/trailer.c
@@ -3,19 +3,22 @@
static void assert_trailers(const char *message, git_message_trailer *trailers)
{
git_message_trailer_array arr;
- size_t i;
+ size_t i, count;
int rc = git_message_trailers(&arr, message);
cl_assert_equal_i(0, rc);
- for(i=0; i<arr.count; i++) {
+ for (i = 0, count = 0; trailers[i].key != NULL; i++, count++)
+ ;
+
+ cl_assert_equal_sz(arr.count, count);
+
+ for (i=0; i < count; i++) {
cl_assert_equal_s(arr.trailers[i].key, trailers[i].key);
cl_assert_equal_s(arr.trailers[i].value, trailers[i].value);
}
- cl_assert_equal_i(0, rc);
-
git_message_trailer_array_free(&arr);
}
@@ -162,3 +165,23 @@ void test_message_trailer__invalid(void)
"Another: trailer\n"
, trailers);
}
+
+void test_message_trailer__ignores_dashes(void)
+{
+ git_message_trailer trailers[] = {
+ { "Signed-off-by", "some@one.com" },
+ { "Another", "trailer" },
+ { NULL, NULL },
+ };
+
+ assert_trailers(
+ "Message\n"
+ "\n"
+ "Markdown header\n"
+ "---------------\n"
+ "Lorem ipsum\n"
+ "\n"
+ "Signed-off-by: some@one.com\n"
+ "Another: trailer\n"
+ , trailers);
+}
diff --git a/tests/libgit2/network/fetchlocal.c b/tests/libgit2/network/fetchlocal.c
index dc37c38ab6b..fef7ed5288a 100644
--- a/tests/libgit2/network/fetchlocal.c
+++ b/tests/libgit2/network/fetchlocal.c
@@ -108,14 +108,15 @@ void test_network_fetchlocal__prune(void)
git_repository_free(repo);
}
-static int update_tips_fail_on_call(const char *ref, const git_oid *old, const git_oid *new, void *data)
+static int update_refs_fail_on_call(const char *ref, const git_oid *old, const git_oid *new, git_refspec *refspec, void *data)
{
GIT_UNUSED(ref);
GIT_UNUSED(old);
GIT_UNUSED(new);
+ GIT_UNUSED(refspec);
GIT_UNUSED(data);
- cl_fail("update tips called");
+ cl_fail("update refs called");
return 0;
}
@@ -175,7 +176,7 @@ void test_network_fetchlocal__prune_overlapping(void)
git_remote_free(origin);
cl_git_pass(git_remote_lookup(&origin, repo, GIT_REMOTE_ORIGIN));
- options.callbacks.update_tips = update_tips_fail_on_call;
+ options.callbacks.update_refs = update_refs_fail_on_call;
cl_git_pass(git_remote_fetch(origin, NULL, &options, NULL));
assert_ref_exists(repo, "refs/remotes/origin/master");
@@ -190,7 +191,7 @@ void test_network_fetchlocal__prune_overlapping(void)
git_remote_free(origin);
cl_git_pass(git_remote_lookup(&origin, repo, GIT_REMOTE_ORIGIN));
- options.callbacks.update_tips = update_tips_fail_on_call;
+ options.callbacks.update_refs = update_refs_fail_on_call;
cl_git_pass(git_remote_fetch(origin, NULL, &options, NULL));
git_config_free(config);
@@ -510,20 +511,21 @@ void test_network_fetchlocal__prune_load_fetch_prune_config(void)
git_repository_free(repo);
}
-static int update_tips_error(const char *ref, const git_oid *old, const git_oid *new, void *data)
+static int update_refs_error(const char *ref, const git_oid *old, const git_oid *new, git_refspec *refspec, void *data)
{
int *callcount = (int *) data;
GIT_UNUSED(ref);
GIT_UNUSED(old);
GIT_UNUSED(new);
+ GIT_UNUSED(refspec);
(*callcount)++;
return -1;
}
-void test_network_fetchlocal__update_tips_error_is_propagated(void)
+void test_network_fetchlocal__update_refs_error_is_propagated(void)
{
git_repository *repo;
git_reference_iterator *iterator;
@@ -537,7 +539,7 @@ void test_network_fetchlocal__update_tips_error_is_propagated(void)
cl_git_pass(git_remote_create_with_fetchspec(&remote, repo, "origin", cl_git_fixture_url("testrepo.git"), "+refs/heads/*:refs/remotes/update-tips/*"));
- options.callbacks.update_tips = update_tips_error;
+ options.callbacks.update_refs = update_refs_error;
options.callbacks.payload = &callcount;
cl_git_fail(git_remote_fetch(remote, NULL, &options, NULL));
@@ -550,3 +552,83 @@ void test_network_fetchlocal__update_tips_error_is_propagated(void)
git_remote_free(remote);
git_repository_free(repo);
}
+
+#ifndef GIT_DEPRECATE_HARD
+static int update_tips(const char *ref, const git_oid *old, const git_oid *new, void *data)
+{
+ int *called = (int *) data;
+
+ GIT_UNUSED(ref);
+ GIT_UNUSED(old);
+ GIT_UNUSED(new);
+
+ (*called) += 1;
+
+ return 0;
+}
+
+static int update_refs(const char *ref, const git_oid *old, const git_oid *new, git_refspec *spec, void *data)
+{
+ int *called = (int *) data;
+
+ GIT_UNUSED(ref);
+ GIT_UNUSED(old);
+ GIT_UNUSED(new);
+ GIT_UNUSED(spec);
+
+ (*called) += 0x10000;
+
+ return 0;
+}
+#endif
+
+void test_network_fetchlocal__update_tips_backcompat(void)
+{
+#ifndef GIT_DEPRECATE_HARD
+ git_repository *repo;
+ git_remote *remote;
+ git_fetch_options options = GIT_FETCH_OPTIONS_INIT;
+ int callcount = 0;
+
+ cl_git_pass(git_repository_init(&repo, "foo.git", true));
+ cl_set_cleanup(cleanup_local_repo, "foo.git");
+
+ cl_git_pass(git_remote_create_with_fetchspec(&remote, repo, "origin", cl_git_fixture_url("testrepo.git"), "+refs/heads/*:refs/remotes/update-tips/*"));
+
+ options.callbacks.update_tips = update_tips;
+ options.callbacks.payload = &callcount;
+
+ cl_git_pass(git_remote_fetch(remote, NULL, &options, NULL));
+ cl_assert_equal_i(0, (callcount & 0xffff0000));
+ cl_assert((callcount & 0x0000ffff) > 0);
+
+ git_remote_free(remote);
+ git_repository_free(repo);
+#endif
+}
+
+void test_network_fetchlocal__update_refs_is_preferred(void)
+{
+#ifndef GIT_DEPRECATE_HARD
+ git_repository *repo;
+ git_remote *remote;
+ git_fetch_options options = GIT_FETCH_OPTIONS_INIT;
+ int callcount = 0;
+
+ cl_git_pass(git_repository_init(&repo, "foo.git", true));
+ cl_set_cleanup(cleanup_local_repo, "foo.git");
+
+ cl_git_pass(git_remote_create_with_fetchspec(&remote, repo, "origin", cl_git_fixture_url("testrepo.git"), "+refs/heads/*:refs/remotes/update-tips/*"));
+
+ options.callbacks.update_tips = update_tips;
+ options.callbacks.update_refs = update_refs;
+ options.callbacks.payload = &callcount;
+
+ cl_git_pass(git_remote_fetch(remote, NULL, &options, NULL));
+ cl_assert_equal_i(0, (callcount & 0x0000ffff));
+ cl_assert((callcount & 0xffff0000) > 0);
+
+ git_remote_free(remote);
+ git_repository_free(repo);
+#endif
+}
diff --git a/tests/libgit2/network/matchhost.c b/tests/libgit2/network/matchhost.c
deleted file mode 100644
index 3100dc21d70..00000000000
--- a/tests/libgit2/network/matchhost.c
+++ /dev/null
@@ -1,13 +0,0 @@
-#include "clar_libgit2.h"
-#include "netops.h"
-
-void test_network_matchhost__match(void)
-{
- cl_git_pass(gitno__match_host("*.example.org", "www.example.org"));
- cl_git_pass(gitno__match_host("*.foo.example.org", "www.foo.example.org"));
- cl_git_fail(gitno__match_host("*.foo.example.org", "foo.example.org"));
- cl_git_fail(gitno__match_host("*.foo.example.org", "www.example.org"));
- cl_git_fail(gitno__match_host("*.example.org", "example.org"));
- cl_git_fail(gitno__match_host("*.example.org", "www.foo.example.org"));
- cl_git_fail(gitno__match_host("*.example.org", "blah.www.www.example.org"));
-}
diff --git a/tests/libgit2/network/remote/local.c b/tests/libgit2/network/remote/local.c
index 2007f3776a1..88bf2da785e 100644
--- a/tests/libgit2/network/remote/local.c
+++ b/tests/libgit2/network/remote/local.c
@@ -2,6 +2,7 @@
#include "path.h"
#include "posix.h"
#include "git2/sys/repository.h"
+#include "repository.h"
static git_repository *repo;
static git_str file_path_buf = GIT_STR_INIT;
@@ -61,7 +62,7 @@ void test_network_remote_local__retrieve_advertised_references(void)
cl_git_pass(git_remote_ls(&refs, &refs_len, remote));
- cl_assert_equal_i(refs_len, 30);
+ cl_assert_equal_i(refs_len, 31);
}
void test_network_remote_local__retrieve_advertised_before_connect(void)
@@ -85,7 +86,7 @@ void test_network_remote_local__retrieve_advertised_references_after_disconnect(
cl_git_pass(git_remote_ls(&refs, &refs_len, remote));
- cl_assert_equal_i(refs_len, 30);
+ cl_assert_equal_i(refs_len, 31);
}
void test_network_remote_local__retrieve_advertised_references_from_spaced_repository(void)
@@ -100,7 +101,7 @@ void test_network_remote_local__retrieve_advertised_references_from_spaced_repos
cl_git_pass(git_remote_ls(&refs, &refs_len, remote));
- cl_assert_equal_i(refs_len, 30);
+ cl_assert_equal_i(refs_len, 31);
git_remote_free(remote); /* Disconnect from the "spaced repo" before the cleanup */
remote = NULL;
@@ -470,10 +471,11 @@ void test_network_remote_local__anonymous_remote_inmemory_repo(void)
{
git_repository *inmemory;
git_remote *remote;
+ git_repository_new_options repo_opts = GIT_REPOSITORY_NEW_OPTIONS_INIT;
git_str_sets(&file_path_buf, cl_git_path_url(cl_fixture("testrepo.git")));
- cl_git_pass(git_repository_new(&inmemory));
+ cl_git_pass(git_repository_new_ext(&inmemory, &repo_opts));
cl_git_pass(git_remote_create_anonymous(&remote, inmemory, git_str_cstr(&file_path_buf)));
cl_git_pass(git_remote_connect(remote, GIT_DIRECTION_FETCH, NULL, NULL, NULL));
cl_assert(git_remote_connected(remote));
diff --git a/tests/libgit2/network/remote/rename.c b/tests/libgit2/network/remote/rename.c
index b071f9ceffe..39e91fa23f4 100644
--- a/tests/libgit2/network/remote/rename.c
+++ b/tests/libgit2/network/remote/rename.c
@@ -170,7 +170,7 @@ void test_network_remote_rename__overwrite_ref_in_target(void)
git_branch_iterator *iter;
git_strarray problems = {0};
- cl_git_pass(git_oid__fromstr(&id, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1));
cl_git_pass(git_reference_create(&ref, _repo, "refs/remotes/renamed/master", &id, 1, NULL));
git_reference_free(ref);
@@ -216,7 +216,7 @@ void test_network_remote_rename__symref_head(void)
cl_assert_equal_i(0, problems.count);
git_strarray_dispose(&problems);
- cl_git_pass(git_vector_init(&refs, 2, (git_vector_cmp) git_reference_cmp));
+ cl_git_pass(git_vector_init(&refs, 2, git_reference__cmp_cb));
cl_git_pass(git_branch_iterator_new(&iter, _repo, GIT_BRANCH_REMOTE));
while ((error = git_branch_next(&ref, &btype, iter)) == 0) {
@@ -238,7 +238,7 @@ void test_network_remote_rename__symref_head(void)
cl_assert_equal_s("be3563ae3f795b2b4353bcce3a527ad0a4f7f644", idstr);
git_reference_free(ref);
- git_vector_free(&refs);
+ git_vector_dispose(&refs);
cl_git_fail_with(GIT_ITEROVER, git_branch_next(&ref, &btype, iter));
git_branch_iterator_free(iter);
diff --git a/tests/libgit2/network/remote/tag.c b/tests/libgit2/network/remote/tag.c
new file mode 100644
index 00000000000..7a166a94f13
--- /dev/null
+++ b/tests/libgit2/network/remote/tag.c
@@ -0,0 +1,93 @@
+#include "clar_libgit2.h"
+#include "git2/sys/commit.h"
+
+static git_remote *_remote;
+static git_repository *_repo, *_dummy;
+
+void test_network_remote_tag__initialize(void)
+{
+ cl_fixture_sandbox("testrepo.git");
+ git_repository_open(&_repo, "testrepo.git");
+
+ /* We need a repository to have a remote */
+ cl_git_pass(git_repository_init(&_dummy, "dummytag.git", true));
+ cl_git_pass(git_remote_create(&_remote, _dummy, "origin", cl_git_path_url("testrepo.git")));
+}
+
+void test_network_remote_tag__cleanup(void)
+{
+ git_remote_free(_remote);
+ _remote = NULL;
+
+ git_repository_free(_repo);
+ _repo = NULL;
+
+ git_repository_free(_dummy);
+ _dummy = NULL;
+
+ cl_fixture_cleanup("testrepo.git");
+ cl_fixture_cleanup("dummytag.git");
+}
+
+/*
+ * Create one commit, one tree, one blob.
+ * Create two tags: one for the commit, one for the blob.
+ */
+static void create_commit_with_tags(git_reference **out, git_oid *out_commit_tag_id, git_oid *out_blob_tag_id, git_repository *repo)
+{
+ git_treebuilder *treebuilder;
+ git_oid blob_id, tree_id, commit_id;
+ git_signature *sig;
+ git_object *target;
+
+ cl_git_pass(git_treebuilder_new(&treebuilder, repo, NULL));
+
+ cl_git_pass(git_blob_create_from_buffer(&blob_id, repo, "", 0));
+ cl_git_pass(git_treebuilder_insert(NULL, treebuilder, "README.md", &blob_id, 0100644));
+ cl_git_pass(git_treebuilder_write(&tree_id, treebuilder));
+
+ cl_git_pass(git_signature_now(&sig, "Pusher Joe", "pjoe"));
+ cl_git_pass(git_commit_create_from_ids(&commit_id, repo, NULL, sig, sig,
+ NULL, "Tree with tags\n", &tree_id, 0, NULL));
+ cl_git_pass(git_reference_create(out, repo, "refs/heads/tree-with-tags", &commit_id, true, "commit yo"));
+
+ cl_git_pass(git_object_lookup(&target, repo, &commit_id, GIT_OBJECT_COMMIT));
+ cl_git_pass(git_tag_create_lightweight(out_commit_tag_id, repo, "tagged-commit", target, true));
+ git_object_free(target);
+
+ cl_git_pass(git_object_lookup(&target, repo, &blob_id, GIT_OBJECT_BLOB));
+ cl_git_pass(git_tag_create_lightweight(out_blob_tag_id, repo, "tagged-blob", target, true));
+ git_object_free(target);
+
+ git_treebuilder_free(treebuilder);
+ git_signature_free(sig);
+}
+
+void test_network_remote_tag__push_different_tag_types(void)
+{
+ git_push_options opts = GIT_PUSH_OPTIONS_INIT;
+ git_reference *ref;
+ git_oid commit_tag_id, blob_tag_id;
+ char* refspec_tree = "refs/heads/tree-with-tags";
+ char* refspec_tagged_commit = "refs/tags/tagged-commit";
+ char* refspec_tagged_blob = "refs/tags/tagged-blob";
+ const git_strarray refspecs_tree = { &refspec_tree, 1 };
+ const git_strarray refspecs_tagged_commit = { &refspec_tagged_commit, 1 };
+ const git_strarray refspecs_tagged_blob = { &refspec_tagged_blob, 1 };
+
+ create_commit_with_tags(&ref, &commit_tag_id, &blob_tag_id, _dummy);
+
+ /* Push tree */
+ cl_git_pass(git_remote_push(_remote, &refspecs_tree, &opts));
+ git_reference_free(ref);
+ cl_git_pass(git_reference_lookup(&ref, _repo, "refs/heads/tree-with-tags"));
+ git_reference_free(ref);
+
+ /* Push tagged commit */
+ cl_git_pass(git_remote_push(_remote, &refspecs_tagged_commit, &opts));
+ cl_git_pass(git_reference_name_to_id(&commit_tag_id, _repo, "refs/tags/tagged-commit"));
+
+ /* Push tagged blob */
+ cl_git_pass(git_remote_push(_remote, &refspecs_tagged_blob, &opts));
+ cl_git_pass(git_reference_name_to_id(&blob_tag_id, _repo, "refs/tags/tagged-blob"));
+}
diff --git a/tests/libgit2/notes/notes.c b/tests/libgit2/notes/notes.c
index 06c4409551b..fb0a70d059c 100644
--- a/tests/libgit2/notes/notes.c
+++ b/tests/libgit2/notes/notes.c
@@ -33,7 +33,7 @@ static void create_note(git_oid *note_oid, const char *canonical_namespace, cons
{
git_oid oid;
- cl_git_pass(git_oid__fromstr(&oid, target_sha, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, target_sha, GIT_OID_SHA1));
cl_git_pass(git_note_create(note_oid, _repo, canonical_namespace, _sig, _sig, &oid, message, 0));
}
@@ -60,10 +60,10 @@ static int note_list_cb(
cl_assert(*count < EXPECTATIONS_COUNT);
- cl_git_pass(git_oid__fromstr(&expected_note_oid, list_expectations[*count].note_sha, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected_note_oid, list_expectations[*count].note_sha, GIT_OID_SHA1));
cl_assert_equal_oid(&expected_note_oid, blob_id);
- cl_git_pass(git_oid__fromstr(&expected_target_oid, list_expectations[*count].annotated_object_sha, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected_target_oid, list_expectations[*count].annotated_object_sha, GIT_OID_SHA1));
cl_assert_equal_oid(&expected_target_oid, annotated_obj_id);
(*count)++;
@@ -85,12 +85,12 @@ static int note_list_create_cb(
size_t i;
for (i = 0; notes[i].note_oid != NULL; i++) {
- cl_git_pass(git_oid__fromstr(&expected_note_oid, notes[i].note_oid, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected_note_oid, notes[i].note_oid, GIT_OID_SHA1));
if (git_oid_cmp(&expected_note_oid, blob_oid) != 0)
continue;
- cl_git_pass(git_oid__fromstr(&expected_target_oid, notes[i].object_oid, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected_target_oid, notes[i].object_oid, GIT_OID_SHA1));
if (git_oid_cmp(&expected_target_oid, annotated_obj_id) != 0)
continue;
@@ -140,7 +140,7 @@ void test_notes_notes__can_create_a_note_from_commit(void)
{ NULL, NULL, 0 }
};
- cl_git_pass(git_oid__fromstr(&oid, can_create_a_note_from_commit[0].object_oid, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, can_create_a_note_from_commit[0].object_oid, GIT_OID_SHA1));
cl_git_pass(git_note_commit_create(¬es_commit_out, NULL, _repo, NULL, _sig, _sig, &oid, "I decorate 4a20\n", 1));
@@ -169,11 +169,11 @@ void test_notes_notes__can_create_a_note_from_commit_given_an_existing_commit(vo
{ NULL, NULL, 0 }
};
- cl_git_pass(git_oid__fromstr(&oid, "4a202b346bb0fb0db7eff3cffeb3c70babbd2045", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, "4a202b346bb0fb0db7eff3cffeb3c70babbd2045", GIT_OID_SHA1));
cl_git_pass(git_note_commit_create(¬es_commit_out, NULL, _repo, NULL, _sig, _sig, &oid, "I decorate 4a20\n", 0));
- cl_git_pass(git_oid__fromstr(&oid, "9fd738e8f7967c078dceed8190330fc8648ee56a", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, "9fd738e8f7967c078dceed8190330fc8648ee56a", GIT_OID_SHA1));
git_commit_lookup(&existing_notes_commit, _repo, ¬es_commit_out);
@@ -274,7 +274,7 @@ void test_notes_notes__inserting_a_note_without_passing_a_namespace_uses_the_def
git_note *note, *default_namespace_note;
git_buf default_ref = GIT_BUF_INIT;
- cl_git_pass(git_oid__fromstr(&target_oid, "08b041783f40edfe12bb406c9c9a8a040177c125", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&target_oid, "08b041783f40edfe12bb406c9c9a8a040177c125", GIT_OID_SHA1));
cl_git_pass(git_note_default_ref(&default_ref, _repo));
create_note(¬e_oid, NULL, "08b041783f40edfe12bb406c9c9a8a040177c125", "hello world\n");
@@ -295,7 +295,7 @@ void test_notes_notes__can_insert_a_note_with_a_custom_namespace(void)
git_oid note_oid, target_oid;
git_note *note;
- cl_git_pass(git_oid__fromstr(&target_oid, "08b041783f40edfe12bb406c9c9a8a040177c125", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&target_oid, "08b041783f40edfe12bb406c9c9a8a040177c125", GIT_OID_SHA1));
create_note(¬e_oid, "refs/notes/some/namespace", "08b041783f40edfe12bb406c9c9a8a040177c125", "hello world on a custom namespace\n");
@@ -315,7 +315,7 @@ void test_notes_notes__creating_a_note_on_a_target_which_already_has_one_returns
int error;
git_oid note_oid, target_oid;
- cl_git_pass(git_oid__fromstr(&target_oid, "08b041783f40edfe12bb406c9c9a8a040177c125", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&target_oid, "08b041783f40edfe12bb406c9c9a8a040177c125", GIT_OID_SHA1));
create_note(¬e_oid, NULL, "08b041783f40edfe12bb406c9c9a8a040177c125", "hello world\n");
error = git_note_create(¬e_oid, _repo, NULL, _sig, _sig, &target_oid, "hello world\n", 0);
@@ -334,7 +334,7 @@ void test_notes_notes__creating_a_note_on_a_target_can_overwrite_existing_note(v
git_oid note_oid, target_oid;
git_note *note, *namespace_note;
- cl_git_pass(git_oid__fromstr(&target_oid, "08b041783f40edfe12bb406c9c9a8a040177c125", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&target_oid, "08b041783f40edfe12bb406c9c9a8a040177c125", GIT_OID_SHA1));
create_note(¬e_oid, NULL, "08b041783f40edfe12bb406c9c9a8a040177c125", "hello old world\n");
cl_git_pass(git_note_create(¬e_oid, _repo, NULL, _sig, _sig, &target_oid, "hello new world\n", 1));
@@ -381,7 +381,7 @@ void test_notes_notes__can_read_a_note(void)
create_note(¬e_oid, "refs/notes/i-can-see-dead-notes", "4a202b346bb0fb0db7eff3cffeb3c70babbd2045", "I decorate 4a20\n");
- cl_git_pass(git_oid__fromstr(&target_oid, "4a202b346bb0fb0db7eff3cffeb3c70babbd2045", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&target_oid, "4a202b346bb0fb0db7eff3cffeb3c70babbd2045", GIT_OID_SHA1));
cl_git_pass(git_note_read(¬e, _repo, "refs/notes/i-can-see-dead-notes", &target_oid));
@@ -397,7 +397,7 @@ void test_notes_notes__can_read_a_note_from_a_commit(void)
git_commit *notes_commit;
git_note *note;
- cl_git_pass(git_oid__fromstr(&oid, "4a202b346bb0fb0db7eff3cffeb3c70babbd2045", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, "4a202b346bb0fb0db7eff3cffeb3c70babbd2045", GIT_OID_SHA1));
cl_git_pass(git_note_commit_create(¬es_commit_oid, NULL, _repo, NULL, _sig, _sig, &oid, "I decorate 4a20\n", 1));
cl_git_pass(git_commit_lookup(¬es_commit, _repo, ¬es_commit_oid));
cl_assert(notes_commit);
@@ -416,7 +416,7 @@ void test_notes_notes__attempt_to_read_a_note_from_a_commit_with_no_note_fails(v
git_commit *notes_commit;
git_note *note;
- cl_git_pass(git_oid__fromstr(&oid, "4a202b346bb0fb0db7eff3cffeb3c70babbd2045", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, "4a202b346bb0fb0db7eff3cffeb3c70babbd2045", GIT_OID_SHA1));
cl_git_pass(git_note_commit_create(¬es_commit_oid, NULL, _repo, NULL, _sig, _sig, &oid, "I decorate 4a20\n", 1));
@@ -450,7 +450,7 @@ void test_notes_notes__can_insert_a_note_in_an_existing_fanout(void)
git_oid note_oid, target_oid;
git_note *_note;
- cl_git_pass(git_oid__fromstr(&target_oid, "08b041783f40edfe12bb406c9c9a8a040177c125", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&target_oid, "08b041783f40edfe12bb406c9c9a8a040177c125", GIT_OID_SHA1));
for (i = 0; i < MESSAGES_COUNT; i++) {
cl_git_pass(git_note_create(¬e_oid, _repo, "refs/notes/fanout", _sig, _sig, &target_oid, messages[i], 0));
@@ -470,10 +470,10 @@ void test_notes_notes__can_read_a_note_in_an_existing_fanout(void)
git_oid note_oid, target_oid;
git_note *note;
- cl_git_pass(git_oid__fromstr(&target_oid, "8496071c1b46c854b31185ea97743be6a8774479", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&target_oid, "8496071c1b46c854b31185ea97743be6a8774479", GIT_OID_SHA1));
cl_git_pass(git_note_read(¬e, _repo, "refs/notes/fanout", &target_oid));
- cl_git_pass(git_oid__fromstr(¬e_oid, "08b041783f40edfe12bb406c9c9a8a040177c125", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(¬e_oid, "08b041783f40edfe12bb406c9c9a8a040177c125", GIT_OID_SHA1));
cl_assert_equal_oid(git_note_id(note), ¬e_oid);
git_note_free(note);
@@ -487,7 +487,7 @@ void test_notes_notes__can_remove_a_note(void)
create_note(¬e_oid, "refs/notes/i-can-see-dead-notes", "4a202b346bb0fb0db7eff3cffeb3c70babbd2045", "I decorate 4a20\n");
- cl_git_pass(git_oid__fromstr(&target_oid, "4a202b346bb0fb0db7eff3cffeb3c70babbd2045", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&target_oid, "4a202b346bb0fb0db7eff3cffeb3c70babbd2045", GIT_OID_SHA1));
cl_git_pass(git_note_remove(_repo, "refs/notes/i-can-see-dead-notes", _sig, _sig, &target_oid));
cl_git_fail(git_note_read(¬e, _repo, "refs/notes/i-can-see-dead-notes", &target_oid));
@@ -501,7 +501,7 @@ void test_notes_notes__can_remove_a_note_from_commit(void)
git_commit *existing_notes_commit;
git_reference *ref;
- cl_git_pass(git_oid__fromstr(&oid, "4a202b346bb0fb0db7eff3cffeb3c70babbd2045", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, "4a202b346bb0fb0db7eff3cffeb3c70babbd2045", GIT_OID_SHA1));
cl_git_pass(git_note_commit_create(¬es_commit_oid, NULL, _repo, NULL, _sig, _sig, &oid, "I decorate 4a20\n", 0));
@@ -528,7 +528,7 @@ void test_notes_notes__can_remove_a_note_in_an_existing_fanout(void)
git_oid target_oid;
git_note *note;
- cl_git_pass(git_oid__fromstr(&target_oid, "8496071c1b46c854b31185ea97743be6a8774479", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&target_oid, "8496071c1b46c854b31185ea97743be6a8774479", GIT_OID_SHA1));
cl_git_pass(git_note_remove(_repo, "refs/notes/fanout", _sig, _sig, &target_oid));
cl_git_fail(git_note_read(¬e, _repo, "refs/notes/fanout", &target_oid));
@@ -539,7 +539,7 @@ void test_notes_notes__removing_a_note_which_doesnt_exists_returns_ENOTFOUND(voi
int error;
git_oid target_oid;
- cl_git_pass(git_oid__fromstr(&target_oid, "8496071c1b46c854b31185ea97743be6a8774479", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&target_oid, "8496071c1b46c854b31185ea97743be6a8774479", GIT_OID_SHA1));
cl_git_pass(git_note_remove(_repo, "refs/notes/fanout", _sig, _sig, &target_oid));
error = git_note_remove(_repo, "refs/notes/fanout", _sig, _sig, &target_oid);
@@ -628,8 +628,8 @@ void test_notes_notes__iterate_from_commit(void)
};
int i, err;
- cl_git_pass(git_oid__fromstr(&(oids[0]), "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&(oids[1]), "c47800c7266a2be04c571c04d5a6614691ea99bd", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&(oids[0]), "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&(oids[1]), "c47800c7266a2be04c571c04d5a6614691ea99bd", GIT_OID_SHA1));
cl_git_pass(git_note_commit_create(¬es_commit_oids[0], NULL, _repo, NULL, _sig, _sig, &(oids[0]), note_message[0], 0));
diff --git a/tests/libgit2/notes/notesref.c b/tests/libgit2/notes/notesref.c
index 8696ff66a60..13def68e5b0 100644
--- a/tests/libgit2/notes/notesref.c
+++ b/tests/libgit2/notes/notesref.c
@@ -36,7 +36,7 @@ void test_notes_notesref__config_corenotesref(void)
git_buf default_ref = GIT_BUF_INIT;
cl_git_pass(git_signature_now(&_sig, "alice", "alice@example.com"));
- cl_git_pass(git_oid__fromstr(&oid, "8496071c1b46c854b31185ea97743be6a8774479", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, "8496071c1b46c854b31185ea97743be6a8774479", GIT_OID_SHA1));
cl_git_pass(git_repository_config(&_cfg, _repo));
diff --git a/tests/libgit2/object/blob/fromstream.c b/tests/libgit2/object/blob/fromstream.c
index dad0b52e155..52eb2967959 100644
--- a/tests/libgit2/object/blob/fromstream.c
+++ b/tests/libgit2/object/blob/fromstream.c
@@ -23,7 +23,7 @@ void test_object_blob_fromstream__multiple_write(void)
git_writestream *stream;
int i, howmany = 6;
- cl_git_pass(git_oid__fromstr(&expected_id, "321cbdf08803c744082332332838df6bd160f8f9", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected_id, "321cbdf08803c744082332332838df6bd160f8f9", GIT_OID_SHA1));
cl_git_fail_with(GIT_ENOTFOUND,
git_object_lookup(&blob, repo, &expected_id, GIT_OBJECT_ANY));
@@ -64,7 +64,7 @@ static void assert_named_chunked_blob(const char *expected_sha, const char *fake
git_writestream *stream;
int i, howmany = 6;
- cl_git_pass(git_oid__fromstr(&expected_id, expected_sha, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected_id, expected_sha, GIT_OID_SHA1));
cl_git_pass(git_blob_create_from_stream(&stream, repo, fake_name));
diff --git a/tests/libgit2/object/cache.c b/tests/libgit2/object/cache.c
index bf8c6fb53cb..b10c97cd034 100644
--- a/tests/libgit2/object/cache.c
+++ b/tests/libgit2/object/cache.c
@@ -91,7 +91,7 @@ void test_object_cache__cache_counts(void)
for (i = 0; g_data[i].sha != NULL; ++i) {
int count = (int)git_cache_size(&g_repo->objects);
- cl_git_pass(git_oid__fromstr(&oid, g_data[i].sha, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, g_data[i].sha, GIT_OID_SHA1));
/* alternate between loading raw and parsed objects */
if ((i & 1) == 0) {
@@ -118,7 +118,7 @@ void test_object_cache__cache_counts(void)
for (i = 0; g_data[i].sha != NULL; ++i) {
int count = (int)git_cache_size(&g_repo->objects);
- cl_git_pass(git_oid__fromstr(&oid, g_data[i].sha, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, g_data[i].sha, GIT_OID_SHA1));
cl_git_pass(git_object_lookup(&obj, g_repo, &oid, GIT_OBJECT_ANY));
cl_assert(g_data[i].type == git_object_type(obj));
git_object_free(obj);
@@ -136,14 +136,14 @@ static void *cache_parsed(void *arg)
git_object *obj;
for (i = ((int *)arg)[1]; g_data[i].sha != NULL; i += 2) {
- cl_git_pass(git_oid__fromstr(&oid, g_data[i].sha, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, g_data[i].sha, GIT_OID_SHA1));
cl_git_pass(git_object_lookup(&obj, g_repo, &oid, GIT_OBJECT_ANY));
cl_assert(g_data[i].type == git_object_type(obj));
git_object_free(obj);
}
for (i = 0; i < ((int *)arg)[1]; i += 2) {
- cl_git_pass(git_oid__fromstr(&oid, g_data[i].sha, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, g_data[i].sha, GIT_OID_SHA1));
cl_git_pass(git_object_lookup(&obj, g_repo, &oid, GIT_OBJECT_ANY));
cl_assert(g_data[i].type == git_object_type(obj));
git_object_free(obj);
@@ -162,14 +162,14 @@ static void *cache_raw(void *arg)
cl_git_pass(git_repository_odb(&odb, g_repo));
for (i = ((int *)arg)[1]; g_data[i].sha != NULL; i += 2) {
- cl_git_pass(git_oid__fromstr(&oid, g_data[i].sha, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, g_data[i].sha, GIT_OID_SHA1));
cl_git_pass(git_odb_read(&odb_obj, odb, &oid));
cl_assert(g_data[i].type == git_odb_object_type(odb_obj));
git_odb_object_free(odb_obj);
}
for (i = 0; i < ((int *)arg)[1]; i += 2) {
- cl_git_pass(git_oid__fromstr(&oid, g_data[i].sha, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, g_data[i].sha, GIT_OID_SHA1));
cl_git_pass(git_odb_read(&odb_obj, odb, &oid));
cl_assert(g_data[i].type == git_odb_object_type(odb_obj));
git_odb_object_free(odb_obj);
@@ -234,7 +234,7 @@ static void *cache_quick(void *arg)
git_oid oid;
git_object *obj;
- cl_git_pass(git_oid__fromstr(&oid, g_data[4].sha, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, g_data[4].sha, GIT_OID_SHA1));
cl_git_pass(git_object_lookup(&obj, g_repo, &oid, GIT_OBJECT_ANY));
cl_assert(g_data[4].type == git_object_type(obj));
git_object_free(obj);
diff --git a/tests/libgit2/object/commit/commitstagedfile.c b/tests/libgit2/object/commit/commitstagedfile.c
index 61f50b2af60..565c888e468 100644
--- a/tests/libgit2/object/commit/commitstagedfile.c
+++ b/tests/libgit2/object/commit/commitstagedfile.c
@@ -64,9 +64,9 @@ void test_object_commit_commitstagedfile__generate_predictable_object_ids(void)
* 100644 blob 9daeafb9864cf43055ae93beb0afd6c7d144bfa4 test.txt
*/
- cl_git_pass(git_oid__fromstr(&expected_commit_oid, "1fe3126578fc4eca68c193e4a3a0a14a0704624d", GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&expected_tree_oid, "2b297e643c551e76cfa1f93810c50811382f9117", GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&expected_blob_oid, "9daeafb9864cf43055ae93beb0afd6c7d144bfa4", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected_commit_oid, "1fe3126578fc4eca68c193e4a3a0a14a0704624d", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected_tree_oid, "2b297e643c551e76cfa1f93810c50811382f9117", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected_blob_oid, "9daeafb9864cf43055ae93beb0afd6c7d144bfa4", GIT_OID_SHA1));
/*
* Add a new file to the index
diff --git a/tests/libgit2/object/commit/parse.c b/tests/libgit2/object/commit/parse.c
index 6f9a6550789..78413fb4982 100644
--- a/tests/libgit2/object/commit/parse.c
+++ b/tests/libgit2/object/commit/parse.c
@@ -54,7 +54,7 @@ static void assert_commit_parses(
if (expected_treeid) {
git_oid tree_oid;
- cl_git_pass(git_oid__fromstr(&tree_oid, expected_treeid, oid_type));
+ cl_git_pass(git_oid_from_string(&tree_oid, expected_treeid, oid_type));
cl_assert_equal_oid(&tree_oid, &commit->tree_id);
}
diff --git a/tests/libgit2/object/lookup.c b/tests/libgit2/object/lookup.c
index 7ef1dbd1c96..2285a488126 100644
--- a/tests/libgit2/object/lookup.c
+++ b/tests/libgit2/object/lookup.c
@@ -20,7 +20,7 @@ void test_object_lookup__lookup_wrong_type_returns_enotfound(void)
git_oid oid;
git_object *object;
- cl_git_pass(git_oid__fromstr(&oid, commit, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, commit, GIT_OID_SHA1));
cl_assert_equal_i(
GIT_ENOTFOUND, git_object_lookup(&object, g_repo, &oid, GIT_OBJECT_TAG));
}
@@ -31,7 +31,7 @@ void test_object_lookup__lookup_nonexisting_returns_enotfound(void)
git_oid oid;
git_object *object;
- cl_git_pass(git_oid__fromstr(&oid, unknown, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, unknown, GIT_OID_SHA1));
cl_assert_equal_i(
GIT_ENOTFOUND, git_object_lookup(&object, g_repo, &oid, GIT_OBJECT_ANY));
}
@@ -42,7 +42,7 @@ void test_object_lookup__lookup_wrong_type_by_abbreviated_id_returns_enotfound(v
git_oid oid;
git_object *object;
- cl_git_pass(git_oid__fromstrn(&oid, commit, strlen(commit), GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&oid, commit, strlen(commit), GIT_OID_SHA1));
cl_assert_equal_i(
GIT_ENOTFOUND, git_object_lookup_prefix(&object, g_repo, &oid, strlen(commit), GIT_OBJECT_TAG));
}
@@ -53,7 +53,7 @@ void test_object_lookup__lookup_wrong_type_eventually_returns_enotfound(void)
git_oid oid;
git_object *object;
- cl_git_pass(git_oid__fromstr(&oid, commit, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, commit, GIT_OID_SHA1));
cl_git_pass(git_object_lookup(&object, g_repo, &oid, GIT_OBJECT_COMMIT));
git_object_free(object);
@@ -71,7 +71,7 @@ void test_object_lookup__lookup_corrupt_object_returns_error(void)
git_object *object;
size_t i;
- cl_git_pass(git_oid__fromstr(&oid, commit, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, commit, GIT_OID_SHA1));
cl_git_pass(git_str_joinpath(&path, git_repository_path(g_repo), file));
cl_git_pass(git_futils_readbuffer(&contents, path.ptr));
@@ -101,7 +101,7 @@ void test_object_lookup__lookup_object_with_wrong_hash_returns_error(void)
git_object *object;
git_oid oid;
- cl_git_pass(git_oid__fromstr(&oid, commit, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, commit, GIT_OID_SHA1));
/* Copy object to another location with wrong hash */
cl_git_pass(git_str_joinpath(&oldpath, git_repository_path(g_repo), oldloose));
diff --git a/tests/libgit2/object/lookup256.c b/tests/libgit2/object/lookup256.c
index 3e1dab6610a..cd1aa648926 100644
--- a/tests/libgit2/object/lookup256.c
+++ b/tests/libgit2/object/lookup256.c
@@ -29,7 +29,7 @@ void test_object_lookup256__lookup_wrong_type_returns_enotfound(void)
git_oid oid;
git_object *object;
- cl_git_pass(git_oid__fromstr(&oid, commit, GIT_OID_SHA256));
+ cl_git_pass(git_oid_from_string(&oid, commit, GIT_OID_SHA256));
cl_assert_equal_i(
GIT_ENOTFOUND, git_object_lookup(&object, g_repo, &oid, GIT_OBJECT_TAG));
#endif
@@ -44,7 +44,7 @@ void test_object_lookup256__lookup_nonexisting_returns_enotfound(void)
git_oid oid;
git_object *object;
- cl_git_pass(git_oid__fromstr(&oid, unknown, GIT_OID_SHA256));
+ cl_git_pass(git_oid_from_string(&oid, unknown, GIT_OID_SHA256));
cl_assert_equal_i(
GIT_ENOTFOUND, git_object_lookup(&object, g_repo, &oid, GIT_OBJECT_ANY));
#endif
@@ -59,7 +59,7 @@ void test_object_lookup256__lookup_wrong_type_by_abbreviated_id_returns_enotfoun
git_oid oid;
git_object *object;
- cl_git_pass(git_oid__fromstrn(&oid, commit, strlen(commit), GIT_OID_SHA256));
+ cl_git_pass(git_oid_from_prefix(&oid, commit, strlen(commit), GIT_OID_SHA256));
cl_assert_equal_i(
GIT_ENOTFOUND, git_object_lookup_prefix(&object, g_repo, &oid, strlen(commit), GIT_OBJECT_TAG));
#endif
@@ -74,7 +74,7 @@ void test_object_lookup256__lookup_wrong_type_eventually_returns_enotfound(void)
git_oid oid;
git_object *object;
- cl_git_pass(git_oid__fromstr(&oid, commit, GIT_OID_SHA256));
+ cl_git_pass(git_oid_from_string(&oid, commit, GIT_OID_SHA256));
cl_git_pass(git_object_lookup(&object, g_repo, &oid, GIT_OBJECT_COMMIT));
git_object_free(object);
@@ -96,7 +96,7 @@ void test_object_lookup256__lookup_corrupt_object_returns_error(void)
git_object *object;
size_t i;
- cl_git_pass(git_oid__fromstr(&oid, commit, GIT_OID_SHA256));
+ cl_git_pass(git_oid_from_string(&oid, commit, GIT_OID_SHA256));
cl_git_pass(git_str_joinpath(&path, git_repository_path(g_repo), file));
cl_git_pass(git_futils_readbuffer(&contents, path.ptr));
@@ -131,7 +131,7 @@ void test_object_lookup256__lookup_object_with_wrong_hash_returns_error(void)
git_object *object;
git_oid oid;
- cl_git_pass(git_oid__fromstr(&oid, commit, GIT_OID_SHA256));
+ cl_git_pass(git_oid_from_string(&oid, commit, GIT_OID_SHA256));
/* Copy object to another location with wrong hash */
cl_git_pass(git_str_joinpath(&oldpath, git_repository_path(g_repo), oldloose));
diff --git a/tests/libgit2/object/peel.c b/tests/libgit2/object/peel.c
index da3ef17e2dc..7071628974b 100644
--- a/tests/libgit2/object/peel.c
+++ b/tests/libgit2/object/peel.c
@@ -23,12 +23,12 @@ static void assert_peel(
git_object *obj;
git_object *peeled;
- cl_git_pass(git_oid__fromstr(&oid, sha, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, sha, GIT_OID_SHA1));
cl_git_pass(git_object_lookup(&obj, g_repo, &oid, GIT_OBJECT_ANY));
cl_git_pass(git_object_peel(&peeled, obj, requested_type));
- cl_git_pass(git_oid__fromstr(&expected_oid, expected_sha, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected_oid, expected_sha, GIT_OID_SHA1));
cl_assert_equal_oid(&expected_oid, git_object_id(peeled));
cl_assert_equal_i(expected_type, git_object_type(peeled));
@@ -43,7 +43,7 @@ static void assert_peel_error(int error, const char *sha, git_object_t requested
git_object *obj;
git_object *peeled;
- cl_git_pass(git_oid__fromstr(&oid, sha, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, sha, GIT_OID_SHA1));
cl_git_pass(git_object_lookup(&obj, g_repo, &oid, GIT_OBJECT_ANY));
cl_assert_equal_i(error, git_object_peel(&peeled, obj, requested_type));
diff --git a/tests/libgit2/object/raw/chars.c b/tests/libgit2/object/raw/chars.c
index cb159e9ac4a..24d630d3861 100644
--- a/tests/libgit2/object/raw/chars.c
+++ b/tests/libgit2/object/raw/chars.c
@@ -19,10 +19,10 @@ void test_object_raw_chars__find_invalid_chars_in_oid(void)
in[38] = (char)i;
if (git__fromhex(i) >= 0) {
exp[19] = (unsigned char)(git__fromhex(i) << 4);
- cl_git_pass(git_oid__fromstr(&out, in, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&out, in, GIT_OID_SHA1));
cl_assert(memcmp(out.id, exp, GIT_OID_SHA1_SIZE) == 0);
} else {
- cl_git_fail(git_oid__fromstr(&out, in, GIT_OID_SHA1));
+ cl_git_fail(git_oid_from_string(&out, in, GIT_OID_SHA1));
}
}
}
@@ -36,6 +36,6 @@ void test_object_raw_chars__build_valid_oid_from_raw_bytes(void)
0xb7, 0x75, 0x21, 0x3c, 0x23,
0xa8, 0xbd, 0x74, 0xf5, 0xe0,
};
- git_oid__fromraw(&out, exp, GIT_OID_SHA1);
+ git_oid_from_raw(&out, exp, GIT_OID_SHA1);
cl_git_pass(memcmp(out.id, exp, GIT_OID_SHA1_SIZE));
}
diff --git a/tests/libgit2/object/raw/compare.c b/tests/libgit2/object/raw/compare.c
index 9258eef41fe..ace751d75c1 100644
--- a/tests/libgit2/object/raw/compare.c
+++ b/tests/libgit2/object/raw/compare.c
@@ -13,7 +13,7 @@ void test_object_raw_compare__succeed_on_copy_oid(void)
0xa8, 0xbd, 0x74, 0xf5, 0xe0,
};
memset(&b, 0, sizeof(b));
- git_oid__fromraw(&a, exp, GIT_OID_SHA1);
+ git_oid_from_raw(&a, exp, GIT_OID_SHA1);
git_oid_cpy(&b, &a);
cl_git_pass(memcmp(a.id, exp, GIT_OID_SHA1_SIZE));
}
@@ -33,8 +33,8 @@ void test_object_raw_compare__succeed_on_oid_comparison_lesser(void)
0xb7, 0x75, 0x21, 0x3c, 0x23,
0xa8, 0xbd, 0x74, 0xf5, 0xf0,
};
- git_oid__fromraw(&a, a_in, GIT_OID_SHA1);
- git_oid__fromraw(&b, b_in, GIT_OID_SHA1);
+ git_oid_from_raw(&a, a_in, GIT_OID_SHA1);
+ git_oid_from_raw(&b, b_in, GIT_OID_SHA1);
cl_assert(git_oid_cmp(&a, &b) < 0);
}
@@ -47,8 +47,8 @@ void test_object_raw_compare__succeed_on_oid_comparison_equal(void)
0xb7, 0x75, 0x21, 0x3c, 0x23,
0xa8, 0xbd, 0x74, 0xf5, 0xe0,
};
- git_oid__fromraw(&a, a_in, GIT_OID_SHA1);
- git_oid__fromraw(&b, a_in, GIT_OID_SHA1);
+ git_oid_from_raw(&a, a_in, GIT_OID_SHA1);
+ git_oid_from_raw(&b, a_in, GIT_OID_SHA1);
cl_assert(git_oid_cmp(&a, &b) == 0);
}
@@ -67,8 +67,8 @@ void test_object_raw_compare__succeed_on_oid_comparison_greater(void)
0xb7, 0x75, 0x21, 0x3c, 0x23,
0xa8, 0xbd, 0x74, 0xf5, 0xd0,
};
- git_oid__fromraw(&a, a_in, GIT_OID_SHA1);
- git_oid__fromraw(&b, b_in, GIT_OID_SHA1);
+ git_oid_from_raw(&a, a_in, GIT_OID_SHA1);
+ git_oid_from_raw(&b, b_in, GIT_OID_SHA1);
cl_assert(git_oid_cmp(&a, &b) > 0);
}
@@ -78,7 +78,7 @@ void test_object_raw_compare__compare_fmt_oids(void)
git_oid in;
char out[GIT_OID_SHA1_HEXSIZE + 1];
- cl_git_pass(git_oid__fromstr(&in, exp, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&in, exp, GIT_OID_SHA1));
/* Format doesn't touch the last byte */
out[GIT_OID_SHA1_HEXSIZE] = 'Z';
@@ -96,7 +96,7 @@ void test_object_raw_compare__compare_static_oids(void)
git_oid in;
char *out;
- cl_git_pass(git_oid__fromstr(&in, exp, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&in, exp, GIT_OID_SHA1));
out = git_oid_tostr_s(&in);
cl_assert(out);
@@ -110,7 +110,7 @@ void test_object_raw_compare__compare_pathfmt_oids(void)
git_oid in;
char out[GIT_OID_SHA1_HEXSIZE + 2];
- cl_git_pass(git_oid__fromstr(&in, exp1, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&in, exp1, GIT_OID_SHA1));
/* Format doesn't touch the last byte */
out[GIT_OID_SHA1_HEXSIZE + 1] = 'Z';
diff --git a/tests/libgit2/object/raw/convert.c b/tests/libgit2/object/raw/convert.c
index 962476b97e1..ac2d9710db4 100644
--- a/tests/libgit2/object/raw/convert.c
+++ b/tests/libgit2/object/raw/convert.c
@@ -11,7 +11,7 @@ void test_object_raw_convert__succeed_on_oid_to_string_conversion(void)
char *str;
int i;
- cl_git_pass(git_oid__fromstr(&in, exp, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&in, exp, GIT_OID_SHA1));
/* NULL buffer pointer, returns static empty string */
str = git_oid_tostr(NULL, sizeof(out), &in);
@@ -55,7 +55,7 @@ void test_object_raw_convert__succeed_on_oid_to_string_conversion_big(void)
char big[GIT_OID_SHA1_HEXSIZE + 1 + 3]; /* note + 4 => big buffer */
char *str;
- cl_git_pass(git_oid__fromstr(&in, exp, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&in, exp, GIT_OID_SHA1));
/* place some tail material */
big[GIT_OID_SHA1_HEXSIZE+0] = 'W'; /* should be '\0' afterwards */
@@ -88,7 +88,7 @@ void test_object_raw_convert__convert_oid_partially(void)
git_oid in;
char big[GIT_OID_SHA1_HEXSIZE + 1 + 3]; /* note + 4 => big buffer */
- cl_git_pass(git_oid__fromstr(&in, exp, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&in, exp, GIT_OID_SHA1));
git_oid_nfmt(big, sizeof(big), &in);
cl_assert_equal_s(exp, big);
diff --git a/tests/libgit2/object/raw/fromstr.c b/tests/libgit2/object/raw/fromstr.c
index 302d362d714..9eba6dca72f 100644
--- a/tests/libgit2/object/raw/fromstr.c
+++ b/tests/libgit2/object/raw/fromstr.c
@@ -6,9 +6,9 @@
void test_object_raw_fromstr__fail_on_invalid_oid_string(void)
{
git_oid out;
- cl_git_fail(git_oid__fromstr(&out, "", GIT_OID_SHA1));
- cl_git_fail(git_oid__fromstr(&out, "moo", GIT_OID_SHA1));
- cl_git_fail(git_oid__fromstr(&out, "16a67770b7d8d72317c4b775213c23a8bd74f5ez", GIT_OID_SHA1));
+ cl_git_fail(git_oid_from_string(&out, "", GIT_OID_SHA1));
+ cl_git_fail(git_oid_from_string(&out, "moo", GIT_OID_SHA1));
+ cl_git_fail(git_oid_from_string(&out, "16a67770b7d8d72317c4b775213c23a8bd74f5ez", GIT_OID_SHA1));
}
void test_object_raw_fromstr__succeed_on_valid_oid_string(void)
@@ -21,9 +21,9 @@ void test_object_raw_fromstr__succeed_on_valid_oid_string(void)
0xa8, 0xbd, 0x74, 0xf5, 0xe0,
};
- cl_git_pass(git_oid__fromstr(&out, "16a67770b7d8d72317c4b775213c23a8bd74f5e0", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&out, "16a67770b7d8d72317c4b775213c23a8bd74f5e0", GIT_OID_SHA1));
cl_git_pass(memcmp(out.id, exp, GIT_OID_SHA1_SIZE));
- cl_git_pass(git_oid__fromstr(&out, "16A67770B7D8D72317C4b775213C23A8BD74F5E0", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&out, "16A67770B7D8D72317C4b775213C23A8BD74F5E0", GIT_OID_SHA1));
cl_git_pass(memcmp(out.id, exp, GIT_OID_SHA1_SIZE));
}
diff --git a/tests/libgit2/object/raw/hash.c b/tests/libgit2/object/raw/hash.c
index 0df1afc3a5c..914096f6a5e 100644
--- a/tests/libgit2/object/raw/hash.c
+++ b/tests/libgit2/object/raw/hash.c
@@ -32,16 +32,16 @@ void test_object_raw_hash__hash_by_blocks(void)
/* should already be init'd */
cl_git_pass(git_hash_update(&ctx, hello_text, strlen(hello_text)));
cl_git_pass(git_hash_final(hash, &ctx));
- cl_git_pass(git_oid__fromraw(&id2, hash, GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&id1, hello_id, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_raw(&id2, hash, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id1, hello_id, GIT_OID_SHA1));
cl_assert(git_oid_cmp(&id1, &id2) == 0);
/* reinit should permit reuse */
cl_git_pass(git_hash_init(&ctx));
cl_git_pass(git_hash_update(&ctx, bye_text, strlen(bye_text)));
cl_git_pass(git_hash_final(hash, &ctx));
- cl_git_pass(git_oid__fromraw(&id2, hash, GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&id1, bye_id, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_raw(&id2, hash, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id1, bye_id, GIT_OID_SHA1));
cl_assert(git_oid_cmp(&id1, &id2) == 0);
git_hash_ctx_cleanup(&ctx);
@@ -52,9 +52,9 @@ void test_object_raw_hash__hash_buffer_in_single_call(void)
git_oid id1, id2;
unsigned char hash[GIT_HASH_SHA1_SIZE];
- cl_git_pass(git_oid__fromstr(&id1, hello_id, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id1, hello_id, GIT_OID_SHA1));
cl_git_pass(git_hash_buf(hash, hello_text, strlen(hello_text), GIT_HASH_ALGORITHM_SHA1));
- cl_git_pass(git_oid__fromraw(&id2, hash, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_raw(&id2, hash, GIT_OID_SHA1));
cl_assert(git_oid_cmp(&id1, &id2) == 0);
}
@@ -64,7 +64,7 @@ void test_object_raw_hash__hash_vector(void)
git_str_vec vec[2];
unsigned char hash[GIT_HASH_SHA1_SIZE];
- cl_git_pass(git_oid__fromstr(&id1, hello_id, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id1, hello_id, GIT_OID_SHA1));
vec[0].data = hello_text;
vec[0].len = 4;
@@ -72,7 +72,7 @@ void test_object_raw_hash__hash_vector(void)
vec[1].len = strlen(hello_text)-4;
git_hash_vec(hash, vec, 2, GIT_HASH_ALGORITHM_SHA1);
- git_oid__fromraw(&id2, hash, GIT_OID_SHA1);
+ git_oid_from_raw(&id2, hash, GIT_OID_SHA1);
cl_assert(git_oid_cmp(&id1, &id2) == 0);
}
@@ -81,22 +81,22 @@ void test_object_raw_hash__hash_junk_data(void)
{
git_oid id, id_zero;
- cl_git_pass(git_oid__fromstr(&id_zero, zero_id, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id_zero, zero_id, GIT_OID_SHA1));
/* invalid types: */
junk_obj.data = some_data;
hash_object_fail(&id, &junk_obj);
- junk_obj.type = 0; /* EXT1 */
+ junk_obj.type = 0; /* unused */
hash_object_fail(&id, &junk_obj);
- junk_obj.type = 5; /* EXT2 */
+ junk_obj.type = 5; /* unused */
hash_object_fail(&id, &junk_obj);
- junk_obj.type = GIT_OBJECT_OFS_DELTA;
+ junk_obj.type = 6; /* packfile offset delta */
hash_object_fail(&id, &junk_obj);
- junk_obj.type = GIT_OBJECT_REF_DELTA;
+ junk_obj.type = 7; /* packfile ref delta */
hash_object_fail(&id, &junk_obj);
junk_obj.type = 42;
@@ -116,7 +116,7 @@ void test_object_raw_hash__hash_commit_object(void)
{
git_oid id1, id2;
- cl_git_pass(git_oid__fromstr(&id1, commit_id, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id1, commit_id, GIT_OID_SHA1));
hash_object_pass(&id2, &commit_obj);
cl_assert(git_oid_cmp(&id1, &id2) == 0);
}
@@ -125,7 +125,7 @@ void test_object_raw_hash__hash_tree_object(void)
{
git_oid id1, id2;
- cl_git_pass(git_oid__fromstr(&id1, tree_id, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id1, tree_id, GIT_OID_SHA1));
hash_object_pass(&id2, &tree_obj);
cl_assert(git_oid_cmp(&id1, &id2) == 0);
}
@@ -134,7 +134,7 @@ void test_object_raw_hash__hash_tag_object(void)
{
git_oid id1, id2;
- cl_git_pass(git_oid__fromstr(&id1, tag_id, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id1, tag_id, GIT_OID_SHA1));
hash_object_pass(&id2, &tag_obj);
cl_assert(git_oid_cmp(&id1, &id2) == 0);
}
@@ -143,7 +143,7 @@ void test_object_raw_hash__hash_zero_length_object(void)
{
git_oid id1, id2;
- cl_git_pass(git_oid__fromstr(&id1, zero_id, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id1, zero_id, GIT_OID_SHA1));
hash_object_pass(&id2, &zero_obj);
cl_assert(git_oid_cmp(&id1, &id2) == 0);
}
@@ -152,7 +152,7 @@ void test_object_raw_hash__hash_one_byte_object(void)
{
git_oid id1, id2;
- cl_git_pass(git_oid__fromstr(&id1, one_id, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id1, one_id, GIT_OID_SHA1));
hash_object_pass(&id2, &one_obj);
cl_assert(git_oid_cmp(&id1, &id2) == 0);
}
@@ -161,7 +161,7 @@ void test_object_raw_hash__hash_two_byte_object(void)
{
git_oid id1, id2;
- cl_git_pass(git_oid__fromstr(&id1, two_id, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id1, two_id, GIT_OID_SHA1));
hash_object_pass(&id2, &two_obj);
cl_assert(git_oid_cmp(&id1, &id2) == 0);
}
@@ -170,7 +170,7 @@ void test_object_raw_hash__hash_multi_byte_object(void)
{
git_oid id1, id2;
- cl_git_pass(git_oid__fromstr(&id1, some_id, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id1, some_id, GIT_OID_SHA1));
hash_object_pass(&id2, &some_obj);
cl_assert(git_oid_cmp(&id1, &id2) == 0);
}
diff --git a/tests/libgit2/object/raw/short.c b/tests/libgit2/object/raw/short.c
index f867e6ba173..c6d1a4fc1aa 100644
--- a/tests/libgit2/object/raw/short.c
+++ b/tests/libgit2/object/raw/short.c
@@ -36,7 +36,7 @@ static int insert_sequential_oids(
p_snprintf(numbuf, sizeof(numbuf), "%u", (unsigned int)i);
git_hash_buf(hashbuf, numbuf, strlen(numbuf), GIT_HASH_ALGORITHM_SHA1);
- git_oid__fromraw(&oid, hashbuf, GIT_OID_SHA1);
+ git_oid_from_raw(&oid, hashbuf, GIT_OID_SHA1);
oids[i] = git__malloc(GIT_OID_SHA1_HEXSIZE + 1);
cl_assert(oids[i]);
diff --git a/tests/libgit2/object/raw/type2string.c b/tests/libgit2/object/raw/type2string.c
index ebd81f552ae..e3a0764e55a 100644
--- a/tests/libgit2/object/raw/type2string.c
+++ b/tests/libgit2/object/raw/type2string.c
@@ -7,14 +7,14 @@
void test_object_raw_type2string__convert_type_to_string(void)
{
cl_assert_equal_s(git_object_type2string(GIT_OBJECT_INVALID), "");
- cl_assert_equal_s(git_object_type2string(0), ""); /* EXT1 */
+ cl_assert_equal_s(git_object_type2string(0), ""); /* unused */
cl_assert_equal_s(git_object_type2string(GIT_OBJECT_COMMIT), "commit");
cl_assert_equal_s(git_object_type2string(GIT_OBJECT_TREE), "tree");
cl_assert_equal_s(git_object_type2string(GIT_OBJECT_BLOB), "blob");
cl_assert_equal_s(git_object_type2string(GIT_OBJECT_TAG), "tag");
- cl_assert_equal_s(git_object_type2string(5), ""); /* EXT2 */
- cl_assert_equal_s(git_object_type2string(GIT_OBJECT_OFS_DELTA), "OFS_DELTA");
- cl_assert_equal_s(git_object_type2string(GIT_OBJECT_REF_DELTA), "REF_DELTA");
+ cl_assert_equal_s(git_object_type2string(5), ""); /* unused */
+ cl_assert_equal_s(git_object_type2string(6), ""); /* packfile offset delta */
+ cl_assert_equal_s(git_object_type2string(7), ""); /* packfile ref delta */
cl_assert_equal_s(git_object_type2string(-2), "");
cl_assert_equal_s(git_object_type2string(8), "");
@@ -29,26 +29,26 @@ void test_object_raw_type2string__convert_string_to_type(void)
cl_assert(git_object_string2type("tree") == GIT_OBJECT_TREE);
cl_assert(git_object_string2type("blob") == GIT_OBJECT_BLOB);
cl_assert(git_object_string2type("tag") == GIT_OBJECT_TAG);
- cl_assert(git_object_string2type("OFS_DELTA") == GIT_OBJECT_OFS_DELTA);
- cl_assert(git_object_string2type("REF_DELTA") == GIT_OBJECT_REF_DELTA);
+ cl_assert(git_object_string2type("OFS_DELTA") == GIT_OBJECT_INVALID);
+ cl_assert(git_object_string2type("REF_DELTA") == GIT_OBJECT_INVALID);
cl_assert(git_object_string2type("CoMmIt") == GIT_OBJECT_INVALID);
cl_assert(git_object_string2type("hohoho") == GIT_OBJECT_INVALID);
}
-void test_object_raw_type2string__check_type_is_loose(void)
+void test_object_raw_type2string__check_type_is_valid(void)
{
- cl_assert(git_object_typeisloose(GIT_OBJECT_INVALID) == 0);
- cl_assert(git_object_typeisloose(0) == 0); /* EXT1 */
- cl_assert(git_object_typeisloose(GIT_OBJECT_COMMIT) == 1);
- cl_assert(git_object_typeisloose(GIT_OBJECT_TREE) == 1);
- cl_assert(git_object_typeisloose(GIT_OBJECT_BLOB) == 1);
- cl_assert(git_object_typeisloose(GIT_OBJECT_TAG) == 1);
- cl_assert(git_object_typeisloose(5) == 0); /* EXT2 */
- cl_assert(git_object_typeisloose(GIT_OBJECT_OFS_DELTA) == 0);
- cl_assert(git_object_typeisloose(GIT_OBJECT_REF_DELTA) == 0);
-
- cl_assert(git_object_typeisloose(-2) == 0);
- cl_assert(git_object_typeisloose(8) == 0);
- cl_assert(git_object_typeisloose(1234) == 0);
+ cl_assert(git_object_type_is_valid(GIT_OBJECT_INVALID) == 0);
+ cl_assert(git_object_type_is_valid(0) == 0); /* unused */
+ cl_assert(git_object_type_is_valid(GIT_OBJECT_COMMIT) == 1);
+ cl_assert(git_object_type_is_valid(GIT_OBJECT_TREE) == 1);
+ cl_assert(git_object_type_is_valid(GIT_OBJECT_BLOB) == 1);
+ cl_assert(git_object_type_is_valid(GIT_OBJECT_TAG) == 1);
+ cl_assert(git_object_type_is_valid(5) == 0); /* unused */
+ cl_assert(git_object_type_is_valid(6) == 0); /* packfile offset delta */
+ cl_assert(git_object_type_is_valid(7) == 0); /* packfile ref delta */
+
+ cl_assert(git_object_type_is_valid(-2) == 0);
+ cl_assert(git_object_type_is_valid(8) == 0);
+ cl_assert(git_object_type_is_valid(1234) == 0);
}
diff --git a/tests/libgit2/object/raw/write.c b/tests/libgit2/object/raw/write.c
index 346053df59a..dd6fca08f7d 100644
--- a/tests/libgit2/object/raw/write.c
+++ b/tests/libgit2/object/raw/write.c
@@ -66,8 +66,8 @@ void test_body(object_data *d, git_rawobj *o)
git_rawobj tmp;
make_odb_dir();
- cl_git_pass(git_odb__open(&db, odb_dir, NULL));
- cl_git_pass(git_oid__fromstr(&id1, d->id, GIT_OID_SHA1));
+ cl_git_pass(git_odb_open_ext(&db, odb_dir, NULL));
+ cl_git_pass(git_oid_from_string(&id1, d->id, GIT_OID_SHA1));
streaming_write(&id2, db, o);
cl_assert(git_oid_cmp(&id1, &id2) == 0);
diff --git a/tests/libgit2/object/shortid.c b/tests/libgit2/object/shortid.c
index 69fceeedaf0..4af9b45aeaf 100644
--- a/tests/libgit2/object/shortid.c
+++ b/tests/libgit2/object/shortid.c
@@ -4,13 +4,12 @@ git_repository *_repo;
void test_object_shortid__initialize(void)
{
- cl_git_pass(git_repository_open(&_repo, cl_fixture("duplicate.git")));
+ _repo = cl_git_sandbox_init("duplicate.git");
}
void test_object_shortid__cleanup(void)
{
- git_repository_free(_repo);
- _repo = NULL;
+ cl_git_sandbox_cleanup();
}
void test_object_shortid__select(void)
@@ -19,28 +18,28 @@ void test_object_shortid__select(void)
git_object *obj;
git_buf shorty = {0};
- git_oid__fromstr(&full, "ce013625030ba8dba906f756967f9e9ca394464a", GIT_OID_SHA1);
+ git_oid_from_string(&full, "ce013625030ba8dba906f756967f9e9ca394464a", GIT_OID_SHA1);
cl_git_pass(git_object_lookup(&obj, _repo, &full, GIT_OBJECT_ANY));
cl_git_pass(git_object_short_id(&shorty, obj));
cl_assert_equal_i(7, shorty.size);
cl_assert_equal_s("ce01362", shorty.ptr);
git_object_free(obj);
- git_oid__fromstr(&full, "038d718da6a1ebbc6a7780a96ed75a70cc2ad6e2", GIT_OID_SHA1);
+ git_oid_from_string(&full, "038d718da6a1ebbc6a7780a96ed75a70cc2ad6e2", GIT_OID_SHA1);
cl_git_pass(git_object_lookup(&obj, _repo, &full, GIT_OBJECT_ANY));
cl_git_pass(git_object_short_id(&shorty, obj));
cl_assert_equal_i(7, shorty.size);
cl_assert_equal_s("038d718", shorty.ptr);
git_object_free(obj);
- git_oid__fromstr(&full, "dea509d097ce692e167dfc6a48a7a280cc5e877e", GIT_OID_SHA1);
+ git_oid_from_string(&full, "dea509d097ce692e167dfc6a48a7a280cc5e877e", GIT_OID_SHA1);
cl_git_pass(git_object_lookup(&obj, _repo, &full, GIT_OBJECT_ANY));
cl_git_pass(git_object_short_id(&shorty, obj));
cl_assert_equal_i(9, shorty.size);
cl_assert_equal_s("dea509d09", shorty.ptr);
git_object_free(obj);
- git_oid__fromstr(&full, "dea509d0b3cb8ee0650f6ca210bc83f4678851ba", GIT_OID_SHA1);
+ git_oid_from_string(&full, "dea509d0b3cb8ee0650f6ca210bc83f4678851ba", GIT_OID_SHA1);
cl_git_pass(git_object_lookup(&obj, _repo, &full, GIT_OBJECT_ANY));
cl_git_pass(git_object_short_id(&shorty, obj));
cl_assert_equal_i(9, shorty.size);
@@ -49,3 +48,53 @@ void test_object_shortid__select(void)
git_buf_dispose(&shorty);
}
+
+void test_object_shortid__core_abbrev(void)
+{
+ git_oid full;
+ git_object *obj;
+ git_buf shorty = {0};
+ git_config *cfg;
+
+ cl_git_pass(git_repository_config(&cfg, _repo));
+ git_oid_from_string(&full, "ce013625030ba8dba906f756967f9e9ca394464a", GIT_OID_SHA1);
+ cl_git_pass(git_object_lookup(&obj, _repo, &full, GIT_OBJECT_ANY));
+
+ cl_git_pass(git_config_set_string(cfg, "core.abbrev", "auto"));
+ cl_git_pass(git_object_short_id(&shorty, obj));
+ cl_assert_equal_i(7, shorty.size);
+ cl_assert_equal_s("ce01362", shorty.ptr);
+
+ cl_git_pass(git_config_set_string(cfg, "core.abbrev", "off"));
+ cl_git_pass(git_object_short_id(&shorty, obj));
+ cl_assert_equal_i(40, shorty.size);
+ cl_assert_equal_s("ce013625030ba8dba906f756967f9e9ca394464a", shorty.ptr);
+
+ cl_git_pass(git_config_set_string(cfg, "core.abbrev", "false"));
+ cl_git_pass(git_object_short_id(&shorty, obj));
+ cl_assert_equal_i(40, shorty.size);
+ cl_assert_equal_s("ce013625030ba8dba906f756967f9e9ca394464a", shorty.ptr);
+
+ cl_git_pass(git_config_set_string(cfg, "core.abbrev", "99"));
+ cl_git_pass(git_object_short_id(&shorty, obj));
+ cl_assert_equal_i(40, shorty.size);
+ cl_assert_equal_s("ce013625030ba8dba906f756967f9e9ca394464a", shorty.ptr);
+
+ cl_git_pass(git_config_set_string(cfg, "core.abbrev", "4"));
+ cl_git_pass(git_object_short_id(&shorty, obj));
+ cl_assert_equal_i(4, shorty.size);
+ cl_assert_equal_s("ce01", shorty.ptr);
+
+ cl_git_pass(git_config_set_string(cfg, "core.abbrev", "0"));
+ cl_git_fail(git_object_short_id(&shorty, obj));
+ cl_git_pass(git_config_set_string(cfg, "core.abbrev", "3"));
+ cl_git_fail(git_object_short_id(&shorty, obj));
+ cl_git_pass(git_config_set_string(cfg, "core.abbrev", "invalid"));
+ cl_git_fail(git_object_short_id(&shorty, obj));
+ cl_git_pass(git_config_set_string(cfg, "core.abbrev", "true"));
+ cl_git_fail(git_object_short_id(&shorty, obj));
+
+ git_object_free(obj);
+ git_buf_dispose(&shorty);
+ git_config_free(cfg);
+}
diff --git a/tests/libgit2/object/tag/parse.c b/tests/libgit2/object/tag/parse.c
index d7a4d85bfda..a5dec1889f1 100644
--- a/tests/libgit2/object/tag/parse.c
+++ b/tests/libgit2/object/tag/parse.c
@@ -19,7 +19,7 @@ static void assert_tag_parses(const char *data, size_t datalen,
if (expected_oid) {
git_oid oid;
- cl_git_pass(git_oid__fromstr(&oid, expected_oid, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, expected_oid, GIT_OID_SHA1));
cl_assert_equal_oid(&oid, &tag->target);
}
diff --git a/tests/libgit2/object/tag/peel.c b/tests/libgit2/object/tag/peel.c
index db81c5aee2b..0ee8d50428f 100644
--- a/tests/libgit2/object/tag/peel.c
+++ b/tests/libgit2/object/tag/peel.c
@@ -29,7 +29,7 @@ static void retrieve_tag_from_oid(git_tag **tag_out, git_repository *repo, const
{
git_oid oid;
- cl_git_pass(git_oid__fromstr(&oid, sha, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, sha, GIT_OID_SHA1));
cl_git_pass(git_tag_lookup(tag_out, repo, &oid));
}
diff --git a/tests/libgit2/object/tag/read.c b/tests/libgit2/object/tag/read.c
index 6270b567ae3..3bb559ae204 100644
--- a/tests/libgit2/object/tag/read.c
+++ b/tests/libgit2/object/tag/read.c
@@ -32,9 +32,9 @@ void test_object_tag_read__parse(void)
git_commit *commit;
git_oid id1, id2, id_commit;
- git_oid__fromstr(&id1, tag1_id, GIT_OID_SHA1);
- git_oid__fromstr(&id2, tag2_id, GIT_OID_SHA1);
- git_oid__fromstr(&id_commit, tagged_commit, GIT_OID_SHA1);
+ git_oid_from_string(&id1, tag1_id, GIT_OID_SHA1);
+ git_oid_from_string(&id2, tag2_id, GIT_OID_SHA1);
+ git_oid_from_string(&id_commit, tagged_commit, GIT_OID_SHA1);
cl_git_pass(git_tag_lookup(&tag1, g_repo, &id1));
@@ -67,8 +67,8 @@ void test_object_tag_read__parse_without_tagger(void)
/* TODO: This is a little messy */
cl_git_pass(git_repository_open(&bad_tag_repo, cl_fixture("bad_tag.git")));
- git_oid__fromstr(&id, bad_tag_id, GIT_OID_SHA1);
- git_oid__fromstr(&id_commit, badly_tagged_commit, GIT_OID_SHA1);
+ git_oid_from_string(&id, bad_tag_id, GIT_OID_SHA1);
+ git_oid_from_string(&id_commit, badly_tagged_commit, GIT_OID_SHA1);
cl_git_pass(git_tag_lookup(&bad_tag, bad_tag_repo, &id));
cl_assert(bad_tag != NULL);
@@ -99,8 +99,8 @@ void test_object_tag_read__parse_without_message(void)
/* TODO: This is a little messy */
cl_git_pass(git_repository_open(&short_tag_repo, cl_fixture("short_tag.git")));
- git_oid__fromstr(&id, short_tag_id, GIT_OID_SHA1);
- git_oid__fromstr(&id_commit, short_tagged_commit, GIT_OID_SHA1);
+ git_oid_from_string(&id, short_tag_id, GIT_OID_SHA1);
+ git_oid_from_string(&id_commit, short_tagged_commit, GIT_OID_SHA1);
cl_git_pass(git_tag_lookup(&short_tag, short_tag_repo, &id));
cl_assert(short_tag != NULL);
@@ -127,7 +127,7 @@ void test_object_tag_read__without_tagger_nor_message(void)
cl_git_pass(git_repository_open(&repo, cl_fixture("testrepo.git")));
- cl_git_pass(git_oid__fromstr(&id, taggerless, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, taggerless, GIT_OID_SHA1));
cl_git_pass(git_tag_lookup(&tag, repo, &id));
diff --git a/tests/libgit2/object/tag/write.c b/tests/libgit2/object/tag/write.c
index 79e01452a3a..f3090efc9fc 100644
--- a/tests/libgit2/object/tag/write.c
+++ b/tests/libgit2/object/tag/write.c
@@ -30,7 +30,7 @@ void test_object_tag_write__basic(void)
git_reference *ref_tag;
git_object *target;
- git_oid__fromstr(&target_id, tagged_commit, GIT_OID_SHA1);
+ git_oid_from_string(&target_id, tagged_commit, GIT_OID_SHA1);
cl_git_pass(git_object_lookup(&target, g_repo, &target_id, GIT_OBJECT_COMMIT));
/* create signature */
@@ -72,7 +72,7 @@ void test_object_tag_write__overwrite(void)
git_signature *tagger;
git_object *target;
- git_oid__fromstr(&target_id, tagged_commit, GIT_OID_SHA1);
+ git_oid_from_string(&target_id, tagged_commit, GIT_OID_SHA1);
cl_git_pass(git_object_lookup(&target, g_repo, &target_id, GIT_OBJECT_COMMIT));
/* create signature */
@@ -99,7 +99,7 @@ void test_object_tag_write__replace(void)
git_reference *ref_tag;
git_object *target;
- git_oid__fromstr(&target_id, tagged_commit, GIT_OID_SHA1);
+ git_oid_from_string(&target_id, tagged_commit, GIT_OID_SHA1);
cl_git_pass(git_object_lookup(&target, g_repo, &target_id, GIT_OBJECT_COMMIT));
cl_git_pass(git_reference_lookup(&ref_tag, g_repo, "refs/tags/e90810b"));
@@ -135,7 +135,7 @@ void test_object_tag_write__lightweight(void)
git_reference *ref_tag;
git_object *target;
- git_oid__fromstr(&target_id, tagged_commit, GIT_OID_SHA1);
+ git_oid_from_string(&target_id, tagged_commit, GIT_OID_SHA1);
cl_git_pass(git_object_lookup(&target, g_repo, &target_id, GIT_OBJECT_COMMIT));
cl_git_pass(git_tag_create_lightweight(
@@ -163,7 +163,7 @@ void test_object_tag_write__lightweight_over_existing(void)
git_oid target_id, object_id, existing_object_id;
git_object *target;
- git_oid__fromstr(&target_id, tagged_commit, GIT_OID_SHA1);
+ git_oid_from_string(&target_id, tagged_commit, GIT_OID_SHA1);
cl_git_pass(git_object_lookup(&target, g_repo, &target_id, GIT_OBJECT_COMMIT));
cl_assert_equal_i(GIT_EEXISTS, git_tag_create_lightweight(
@@ -173,7 +173,7 @@ void test_object_tag_write__lightweight_over_existing(void)
target,
0));
- git_oid__fromstr(&existing_object_id, tag2_id, GIT_OID_SHA1);
+ git_oid_from_string(&existing_object_id, tag2_id, GIT_OID_SHA1);
cl_assert(git_oid_cmp(&object_id, &existing_object_id) == 0);
git_object_free(target);
@@ -197,7 +197,7 @@ void test_object_tag_write__creating_with_an_invalid_name_returns_EINVALIDSPEC(v
git_signature *tagger;
git_object *target;
- git_oid__fromstr(&target_id, tagged_commit, GIT_OID_SHA1);
+ git_oid_from_string(&target_id, tagged_commit, GIT_OID_SHA1);
cl_git_pass(git_object_lookup(&target, g_repo, &target_id, GIT_OBJECT_COMMIT));
cl_git_pass(git_signature_new(&tagger, tagger_name, tagger_email, 123456789, 60));
@@ -229,7 +229,7 @@ static void create_annotation(git_oid *tag_id, const char *name)
cl_git_pass(git_signature_new(&tagger, tagger_name, tagger_email, 123456789, 60));
- git_oid__fromstr(&target_id, tagged_commit, GIT_OID_SHA1);
+ git_oid_from_string(&target_id, tagged_commit, GIT_OID_SHA1);
cl_git_pass(git_object_lookup(&target, g_repo, &target_id, GIT_OBJECT_COMMIT));
cl_git_pass(git_tag_annotation_create(tag_id, g_repo, name, target, tagger, "boom!"));
@@ -265,7 +265,7 @@ void test_object_tag_write__error_when_create_tag_with_invalid_name(void)
git_signature *tagger;
git_object *target;
- git_oid__fromstr(&target_id, tagged_commit, GIT_OID_SHA1);
+ git_oid_from_string(&target_id, tagged_commit, GIT_OID_SHA1);
cl_git_pass(git_object_lookup(&target, g_repo, &target_id, GIT_OBJECT_COMMIT));
cl_git_pass(git_signature_new(&tagger, tagger_name, tagger_email, 123456789, 60));
diff --git a/tests/libgit2/object/tree/attributes.c b/tests/libgit2/object/tree/attributes.c
index 285d19804f5..516ab6e58fe 100644
--- a/tests/libgit2/object/tree/attributes.c
+++ b/tests/libgit2/object/tree/attributes.c
@@ -21,7 +21,7 @@ void test_object_tree_attributes__ensure_correctness_of_attributes_on_insertion(
git_treebuilder *builder;
git_oid oid;
- cl_git_pass(git_oid__fromstr(&oid, blob_oid, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, blob_oid, GIT_OID_SHA1));
cl_git_pass(git_treebuilder_new(&builder, repo, NULL));
@@ -39,7 +39,7 @@ void test_object_tree_attributes__group_writable_tree_entries_created_with_an_an
const git_tree_entry *entry;
- cl_git_pass(git_oid__fromstr(&tid, tree_oid, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&tid, tree_oid, GIT_OID_SHA1));
cl_git_pass(git_tree_lookup(&tree, repo, &tid));
entry = git_tree_entry_byname(tree, "old_mode.txt");
@@ -56,7 +56,7 @@ void test_object_tree_attributes__treebuilder_reject_invalid_filemode(void)
git_oid bid;
const git_tree_entry *entry;
- cl_git_pass(git_oid__fromstr(&bid, blob_oid, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&bid, blob_oid, GIT_OID_SHA1));
cl_git_pass(git_treebuilder_new(&builder, repo, NULL));
cl_git_fail(git_treebuilder_insert(
@@ -76,7 +76,7 @@ void test_object_tree_attributes__normalize_attributes_when_creating_a_tree_from
git_tree *tree;
const git_tree_entry *entry;
- cl_git_pass(git_oid__fromstr(&tid, tree_oid, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&tid, tree_oid, GIT_OID_SHA1));
cl_git_pass(git_tree_lookup(&tree, repo, &tid));
cl_git_pass(git_treebuilder_new(&builder, repo, tree));
@@ -107,7 +107,7 @@ void test_object_tree_attributes__normalize_600(void)
git_tree *tree;
const git_tree_entry *entry;
- git_oid__fromstr(&id, "0810fb7818088ff5ac41ee49199b51473b1bd6c7", GIT_OID_SHA1);
+ git_oid_from_string(&id, "0810fb7818088ff5ac41ee49199b51473b1bd6c7", GIT_OID_SHA1);
cl_git_pass(git_tree_lookup(&tree, repo, &id));
entry = git_tree_entry_byname(tree, "ListaTeste.xml");
diff --git a/tests/libgit2/object/tree/duplicateentries.c b/tests/libgit2/object/tree/duplicateentries.c
index e9774cac378..b137339c818 100644
--- a/tests/libgit2/object/tree/duplicateentries.c
+++ b/tests/libgit2/object/tree/duplicateentries.c
@@ -45,7 +45,7 @@ static void tree_checker(
cl_assert_equal_i(1, (int)git_tree_entrycount(tree));
entry = git_tree_entry_byindex(tree, 0);
- cl_git_pass(git_oid__fromstr(&oid, expected_sha, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, expected_sha, GIT_OID_SHA1));
cl_assert_equal_i(0, git_oid_cmp(&oid, git_tree_entry_id(entry)));
cl_assert_equal_i(expected_filemode, git_tree_entry_filemode(entry));
@@ -70,7 +70,7 @@ static void two_blobs(git_treebuilder *bld)
git_oid oid;
const git_tree_entry *entry;
- cl_git_pass(git_oid__fromstr(&oid,
+ cl_git_pass(git_oid_from_string(&oid,
"a8233120f6ad708f843d861ce2b7228ec4e3dec6",
GIT_OID_SHA1)); /* blob oid (README) */
@@ -78,7 +78,7 @@ static void two_blobs(git_treebuilder *bld)
&entry, bld, "duplicate", &oid,
GIT_FILEMODE_BLOB));
- cl_git_pass(git_oid__fromstr(&oid,
+ cl_git_pass(git_oid_from_string(&oid,
"a71586c1dfe8a71c6cbf6c129f404c5642ff31bd",
GIT_OID_SHA1)); /* blob oid (new.txt) */
@@ -92,7 +92,7 @@ static void one_blob_and_one_tree(git_treebuilder *bld)
git_oid oid;
const git_tree_entry *entry;
- cl_git_pass(git_oid__fromstr(&oid,
+ cl_git_pass(git_oid_from_string(&oid,
"a8233120f6ad708f843d861ce2b7228ec4e3dec6",
GIT_OID_SHA1)); /* blob oid (README) */
@@ -100,7 +100,7 @@ static void one_blob_and_one_tree(git_treebuilder *bld)
&entry, bld, "duplicate", &oid,
GIT_FILEMODE_BLOB));
- cl_git_pass(git_oid__fromstr(&oid,
+ cl_git_pass(git_oid_from_string(&oid,
"4e0883eeeeebc1fb1735161cea82f7cb5fab7e63",
GIT_OID_SHA1)); /* tree oid (a) */
@@ -131,17 +131,17 @@ static void add_fake_conflicts(git_index *index)
ancestor_entry.path = "duplicate";
ancestor_entry.mode = GIT_FILEMODE_BLOB;
GIT_INDEX_ENTRY_STAGE_SET(&ancestor_entry, 1);
- git_oid__fromstr(&ancestor_entry.id, "a8233120f6ad708f843d861ce2b7228ec4e3dec6", GIT_OID_SHA1);
+ git_oid_from_string(&ancestor_entry.id, "a8233120f6ad708f843d861ce2b7228ec4e3dec6", GIT_OID_SHA1);
our_entry.path = "duplicate";
our_entry.mode = GIT_FILEMODE_BLOB;
GIT_INDEX_ENTRY_STAGE_SET(&our_entry, 2);
- git_oid__fromstr(&our_entry.id, "45b983be36b73c0788dc9cbcb76cbb80fc7bb057", GIT_OID_SHA1);
+ git_oid_from_string(&our_entry.id, "45b983be36b73c0788dc9cbcb76cbb80fc7bb057", GIT_OID_SHA1);
their_entry.path = "duplicate";
their_entry.mode = GIT_FILEMODE_BLOB;
GIT_INDEX_ENTRY_STAGE_SET(&their_entry, 3);
- git_oid__fromstr(&their_entry.id, "a71586c1dfe8a71c6cbf6c129f404c5642ff31bd", GIT_OID_SHA1);
+ git_oid_from_string(&their_entry.id, "a71586c1dfe8a71c6cbf6c129f404c5642ff31bd", GIT_OID_SHA1);
cl_git_pass(git_index_conflict_add(index, &ancestor_entry, &our_entry, &their_entry));
}
diff --git a/tests/libgit2/object/tree/frompath.c b/tests/libgit2/object/tree/frompath.c
index 147e53e9311..1563f71b92d 100644
--- a/tests/libgit2/object/tree/frompath.c
+++ b/tests/libgit2/object/tree/frompath.c
@@ -11,7 +11,7 @@ void test_object_tree_frompath__initialize(void)
cl_git_pass(git_repository_open(&repo, cl_fixture("testrepo.git")));
cl_assert(repo != NULL);
- cl_git_pass(git_oid__fromstr(&id, tree_with_subtrees_oid, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, tree_with_subtrees_oid, GIT_OID_SHA1));
cl_git_pass(git_tree_lookup(&tree, repo, &id));
cl_assert(tree != NULL);
}
diff --git a/tests/libgit2/object/tree/parse.c b/tests/libgit2/object/tree/parse.c
index fc985d672d8..11433c4307f 100644
--- a/tests/libgit2/object/tree/parse.c
+++ b/tests/libgit2/object/tree/parse.c
@@ -35,7 +35,7 @@ static void assert_tree_parses(const char *data, size_t datalen,
const git_tree_entry *entry;
git_oid oid;
- cl_git_pass(git_oid__fromstr(&oid, expected->oid, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, expected->oid, GIT_OID_SHA1));
cl_assert(entry = git_tree_entry_byname(tree, expected->filename));
cl_assert_equal_s(expected->filename, entry->filename);
diff --git a/tests/libgit2/object/tree/read.c b/tests/libgit2/object/tree/read.c
index e18637f035e..cea66e165f9 100644
--- a/tests/libgit2/object/tree/read.c
+++ b/tests/libgit2/object/tree/read.c
@@ -25,7 +25,7 @@ void test_object_tree_read__loaded(void)
git_oid id;
git_tree *tree;
- git_oid__fromstr(&id, tree_oid, GIT_OID_SHA1);
+ git_oid_from_string(&id, tree_oid, GIT_OID_SHA1);
cl_git_pass(git_tree_lookup(&tree, g_repo, &id));
@@ -48,7 +48,7 @@ void test_object_tree_read__two(void)
const git_tree_entry *entry;
git_object *obj;
- git_oid__fromstr(&id, tree_oid, GIT_OID_SHA1);
+ git_oid_from_string(&id, tree_oid, GIT_OID_SHA1);
cl_git_pass(git_tree_lookup(&tree, g_repo, &id));
diff --git a/tests/libgit2/object/tree/update.c b/tests/libgit2/object/tree/update.c
index 1861ac838af..8fb99b95826 100644
--- a/tests/libgit2/object/tree/update.c
+++ b/tests/libgit2/object/tree/update.c
@@ -1,5 +1,6 @@
#include "clar_libgit2.h"
#include "tree.h"
+#include "index.h"
static git_repository *g_repo;
@@ -24,7 +25,7 @@ void test_object_tree_update__remove_blob(void)
{ GIT_TREE_UPDATE_REMOVE, GIT_OID_SHA1_ZERO, GIT_FILEMODE_BLOB /* ignored */, path},
};
- cl_git_pass(git_oid__fromstr(&base_id, "c4dc1555e4d4fa0e0c9c3fc46734c7c35b3ce90b", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&base_id, "c4dc1555e4d4fa0e0c9c3fc46734c7c35b3ce90b", GIT_OID_SHA1));
cl_git_pass(git_tree_lookup(&base_tree, g_repo, &base_id));
/* Create it with an index */
@@ -53,7 +54,7 @@ void test_object_tree_update__remove_blob_deeper(void)
{ GIT_TREE_UPDATE_REMOVE, GIT_OID_SHA1_ZERO, GIT_FILEMODE_BLOB /* ignored */, path},
};
- cl_git_pass(git_oid__fromstr(&base_id, "c4dc1555e4d4fa0e0c9c3fc46734c7c35b3ce90b", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&base_id, "c4dc1555e4d4fa0e0c9c3fc46734c7c35b3ce90b", GIT_OID_SHA1));
cl_git_pass(git_tree_lookup(&base_tree, g_repo, &base_id));
/* Create it with an index */
@@ -84,7 +85,7 @@ void test_object_tree_update__remove_all_entries(void)
{ GIT_TREE_UPDATE_REMOVE, GIT_OID_SHA1_ZERO, GIT_FILEMODE_BLOB /* ignored */, path2},
};
- cl_git_pass(git_oid__fromstr(&base_id, "c4dc1555e4d4fa0e0c9c3fc46734c7c35b3ce90b", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&base_id, "c4dc1555e4d4fa0e0c9c3fc46734c7c35b3ce90b", GIT_OID_SHA1));
cl_git_pass(git_tree_lookup(&base_tree, g_repo, &base_id));
/* Create it with an index */
@@ -115,7 +116,7 @@ void test_object_tree_update__replace_blob(void)
{ GIT_TREE_UPDATE_UPSERT, GIT_OID_SHA1_ZERO, GIT_FILEMODE_BLOB, path},
};
- cl_git_pass(git_oid__fromstr(&base_id, "c4dc1555e4d4fa0e0c9c3fc46734c7c35b3ce90b", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&base_id, "c4dc1555e4d4fa0e0c9c3fc46734c7c35b3ce90b", GIT_OID_SHA1));
cl_git_pass(git_tree_lookup(&base_tree, g_repo, &base_id));
/* Create it with an index */
@@ -123,7 +124,7 @@ void test_object_tree_update__replace_blob(void)
cl_git_pass(git_index_read_tree(idx, base_tree));
entry.path = path;
- cl_git_pass(git_oid__fromstr(&entry.id, "fa49b077972391ad58037050f2a75f74e3671e92", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&entry.id, "fa49b077972391ad58037050f2a75f74e3671e92", GIT_OID_SHA1));
entry.mode = GIT_FILEMODE_BLOB;
cl_git_pass(git_index_add(idx, &entry));
@@ -131,7 +132,7 @@ void test_object_tree_update__replace_blob(void)
git_index_free(idx);
/* Perform the same operation via the tree updater */
- cl_git_pass(git_oid__fromstr(&updates[0].id, "fa49b077972391ad58037050f2a75f74e3671e92", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&updates[0].id, "fa49b077972391ad58037050f2a75f74e3671e92", GIT_OID_SHA1));
cl_git_pass(git_tree_create_updated(&tree_updater_id, g_repo, base_tree, 1, updates));
cl_assert_equal_oid(&tree_index_id, &tree_updater_id);
@@ -158,13 +159,13 @@ void test_object_tree_update__add_blobs(void)
{ GIT_TREE_UPDATE_UPSERT, GIT_OID_SHA1_ZERO, GIT_FILEMODE_BLOB, paths[2]},
};
- cl_git_pass(git_oid__fromstr(&base_id, "c4dc1555e4d4fa0e0c9c3fc46734c7c35b3ce90b", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&base_id, "c4dc1555e4d4fa0e0c9c3fc46734c7c35b3ce90b", GIT_OID_SHA1));
entry.mode = GIT_FILEMODE_BLOB;
- cl_git_pass(git_oid__fromstr(&entry.id, "fa49b077972391ad58037050f2a75f74e3671e92", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&entry.id, "fa49b077972391ad58037050f2a75f74e3671e92", GIT_OID_SHA1));
for (i = 0; i < 3; i++) {
- cl_git_pass(git_oid__fromstr(&updates[i].id, "fa49b077972391ad58037050f2a75f74e3671e92", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&updates[i].id, "fa49b077972391ad58037050f2a75f74e3671e92", GIT_OID_SHA1));
}
for (i = 0; i < 2; i++) {
@@ -215,13 +216,13 @@ void test_object_tree_update__add_blobs_unsorted(void)
{ GIT_TREE_UPDATE_UPSERT, GIT_OID_SHA1_ZERO, GIT_FILEMODE_BLOB, paths[2]},
};
- cl_git_pass(git_oid__fromstr(&base_id, "c4dc1555e4d4fa0e0c9c3fc46734c7c35b3ce90b", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&base_id, "c4dc1555e4d4fa0e0c9c3fc46734c7c35b3ce90b", GIT_OID_SHA1));
entry.mode = GIT_FILEMODE_BLOB;
- cl_git_pass(git_oid__fromstr(&entry.id, "fa49b077972391ad58037050f2a75f74e3671e92", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&entry.id, "fa49b077972391ad58037050f2a75f74e3671e92", GIT_OID_SHA1));
for (i = 0; i < 3; i++) {
- cl_git_pass(git_oid__fromstr(&updates[i].id, "fa49b077972391ad58037050f2a75f74e3671e92", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&updates[i].id, "fa49b077972391ad58037050f2a75f74e3671e92", GIT_OID_SHA1));
}
for (i = 0; i < 2; i++) {
@@ -263,7 +264,7 @@ void test_object_tree_update__add_conflict(void)
};
for (i = 0; i < 2; i++) {
- cl_git_pass(git_oid__fromstr(&updates[i].id, "a71586c1dfe8a71c6cbf6c129f404c5642ff31bd", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&updates[i].id, "a71586c1dfe8a71c6cbf6c129f404c5642ff31bd", GIT_OID_SHA1));
}
cl_git_fail(git_tree_create_updated(&tree_updater_id, g_repo, NULL, 2, updates));
@@ -279,7 +280,7 @@ void test_object_tree_update__add_conflict2(void)
};
for (i = 0; i < 2; i++) {
- cl_git_pass(git_oid__fromstr(&updates[i].id, "a71586c1dfe8a71c6cbf6c129f404c5642ff31bd", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&updates[i].id, "a71586c1dfe8a71c6cbf6c129f404c5642ff31bd", GIT_OID_SHA1));
}
cl_git_fail(git_tree_create_updated(&tree_updater_id, g_repo, NULL, 2, updates));
@@ -294,7 +295,7 @@ void test_object_tree_update__remove_invalid_submodule(void)
};
/* This tree contains a submodule with an all-zero commit for a submodule named 'submodule' */
- cl_git_pass(git_oid__fromstr(&baseline_id, "396c7f1adb7925f51ba13a75f48252f44c5a14a2", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&baseline_id, "396c7f1adb7925f51ba13a75f48252f44c5a14a2", GIT_OID_SHA1));
cl_git_pass(git_tree_lookup(&baseline, g_repo, &baseline_id));
cl_git_pass(git_tree_create_updated(&updated_tree_id, g_repo, baseline, 1, updates));
diff --git a/tests/libgit2/object/tree/walk.c b/tests/libgit2/object/tree/walk.c
index 573a278493a..ee93b7c9a48 100644
--- a/tests/libgit2/object/tree/walk.c
+++ b/tests/libgit2/object/tree/walk.c
@@ -33,7 +33,7 @@ void test_object_tree_walk__0(void)
git_tree *tree;
int ct;
- git_oid__fromstr(&id, tree_oid, GIT_OID_SHA1);
+ git_oid_from_string(&id, tree_oid, GIT_OID_SHA1);
cl_git_pass(git_tree_lookup(&tree, g_repo, &id));
@@ -77,7 +77,7 @@ void test_object_tree_walk__1(void)
git_tree *tree;
int ct;
- git_oid__fromstr(&id, tree_oid, GIT_OID_SHA1);
+ git_oid_from_string(&id, tree_oid, GIT_OID_SHA1);
cl_git_pass(git_tree_lookup(&tree, g_repo, &id));
@@ -138,7 +138,7 @@ void test_object_tree_walk__2(void)
struct treewalk_skip_data data;
/* look up a deep tree */
- git_oid__fromstr(&id, "ae90f12eea699729ed24555e40b9fd669da12a12", GIT_OID_SHA1);
+ git_oid_from_string(&id, "ae90f12eea699729ed24555e40b9fd669da12a12", GIT_OID_SHA1);
cl_git_pass(git_tree_lookup(&tree, g_repo, &id));
memset(&data, 0, sizeof(data));
diff --git a/tests/libgit2/object/tree/write.c b/tests/libgit2/object/tree/write.c
index 71a4c54f60d..ed74aca4aae 100644
--- a/tests/libgit2/object/tree/write.c
+++ b/tests/libgit2/object/tree/write.c
@@ -29,9 +29,9 @@ void test_object_tree_write__from_memory(void)
git_tree *tree;
git_oid id, bid, rid, id2;
- git_oid__fromstr(&id, first_tree, GIT_OID_SHA1);
- git_oid__fromstr(&id2, second_tree, GIT_OID_SHA1);
- git_oid__fromstr(&bid, blob_oid, GIT_OID_SHA1);
+ git_oid_from_string(&id, first_tree, GIT_OID_SHA1);
+ git_oid_from_string(&id2, second_tree, GIT_OID_SHA1);
+ git_oid_from_string(&bid, blob_oid, GIT_OID_SHA1);
/* create a second tree from first tree using `git_treebuilder_insert`
* on REPOSITORY_FOLDER.
@@ -71,10 +71,10 @@ void test_object_tree_write__subtree(void)
git_oid id, bid, subtree_id, id2, id3;
git_oid id_hiearar;
- git_oid__fromstr(&id, first_tree, GIT_OID_SHA1);
- git_oid__fromstr(&id2, second_tree, GIT_OID_SHA1);
- git_oid__fromstr(&id3, third_tree, GIT_OID_SHA1);
- git_oid__fromstr(&bid, blob_oid, GIT_OID_SHA1);
+ git_oid_from_string(&id, first_tree, GIT_OID_SHA1);
+ git_oid_from_string(&id2, second_tree, GIT_OID_SHA1);
+ git_oid_from_string(&id3, third_tree, GIT_OID_SHA1);
+ git_oid_from_string(&bid, blob_oid, GIT_OID_SHA1);
/* create subtree */
cl_git_pass(git_treebuilder_new(&builder, g_repo, NULL));
@@ -135,8 +135,8 @@ void test_object_tree_write__sorted_subtrees(void)
git_oid bid, tid, tree_oid;
- cl_git_pass(git_oid__fromstr(&bid, blob_oid, GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&tid, first_tree, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&bid, blob_oid, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&tid, first_tree, GIT_OID_SHA1));
cl_git_pass(git_treebuilder_new(&builder, g_repo, NULL));
@@ -195,7 +195,7 @@ void test_object_tree_write__removing_and_re_adding_in_treebuilder(void)
git_oid entry_oid, tree_oid;
git_tree *tree;
- cl_git_pass(git_oid__fromstr(&entry_oid, blob_oid, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&entry_oid, blob_oid, GIT_OID_SHA1));
cl_git_pass(git_treebuilder_new(&builder, g_repo, NULL));
@@ -286,7 +286,7 @@ void test_object_tree_write__filtering(void)
git_oid entry_oid, tree_oid;
git_tree *tree;
- git_oid__fromstr(&entry_oid, blob_oid, GIT_OID_SHA1);
+ git_oid_from_string(&entry_oid, blob_oid, GIT_OID_SHA1);
cl_git_pass(git_treebuilder_new(&builder, g_repo, NULL));
@@ -348,7 +348,7 @@ void test_object_tree_write__cruel_paths(void)
int count = 0, i, j;
git_tree_entry *te;
- git_oid__fromstr(&bid, blob_oid, GIT_OID_SHA1);
+ git_oid_from_string(&bid, blob_oid, GIT_OID_SHA1);
/* create tree */
cl_git_pass(git_treebuilder_new(&builder, g_repo, NULL));
@@ -411,7 +411,7 @@ void test_object_tree_write__protect_filesystems(void)
git_treebuilder *builder;
git_oid bid;
- cl_git_pass(git_oid__fromstr(&bid, "fa49b077972391ad58037050f2a75f74e3671e92", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&bid, "fa49b077972391ad58037050f2a75f74e3671e92", GIT_OID_SHA1));
/* Ensure that (by default) we can write objects with funny names on
* platforms that are not affected.
@@ -460,12 +460,12 @@ static void test_invalid_objects(bool should_allow_invalid)
"Expected function call to fail: " #expr), \
NULL, 1)
- cl_git_pass(git_oid__fromstr(&valid_blob_id, blob_oid, GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&invalid_blob_id,
+ cl_git_pass(git_oid_from_string(&valid_blob_id, blob_oid, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&invalid_blob_id,
"1234567890123456789012345678901234567890",
GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&valid_tree_id, first_tree, GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&invalid_tree_id,
+ cl_git_pass(git_oid_from_string(&valid_tree_id, first_tree, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&invalid_tree_id,
"0000000000111111111122222222223333333333",
GIT_OID_SHA1));
@@ -497,7 +497,7 @@ static void test_inserting_submodule(void)
git_treebuilder *bld;
git_oid sm_id;
- cl_git_pass(git_oid__fromstr(&sm_id, "da39a3ee5e6b4b0d3255bfef95601890afd80709", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&sm_id, "da39a3ee5e6b4b0d3255bfef95601890afd80709", GIT_OID_SHA1));
cl_git_pass(git_treebuilder_new(&bld, g_repo, NULL));
cl_git_pass(git_treebuilder_insert(NULL, bld, "sm", &sm_id, GIT_FILEMODE_COMMIT));
git_treebuilder_free(bld);
diff --git a/tests/libgit2/odb/alternates.c b/tests/libgit2/odb/alternates.c
index 4d2da6b1f39..21dcaa85796 100644
--- a/tests/libgit2/odb/alternates.c
+++ b/tests/libgit2/odb/alternates.c
@@ -52,7 +52,7 @@ void test_odb_alternates__chained(void)
/* Now load B and see if we can find an object from testrepo.git */
cl_git_pass(git_repository_open(&repo, paths[1]));
- git_oid__fromstr(&oid, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1);
+ git_oid_from_string(&oid, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, repo, &oid));
git_commit_free(commit);
git_repository_free(repo);
@@ -74,7 +74,43 @@ void test_odb_alternates__long_chain(void)
/* Now load the last one and see if we can find an object from testrepo.git */
cl_git_pass(git_repository_open(&repo, paths[ARRAY_SIZE(paths)-1]));
- git_oid__fromstr(&oid, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1);
+ git_oid_from_string(&oid, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1);
cl_git_fail(git_commit_lookup(&commit, repo, &oid));
git_repository_free(repo);
}
+
+void test_odb_alternates__relative(void)
+{
+ git_commit *commit;
+ git_oid oid;
+
+ /* Set the alternate A -> testrepo.git */
+ init_linked_repo(paths[0], cl_fixture("testrepo.git"));
+
+ /* Set the alternate B -> A */
+ init_linked_repo(paths[1], paths[0]);
+ /* Set the alternate C -> B */
+ init_linked_repo(paths[2], paths[1]);
+
+ /* Use a relative alternates path for B -> A */
+ cl_git_pass(git_fs_path_prettify(&filepath, paths[1], NULL));
+ cl_git_pass(git_str_joinpath(&filepath, filepath.ptr, "objects/info/alternates"));
+
+ cl_git_pass(git_filebuf_open(&file, git_str_cstr(&filepath), 0, 0666));
+ git_filebuf_printf(&file, "../../%s/objects\n", paths[0]);
+ cl_git_pass(git_filebuf_commit(&file));
+
+ /* Now load B and see if we can find an object from testrepo.git */
+ cl_git_pass(git_repository_open(&repo, paths[1]));
+ git_oid_from_string(&oid, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1);
+ cl_git_pass(git_commit_lookup(&commit, repo, &oid));
+ git_commit_free(commit);
+ git_repository_free(repo);
+
+ /* Now load C and see if we can find an object from testrepo.git */
+ cl_git_pass(git_repository_open(&repo, paths[2]));
+ git_oid_from_string(&oid, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1);
+ cl_git_pass(git_commit_lookup(&commit, repo, &oid));
+ git_commit_free(commit);
+ git_repository_free(repo);
+}
diff --git a/tests/libgit2/odb/backend/backend_helpers.c b/tests/libgit2/odb/backend/backend_helpers.c
index c1a0070d6b3..d4d04b22c52 100644
--- a/tests/libgit2/odb/backend/backend_helpers.c
+++ b/tests/libgit2/odb/backend/backend_helpers.c
@@ -9,7 +9,7 @@ static int search_object(const fake_object **out, fake_backend *fake, const git_
while (obj && obj->oid) {
git_oid current_oid;
- git_oid__fromstr(¤t_oid, obj->oid, GIT_OID_SHA1);
+ git_oid_from_string(¤t_oid, obj->oid, GIT_OID_SHA1);
if (git_oid_ncmp(¤t_oid, oid, len) == 0) {
if (found)
@@ -52,7 +52,7 @@ static int fake_backend__exists_prefix(
return error;
if (out)
- git_oid__fromstr(out, obj->oid, GIT_OID_SHA1);
+ git_oid_from_string(out, obj->oid, GIT_OID_SHA1);
return 0;
}
@@ -115,7 +115,7 @@ static int fake_backend__read_prefix(
if ((error = search_object(&obj, fake, short_oid, len)) < 0)
return error;
- git_oid__fromstr(out_oid, obj->oid, GIT_OID_SHA1);
+ git_oid_from_string(out_oid, obj->oid, GIT_OID_SHA1);
*len_p = strlen(obj->content);
*buffer_p = git__strdup(obj->content);
*type_p = GIT_OBJECT_BLOB;
diff --git a/tests/libgit2/odb/backend/loose.c b/tests/libgit2/odb/backend/loose.c
index 781b61d9ff9..d917ca8ae4b 100644
--- a/tests/libgit2/odb/backend/loose.c
+++ b/tests/libgit2/odb/backend/loose.c
@@ -19,7 +19,7 @@ void test_odb_backend_loose__initialize(void)
cl_git_pass(git_odb_backend_loose(&backend, "testrepo.git/objects", 0, 0, 0, 0));
#endif
- cl_git_pass(git_odb__new(&_odb, NULL));
+ cl_git_pass(git_odb_new(&_odb));
cl_git_pass(git_odb_add_backend(_odb, backend, 10));
cl_git_pass(git_repository_wrap_odb(&_repo, _odb));
}
@@ -32,12 +32,31 @@ void test_odb_backend_loose__cleanup(void)
cl_fixture_cleanup("testrepo.git");
}
-void test_odb_backend_loose__read(void)
+void test_odb_backend_loose__read_from_odb(void)
{
git_oid oid;
git_odb_object *obj;
- cl_git_pass(git_oid__fromstr(&oid, "1385f264afb75a56a5bec74243be9b367ba4ca08", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, "1385f264afb75a56a5bec74243be9b367ba4ca08", GIT_OID_SHA1));
cl_git_pass(git_odb_read(&obj, _odb, &oid));
git_odb_object_free(obj);
+
+ cl_git_pass(git_oid_from_string(&oid, "fd093bff70906175335656e6ce6ae05783708765", GIT_OID_SHA1));
+ cl_git_pass(git_odb_read(&obj, _odb, &oid));
+ git_odb_object_free(obj);
+}
+
+void test_odb_backend_loose__read_from_repo(void)
+{
+ git_oid oid;
+ git_blob *blob;
+ git_tree *tree;
+
+ cl_git_pass(git_oid_from_string(&oid, "1385f264afb75a56a5bec74243be9b367ba4ca08", GIT_OID_SHA1));
+ cl_git_pass(git_blob_lookup(&blob, _repo, &oid));
+ git_blob_free(blob);
+
+ cl_git_pass(git_oid_from_string(&oid, "fd093bff70906175335656e6ce6ae05783708765", GIT_OID_SHA1));
+ cl_git_pass(git_tree_lookup(&tree, _repo, &oid));
+ git_tree_free(tree);
}
diff --git a/tests/libgit2/odb/backend/mempack.c b/tests/libgit2/odb/backend/mempack.c
index eb8ab3cb0b2..89e09577c1e 100644
--- a/tests/libgit2/odb/backend/mempack.c
+++ b/tests/libgit2/odb/backend/mempack.c
@@ -8,14 +8,13 @@ static git_odb *_odb;
static git_oid _oid;
static git_odb_object *_obj;
static git_repository *_repo;
+static git_odb_backend *_backend;
void test_odb_backend_mempack__initialize(void)
{
- git_odb_backend *backend;
-
- cl_git_pass(git_mempack_new(&backend));
- cl_git_pass(git_odb__new(&_odb, NULL));
- cl_git_pass(git_odb_add_backend(_odb, backend, 10));
+ cl_git_pass(git_mempack_new(&_backend));
+ cl_git_pass(git_odb_new(&_odb));
+ cl_git_pass(git_odb_add_backend(_odb, _backend, 10));
cl_git_pass(git_repository_wrap_odb(&_repo, _odb));
}
@@ -35,13 +34,13 @@ void test_odb_backend_mempack__write_succeeds(void)
void test_odb_backend_mempack__read_of_missing_object_fails(void)
{
- cl_git_pass(git_oid__fromstr(&_oid, "f6ea0495187600e7b2288c8ac19c5886383a4633", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&_oid, "f6ea0495187600e7b2288c8ac19c5886383a4633", GIT_OID_SHA1));
cl_git_fail_with(GIT_ENOTFOUND, git_odb_read(&_obj, _odb, &_oid));
}
void test_odb_backend_mempack__exists_of_missing_object_fails(void)
{
- cl_git_pass(git_oid__fromstr(&_oid, "f6ea0495187600e7b2288c8ac19c5886383a4633", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&_oid, "f6ea0495187600e7b2288c8ac19c5886383a4633", GIT_OID_SHA1));
cl_assert(git_odb_exists(_odb, &_oid) == 0);
}
@@ -59,3 +58,25 @@ void test_odb_backend_mempack__blob_create_from_buffer_succeeds(void)
cl_git_pass(git_blob_create_from_buffer(&_oid, _repo, data, strlen(data) + 1));
cl_assert(git_odb_exists(_odb, &_oid) == 1);
}
+
+void test_odb_backend_mempack__empty_object_count_succeeds(void)
+{
+ size_t count;
+ cl_git_pass(git_mempack_object_count(&count, _backend));
+ cl_assert_equal_sz(0, count);
+}
+
+void test_odb_backend_mempack__object_count_succeeds(void)
+{
+ const char *data = "data";
+ size_t count;
+ cl_git_pass(git_odb_write(&_oid, _odb, data, strlen(data) + 1, GIT_OBJECT_BLOB));
+ cl_git_pass(git_mempack_object_count(&count, _backend));
+ cl_assert_equal_sz(1, count);
+}
+
+void test_odb_backend_mempack__object_count_fails(void)
+{
+ size_t count;
+ cl_git_fail_with(-1, git_mempack_object_count(&count, 0));
+}
diff --git a/tests/libgit2/odb/backend/multiple.c b/tests/libgit2/odb/backend/multiple.c
index 97588164db9..689fbc2140a 100644
--- a/tests/libgit2/odb/backend/multiple.c
+++ b/tests/libgit2/odb/backend/multiple.c
@@ -24,7 +24,7 @@ void test_odb_backend_multiple__initialize(void)
{
git_odb_backend *backend;
- git_oid__fromstr(&_existing_oid, EXISTING_HASH, GIT_OID_SHA1);
+ git_oid_from_string(&_existing_oid, EXISTING_HASH, GIT_OID_SHA1);
_obj = NULL;
_repo = cl_git_sandbox_init("testrepo.git");
diff --git a/tests/libgit2/odb/backend/nobackend.c b/tests/libgit2/odb/backend/nobackend.c
index 7d9394c6f33..b33f79abb90 100644
--- a/tests/libgit2/odb/backend/nobackend.c
+++ b/tests/libgit2/odb/backend/nobackend.c
@@ -11,9 +11,15 @@ void test_odb_backend_nobackend__initialize(void)
git_odb *odb;
git_refdb *refdb;
- cl_git_pass(git_repository_new(&_repo));
+ git_repository_new_options repo_opts = GIT_REPOSITORY_NEW_OPTIONS_INIT;
+ git_odb_options odb_opts = GIT_ODB_OPTIONS_INIT;
+
+ repo_opts.oid_type = GIT_OID_SHA1;
+ odb_opts.oid_type = GIT_OID_SHA1;
+
+ cl_git_pass(git_repository_new_ext(&_repo, &repo_opts));
cl_git_pass(git_config_new(&config));
- cl_git_pass(git_odb__new(&odb, NULL));
+ cl_git_pass(git_odb_new_ext(&odb, &odb_opts));
cl_git_pass(git_refdb_new(&refdb, _repo));
git_repository_set_config(_repo, config);
diff --git a/tests/libgit2/odb/backend/nonrefreshing.c b/tests/libgit2/odb/backend/nonrefreshing.c
index 5084eb7f746..82e0ab05352 100644
--- a/tests/libgit2/odb/backend/nonrefreshing.c
+++ b/tests/libgit2/odb/backend/nonrefreshing.c
@@ -33,8 +33,8 @@ static void setup_repository_and_backend(void)
void test_odb_backend_nonrefreshing__initialize(void)
{
- git_oid__fromstr(&_nonexisting_oid, NONEXISTING_HASH, GIT_OID_SHA1);
- git_oid__fromstr(&_existing_oid, EXISTING_HASH, GIT_OID_SHA1);
+ git_oid_from_string(&_nonexisting_oid, NONEXISTING_HASH, GIT_OID_SHA1);
+ git_oid_from_string(&_existing_oid, EXISTING_HASH, GIT_OID_SHA1);
setup_repository_and_backend();
}
diff --git a/tests/libgit2/odb/backend/refreshing.c b/tests/libgit2/odb/backend/refreshing.c
index fcba748ee0d..cf82630df26 100644
--- a/tests/libgit2/odb/backend/refreshing.c
+++ b/tests/libgit2/odb/backend/refreshing.c
@@ -33,8 +33,8 @@ static void setup_repository_and_backend(void)
void test_odb_backend_refreshing__initialize(void)
{
- git_oid__fromstr(&_nonexisting_oid, NONEXISTING_HASH, GIT_OID_SHA1);
- git_oid__fromstr(&_existing_oid, EXISTING_HASH, GIT_OID_SHA1);
+ git_oid_from_string(&_nonexisting_oid, NONEXISTING_HASH, GIT_OID_SHA1);
+ git_oid_from_string(&_existing_oid, EXISTING_HASH, GIT_OID_SHA1);
setup_repository_and_backend();
}
diff --git a/tests/libgit2/odb/backend/simple.c b/tests/libgit2/odb/backend/simple.c
index 25dfd90a2e2..da52d307f06 100644
--- a/tests/libgit2/odb/backend/simple.c
+++ b/tests/libgit2/odb/backend/simple.c
@@ -49,7 +49,7 @@ void test_odb_backend_simple__read_of_object_succeeds(void)
setup_backend(objs);
- cl_git_pass(git_oid__fromstr(&_oid, objs[0].oid, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&_oid, objs[0].oid, GIT_OID_SHA1));
cl_git_pass(git_odb_read(&_obj, _odb, &_oid));
assert_object_contains(_obj, objs[0].content);
@@ -64,7 +64,7 @@ void test_odb_backend_simple__read_of_nonexisting_object_fails(void)
setup_backend(objs);
- cl_git_pass(git_oid__fromstr(&_oid, "f6ea0495187600e7b2288c8ac19c5886383a4633", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&_oid, "f6ea0495187600e7b2288c8ac19c5886383a4633", GIT_OID_SHA1));
cl_git_fail_with(GIT_ENOTFOUND, git_odb_read(&_obj, _odb, &_oid));
}
@@ -77,7 +77,7 @@ void test_odb_backend_simple__read_with_hash_mismatch_fails(void)
setup_backend(objs);
- cl_git_pass(git_oid__fromstr(&_oid, objs[0].oid, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&_oid, objs[0].oid, GIT_OID_SHA1));
cl_git_fail_with(GIT_EMISMATCH, git_odb_read(&_obj, _odb, &_oid));
}
@@ -89,7 +89,7 @@ void test_odb_backend_simple__read_with_hash_mismatch_succeeds_without_verificat
};
setup_backend(objs);
- cl_git_pass(git_oid__fromstr(&_oid, objs[0].oid, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&_oid, objs[0].oid, GIT_OID_SHA1));
cl_git_pass(git_libgit2_opts(GIT_OPT_ENABLE_STRICT_HASH_VERIFICATION, 0));
cl_git_pass(git_odb_read(&_obj, _odb, &_oid));
@@ -106,7 +106,7 @@ void test_odb_backend_simple__read_prefix_succeeds(void)
setup_backend(objs);
- cl_git_pass(git_oid__fromstr(&_oid, "f6ea0495187600e7b2288c8ac19c5886383a4632", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&_oid, "f6ea0495187600e7b2288c8ac19c5886383a4632", GIT_OID_SHA1));
cl_git_pass(git_odb_read(&_obj, _odb, &_oid));
assert_object_contains(_obj, objs[0].content);
@@ -122,7 +122,7 @@ void test_odb_backend_simple__read_prefix_of_nonexisting_object_fails(void)
setup_backend(objs);
- cl_git_pass(git_oid__fromstrn(&_oid, hash, strlen(hash), GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&_oid, hash, strlen(hash), GIT_OID_SHA1));
cl_git_fail_with(GIT_ENOTFOUND, git_odb_read(&_obj, _odb, &_oid));
}
@@ -136,7 +136,7 @@ void test_odb_backend_simple__read_with_ambiguous_prefix_fails(void)
setup_backend(objs);
- cl_git_pass(git_oid__fromstr(&_oid, objs[0].oid, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&_oid, objs[0].oid, GIT_OID_SHA1));
cl_git_fail_with(GIT_EAMBIGUOUS, git_odb_read_prefix(&_obj, _odb, &_oid, 7));
}
@@ -150,7 +150,7 @@ void test_odb_backend_simple__read_with_highly_ambiguous_prefix(void)
setup_backend(objs);
- cl_git_pass(git_oid__fromstr(&_oid, objs[0].oid, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&_oid, objs[0].oid, GIT_OID_SHA1));
cl_git_pass(git_libgit2_opts(GIT_OPT_ENABLE_STRICT_HASH_VERIFICATION, 0));
cl_git_fail_with(GIT_EAMBIGUOUS, git_odb_read_prefix(&_obj, _odb, &_oid, 39));
cl_git_pass(git_odb_read_prefix(&_obj, _odb, &_oid, 40));
@@ -166,7 +166,7 @@ void test_odb_backend_simple__exists_succeeds(void)
setup_backend(objs);
- cl_git_pass(git_oid__fromstr(&_oid, objs[0].oid, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&_oid, objs[0].oid, GIT_OID_SHA1));
cl_assert(git_odb_exists(_odb, &_oid));
}
@@ -179,7 +179,7 @@ void test_odb_backend_simple__exists_fails_for_nonexisting_object(void)
setup_backend(objs);
- cl_git_pass(git_oid__fromstr(&_oid, "f6ea0495187600e7b2288c8ac19c5886383a4633", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&_oid, "f6ea0495187600e7b2288c8ac19c5886383a4633", GIT_OID_SHA1));
cl_assert(git_odb_exists(_odb, &_oid) == 0);
}
@@ -194,7 +194,7 @@ void test_odb_backend_simple__exists_prefix_succeeds(void)
setup_backend(objs);
- cl_git_pass(git_oid__fromstr(&_oid, objs[0].oid, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&_oid, objs[0].oid, GIT_OID_SHA1));
cl_git_pass(git_odb_exists_prefix(&found, _odb, &_oid, 12));
cl_assert(git_oid_equal(&found, &_oid));
}
@@ -209,7 +209,7 @@ void test_odb_backend_simple__exists_with_ambiguous_prefix_fails(void)
setup_backend(objs);
- cl_git_pass(git_oid__fromstr(&_oid, objs[0].oid, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&_oid, objs[0].oid, GIT_OID_SHA1));
cl_git_fail_with(GIT_EAMBIGUOUS, git_odb_exists_prefix(NULL, _odb, &_oid, 7));
}
@@ -224,7 +224,7 @@ void test_odb_backend_simple__exists_with_highly_ambiguous_prefix(void)
setup_backend(objs);
- cl_git_pass(git_oid__fromstr(&_oid, objs[0].oid, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&_oid, objs[0].oid, GIT_OID_SHA1));
cl_git_pass(git_libgit2_opts(GIT_OPT_ENABLE_STRICT_HASH_VERIFICATION, 0));
cl_git_fail_with(GIT_EAMBIGUOUS, git_odb_exists_prefix(&found, _odb, &_oid, 39));
cl_git_pass(git_odb_exists_prefix(&found, _odb, &_oid, 40));
diff --git a/tests/libgit2/odb/emptyobjects.c b/tests/libgit2/odb/emptyobjects.c
index e7cc668d16c..baa6330b6be 100644
--- a/tests/libgit2/odb/emptyobjects.c
+++ b/tests/libgit2/odb/emptyobjects.c
@@ -24,7 +24,7 @@ void test_odb_emptyobjects__blob_notfound(void)
git_oid id, written_id;
git_blob *blob;
- cl_git_pass(git_oid__fromstr(&id, "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391", GIT_OID_SHA1));
cl_git_fail_with(GIT_ENOTFOUND, git_blob_lookup(&blob, g_repo, &id));
cl_git_pass(git_odb_write(&written_id, g_odb, "", 0, GIT_OBJECT_BLOB));
@@ -36,7 +36,7 @@ void test_odb_emptyobjects__read_tree(void)
git_oid id;
git_tree *tree;
- cl_git_pass(git_oid__fromstr(&id, "4b825dc642cb6eb9a060e54bf8d69288fbee4904", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, "4b825dc642cb6eb9a060e54bf8d69288fbee4904", GIT_OID_SHA1));
cl_git_pass(git_tree_lookup(&tree, g_repo, &id));
cl_assert_equal_i(GIT_OBJECT_TREE, git_object_type((git_object *) tree));
cl_assert_equal_i(0, git_tree_entrycount(tree));
@@ -49,7 +49,7 @@ void test_odb_emptyobjects__read_tree_odb(void)
git_oid id;
git_odb_object *tree_odb;
- cl_git_pass(git_oid__fromstr(&id, "4b825dc642cb6eb9a060e54bf8d69288fbee4904", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, "4b825dc642cb6eb9a060e54bf8d69288fbee4904", GIT_OID_SHA1));
cl_git_pass(git_odb_read(&tree_odb, g_odb, &id));
cl_assert(git_odb_object_data(tree_odb));
cl_assert_equal_s("", git_odb_object_data(tree_odb));
diff --git a/tests/libgit2/odb/foreach.c b/tests/libgit2/odb/foreach.c
index 56b3e882ce0..091bd783e5b 100644
--- a/tests/libgit2/odb/foreach.c
+++ b/tests/libgit2/odb/foreach.c
@@ -50,8 +50,11 @@ void test_odb_foreach__one_pack(void)
{
git_odb_backend *backend = NULL;
int nobj = 0;
+ git_odb_options odb_opts = GIT_ODB_OPTIONS_INIT;
- cl_git_pass(git_odb__new(&_odb, NULL));
+ odb_opts.oid_type = GIT_OID_SHA1;
+
+ cl_git_pass(git_odb_new_ext(&_odb, &odb_opts));
#ifdef GIT_EXPERIMENTAL_SHA256
cl_git_pass(git_odb_backend_one_pack(&backend,
diff --git a/tests/libgit2/odb/freshen.c b/tests/libgit2/odb/freshen.c
index e337c82b773..b425abad259 100644
--- a/tests/libgit2/odb/freshen.c
+++ b/tests/libgit2/odb/freshen.c
@@ -43,7 +43,7 @@ void test_odb_freshen__loose_blob(void)
git_oid expected_id, id;
struct stat before, after;
- cl_git_pass(git_oid__fromstr(&expected_id, LOOSE_BLOB_ID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected_id, LOOSE_BLOB_ID, GIT_OID_SHA1));
set_time_wayback(&before, LOOSE_BLOB_FN);
/* make sure we freshen a blob */
@@ -64,7 +64,7 @@ void test_odb_freshen__readonly_object(void)
git_oid expected_id, id;
struct stat before, after;
- cl_git_pass(git_oid__fromstr(&expected_id, UNIQUE_BLOB_ID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected_id, UNIQUE_BLOB_ID, GIT_OID_SHA1));
cl_git_pass(git_blob_create_from_buffer(&id, repo, UNIQUE_STR, CONST_STRLEN(UNIQUE_STR)));
cl_assert_equal_oid(&expected_id, &id);
@@ -89,7 +89,7 @@ void test_odb_freshen__loose_tree(void)
git_tree *tree;
struct stat before, after;
- cl_git_pass(git_oid__fromstr(&expected_id, LOOSE_TREE_ID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected_id, LOOSE_TREE_ID, GIT_OID_SHA1));
set_time_wayback(&before, LOOSE_TREE_FN);
cl_git_pass(git_tree_lookup(&tree, repo, &expected_id));
@@ -113,11 +113,11 @@ void test_odb_freshen__tree_during_commit(void)
git_signature *signature;
struct stat before, after;
- cl_git_pass(git_oid__fromstr(&tree_id, LOOSE_TREE_ID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&tree_id, LOOSE_TREE_ID, GIT_OID_SHA1));
cl_git_pass(git_tree_lookup(&tree, repo, &tree_id));
set_time_wayback(&before, LOOSE_TREE_FN);
- cl_git_pass(git_oid__fromstr(&parent_id, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&parent_id, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1));
cl_git_pass(git_commit_lookup(&parent, repo, &parent_id));
cl_git_pass(git_signature_new(&signature,
@@ -147,7 +147,7 @@ void test_odb_freshen__packed_object(void)
struct stat before, after;
struct p_timeval old_times[2];
- cl_git_pass(git_oid__fromstr(&expected_id, PACKED_ID, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected_id, PACKED_ID, GIT_OID_SHA1));
old_times[0].tv_sec = 1234567890;
old_times[0].tv_usec = 0;
diff --git a/tests/libgit2/odb/largefiles.c b/tests/libgit2/odb/largefiles.c
index 2ec48102b38..0f53e477bc2 100644
--- a/tests/libgit2/odb/largefiles.c
+++ b/tests/libgit2/odb/largefiles.c
@@ -57,7 +57,7 @@ void test_odb_largefiles__write_from_memory(void)
for (i = 0; i < (3041*126103); i++)
cl_git_pass(git_str_puts(&buf, "Hello, world.\n"));
- git_oid__fromstr(&expected, "3fb56989cca483b21ba7cb0a6edb229d10e1c26c", GIT_OID_SHA1);
+ git_oid_from_string(&expected, "3fb56989cca483b21ba7cb0a6edb229d10e1c26c", GIT_OID_SHA1);
cl_git_pass(git_odb_write(&oid, odb, buf.ptr, buf.size, GIT_OBJECT_BLOB));
cl_assert_equal_oid(&expected, &oid);
@@ -75,7 +75,7 @@ void test_odb_largefiles__streamwrite(void)
!cl_is_env_set("GITTEST_SLOW"))
cl_skip();
- git_oid__fromstr(&expected, "3fb56989cca483b21ba7cb0a6edb229d10e1c26c", GIT_OID_SHA1);
+ git_oid_from_string(&expected, "3fb56989cca483b21ba7cb0a6edb229d10e1c26c", GIT_OID_SHA1);
writefile(&oid);
cl_assert_equal_oid(&expected, &oid);
diff --git a/tests/libgit2/odb/loose.c b/tests/libgit2/odb/loose.c
index 0409dfb2812..e68d5d13b4d 100644
--- a/tests/libgit2/odb/loose.c
+++ b/tests/libgit2/odb/loose.c
@@ -44,8 +44,8 @@ static void test_read_object(object_data *data)
write_object_files(data);
- cl_git_pass(git_odb__open(&odb, "test-objects", &opts));
- cl_git_pass(git_oid__fromstr(&id, data->id, data->id_type));
+ cl_git_pass(git_odb_open_ext(&odb, "test-objects", &opts));
+ cl_git_pass(git_oid_from_string(&id, data->id, data->id_type));
cl_git_pass(git_odb_read(&obj, odb, &id));
tmp.data = obj->buffer;
@@ -70,8 +70,8 @@ static void test_read_header(object_data *data)
write_object_files(data);
- cl_git_pass(git_odb__open(&odb, "test-objects", &opts));
- cl_git_pass(git_oid__fromstr(&id, data->id, data->id_type));
+ cl_git_pass(git_odb_open_ext(&odb, "test-objects", &opts));
+ cl_git_pass(git_oid_from_string(&id, data->id, data->id_type));
cl_git_pass(git_odb_read_header(&len, &type, odb, &id));
cl_assert_equal_sz(data->dlen, len);
@@ -95,8 +95,8 @@ static void test_readstream_object(object_data *data, size_t blocksize)
write_object_files(data);
- cl_git_pass(git_odb__open(&odb, "test-objects", &opts));
- cl_git_pass(git_oid__fromstr(&id, data->id, data->id_type));
+ cl_git_pass(git_odb_open_ext(&odb, "test-objects", &opts));
+ cl_git_pass(git_oid_from_string(&id, data->id, data->id_type));
cl_git_pass(git_odb_open_rstream(&stream, &tmp.len, &tmp.type, odb, &id));
remain = tmp.len;
@@ -139,20 +139,20 @@ void test_odb_loose__exists_sha1(void)
git_odb *odb;
write_object_files(&one);
- cl_git_pass(git_odb__open(&odb, "test-objects", NULL));
+ cl_git_pass(git_odb_open(&odb, "test-objects"));
- cl_git_pass(git_oid__fromstr(&id, one.id, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, one.id, GIT_OID_SHA1));
cl_assert(git_odb_exists(odb, &id));
- cl_git_pass(git_oid__fromstrp(&id, "8b137891", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&id, "8b137891", 8, GIT_OID_SHA1));
cl_git_pass(git_odb_exists_prefix(&id2, odb, &id, 8));
cl_assert_equal_i(0, git_oid_streq(&id2, one.id));
/* Test for a missing object */
- cl_git_pass(git_oid__fromstr(&id, "8b137891791fe96927ad78e64b0aad7bded08baa", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, "8b137891791fe96927ad78e64b0aad7bded08baa", GIT_OID_SHA1));
cl_assert(!git_odb_exists(odb, &id));
- cl_git_pass(git_oid__fromstrp(&id, "8b13789a", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&id, "8b13789a", 8, GIT_OID_SHA1));
cl_assert_equal_i(GIT_ENOTFOUND, git_odb_exists_prefix(&id2, odb, &id, 8));
git_odb_free(odb);
@@ -170,20 +170,20 @@ void test_odb_loose__exists_sha256(void)
odb_opts.oid_type = GIT_OID_SHA256;
write_object_files(&one_sha256);
- cl_git_pass(git_odb__open(&odb, "test-objects", &odb_opts));
+ cl_git_pass(git_odb_open_ext(&odb, "test-objects", &odb_opts));
- cl_git_pass(git_oid__fromstr(&id, one_sha256.id, GIT_OID_SHA256));
+ cl_git_pass(git_oid_from_string(&id, one_sha256.id, GIT_OID_SHA256));
cl_assert(git_odb_exists(odb, &id));
- cl_git_pass(git_oid__fromstrp(&id, "4c0d52d1", GIT_OID_SHA256));
+ cl_git_pass(git_oid_from_prefix(&id, "4c0d52d1", 8, GIT_OID_SHA256));
cl_git_pass(git_odb_exists_prefix(&id2, odb, &id, 8));
cl_assert_equal_i(0, git_oid_streq(&id2, one_sha256.id));
/* Test for a missing object */
- cl_git_pass(git_oid__fromstr(&id, "4c0d52d180c61d01ce1a91dec5ee58f0cbe65fd59433aea803ab927965493faa", GIT_OID_SHA256));
+ cl_git_pass(git_oid_from_string(&id, "4c0d52d180c61d01ce1a91dec5ee58f0cbe65fd59433aea803ab927965493faa", GIT_OID_SHA256));
cl_assert(!git_odb_exists(odb, &id));
- cl_git_pass(git_oid__fromstrp(&id, "4c0d52da", GIT_OID_SHA256));
+ cl_git_pass(git_oid_from_prefix(&id, "4c0d52da", 8, GIT_OID_SHA256));
cl_assert_equal_i(GIT_ENOTFOUND, git_odb_exists_prefix(&id2, odb, &id, 8));
git_odb_free(odb);
@@ -304,7 +304,7 @@ static void test_write_object_permission(
opts.dir_mode = dir_mode;
opts.file_mode = file_mode;
- cl_git_pass(git_odb__new(&odb, NULL));
+ cl_git_pass(git_odb_new(&odb));
cl_git_pass(git_odb__backend_loose(&backend, "test-objects", &opts));
cl_git_pass(git_odb_add_backend(odb, backend, 1));
cl_git_pass(git_odb_write(&oid, odb, "Test data\n", 10, GIT_OBJECT_BLOB));
@@ -338,16 +338,17 @@ static void write_object_to_loose_odb(int fsync)
git_odb *odb;
git_odb_backend *backend;
git_oid oid;
- git_odb_backend_loose_options opts = GIT_ODB_BACKEND_LOOSE_OPTIONS_INIT;
+ git_odb_options odb_opts = GIT_ODB_OPTIONS_INIT;
+ git_odb_backend_loose_options backend_opts = GIT_ODB_BACKEND_LOOSE_OPTIONS_INIT;
if (fsync)
- opts.flags |= GIT_ODB_BACKEND_LOOSE_FSYNC;
+ backend_opts.flags |= GIT_ODB_BACKEND_LOOSE_FSYNC;
- opts.dir_mode = 0777;
- opts.file_mode = 0666;
+ backend_opts.dir_mode = 0777;
+ backend_opts.file_mode = 0666;
- cl_git_pass(git_odb__new(&odb, NULL));
- cl_git_pass(git_odb__backend_loose(&backend, "test-objects", &opts));
+ cl_git_pass(git_odb_new_ext(&odb, &odb_opts));
+ cl_git_pass(git_odb__backend_loose(&backend, "test-objects", &backend_opts));
cl_git_pass(git_odb_add_backend(odb, backend, 1));
cl_git_pass(git_odb_write(&oid, odb, "Test data\n", 10, GIT_OBJECT_BLOB));
git_odb_free(odb);
diff --git a/tests/libgit2/odb/mixed.c b/tests/libgit2/odb/mixed.c
index 19e6dcebf1e..2c66afe4cac 100644
--- a/tests/libgit2/odb/mixed.c
+++ b/tests/libgit2/odb/mixed.c
@@ -5,7 +5,7 @@ static git_odb *_odb;
void test_odb_mixed__initialize(void)
{
- cl_git_pass(git_odb__open(&_odb, cl_fixture("duplicate.git/objects"), NULL));
+ cl_git_pass(git_odb_open_ext(&_odb, cl_fixture("duplicate.git/objects"), NULL));
}
void test_odb_mixed__cleanup(void)
@@ -20,13 +20,13 @@ void test_odb_mixed__dup_oid(void) {
git_oid oid;
git_odb_object *obj;
- cl_git_pass(git_oid__fromstr(&oid, hex, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, hex, GIT_OID_SHA1));
cl_git_pass(git_odb_read_prefix(&obj, _odb, &oid, GIT_OID_SHA1_HEXSIZE));
git_odb_object_free(obj);
cl_git_pass(git_odb_exists_prefix(NULL, _odb, &oid, GIT_OID_SHA1_HEXSIZE));
- cl_git_pass(git_oid__fromstrn(&oid, short_hex, sizeof(short_hex) - 1, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&oid, short_hex, sizeof(short_hex) - 1, GIT_OID_SHA1));
cl_git_pass(git_odb_read_prefix(&obj, _odb, &oid, sizeof(short_hex) - 1));
git_odb_object_free(obj);
@@ -48,63 +48,63 @@ void test_odb_mixed__dup_oid_prefix_0(void) {
/* ambiguous in the same pack file */
strncpy(hex, "dea509d0", sizeof(hex));
- cl_git_pass(git_oid__fromstrn(&oid, hex, strlen(hex), GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&oid, hex, strlen(hex), GIT_OID_SHA1));
cl_assert_equal_i(
GIT_EAMBIGUOUS, git_odb_read_prefix(&obj, _odb, &oid, strlen(hex)));
cl_assert_equal_i(
GIT_EAMBIGUOUS, git_odb_exists_prefix(&found, _odb, &oid, strlen(hex)));
strncpy(hex, "dea509d09", sizeof(hex));
- cl_git_pass(git_oid__fromstrn(&oid, hex, strlen(hex), GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&oid, hex, strlen(hex), GIT_OID_SHA1));
cl_git_pass(git_odb_read_prefix(&obj, _odb, &oid, strlen(hex)));
cl_git_pass(git_odb_exists_prefix(&found, _odb, &oid, strlen(hex)));
cl_assert_equal_oid(&found, git_odb_object_id(obj));
git_odb_object_free(obj);
strncpy(hex, "dea509d0b", sizeof(hex));
- cl_git_pass(git_oid__fromstrn(&oid, hex, strlen(hex), GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&oid, hex, strlen(hex), GIT_OID_SHA1));
cl_git_pass(git_odb_read_prefix(&obj, _odb, &oid, strlen(hex)));
git_odb_object_free(obj);
/* ambiguous in different pack files */
strncpy(hex, "81b5bff5", sizeof(hex));
- cl_git_pass(git_oid__fromstrn(&oid, hex, strlen(hex), GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&oid, hex, strlen(hex), GIT_OID_SHA1));
cl_assert_equal_i(
GIT_EAMBIGUOUS, git_odb_read_prefix(&obj, _odb, &oid, strlen(hex)));
cl_assert_equal_i(
GIT_EAMBIGUOUS, git_odb_exists_prefix(&found, _odb, &oid, strlen(hex)));
strncpy(hex, "81b5bff5b", sizeof(hex));
- cl_git_pass(git_oid__fromstrn(&oid, hex, strlen(hex), GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&oid, hex, strlen(hex), GIT_OID_SHA1));
cl_git_pass(git_odb_read_prefix(&obj, _odb, &oid, strlen(hex)));
cl_git_pass(git_odb_exists_prefix(&found, _odb, &oid, strlen(hex)));
cl_assert_equal_oid(&found, git_odb_object_id(obj));
git_odb_object_free(obj);
strncpy(hex, "81b5bff5f", sizeof(hex));
- cl_git_pass(git_oid__fromstrn(&oid, hex, strlen(hex), GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&oid, hex, strlen(hex), GIT_OID_SHA1));
cl_git_pass(git_odb_read_prefix(&obj, _odb, &oid, strlen(hex)));
git_odb_object_free(obj);
/* ambiguous in pack file and loose */
strncpy(hex, "0ddeaded", sizeof(hex));
- cl_git_pass(git_oid__fromstrn(&oid, hex, strlen(hex), GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&oid, hex, strlen(hex), GIT_OID_SHA1));
cl_assert_equal_i(
GIT_EAMBIGUOUS, git_odb_read_prefix(&obj, _odb, &oid, strlen(hex)));
cl_assert_equal_i(
GIT_EAMBIGUOUS, git_odb_exists_prefix(&found, _odb, &oid, strlen(hex)));
strncpy(hex, "0ddeaded9", sizeof(hex));
- cl_git_pass(git_oid__fromstrn(&oid, hex, strlen(hex), GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&oid, hex, strlen(hex), GIT_OID_SHA1));
cl_git_pass(git_odb_read_prefix(&obj, _odb, &oid, strlen(hex)));
cl_git_pass(git_odb_exists_prefix(&found, _odb, &oid, strlen(hex)));
cl_assert_equal_oid(&found, git_odb_object_id(obj));
git_odb_object_free(obj);
strncpy(hex, "0ddeadede", sizeof(hex));
- cl_git_pass(git_oid__fromstrn(&oid, hex, strlen(hex), GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&oid, hex, strlen(hex), GIT_OID_SHA1));
cl_git_pass(git_odb_read_prefix(&obj, _odb, &oid, strlen(hex)));
git_odb_object_free(obj);
}
@@ -170,7 +170,7 @@ static void setup_prefix_query(
size_t len = strlen(expand_id_test_data[i].lookup_id);
- git_oid__fromstrn(&id->id, expand_id_test_data[i].lookup_id, len, GIT_OID_SHA1);
+ git_oid_from_prefix(&id->id, expand_id_test_data[i].lookup_id, len, GIT_OID_SHA1);
id->length = (unsigned short)len;
id->type = expand_id_test_data[i].expected_type;
}
@@ -191,7 +191,7 @@ static void assert_found_objects(git_odb_expand_id *ids)
git_object_t expected_type = 0;
if (expand_id_test_data[i].expected_id) {
- git_oid__fromstr(&expected_id, expand_id_test_data[i].expected_id, GIT_OID_SHA1);
+ git_oid_from_string(&expected_id, expand_id_test_data[i].expected_id, GIT_OID_SHA1);
expected_len = GIT_OID_SHA1_HEXSIZE;
expected_type = expand_id_test_data[i].expected_type;
}
diff --git a/tests/libgit2/odb/open.c b/tests/libgit2/odb/open.c
new file mode 100644
index 00000000000..1a178e0c1f4
--- /dev/null
+++ b/tests/libgit2/odb/open.c
@@ -0,0 +1,34 @@
+#include "clar_libgit2.h"
+#include "odb.h"
+
+void test_odb_open__initialize(void)
+{
+ cl_fixture_sandbox("testrepo.git");
+}
+
+void test_odb_open__cleanup(void)
+{
+ cl_fixture_cleanup("testrepo.git");
+}
+
+void test_odb_open__exists(void)
+{
+ git_odb *odb;
+ git_oid one, two;
+ git_odb_options opts = GIT_ODB_OPTIONS_INIT;
+
+ cl_git_pass(git_odb_open_ext(&odb, "testrepo.git/objects", &opts));
+
+#ifdef GIT_EXPERIMENTAL_SHA256
+ cl_git_pass(git_oid_from_string(&one, "1385f264afb75a56a5bec74243be9b367ba4ca08", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&two, "00112233445566778899aabbccddeeff00112233", GIT_OID_SHA1));
+#else
+ cl_git_pass(git_oid_fromstr(&one, "1385f264afb75a56a5bec74243be9b367ba4ca08"));
+ cl_git_pass(git_oid_fromstr(&two, "00112233445566778899aabbccddeeff00112233"));
+#endif
+
+ cl_assert(git_odb_exists(odb, &one));
+ cl_assert(!git_odb_exists(odb, &two));
+
+ git_odb_free(odb);
+}
diff --git a/tests/libgit2/odb/packed.c b/tests/libgit2/odb/packed.c
index b41041fc112..f33df1054fe 100644
--- a/tests/libgit2/odb/packed.c
+++ b/tests/libgit2/odb/packed.c
@@ -6,7 +6,7 @@ static git_odb *_odb;
void test_odb_packed__initialize(void)
{
- cl_git_pass(git_odb__open(&_odb, cl_fixture("testrepo.git/objects"), NULL));
+ cl_git_pass(git_odb_open_ext(&_odb, cl_fixture("testrepo.git/objects"), NULL));
}
void test_odb_packed__cleanup(void)
@@ -23,7 +23,7 @@ void test_odb_packed__mass_read(void)
git_oid id;
git_odb_object *obj;
- cl_git_pass(git_oid__fromstr(&id, packed_objects[i], GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, packed_objects[i], GIT_OID_SHA1));
cl_assert(git_odb_exists(_odb, &id) == 1);
cl_git_pass(git_odb_read(&obj, _odb, &id));
@@ -41,7 +41,7 @@ void test_odb_packed__read_header_0(void)
size_t len;
git_object_t type;
- cl_git_pass(git_oid__fromstr(&id, packed_objects[i], GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, packed_objects[i], GIT_OID_SHA1));
cl_git_pass(git_odb_read(&obj, _odb, &id));
cl_git_pass(git_odb_read_header(&len, &type, _odb, &id));
@@ -63,7 +63,7 @@ void test_odb_packed__read_header_1(void)
size_t len;
git_object_t type;
- cl_git_pass(git_oid__fromstr(&id, loose_objects[i], GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, loose_objects[i], GIT_OID_SHA1));
cl_assert(git_odb_exists(_odb, &id) == 1);
diff --git a/tests/libgit2/odb/packed256.c b/tests/libgit2/odb/packed256.c
index 65220fd4c8b..c6ca56ae354 100644
--- a/tests/libgit2/odb/packed256.c
+++ b/tests/libgit2/odb/packed256.c
@@ -13,7 +13,7 @@ void test_odb_packed256__initialize(void)
opts.oid_type = GIT_OID_SHA256;
- cl_git_pass(git_odb__open(
+ cl_git_pass(git_odb_open_ext(
&_odb,
cl_fixture("testrepo_256.git/objects"),
&opts));
@@ -37,7 +37,7 @@ void test_odb_packed256__mass_read(void)
git_oid id;
git_odb_object *obj;
- cl_git_pass(git_oid__fromstr(&id, packed_objects_256[i], GIT_OID_SHA256));
+ cl_git_pass(git_oid_from_string(&id, packed_objects_256[i], GIT_OID_SHA256));
cl_assert(git_odb_exists(_odb, &id) == 1);
cl_git_pass(git_odb_read(&obj, _odb, &id));
@@ -57,7 +57,7 @@ void test_odb_packed256__read_header_0(void)
size_t len;
git_object_t type;
- cl_git_pass(git_oid__fromstr(&id, packed_objects_256[i], GIT_OID_SHA256));
+ cl_git_pass(git_oid_from_string(&id, packed_objects_256[i], GIT_OID_SHA256));
cl_git_pass(git_odb_read(&obj, _odb, &id));
cl_git_pass(git_odb_read_header(&len, &type, _odb, &id));
@@ -81,7 +81,7 @@ void test_odb_packed256__read_header_1(void)
size_t len;
git_object_t type;
- cl_git_pass(git_oid__fromstr(&id, loose_objects_256[i], GIT_OID_SHA256));
+ cl_git_pass(git_oid_from_string(&id, loose_objects_256[i], GIT_OID_SHA256));
cl_assert(git_odb_exists(_odb, &id) == 1);
diff --git a/tests/libgit2/odb/packedone.c b/tests/libgit2/odb/packedone.c
index 8637001ffa7..c564f57d4d4 100644
--- a/tests/libgit2/odb/packedone.c
+++ b/tests/libgit2/odb/packedone.c
@@ -10,7 +10,8 @@ void test_odb_packedone__initialize(void)
{
git_odb_backend *backend = NULL;
- cl_git_pass(git_odb__new(&_odb, NULL));
+ cl_git_pass(git_odb_new_ext(&_odb, NULL));
+
#ifdef GIT_EXPERIMENTAL_SHA256
cl_git_pass(git_odb_backend_one_pack(&backend,
cl_fixture("testrepo.git/objects/pack/pack-a81e489679b7d3418f9ab594bda8ceb37dd4c695.idx"),
@@ -36,7 +37,7 @@ void test_odb_packedone__mass_read(void)
git_oid id;
git_odb_object *obj;
- cl_git_pass(git_oid__fromstr(&id, packed_objects_one[i], GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, packed_objects_one[i], GIT_OID_SHA1));
cl_assert(git_odb_exists(_odb, &id) == 1);
cl_git_pass(git_odb_read(&obj, _odb, &id));
@@ -54,7 +55,7 @@ void test_odb_packedone__read_header_0(void)
size_t len;
git_object_t type;
- cl_git_pass(git_oid__fromstr(&id, packed_objects_one[i], GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, packed_objects_one[i], GIT_OID_SHA1));
cl_git_pass(git_odb_read(&obj, _odb, &id));
cl_git_pass(git_odb_read_header(&len, &type, _odb, &id));
diff --git a/tests/libgit2/odb/packedone256.c b/tests/libgit2/odb/packedone256.c
index fdeac42055f..4152145fb0e 100644
--- a/tests/libgit2/odb/packedone256.c
+++ b/tests/libgit2/odb/packedone256.c
@@ -18,7 +18,7 @@ void test_odb_packedone256__initialize(void)
odb_opts.oid_type = GIT_OID_SHA256;
backend_opts.oid_type = GIT_OID_SHA256;
- cl_git_pass(git_odb__new(&_odb, &odb_opts));
+ cl_git_pass(git_odb_new_ext(&_odb, &odb_opts));
cl_git_pass(git_odb_backend_one_pack(
&backend,
cl_fixture("testrepo_256.git/objects/pack/pack-e2f07f30db7e480ea84a0e64ee791b9b270067124b2609019b74f33f256f33fa.idx"),
@@ -44,7 +44,7 @@ void test_odb_packedone256__mass_read(void)
git_oid id;
git_odb_object *obj;
- cl_git_pass(git_oid__fromstr(&id, packed_objects_one256[i], GIT_OID_SHA256));
+ cl_git_pass(git_oid_from_string(&id, packed_objects_one256[i], GIT_OID_SHA256));
cl_assert(git_odb_exists(_odb, &id) == 1);
cl_git_pass(git_odb_read(&obj, _odb, &id));
@@ -64,7 +64,7 @@ void test_odb_packedone256__read_header_0(void)
size_t len;
git_object_t type;
- cl_git_pass(git_oid__fromstr(&id, packed_objects_one256[i], GIT_OID_SHA256));
+ cl_git_pass(git_oid_from_string(&id, packed_objects_one256[i], GIT_OID_SHA256));
cl_git_pass(git_odb_read(&obj, _odb, &id));
cl_git_pass(git_odb_read_header(&len, &type, _odb, &id));
diff --git a/tests/libgit2/odb/sorting.c b/tests/libgit2/odb/sorting.c
index ec4e3696ba1..95d471db5d4 100644
--- a/tests/libgit2/odb/sorting.c
+++ b/tests/libgit2/odb/sorting.c
@@ -7,6 +7,11 @@ typedef struct {
size_t position;
} fake_backend;
+static void odb_backend_free(git_odb_backend *odb)
+{
+ git__free(odb);
+}
+
static git_odb_backend *new_backend(size_t position)
{
fake_backend *b;
@@ -15,7 +20,7 @@ static git_odb_backend *new_backend(size_t position)
if (b == NULL)
return NULL;
- b->base.free = (void (*)(git_odb_backend *)) git__free;
+ b->base.free = odb_backend_free;
b->base.version = GIT_ODB_BACKEND_VERSION;
b->position = position;
return (git_odb_backend *)b;
@@ -37,7 +42,7 @@ static git_odb *_odb;
void test_odb_sorting__initialize(void)
{
- cl_git_pass(git_odb__new(&_odb, NULL));
+ cl_git_pass(git_odb_new(&_odb));
}
void test_odb_sorting__cleanup(void)
@@ -89,7 +94,7 @@ void test_odb_sorting__override_default_backend_priority(void)
);
git_odb__backend_loose(&loose, "./testrepo.git/objects", NULL);
- cl_git_pass(git_odb__open(&new_odb, cl_fixture("testrepo.git/objects"), NULL));
+ cl_git_pass(git_odb_open(&new_odb, cl_fixture("testrepo.git/objects")));
cl_assert_equal_sz(2, git_odb_num_backends(new_odb));
cl_git_pass(git_odb_get_backend(&backend, new_odb, 0));
diff --git a/tests/libgit2/online/badssl.c b/tests/libgit2/online/badssl.c
index 6735e9cdb31..7169d59f2e6 100644
--- a/tests/libgit2/online/badssl.c
+++ b/tests/libgit2/online/badssl.c
@@ -73,3 +73,11 @@ void test_online_badssl__old_cipher(void)
cl_git_fail(git_clone(&g_repo, "https://rc4.badssl.com/fake.git", "./fake", NULL));
cl_git_fail(git_clone(&g_repo, "https://rc4.badssl.com/fake.git", "./fake", &opts));
}
+
+void test_online_badssl__sslv3(void)
+{
+ if (!g_has_ssl)
+ cl_skip();
+
+ cl_git_fail(git_clone(&g_repo, "https://mailserv.baehal.com/fake.git", "./fake", NULL));
+}
diff --git a/tests/libgit2/online/clone.c b/tests/libgit2/online/clone.c
index 1a4cdb520ce..5c283ec4d01 100644
--- a/tests/libgit2/online/clone.c
+++ b/tests/libgit2/online/clone.c
@@ -7,6 +7,7 @@
#include "refs.h"
#define LIVE_REPO_URL "http://github.com/libgit2/TestGitRepository"
+#define LIVE_REPO_AS_DIR "http:/github.com/libgit2/TestGitRepository"
#define LIVE_EMPTYREPO_URL "http://github.com/libgit2/TestEmptyRepository"
#define BB_REPO_URL "https://libgit2-test@bitbucket.org/libgit2-test/testgitrepository.git"
#define BB_REPO_URL_WITH_PASS "https://libgit2-test:YT77Ppm2nq8w4TYjGS8U@bitbucket.org/libgit2-test/testgitrepository.git"
@@ -35,17 +36,21 @@ static char *_remote_proxy_selfsigned = NULL;
static char *_remote_expectcontinue = NULL;
static char *_remote_redirect_initial = NULL;
static char *_remote_redirect_subsequent = NULL;
+static char *_remote_speed_timesout = NULL;
+static char *_remote_speed_slow = NULL;
static char *_github_ssh_pubkey = NULL;
static char *_github_ssh_privkey = NULL;
static char *_github_ssh_passphrase = NULL;
static char *_github_ssh_remotehostkey = NULL;
-static int _orig_proxies_need_reset = 0;
static char *_orig_http_proxy = NULL;
static char *_orig_https_proxy = NULL;
static char *_orig_no_proxy = NULL;
+static char *_ssh_cmd = NULL;
+static char *_orig_ssh_cmd = NULL;
+
static int ssl_cert(git_cert *cert, int valid, const char *host, void *payload)
{
GIT_UNUSED(cert);
@@ -68,7 +73,6 @@ void test_online_clone__initialize(void)
memset(&g_options, 0, sizeof(git_clone_options));
g_options.version = GIT_CLONE_OPTIONS_VERSION;
g_options.checkout_opts = dummy_opts;
- g_options.checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE;
g_options.fetch_opts = dummy_fetch;
g_options.fetch_opts.callbacks.certificate_check = ssl_cert;
@@ -89,16 +93,38 @@ void test_online_clone__initialize(void)
_remote_expectcontinue = cl_getenv("GITTEST_REMOTE_EXPECTCONTINUE");
_remote_redirect_initial = cl_getenv("GITTEST_REMOTE_REDIRECT_INITIAL");
_remote_redirect_subsequent = cl_getenv("GITTEST_REMOTE_REDIRECT_SUBSEQUENT");
+ _remote_speed_timesout = cl_getenv("GITTEST_REMOTE_SPEED_TIMESOUT");
+ _remote_speed_slow = cl_getenv("GITTEST_REMOTE_SPEED_SLOW");
_github_ssh_pubkey = cl_getenv("GITTEST_GITHUB_SSH_PUBKEY");
_github_ssh_privkey = cl_getenv("GITTEST_GITHUB_SSH_KEY");
_github_ssh_passphrase = cl_getenv("GITTEST_GITHUB_SSH_PASSPHRASE");
_github_ssh_remotehostkey = cl_getenv("GITTEST_GITHUB_SSH_REMOTE_HOSTKEY");
+ _orig_http_proxy = cl_getenv("HTTP_PROXY");
+ _orig_https_proxy = cl_getenv("HTTPS_PROXY");
+ _orig_no_proxy = cl_getenv("NO_PROXY");
+
+ _orig_ssh_cmd = cl_getenv("GIT_SSH");
+ _ssh_cmd = cl_getenv("GITTEST_SSH_CMD");
+
+ if (_ssh_cmd)
+ cl_setenv("GIT_SSH", _ssh_cmd);
+ else
+ cl_setenv("GIT_SSH", NULL);
+
if (_remote_expectcontinue)
git_libgit2_opts(GIT_OPT_ENABLE_HTTP_EXPECT_CONTINUE, 1);
- _orig_proxies_need_reset = 0;
+#if !defined(GIT_WIN32)
+ /*
+ * On system that allows ':' in filenames "http://path" can be misinterpreted
+ * as the local path "http:/path".
+ * Create a local non-repository path that looks like LIVE_REPO_URL to make
+ * sure we can handle cloning despite this directory being around.
+ */
+ git_futils_mkdir_r(LIVE_REPO_AS_DIR, 0777);
+#endif
}
void test_online_clone__cleanup(void)
@@ -111,6 +137,10 @@ void test_online_clone__cleanup(void)
cl_fixture_cleanup("./initial");
cl_fixture_cleanup("./subsequent");
+#if !defined(GIT_WIN32)
+ cl_fixture_cleanup("http:");
+#endif
+
git__free(_remote_url);
git__free(_remote_user);
git__free(_remote_pass);
@@ -128,23 +158,30 @@ void test_online_clone__cleanup(void)
git__free(_remote_expectcontinue);
git__free(_remote_redirect_initial);
git__free(_remote_redirect_subsequent);
+ git__free(_remote_speed_timesout);
+ git__free(_remote_speed_slow);
git__free(_github_ssh_pubkey);
git__free(_github_ssh_privkey);
git__free(_github_ssh_passphrase);
git__free(_github_ssh_remotehostkey);
- if (_orig_proxies_need_reset) {
- cl_setenv("HTTP_PROXY", _orig_http_proxy);
- cl_setenv("HTTPS_PROXY", _orig_https_proxy);
- cl_setenv("NO_PROXY", _orig_no_proxy);
+ cl_setenv("HTTP_PROXY", _orig_http_proxy);
+ cl_setenv("HTTPS_PROXY", _orig_https_proxy);
+ cl_setenv("NO_PROXY", _orig_no_proxy);
- git__free(_orig_http_proxy);
- git__free(_orig_https_proxy);
- git__free(_orig_no_proxy);
- }
+ git__free(_orig_http_proxy);
+ git__free(_orig_https_proxy);
+ git__free(_orig_no_proxy);
+
+ cl_setenv("GIT_SSH", _orig_ssh_cmd);
+ git__free(_orig_ssh_cmd);
+
+ git__free(_ssh_cmd);
git_libgit2_opts(GIT_OPT_SET_SSL_CERT_LOCATIONS, NULL, NULL);
+ git_libgit2_opts(GIT_OPT_SET_SERVER_TIMEOUT, 0);
+ git_libgit2_opts(GIT_OPT_SET_SERVER_CONNECT_TIMEOUT, 0);
}
void test_online_clone__network_full(void)
@@ -211,7 +248,6 @@ void test_online_clone__can_checkout_a_cloned_repo(void)
bool checkout_progress_cb_was_called = false,
fetch_progress_cb_was_called = false;
- g_options.checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE;
g_options.checkout_opts.progress_cb = &checkout_progress;
g_options.checkout_opts.progress_payload = &checkout_progress_cb_was_called;
g_options.fetch_opts.callbacks.transfer_progress = &fetch_progress;
@@ -281,10 +317,10 @@ void test_online_clone__clone_mirror(void)
cl_fixture_cleanup("./foo.git");
}
-static int update_tips(const char *refname, const git_oid *a, const git_oid *b, void *payload)
+static int update_refs(const char *refname, const git_oid *a, const git_oid *b, git_refspec *spec, void *payload)
{
int *callcount = (int*)payload;
- GIT_UNUSED(refname); GIT_UNUSED(a); GIT_UNUSED(b);
+ GIT_UNUSED(refname); GIT_UNUSED(a); GIT_UNUSED(b); GIT_UNUSED(spec);
*callcount = *callcount + 1;
return 0;
}
@@ -293,7 +329,7 @@ void test_online_clone__custom_remote_callbacks(void)
{
int callcount = 0;
- g_options.fetch_opts.callbacks.update_tips = update_tips;
+ g_options.fetch_opts.callbacks.update_refs = update_refs;
g_options.fetch_opts.callbacks.payload = &callcount;
cl_git_pass(git_clone(&g_repo, LIVE_REPO_URL, "./foo", &g_options));
@@ -580,6 +616,17 @@ static int succeed_certificate_check(git_cert *cert, int valid, const char *host
return 0;
}
+static int x509_succeed_certificate_check(git_cert *cert, int valid, const char *host, void *payload)
+{
+ GIT_UNUSED(valid);
+ GIT_UNUSED(payload);
+
+ cl_assert_equal_s("github.com", host);
+ cl_assert_equal_i(GIT_CERT_X509, cert->cert_type);
+
+ return 0;
+}
+
static int fail_certificate_check(git_cert *cert, int valid, const char *host, void *payload)
{
GIT_UNUSED(cert);
@@ -616,7 +663,7 @@ static int github_credentials(
void test_online_clone__ssh_github(void)
{
-#if !defined(GIT_SSH) || !defined(GIT_SSH_MEMORY_CREDENTIALS)
+#if !defined(GIT_SSH) || !defined(GIT_SSH_LIBSSH2_MEMORY_CREDENTIALS)
clar__skip();
#endif
@@ -631,11 +678,29 @@ void test_online_clone__ssh_github(void)
cl_git_pass(git_clone(&g_repo, SSH_REPO_URL, "./foo", &g_options));
}
+void test_online_clone__ssh_github_shallow(void)
+{
+#if !defined(GIT_SSH) || !defined(GIT_SSH_LIBSSH2_MEMORY_CREDENTIALS)
+ clar__skip();
+#endif
+
+ if (!_github_ssh_pubkey || !_github_ssh_privkey)
+ clar__skip();
+
+ cl_fake_homedir(NULL);
+
+ g_options.fetch_opts.callbacks.credentials = github_credentials;
+ g_options.fetch_opts.callbacks.certificate_check = succeed_certificate_check;
+ g_options.fetch_opts.depth = 1;
+
+ cl_git_pass(git_clone(&g_repo, SSH_REPO_URL, "./foo", &g_options));
+}
+
void test_online_clone__ssh_auth_methods(void)
{
int with_user;
-#ifndef GIT_SSH
+#ifndef GIT_SSH_LIBSSH2
clar__skip();
#endif
g_options.fetch_opts.callbacks.credentials = check_ssh_auth_methods;
@@ -657,7 +722,7 @@ void test_online_clone__ssh_auth_methods(void)
*/
void test_online_clone__ssh_certcheck_accepts_unknown(void)
{
-#if !defined(GIT_SSH) || !defined(GIT_SSH_MEMORY_CREDENTIALS)
+#if !defined(GIT_SSH_LIBSSH2) || !defined(GIT_SSH_LIBSSH2_MEMORY_CREDENTIALS)
clar__skip();
#endif
@@ -686,7 +751,7 @@ void test_online_clone__ssh_certcheck_override_knownhosts(void)
{
git_str knownhostsfile = GIT_STR_INIT;
-#if !defined(GIT_SSH) || !defined(GIT_SSH_MEMORY_CREDENTIALS)
+#if !defined(GIT_SSH) || !defined(GIT_SSH_LIBSSH2_MEMORY_CREDENTIALS)
clar__skip();
#endif
@@ -775,9 +840,10 @@ static int cred_foo_bar(git_credential **cred, const char *url, const char *user
void test_online_clone__ssh_cannot_change_username(void)
{
-#ifndef GIT_SSH
+#ifndef GIT_SSH_LIBSSH2
clar__skip();
#endif
+
g_options.fetch_opts.callbacks.credentials = cred_foo_bar;
cl_git_fail(git_clone(&g_repo, "ssh://git@github.com/libgit2/TestGitRepository", "./foo", &g_options));
@@ -793,7 +859,7 @@ static int ssh_certificate_check(git_cert *cert, int valid, const char *host, vo
cl_assert(_remote_ssh_fingerprint);
- cl_git_pass(git_oid__fromstrp(&expected, _remote_ssh_fingerprint, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&expected, _remote_ssh_fingerprint, strlen(_remote_ssh_fingerprint), GIT_OID_SHA1));
cl_assert_equal_i(GIT_CERT_HOSTKEY_LIBSSH2, cert->cert_type);
key = (git_cert_hostkey *) cert;
@@ -819,6 +885,10 @@ static int ssh_certificate_check(git_cert *cert, int valid, const char *host, vo
void test_online_clone__ssh_cert(void)
{
+#ifndef GIT_SSH_LIBSSH2
+ cl_skip();
+#endif
+
g_options.fetch_opts.callbacks.certificate_check = ssh_certificate_check;
if (!_remote_ssh_fingerprint)
@@ -875,7 +945,7 @@ static int ssh_memory_cred_cb(git_credential **cred, const char *url, const char
void test_online_clone__ssh_memory_auth(void)
{
-#ifndef GIT_SSH_MEMORY_CREDENTIALS
+#ifndef GIT_SSH_LIBSSH2_MEMORY_CREDENTIALS
clar__skip();
#endif
if (!_remote_url || !_remote_user || !_remote_ssh_privkey || strncmp(_remote_url, "ssh://", 5) != 0)
@@ -890,18 +960,18 @@ void test_online_clone__certificate_invalid(void)
{
g_options.fetch_opts.callbacks.certificate_check = fail_certificate_check;
- cl_git_fail_with(git_clone(&g_repo, "https://github.com/libgit2/TestGitRepository", "./foo", &g_options),
- GIT_ECERTIFICATE);
+ cl_git_fail_with(GIT_ECERTIFICATE,
+ git_clone(&g_repo, "https://github.com/libgit2/TestGitRepository", "./foo", &g_options));
-#ifdef GIT_SSH
- cl_git_fail_with(git_clone(&g_repo, "ssh://github.com/libgit2/TestGitRepository", "./foo", &g_options),
- GIT_ECERTIFICATE);
+#ifdef GIT_SSH_LIBSSH2
+ cl_git_fail_with(GIT_ECERTIFICATE,
+ git_clone(&g_repo, "ssh://github.com/libgit2/TestGitRepository", "./foo", &g_options));
#endif
}
void test_online_clone__certificate_valid(void)
{
- g_options.fetch_opts.callbacks.certificate_check = succeed_certificate_check;
+ g_options.fetch_opts.callbacks.certificate_check = x509_succeed_certificate_check;
cl_git_pass(git_clone(&g_repo, "https://github.com/libgit2/TestGitRepository", "./foo", &g_options));
}
@@ -949,6 +1019,92 @@ static int proxy_cert_cb(git_cert *cert, int valid, const char *host, void *payl
return valid ? 0 : GIT_ECERTIFICATE;
}
+void test_online_clone__proxy_http_host_port_in_opts(void)
+{
+ if (!_remote_proxy_host || !_remote_proxy_user || !_remote_proxy_pass)
+ cl_skip();
+
+ if (_remote_proxy_scheme && strcmp(_remote_proxy_scheme, "http") != 0)
+ cl_skip();
+
+ g_options.fetch_opts.proxy_opts.type = GIT_PROXY_SPECIFIED;
+ g_options.fetch_opts.proxy_opts.url = _remote_proxy_host;
+ g_options.fetch_opts.proxy_opts.credentials = proxy_cred_cb;
+
+ called_proxy_creds = 0;
+ cl_git_pass(git_clone(&g_repo, "https://github.com/libgit2/TestGitRepository", "./foo", &g_options));
+ cl_assert(called_proxy_creds == 1);
+}
+
+void test_online_clone__proxy_http_host_port_in_env(void)
+{
+ if (!_remote_proxy_host || !_remote_proxy_user || !_remote_proxy_pass)
+ cl_skip();
+
+ if (_remote_proxy_scheme && strcmp(_remote_proxy_scheme, "http") != 0)
+ cl_skip();
+
+ cl_setenv("HTTP_PROXY", _remote_proxy_host);
+ cl_setenv("HTTPS_PROXY", _remote_proxy_host);
+ cl_setenv("NO_PROXY", NULL);
+
+ g_options.fetch_opts.proxy_opts.type = GIT_PROXY_AUTO;
+ g_options.fetch_opts.proxy_opts.credentials = proxy_cred_cb;
+
+ called_proxy_creds = 0;
+ cl_git_pass(git_clone(&g_repo, "https://github.com/libgit2/TestGitRepository", "./foo", &g_options));
+ cl_assert(called_proxy_creds == 1);
+}
+
+static int repository_create_with_proxy(
+ git_repository **out,
+ const char *path,
+ int bare,
+ void *payload)
+{
+ git_repository *repo;
+ git_config *config;
+ char *value = (char *)payload;
+
+ cl_git_pass(git_repository_init(&repo, path, bare));
+ cl_git_pass(git_repository_config(&config, repo));
+
+ cl_git_pass(git_config_set_string(config, "http.proxy", value));
+
+ git_config_free(config);
+
+ *out = repo;
+ return 0;
+}
+
+void test_online_clone__proxy_http_host_port_in_config(void)
+{
+ if (!_remote_proxy_host || !_remote_proxy_user || !_remote_proxy_pass)
+ cl_skip();
+
+ g_options.fetch_opts.proxy_opts.type = GIT_PROXY_AUTO;
+ g_options.fetch_opts.proxy_opts.credentials = proxy_cred_cb;
+ g_options.repository_cb = repository_create_with_proxy;
+ g_options.repository_cb_payload = _remote_proxy_host;
+
+ called_proxy_creds = 0;
+ cl_git_pass(git_clone(&g_repo, "https://github.com/libgit2/TestGitRepository", "./foo", &g_options));
+ cl_assert(called_proxy_creds == 1);
+}
+
+void test_online_clone__proxy_invalid_url(void)
+{
+ g_options.fetch_opts.proxy_opts.type = GIT_PROXY_SPECIFIED;
+ g_options.fetch_opts.proxy_opts.credentials = proxy_cred_cb;
+ g_options.fetch_opts.proxy_opts.certificate_check = proxy_cert_cb;
+
+ g_options.fetch_opts.proxy_opts.url = "noschemeorport";
+ cl_git_fail(git_clone(&g_repo, "http://github.com/libgit2/TestGitRepository", "./foo", &g_options));
+
+ g_options.fetch_opts.proxy_opts.url = "noscheme:8080";
+ cl_git_fail(git_clone(&g_repo, "http://github.com/libgit2/TestGitRepository", "./foo", &g_options));
+}
+
void test_online_clone__proxy_credentials_request(void)
{
git_str url = GIT_STR_INIT;
@@ -971,7 +1127,7 @@ void test_online_clone__proxy_credentials_request(void)
git_str_dispose(&url);
}
-void test_online_clone__proxy_credentials_in_url(void)
+void test_online_clone__proxy_credentials_in_well_formed_url(void)
{
git_str url = GIT_STR_INIT;
@@ -992,17 +1148,35 @@ void test_online_clone__proxy_credentials_in_url(void)
git_str_dispose(&url);
}
-void test_online_clone__proxy_credentials_in_environment(void)
+void test_online_clone__proxy_credentials_in_host_port_format(void)
{
git_str url = GIT_STR_INIT;
if (!_remote_proxy_host || !_remote_proxy_user || !_remote_proxy_pass)
cl_skip();
- _orig_http_proxy = cl_getenv("HTTP_PROXY");
- _orig_https_proxy = cl_getenv("HTTPS_PROXY");
- _orig_no_proxy = cl_getenv("NO_PROXY");
- _orig_proxies_need_reset = 1;
+ if (_remote_proxy_scheme && strcmp(_remote_proxy_scheme, "http") != 0)
+ cl_skip();
+
+ cl_git_pass(git_str_printf(&url, "%s:%s@%s",
+ _remote_proxy_user, _remote_proxy_pass, _remote_proxy_host));
+
+ g_options.fetch_opts.proxy_opts.type = GIT_PROXY_SPECIFIED;
+ g_options.fetch_opts.proxy_opts.url = url.ptr;
+ g_options.fetch_opts.proxy_opts.certificate_check = proxy_cert_cb;
+ called_proxy_creds = 0;
+ cl_git_pass(git_clone(&g_repo, "http://github.com/libgit2/TestGitRepository", "./foo", &g_options));
+ cl_assert(called_proxy_creds == 0);
+
+ git_str_dispose(&url);
+}
+
+void test_online_clone__proxy_credentials_in_environment(void)
+{
+ git_str url = GIT_STR_INIT;
+
+ if (!_remote_proxy_host || !_remote_proxy_user || !_remote_proxy_pass)
+ cl_skip();
g_options.fetch_opts.proxy_opts.type = GIT_PROXY_AUTO;
g_options.fetch_opts.proxy_opts.certificate_check = proxy_cert_cb;
@@ -1196,3 +1370,71 @@ void test_online_clone__sha256(void)
git_reference_free(head);
#endif
}
+
+void test_online_clone__connect_timeout_configurable(void)
+{
+#ifdef GIT_HTTPS_WINHTTP
+ cl_skip();
+#else
+ uint64_t start, finish;
+
+ start = git_time_monotonic();
+
+ cl_git_pass(git_libgit2_opts(GIT_OPT_SET_SERVER_CONNECT_TIMEOUT, 1));
+ cl_git_fail(git_clone(&g_repo, "http://www.google.com:8000/", "./timedout", NULL));
+ cl_assert(git_error_last() && strstr(git_error_last()->message, "timed out"));
+
+ finish = git_time_monotonic();
+
+ cl_assert(finish - start < 1000);
+#endif
+}
+
+void test_online_clone__connect_timeout_default(void)
+{
+#ifdef GIT_HTTPS_WINHTTP
+ cl_skip();
+#else
+ /* This test takes ~ 75 seconds on Unix. */
+ if (!cl_is_env_set("GITTEST_INVASIVE_SPEED"))
+ cl_skip();
+
+ /*
+ * Use a host/port pair that blackholes packets and does not
+ * send an RST.
+ */
+ cl_git_fail_with(GIT_TIMEOUT, git_clone(&g_repo, "http://www.google.com:8000/", "./refused", NULL));
+ cl_assert(git_error_last() && strstr(git_error_last()->message, "timed out"));
+#endif
+}
+
+void test_online_clone__timeout_configurable_times_out(void)
+{
+#ifdef GIT_HTTPS_WINHTTP
+ cl_skip();
+#else
+ git_repository *failed_repo;
+
+ if (!_remote_speed_timesout)
+ cl_skip();
+
+ cl_git_pass(git_libgit2_opts(GIT_OPT_SET_SERVER_TIMEOUT, 1000));
+
+ cl_git_fail_with(GIT_TIMEOUT, git_clone(&failed_repo, _remote_speed_timesout, "./timedout", NULL));
+ cl_assert(git_error_last() && strstr(git_error_last()->message, "timed out"));
+#endif
+}
+
+void test_online_clone__timeout_configurable_succeeds_slowly(void)
+{
+#ifdef GIT_HTTPS_WINHTTP
+ cl_skip();
+#else
+ if (!_remote_speed_slow)
+ cl_skip();
+
+ cl_git_pass(git_libgit2_opts(GIT_OPT_SET_SERVER_TIMEOUT, 1000));
+
+ cl_git_pass(git_clone(&g_repo, _remote_speed_slow, "./slow-but-successful", NULL));
+#endif
+}
diff --git a/tests/libgit2/online/customcert.c b/tests/libgit2/online/customcert.c
index 7932a9e68f3..ef05bb4ea15 100644
--- a/tests/libgit2/online/customcert.c
+++ b/tests/libgit2/online/customcert.c
@@ -1,3 +1,4 @@
+#include "clar.h"
#include "clar_libgit2.h"
#include "path.h"
@@ -6,65 +7,75 @@
#include "remote.h"
#include "futils.h"
#include "refs.h"
+#include "str.h"
+#include "streams/openssl.h"
+
+#ifdef GIT_HTTPS_OPENSSL
+# include <openssl/ssl.h>
+# include <openssl/err.h>
+# include <openssl/x509v3.h>
+#endif
/*
- * Certificate one is in the `certs` folder; certificate two is in the
- * `self-signed.pem` file.
+ * Certificates for https://test.libgit2.org/ are in the `certs` folder.
*/
+#define CUSTOM_CERT_DIR "certs"
+
#define CUSTOM_CERT_ONE_URL "https://test.libgit2.org:1443/anonymous/test.git"
-#define CUSTOM_CERT_ONE_PATH "certs"
+#define CUSTOM_CERT_ONE_PATH "one"
#define CUSTOM_CERT_TWO_URL "https://test.libgit2.org:2443/anonymous/test.git"
-#define CUSTOM_CERT_TWO_FILE "self-signed.pem"
+#define CUSTOM_CERT_TWO_FILE "two.pem"
-#if (GIT_OPENSSL || GIT_MBEDTLS)
+#define CUSTOM_CERT_THREE_URL "https://test.libgit2.org:3443/anonymous/test.git"
+#define CUSTOM_CERT_THREE_FILE "three.pem.raw"
+
+#if (GIT_HTTPS_OPENSSL || GIT_HTTPS_OPENSSL_DYNAMIC || GIT_HTTPS_MBEDTLS)
static git_repository *g_repo;
-static int initialized = false;
#endif
void test_online_customcert__initialize(void)
{
-#if (GIT_OPENSSL || GIT_MBEDTLS)
- g_repo = NULL;
+#if (GIT_HTTPS_OPENSSL || GIT_HTTPS_OPENSSL_DYNAMIC || GIT_HTTPS_MBEDTLS)
+ git_str path = GIT_STR_INIT, file = GIT_STR_INIT;
+ char cwd[GIT_PATH_MAX];
- if (!initialized) {
- git_str path = GIT_STR_INIT, file = GIT_STR_INIT;
- char cwd[GIT_PATH_MAX];
+ g_repo = NULL;
- cl_fixture_sandbox(CUSTOM_CERT_ONE_PATH);
- cl_fixture_sandbox(CUSTOM_CERT_TWO_FILE);
+ cl_fixture_sandbox(CUSTOM_CERT_DIR);
- cl_must_pass(p_getcwd(cwd, GIT_PATH_MAX));
- cl_git_pass(git_str_joinpath(&path, cwd, CUSTOM_CERT_ONE_PATH));
- cl_git_pass(git_str_joinpath(&file, cwd, CUSTOM_CERT_TWO_FILE));
+ cl_must_pass(p_getcwd(cwd, GIT_PATH_MAX));
+ cl_git_pass(git_str_join_n(&path, '/', 3, cwd, CUSTOM_CERT_DIR, CUSTOM_CERT_ONE_PATH));
+ cl_git_pass(git_str_join_n(&file, '/', 3, cwd, CUSTOM_CERT_DIR, CUSTOM_CERT_TWO_FILE));
- cl_git_pass(git_libgit2_opts(GIT_OPT_SET_SSL_CERT_LOCATIONS,
- file.ptr, path.ptr));
- initialized = true;
+ cl_git_pass(git_libgit2_opts(GIT_OPT_SET_SSL_CERT_LOCATIONS,
+ file.ptr, path.ptr));
- git_str_dispose(&file);
- git_str_dispose(&path);
- }
+ git_str_dispose(&file);
+ git_str_dispose(&path);
#endif
}
void test_online_customcert__cleanup(void)
{
-#if (GIT_OPENSSL || GIT_MBEDTLS)
+#if (GIT_HTTPS_OPENSSL || GIT_HTTPS_OPENSSL_DYNAMIC || GIT_HTTPS_MBEDTLS)
if (g_repo) {
git_repository_free(g_repo);
g_repo = NULL;
}
cl_fixture_cleanup("./cloned");
- cl_fixture_cleanup(CUSTOM_CERT_ONE_PATH);
- cl_fixture_cleanup(CUSTOM_CERT_TWO_FILE);
+ cl_fixture_cleanup(CUSTOM_CERT_DIR);
+#endif
+
+#if (GIT_HTTPS_OPENSSL || GIT_HTTPS_OPENSSL_DYNAMIC)
+ git_openssl__reset_context();
#endif
}
void test_online_customcert__file(void)
{
-#if (GIT_OPENSSL || GIT_MBEDTLS)
+#if (GIT_HTTPS_OPENSSL || GIT_HTTPS_OPENSSL_DYNAMIC || GIT_HTTPS_MBEDTLS)
cl_git_pass(git_clone(&g_repo, CUSTOM_CERT_ONE_URL, "./cloned", NULL));
cl_assert(git_fs_path_exists("./cloned/master.txt"));
#endif
@@ -72,8 +83,39 @@ void test_online_customcert__file(void)
void test_online_customcert__path(void)
{
-#if (GIT_OPENSSL || GIT_MBEDTLS)
+#if (GIT_HTTPS_OPENSSL || GIT_HTTPS_OPENSSL_DYNAMIC || GIT_HTTPS_MBEDTLS)
cl_git_pass(git_clone(&g_repo, CUSTOM_CERT_TWO_URL, "./cloned", NULL));
cl_assert(git_fs_path_exists("./cloned/master.txt"));
#endif
}
+
+void test_online_customcert__raw_x509(void)
+{
+#if GIT_HTTPS_OPENSSL
+ X509* x509_cert = NULL;
+ char cwd[GIT_PATH_MAX];
+ git_str raw_file = GIT_STR_INIT,
+ raw_file_data = GIT_STR_INIT,
+ raw_cert = GIT_STR_INIT;
+ const unsigned char *raw_cert_bytes = NULL;
+
+ cl_must_pass(p_getcwd(cwd, GIT_PATH_MAX));
+
+ cl_git_pass(git_str_join_n(&raw_file, '/', 3, cwd, CUSTOM_CERT_DIR, CUSTOM_CERT_THREE_FILE));
+
+ cl_git_pass(git_futils_readbuffer(&raw_file_data, git_str_cstr(&raw_file)));
+ cl_git_pass(git_str_decode_base64(&raw_cert, git_str_cstr(&raw_file_data), git_str_len(&raw_file_data)));
+
+ raw_cert_bytes = (const unsigned char *)git_str_cstr(&raw_cert);
+ x509_cert = d2i_X509(NULL, &raw_cert_bytes, git_str_len(&raw_cert));
+ cl_git_pass(git_libgit2_opts(GIT_OPT_ADD_SSL_X509_CERT, x509_cert));
+ X509_free(x509_cert);
+
+ cl_git_pass(git_clone(&g_repo, CUSTOM_CERT_THREE_URL, "./cloned", NULL));
+ cl_assert(git_fs_path_exists("./cloned/master.txt"));
+
+ git_str_dispose(&raw_cert);
+ git_str_dispose(&raw_file_data);
+ git_str_dispose(&raw_file);
+#endif
+}
diff --git a/tests/libgit2/online/fetch.c b/tests/libgit2/online/fetch.c
index a557bbf7506..9c2d3d75ad0 100644
--- a/tests/libgit2/online/fetch.c
+++ b/tests/libgit2/online/fetch.c
@@ -39,9 +39,13 @@ void test_online_fetch__cleanup(void)
git__free(_remote_redirect_subsequent);
}
-static int update_tips(const char *refname, const git_oid *a, const git_oid *b, void *data)
+static int update_refs(const char *refname, const git_oid *a, const git_oid *b, git_refspec *spec, void *data)
{
- GIT_UNUSED(refname); GIT_UNUSED(a); GIT_UNUSED(b); GIT_UNUSED(data);
+ GIT_UNUSED(refname);
+ GIT_UNUSED(a);
+ GIT_UNUSED(b);
+ GIT_UNUSED(spec);
+ GIT_UNUSED(data);
++counter;
@@ -62,7 +66,7 @@ static void do_fetch(const char *url, git_remote_autotag_option_t flag, int n)
size_t bytes_received = 0;
options.callbacks.transfer_progress = progress;
- options.callbacks.update_tips = update_tips;
+ options.callbacks.update_refs = update_refs;
options.callbacks.payload = &bytes_received;
options.download_tags = flag;
counter = 0;
@@ -110,6 +114,26 @@ void test_online_fetch__fetch_twice(void)
git_remote_free(remote);
}
+void test_online_fetch__fetch_with_empty_http_proxy(void)
+{
+ git_remote *remote;
+ git_config *config;
+ git_fetch_options opts = GIT_FETCH_OPTIONS_INIT;
+
+ opts.proxy_opts.type = GIT_PROXY_AUTO;
+
+ cl_git_pass(git_repository_config(&config, _repo));
+ cl_git_pass(git_config_set_string(config, "http.proxy", ""));
+
+ cl_git_pass(git_remote_create(&remote, _repo, "test",
+ "https://github.com/libgit2/TestGitRepository"));
+ cl_git_pass(git_remote_fetch(remote, NULL, &opts, NULL));
+
+ git_remote_disconnect(remote);
+ git_remote_free(remote);
+ git_config_free(config);
+}
+
static int transferProgressCallback(const git_indexer_progress *stats, void *payload)
{
bool *invoked = (bool *)payload;
@@ -128,6 +152,8 @@ void test_online_fetch__doesnt_retrieve_a_pack_when_the_repository_is_up_to_date
git_clone_options opts = GIT_CLONE_OPTIONS_INIT;
opts.bare = true;
+ counter = 0;
+
cl_git_pass(git_clone(&_repository, "https://github.com/libgit2/TestGitRepository.git",
"./fetch/lg2", &opts));
git_repository_free(_repository);
@@ -141,11 +167,52 @@ void test_online_fetch__doesnt_retrieve_a_pack_when_the_repository_is_up_to_date
options.callbacks.transfer_progress = &transferProgressCallback;
options.callbacks.payload = &invoked;
+ options.callbacks.update_refs = update_refs;
cl_git_pass(git_remote_download(remote, NULL, &options));
cl_assert_equal_i(false, invoked);
- cl_git_pass(git_remote_update_tips(remote, &options.callbacks, 1, options.download_tags, NULL));
+ cl_git_pass(git_remote_update_tips(remote, &options.callbacks, GIT_REMOTE_UPDATE_FETCHHEAD, options.download_tags, NULL));
+ cl_assert_equal_i(0, counter);
+
+ git_remote_disconnect(remote);
+
+ git_remote_free(remote);
+ git_repository_free(_repository);
+}
+
+void test_online_fetch__report_unchanged_tips(void)
+{
+ git_repository *_repository;
+ bool invoked = false;
+ git_remote *remote;
+ git_fetch_options options = GIT_FETCH_OPTIONS_INIT;
+ git_clone_options opts = GIT_CLONE_OPTIONS_INIT;
+ opts.bare = true;
+
+ counter = 0;
+
+ cl_git_pass(git_clone(&_repository, "https://github.com/libgit2/TestGitRepository.git",
+ "./fetch/lg2", &opts));
+ git_repository_free(_repository);
+
+ cl_git_pass(git_repository_open(&_repository, "./fetch/lg2"));
+
+ cl_git_pass(git_remote_lookup(&remote, _repository, "origin"));
+ cl_git_pass(git_remote_connect(remote, GIT_DIRECTION_FETCH, NULL, NULL, NULL));
+
+ cl_assert_equal_i(false, invoked);
+
+ options.callbacks.transfer_progress = &transferProgressCallback;
+ options.callbacks.payload = &invoked;
+ options.callbacks.update_refs = update_refs;
+ cl_git_pass(git_remote_download(remote, NULL, &options));
+
+ cl_assert_equal_i(false, invoked);
+
+ cl_git_pass(git_remote_update_tips(remote, &options.callbacks, GIT_REMOTE_UPDATE_REPORT_UNCHANGED, options.download_tags, NULL));
+ cl_assert(counter > 0);
+
git_remote_disconnect(remote);
git_remote_free(remote);
@@ -304,7 +371,7 @@ void test_online_fetch__reachable_commit(void)
refspecs.strings = &refspec;
refspecs.count = 1;
- git_oid__fromstr(&expected_id, "2c349335b7f797072cf729c4f3bb0914ecb6dec9", GIT_OID_SHA1);
+ git_oid_from_string(&expected_id, "2c349335b7f797072cf729c4f3bb0914ecb6dec9", GIT_OID_SHA1);
cl_git_pass(git_remote_create(&remote, _repo, "test",
"https://github.com/libgit2/TestGitRepository"));
@@ -334,7 +401,7 @@ void test_online_fetch__reachable_commit_without_destination(void)
refspecs.strings = &refspec;
refspecs.count = 1;
- git_oid__fromstr(&expected_id, "2c349335b7f797072cf729c4f3bb0914ecb6dec9", GIT_OID_SHA1);
+ git_oid_from_string(&expected_id, "2c349335b7f797072cf729c4f3bb0914ecb6dec9", GIT_OID_SHA1);
cl_git_pass(git_remote_create(&remote, _repo, "test",
"https://github.com/libgit2/TestGitRepository"));
diff --git a/tests/libgit2/online/fetchhead.c b/tests/libgit2/online/fetchhead.c
index 1b66c528e97..60a2b625d32 100644
--- a/tests/libgit2/online/fetchhead.c
+++ b/tests/libgit2/online/fetchhead.c
@@ -12,12 +12,9 @@ static git_clone_options g_options;
void test_online_fetchhead__initialize(void)
{
- git_fetch_options dummy_fetch = GIT_FETCH_OPTIONS_INIT;
g_repo = NULL;
- memset(&g_options, 0, sizeof(git_clone_options));
- g_options.version = GIT_CLONE_OPTIONS_VERSION;
- g_options.fetch_opts = dummy_fetch;
+ git_clone_options_init(&g_options, GIT_CLONE_OPTIONS_VERSION);
}
void test_online_fetchhead__cleanup(void)
diff --git a/tests/libgit2/online/push.c b/tests/libgit2/online/push.c
index 204572cf57b..969ecaff631 100644
--- a/tests/libgit2/online/push.c
+++ b/tests/libgit2/online/push.c
@@ -5,6 +5,7 @@
#include "push_util.h"
#include "refspec.h"
#include "remote.h"
+#include "futils.h"
static git_repository *_repo;
@@ -20,7 +21,12 @@ static char *_remote_ssh_passphrase = NULL;
static char *_remote_default = NULL;
static char *_remote_expectcontinue = NULL;
-static int cred_acquire_cb(git_credential **, const char *, const char *, unsigned int, void *);
+static char *_remote_push_options = NULL;
+
+static char *_orig_ssh_cmd = NULL;
+static char *_ssh_cmd = NULL;
+
+static int cred_acquire_cb(git_credential **, const char *, const char *, unsigned int, void *);
static git_remote *_remote;
static record_callbacks_data _record_cbs_data = {{ 0 }};
@@ -159,7 +165,7 @@ static void do_verify_push_status(record_callbacks_data *data, const push_status
git__free(s);
}
- git_vector_free(actual);
+ git_vector_dispose(actual);
}
/**
@@ -266,7 +272,7 @@ static void verify_tracking_branches(git_remote *remote, expected_ref expected_r
git_vector_foreach(&actual_refs, i, actual_ref)
git__free(actual_ref);
- git_vector_free(&actual_refs);
+ git_vector_dispose(&actual_refs);
git_str_dispose(&msg);
git_buf_dispose(&ref_name);
}
@@ -344,18 +350,18 @@ void test_online_push__initialize(void)
* * a78705c3b2725f931d3ee05348d83cc26700f247 (b2, b1) added fold and fold/b.txt
* * 5c0bb3d1b9449d1cc69d7519fd05166f01840915 added a.txt
*/
- git_oid__fromstr(&_oid_b6, "951bbbb90e2259a4c8950db78946784fb53fcbce", GIT_OID_SHA1);
- git_oid__fromstr(&_oid_b5, "fa38b91f199934685819bea316186d8b008c52a2", GIT_OID_SHA1);
- git_oid__fromstr(&_oid_b4, "27b7ce66243eb1403862d05f958c002312df173d", GIT_OID_SHA1);
- git_oid__fromstr(&_oid_b3, "d9b63a88223d8367516f50bd131a5f7349b7f3e4", GIT_OID_SHA1);
- git_oid__fromstr(&_oid_b2, "a78705c3b2725f931d3ee05348d83cc26700f247", GIT_OID_SHA1);
- git_oid__fromstr(&_oid_b1, "a78705c3b2725f931d3ee05348d83cc26700f247", GIT_OID_SHA1);
-
- git_oid__fromstr(&_tag_commit, "805c54522e614f29f70d2413a0470247d8b424ac", GIT_OID_SHA1);
- git_oid__fromstr(&_tag_tree, "ff83aa4c5e5d28e3bcba2f5c6e2adc61286a4e5e", GIT_OID_SHA1);
- git_oid__fromstr(&_tag_blob, "b483ae7ba66decee9aee971f501221dea84b1498", GIT_OID_SHA1);
- git_oid__fromstr(&_tag_lightweight, "951bbbb90e2259a4c8950db78946784fb53fcbce", GIT_OID_SHA1);
- git_oid__fromstr(&_tag_tag, "eea4f2705eeec2db3813f2430829afce99cd00b5", GIT_OID_SHA1);
+ git_oid_from_string(&_oid_b6, "951bbbb90e2259a4c8950db78946784fb53fcbce", GIT_OID_SHA1);
+ git_oid_from_string(&_oid_b5, "fa38b91f199934685819bea316186d8b008c52a2", GIT_OID_SHA1);
+ git_oid_from_string(&_oid_b4, "27b7ce66243eb1403862d05f958c002312df173d", GIT_OID_SHA1);
+ git_oid_from_string(&_oid_b3, "d9b63a88223d8367516f50bd131a5f7349b7f3e4", GIT_OID_SHA1);
+ git_oid_from_string(&_oid_b2, "a78705c3b2725f931d3ee05348d83cc26700f247", GIT_OID_SHA1);
+ git_oid_from_string(&_oid_b1, "a78705c3b2725f931d3ee05348d83cc26700f247", GIT_OID_SHA1);
+
+ git_oid_from_string(&_tag_commit, "805c54522e614f29f70d2413a0470247d8b424ac", GIT_OID_SHA1);
+ git_oid_from_string(&_tag_tree, "ff83aa4c5e5d28e3bcba2f5c6e2adc61286a4e5e", GIT_OID_SHA1);
+ git_oid_from_string(&_tag_blob, "b483ae7ba66decee9aee971f501221dea84b1498", GIT_OID_SHA1);
+ git_oid_from_string(&_tag_lightweight, "951bbbb90e2259a4c8950db78946784fb53fcbce", GIT_OID_SHA1);
+ git_oid_from_string(&_tag_tag, "eea4f2705eeec2db3813f2430829afce99cd00b5", GIT_OID_SHA1);
/* Remote URL environment variable must be set. User and password are optional. */
@@ -367,8 +373,17 @@ void test_online_push__initialize(void)
_remote_ssh_passphrase = cl_getenv("GITTEST_REMOTE_SSH_PASSPHRASE");
_remote_default = cl_getenv("GITTEST_REMOTE_DEFAULT");
_remote_expectcontinue = cl_getenv("GITTEST_REMOTE_EXPECTCONTINUE");
+ _remote_push_options = cl_getenv("GITTEST_PUSH_OPTIONS");
_remote = NULL;
+ _orig_ssh_cmd = cl_getenv("GIT_SSH");
+ _ssh_cmd = cl_getenv("GITTEST_SSH_CMD");
+
+ if (_ssh_cmd)
+ cl_setenv("GIT_SSH", _ssh_cmd);
+ else
+ cl_setenv("GIT_SSH", NULL);
+
/* Skip the test if we're missing the remote URL */
if (!_remote_url)
cl_skip();
@@ -401,7 +416,7 @@ void test_online_push__initialize(void)
}
git_remote_disconnect(_remote);
- git_vector_free_deep(&delete_specs);
+ git_vector_dispose_deep(&delete_specs);
/* Now that we've deleted everything, fetch from the remote */
memcpy(&fetch_opts.callbacks, &_record_cbs, sizeof(git_remote_callbacks));
@@ -422,6 +437,10 @@ void test_online_push__cleanup(void)
git__free(_remote_ssh_passphrase);
git__free(_remote_default);
git__free(_remote_expectcontinue);
+ git__free(_remote_push_options);
+
+ git__free(_orig_ssh_cmd);
+ git__free(_ssh_cmd);
/* Freed by cl_git_sandbox_cleanup */
_repo = NULL;
@@ -430,6 +449,7 @@ void test_online_push__cleanup(void)
record_callbacks_data_clear(&_record_cbs_data);
+ cl_fixture_cleanup("push-options-result");
cl_fixture_cleanup("testrepo.git");
cl_git_sandbox_cleanup();
}
@@ -472,7 +492,8 @@ static void do_push(
const char *refspecs[], size_t refspecs_len,
push_status expected_statuses[], size_t expected_statuses_len,
expected_ref expected_refs[], size_t expected_refs_len,
- int expected_ret, int check_progress_cb, int check_update_tips_cb)
+ int expected_ret, int check_progress_cb, int check_update_tips_cb,
+ git_strarray *remote_push_options)
{
git_push_options opts = GIT_PUSH_OPTIONS_INIT;
size_t i;
@@ -484,6 +505,9 @@ static void do_push(
/* Auto-detect the number of threads to use */
opts.pb_parallelism = 0;
+ if (remote_push_options)
+ memcpy(&opts.remote_push_options, remote_push_options, sizeof(git_strarray));
+
memcpy(&opts.callbacks, &_record_cbs, sizeof(git_remote_callbacks));
data = opts.callbacks.payload;
@@ -527,13 +551,12 @@ static void do_push(
verify_update_tips_callback(_remote, expected_refs, expected_refs_len);
}
-
}
/* Call push_finish() without ever calling git_push_add_refspec() */
void test_online_push__noop(void)
{
- do_push(NULL, 0, NULL, 0, NULL, 0, 0, 0, 1);
+ do_push(NULL, 0, NULL, 0, NULL, 0, 0, 0, 1, NULL);
}
void test_online_push__b1(void)
@@ -543,7 +566,9 @@ void test_online_push__b1(void)
expected_ref exp_refs[] = { { "refs/heads/b1", &_oid_b1 } };
do_push(specs, ARRAY_SIZE(specs),
exp_stats, ARRAY_SIZE(exp_stats),
- exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1);
+ exp_refs, ARRAY_SIZE(exp_refs),
+ 0, 1, 1,
+ NULL);
}
void test_online_push__b2(void)
@@ -553,7 +578,9 @@ void test_online_push__b2(void)
expected_ref exp_refs[] = { { "refs/heads/b2", &_oid_b2 } };
do_push(specs, ARRAY_SIZE(specs),
exp_stats, ARRAY_SIZE(exp_stats),
- exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1);
+ exp_refs, ARRAY_SIZE(exp_refs),
+ 0, 1, 1,
+ NULL);
}
void test_online_push__b3(void)
@@ -563,7 +590,9 @@ void test_online_push__b3(void)
expected_ref exp_refs[] = { { "refs/heads/b3", &_oid_b3 } };
do_push(specs, ARRAY_SIZE(specs),
exp_stats, ARRAY_SIZE(exp_stats),
- exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1);
+ exp_refs, ARRAY_SIZE(exp_refs),
+ 0, 1, 1,
+ NULL);
}
void test_online_push__b4(void)
@@ -573,7 +602,9 @@ void test_online_push__b4(void)
expected_ref exp_refs[] = { { "refs/heads/b4", &_oid_b4 } };
do_push(specs, ARRAY_SIZE(specs),
exp_stats, ARRAY_SIZE(exp_stats),
- exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1);
+ exp_refs, ARRAY_SIZE(exp_refs),
+ 0, 1, 1,
+ NULL);
}
void test_online_push__b5(void)
@@ -583,13 +614,15 @@ void test_online_push__b5(void)
expected_ref exp_refs[] = { { "refs/heads/b5", &_oid_b5 } };
do_push(specs, ARRAY_SIZE(specs),
exp_stats, ARRAY_SIZE(exp_stats),
- exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1);
+ exp_refs, ARRAY_SIZE(exp_refs),
+ 0, 1, 1,
+ NULL);
}
void test_online_push__b5_cancel(void)
{
const char *specs[] = { "refs/heads/b5:refs/heads/b5" };
- do_push(specs, ARRAY_SIZE(specs), NULL, 0, NULL, 0, GIT_EUSER, 1, 1);
+ do_push(specs, ARRAY_SIZE(specs), NULL, 0, NULL, 0, GIT_EUSER, 1, 1, NULL);
}
void test_online_push__multi(void)
@@ -620,7 +653,9 @@ void test_online_push__multi(void)
};
do_push(specs, ARRAY_SIZE(specs),
exp_stats, ARRAY_SIZE(exp_stats),
- exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1);
+ exp_refs, ARRAY_SIZE(exp_refs),
+ 0, 1, 1,
+ NULL);
cl_git_pass(git_reflog_read(&log, _repo, "refs/remotes/test/b1"));
entry = git_reflog_entry_byindex(log, 0);
@@ -641,16 +676,21 @@ void test_online_push__implicit_tgt(void)
const char *specs2[] = { "refs/heads/b2" };
push_status exp_stats2[] = { { "refs/heads/b2", 1 } };
expected_ref exp_refs2[] = {
- { "refs/heads/b1", &_oid_b1 },
- { "refs/heads/b2", &_oid_b2 }
+ { "refs/heads/b1", &_oid_b1 },
+ { "refs/heads/b2", &_oid_b2 }
};
do_push(specs1, ARRAY_SIZE(specs1),
exp_stats1, ARRAY_SIZE(exp_stats1),
- exp_refs1, ARRAY_SIZE(exp_refs1), 0, 1, 1);
+ exp_refs1, ARRAY_SIZE(exp_refs1),
+ 0, 1, 1,
+ NULL);
+
do_push(specs2, ARRAY_SIZE(specs2),
exp_stats2, ARRAY_SIZE(exp_stats2),
- exp_refs2, ARRAY_SIZE(exp_refs2), 0, 0, 0);
+ exp_refs2, ARRAY_SIZE(exp_refs2),
+ 0, 0, 0,
+ NULL);
}
void test_online_push__fast_fwd(void)
@@ -672,19 +712,27 @@ void test_online_push__fast_fwd(void)
do_push(specs_init, ARRAY_SIZE(specs_init),
exp_stats_init, ARRAY_SIZE(exp_stats_init),
- exp_refs_init, ARRAY_SIZE(exp_refs_init), 0, 1, 1);
+ exp_refs_init, ARRAY_SIZE(exp_refs_init),
+ 0, 1, 1,
+ NULL);
do_push(specs_ff, ARRAY_SIZE(specs_ff),
exp_stats_ff, ARRAY_SIZE(exp_stats_ff),
- exp_refs_ff, ARRAY_SIZE(exp_refs_ff), 0, 0, 0);
+ exp_refs_ff, ARRAY_SIZE(exp_refs_ff),
+ 0, 0, 0,
+ NULL);
do_push(specs_reset, ARRAY_SIZE(specs_reset),
exp_stats_init, ARRAY_SIZE(exp_stats_init),
- exp_refs_init, ARRAY_SIZE(exp_refs_init), 0, 0, 0);
+ exp_refs_init, ARRAY_SIZE(exp_refs_init),
+ 0, 0, 0,
+ NULL);
do_push(specs_ff_force, ARRAY_SIZE(specs_ff_force),
exp_stats_ff, ARRAY_SIZE(exp_stats_ff),
- exp_refs_ff, ARRAY_SIZE(exp_refs_ff), 0, 0, 0);
+ exp_refs_ff, ARRAY_SIZE(exp_refs_ff),
+ 0, 0, 0,
+ NULL);
}
void test_online_push__tag_commit(void)
@@ -694,7 +742,9 @@ void test_online_push__tag_commit(void)
expected_ref exp_refs[] = { { "refs/tags/tag-commit", &_tag_commit } };
do_push(specs, ARRAY_SIZE(specs),
exp_stats, ARRAY_SIZE(exp_stats),
- exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1);
+ exp_refs, ARRAY_SIZE(exp_refs),
+ 0, 1, 1,
+ NULL);
}
void test_online_push__tag_tree(void)
@@ -704,7 +754,9 @@ void test_online_push__tag_tree(void)
expected_ref exp_refs[] = { { "refs/tags/tag-tree", &_tag_tree } };
do_push(specs, ARRAY_SIZE(specs),
exp_stats, ARRAY_SIZE(exp_stats),
- exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1);
+ exp_refs, ARRAY_SIZE(exp_refs),
+ 0, 1, 1,
+ NULL);
}
void test_online_push__tag_blob(void)
@@ -714,7 +766,9 @@ void test_online_push__tag_blob(void)
expected_ref exp_refs[] = { { "refs/tags/tag-blob", &_tag_blob } };
do_push(specs, ARRAY_SIZE(specs),
exp_stats, ARRAY_SIZE(exp_stats),
- exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1);
+ exp_refs, ARRAY_SIZE(exp_refs),
+ 0, 1, 1,
+ NULL);
}
void test_online_push__tag_lightweight(void)
@@ -724,7 +778,9 @@ void test_online_push__tag_lightweight(void)
expected_ref exp_refs[] = { { "refs/tags/tag-lightweight", &_tag_lightweight } };
do_push(specs, ARRAY_SIZE(specs),
exp_stats, ARRAY_SIZE(exp_stats),
- exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1);
+ exp_refs, ARRAY_SIZE(exp_refs),
+ 0, 1, 1,
+ NULL);
}
void test_online_push__tag_to_tag(void)
@@ -734,7 +790,9 @@ void test_online_push__tag_to_tag(void)
expected_ref exp_refs[] = { { "refs/tags/tag-tag", &_tag_tag } };
do_push(specs, ARRAY_SIZE(specs),
exp_stats, ARRAY_SIZE(exp_stats),
- exp_refs, ARRAY_SIZE(exp_refs), 0, 0, 0);
+ exp_refs, ARRAY_SIZE(exp_refs),
+ 0, 0, 0,
+ NULL);
}
void test_online_push__force(void)
@@ -751,17 +809,80 @@ void test_online_push__force(void)
do_push(specs1, ARRAY_SIZE(specs1),
exp_stats1, ARRAY_SIZE(exp_stats1),
- exp_refs1, ARRAY_SIZE(exp_refs1), 0, 1, 1);
+ exp_refs1, ARRAY_SIZE(exp_refs1),
+ 0, 1, 1,
+ NULL);
do_push(specs2, ARRAY_SIZE(specs2),
NULL, 0,
- exp_refs1, ARRAY_SIZE(exp_refs1), GIT_ENONFASTFORWARD, 0, 0);
+ exp_refs1, ARRAY_SIZE(exp_refs1),
+ GIT_ENONFASTFORWARD, 0, 0,
+ NULL);
/* Non-fast-forward update with force should pass. */
record_callbacks_data_clear(&_record_cbs_data);
do_push(specs2_force, ARRAY_SIZE(specs2_force),
exp_stats2_force, ARRAY_SIZE(exp_stats2_force),
- exp_refs2_force, ARRAY_SIZE(exp_refs2_force), 0, 1, 1);
+ exp_refs2_force, ARRAY_SIZE(exp_refs2_force),
+ 0, 1, 1,
+ NULL);
+}
+
+static void push_option_test(git_strarray given_options, const char *expected_option)
+{
+ const char *specs[] = { "refs/heads/b1:refs/heads/b1" };
+ push_status exp_stats[] = { { "refs/heads/b1", 1 } };
+ expected_ref exp_refs[] = { { "refs/heads/b1", &_oid_b1 } };
+ git_str push_options_path = GIT_STR_INIT;
+ git_str push_options_result = GIT_STR_INIT;
+ char *options[16];
+ git_strarray push_options = { options, given_options.count + 1 };
+ size_t i;
+
+ /* Skip the test if we're missing the push options result file */
+ if (!_remote_push_options)
+ cl_skip();
+
+ cl_assert(given_options.count < 16);
+
+ cl_git_pass(git_str_joinpath(&push_options_path, clar_sandbox_path(), "push-options-result"));
+
+ options[0] = push_options_path.ptr;
+ for (i = 0; i < given_options.count; i++)
+ options[i + 1] = given_options.strings[i];
+
+ do_push(specs, ARRAY_SIZE(specs),
+ exp_stats, ARRAY_SIZE(exp_stats),
+ exp_refs, ARRAY_SIZE(exp_refs),
+ 0, 1, 1,
+ &push_options);
+
+ cl_assert(git_fs_path_exists(push_options_path.ptr));
+ cl_git_pass(git_futils_readbuffer(&push_options_result, push_options_path.ptr));
+
+ cl_assert_equal_s(expected_option, git_str_cstr(&push_options_result));
+ git_str_dispose(&push_options_result);
+ git_str_dispose(&push_options_path);
+}
+
+void test_online_push__options(void)
+{
+ char *push_options_string_args_test_1[1] = { "test_string" };
+ git_strarray push_options_test_1 = { push_options_string_args_test_1, 1 };
+
+ char *push_options_string_args_test_2[2] = { "test_string", "another arg?" };
+ git_strarray push_options_test_2 = { push_options_string_args_test_2, 2 };
+
+ char *push_options_string_args_test_3[1] = { "👨ðŸ¿â€ðŸ’» but can it do unicode? 🇺🇦" };
+ git_strarray push_options_test_3 = { push_options_string_args_test_3, 1 };
+
+ char *push_options_string_args_test_4[3] = { "\0", "\0", "\0" };
+ git_strarray push_options_test_4 = { push_options_string_args_test_4, 3 };
+
+ push_option_test(push_options_test_1, "test_string");
+ push_option_test(push_options_test_2, "test_stringanother arg?");
+ push_option_test(push_options_test_3, "👨ðŸ¿â€ðŸ’» but can it do unicode? 🇺🇦");
+ push_option_test(push_options_test_4, "\0\0\0");
}
void test_online_push__delete(void)
@@ -792,7 +913,9 @@ void test_online_push__delete(void)
do_push(specs1, ARRAY_SIZE(specs1),
exp_stats1, ARRAY_SIZE(exp_stats1),
- exp_refs1, ARRAY_SIZE(exp_refs1), 0, 1, 1);
+ exp_refs1, ARRAY_SIZE(exp_refs1),
+ 0, 1, 1,
+ NULL);
/* When deleting a non-existent branch, the git client sends zero for both
* the old and new commit id. This should succeed on the server with the
@@ -802,23 +925,35 @@ void test_online_push__delete(void)
*/
do_push(specs_del_fake, ARRAY_SIZE(specs_del_fake),
exp_stats_fake, 1,
- exp_refs1, ARRAY_SIZE(exp_refs1), 0, 0, 0);
+ exp_refs1, ARRAY_SIZE(exp_refs1),
+ 0, 0, 0,
+ NULL);
+
do_push(specs_del_fake_force, ARRAY_SIZE(specs_del_fake_force),
exp_stats_fake, 1,
- exp_refs1, ARRAY_SIZE(exp_refs1), 0, 0, 0);
+ exp_refs1, ARRAY_SIZE(exp_refs1),
+ 0, 0, 0,
+ NULL);
/* Delete one of the pushed branches. */
do_push(specs_delete, ARRAY_SIZE(specs_delete),
exp_stats_delete, ARRAY_SIZE(exp_stats_delete),
- exp_refs_delete, ARRAY_SIZE(exp_refs_delete), 0, 0, 0);
+ exp_refs_delete, ARRAY_SIZE(exp_refs_delete),
+ 0, 0, 0,
+ NULL);
/* Re-push branches and retry delete with force. */
do_push(specs1, ARRAY_SIZE(specs1),
exp_stats1, ARRAY_SIZE(exp_stats1),
- exp_refs1, ARRAY_SIZE(exp_refs1), 0, 0, 0);
+ exp_refs1, ARRAY_SIZE(exp_refs1),
+ 0, 0, 0,
+ NULL);
+
do_push(specs_delete_force, ARRAY_SIZE(specs_delete_force),
exp_stats_delete, ARRAY_SIZE(exp_stats_delete),
- exp_refs_delete, ARRAY_SIZE(exp_refs_delete), 0, 0, 0);
+ exp_refs_delete, ARRAY_SIZE(exp_refs_delete),
+ 0, 0, 0,
+ NULL);
}
void test_online_push__bad_refspecs(void)
@@ -862,7 +997,9 @@ void test_online_push__expressions(void)
do_push(specs_left_expr, ARRAY_SIZE(specs_left_expr),
exp_stats, ARRAY_SIZE(exp_stats),
- exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1);
+ exp_refs, ARRAY_SIZE(exp_refs),
+ 0, 1, 1,
+ NULL);
}
void test_online_push__notes(void)
@@ -874,7 +1011,7 @@ void test_online_push__notes(void)
expected_ref exp_refs[] = { { "refs/notes/commits", &expected_oid } };
const char *specs_del[] = { ":refs/notes/commits" };
- git_oid__fromstr(&expected_oid, "8461a99b27b7043e58ff6e1f5d2cf07d282534fb", GIT_OID_SHA1);
+ git_oid_from_string(&expected_oid, "8461a99b27b7043e58ff6e1f5d2cf07d282534fb", GIT_OID_SHA1);
target_oid = &_oid_b6;
@@ -884,13 +1021,17 @@ void test_online_push__notes(void)
do_push(specs, ARRAY_SIZE(specs),
exp_stats, ARRAY_SIZE(exp_stats),
- exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1);
+ exp_refs, ARRAY_SIZE(exp_refs),
+ 0, 1, 1,
+ NULL);
/* And make sure to delete the note */
do_push(specs_del, ARRAY_SIZE(specs_del),
exp_stats, 1,
- NULL, 0, 0, 0, 0);
+ NULL, 0,
+ 0, 0, 0,
+ NULL);
git_signature_free(signature);
}
@@ -905,7 +1046,7 @@ void test_online_push__configured(void)
expected_ref exp_refs[] = { { "refs/notes/commits", &expected_oid } };
const char *specs_del[] = { ":refs/notes/commits" };
- git_oid__fromstr(&expected_oid, "8461a99b27b7043e58ff6e1f5d2cf07d282534fb", GIT_OID_SHA1);
+ git_oid_from_string(&expected_oid, "8461a99b27b7043e58ff6e1f5d2cf07d282534fb", GIT_OID_SHA1);
target_oid = &_oid_b6;
@@ -920,13 +1061,17 @@ void test_online_push__configured(void)
do_push(NULL, 0,
exp_stats, ARRAY_SIZE(exp_stats),
- exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1);
+ exp_refs, ARRAY_SIZE(exp_refs),
+ 0, 1, 1,
+ NULL);
/* And make sure to delete the note */
do_push(specs_del, ARRAY_SIZE(specs_del),
exp_stats, 1,
- NULL, 0, 0, 0, 0);
+ NULL, 0,
+ 0, 0, 0,
+ NULL);
git_signature_free(signature);
}
diff --git a/tests/libgit2/online/push_util.c b/tests/libgit2/online/push_util.c
index 94919e9b2a2..88651672d0a 100644
--- a/tests/libgit2/online/push_util.c
+++ b/tests/libgit2/online/push_util.c
@@ -24,22 +24,24 @@ void record_callbacks_data_clear(record_callbacks_data *data)
git_vector_foreach(&data->updated_tips, i, tip)
updated_tip_free(tip);
- git_vector_free(&data->updated_tips);
+ git_vector_dispose(&data->updated_tips);
git_vector_foreach(&data->statuses, i, status)
push_status_free(status);
- git_vector_free(&data->statuses);
+ git_vector_dispose(&data->statuses);
data->pack_progress_calls = 0;
data->transfer_progress_calls = 0;
}
-int record_update_tips_cb(const char *refname, const git_oid *a, const git_oid *b, void *data)
+int record_update_refs_cb(const char *refname, const git_oid *a, const git_oid *b, git_refspec *spec, void *data)
{
updated_tip *t;
record_callbacks_data *record_data = (record_callbacks_data *)data;
+ GIT_UNUSED(spec);
+
cl_assert(t = git__calloc(1, sizeof(*t)));
cl_assert(t->name = git__strdup(refname));
diff --git a/tests/libgit2/online/push_util.h b/tests/libgit2/online/push_util.h
index 5f669feaf0c..07b46bf4454 100644
--- a/tests/libgit2/online/push_util.h
+++ b/tests/libgit2/online/push_util.h
@@ -12,7 +12,7 @@ extern const git_oid OID_ZERO;
* @param data pointer to a record_callbacks_data instance
*/
#define RECORD_CALLBACKS_INIT(data) \
- { GIT_REMOTE_CALLBACKS_VERSION, NULL, NULL, cred_acquire_cb, NULL, NULL, record_update_tips_cb, NULL, NULL, NULL, NULL, NULL, NULL, data, NULL }
+ { GIT_REMOTE_CALLBACKS_VERSION, NULL, NULL, cred_acquire_cb, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, data, NULL, record_update_refs_cb }
typedef struct {
char *name;
@@ -50,7 +50,7 @@ void record_callbacks_data_clear(record_callbacks_data *data);
*
* @param data (git_vector *) of updated_tip instances
*/
-int record_update_tips_cb(const char *refname, const git_oid *a, const git_oid *b, void *data);
+int record_update_refs_cb(const char *refname, const git_oid *a, const git_oid *b, git_refspec *spec, void *data);
/**
* Create a set of refspecs that deletes each of the inputs
diff --git a/tests/libgit2/online/shallow.c b/tests/libgit2/online/shallow.c
new file mode 100644
index 00000000000..8d71c6be507
--- /dev/null
+++ b/tests/libgit2/online/shallow.c
@@ -0,0 +1,453 @@
+#include "clar_libgit2.h"
+#include "futils.h"
+#include "repository.h"
+
+static int remote_single_branch(git_remote **out, git_repository *repo, const char *name, const char *url, void *payload)
+{
+ GIT_UNUSED(payload);
+
+ cl_git_pass(git_remote_create_with_fetchspec(out, repo, name, url, "+refs/heads/master:refs/remotes/origin/master"));
+
+ return 0;
+}
+
+void test_online_shallow__clone_depth_zero(void)
+{
+ git_str path = GIT_STR_INIT;
+ git_repository *repo;
+ git_clone_options clone_opts = GIT_CLONE_OPTIONS_INIT;
+ git_oid *roots;
+ size_t roots_len;
+
+ clone_opts.fetch_opts.depth = 0;
+ clone_opts.remote_cb = remote_single_branch;
+
+ git_str_joinpath(&path, clar_sandbox_path(), "shallowclone_0");
+
+ cl_git_pass(git_clone(&repo, "https://github.com/libgit2/TestGitRepository", git_str_cstr(&path), &clone_opts));
+
+ /* cloning with depth 0 results in a full clone. */
+ cl_assert_equal_b(false, git_repository_is_shallow(repo));
+
+ /* full clones do not have shallow roots. */
+ cl_git_pass(git_repository__shallow_roots(&roots, &roots_len, repo));
+ cl_assert_equal_i(0, roots_len);
+
+ git__free(roots);
+ git_str_dispose(&path);
+ git_repository_free(repo);
+}
+
+void test_online_shallow__clone_depth_one(void)
+{
+ git_str path = GIT_STR_INIT;
+ git_repository *repo;
+ git_revwalk *walk;
+ git_clone_options clone_opts = GIT_CLONE_OPTIONS_INIT;
+ git_oid oid;
+ git_oid *roots;
+ size_t roots_len;
+ size_t num_commits = 0;
+ int error = 0;
+
+ clone_opts.fetch_opts.depth = 1;
+ clone_opts.remote_cb = remote_single_branch;
+
+ git_str_joinpath(&path, clar_sandbox_path(), "shallowclone_1");
+
+ cl_git_pass(git_clone(&repo, "https://github.com/libgit2/TestGitRepository", git_str_cstr(&path), &clone_opts));
+
+ cl_assert_equal_b(true, git_repository_is_shallow(repo));
+
+ cl_git_pass(git_repository__shallow_roots(&roots, &roots_len, repo));
+ cl_assert_equal_i(1, roots_len);
+ cl_assert_equal_s("49322bb17d3acc9146f98c97d078513228bbf3c0", git_oid_tostr_s(&roots[0]));
+
+ git_revwalk_new(&walk, repo);
+
+ git_revwalk_push_head(walk);
+
+ while ((error = git_revwalk_next(&oid, walk)) == GIT_OK) {
+ num_commits++;
+ }
+
+ cl_assert_equal_i(num_commits, 1);
+ cl_assert_equal_i(error, GIT_ITEROVER);
+
+ git__free(roots);
+ git_str_dispose(&path);
+ git_revwalk_free(walk);
+ git_repository_free(repo);
+}
+
+void test_online_shallow__clone_depth_five(void)
+{
+ git_str path = GIT_STR_INIT;
+ git_repository *repo;
+ git_revwalk *walk;
+ git_clone_options clone_opts = GIT_CLONE_OPTIONS_INIT;
+ git_oid oid;
+ git_oid *roots;
+ size_t roots_len;
+ size_t num_commits = 0;
+ int error = 0;
+
+ clone_opts.fetch_opts.depth = 5;
+ clone_opts.remote_cb = remote_single_branch;
+
+ git_str_joinpath(&path, clar_sandbox_path(), "shallowclone_5");
+
+ cl_git_pass(git_clone(&repo, "https://github.com/libgit2/TestGitRepository", git_str_cstr(&path), &clone_opts));
+
+ cl_assert_equal_b(true, git_repository_is_shallow(repo));
+
+ cl_git_pass(git_repository__shallow_roots(&roots, &roots_len, repo));
+ cl_assert_equal_i(3, roots_len);
+ cl_assert_equal_s("c070ad8c08840c8116da865b2d65593a6bb9cd2a", git_oid_tostr_s(&roots[0]));
+ cl_assert_equal_s("0966a434eb1a025db6b71485ab63a3bfbea520b6", git_oid_tostr_s(&roots[1]));
+ cl_assert_equal_s("83834a7afdaa1a1260568567f6ad90020389f664", git_oid_tostr_s(&roots[2]));
+
+ git_revwalk_new(&walk, repo);
+
+ git_revwalk_push_head(walk);
+
+ while ((error = git_revwalk_next(&oid, walk)) == GIT_OK) {
+ num_commits++;
+ }
+
+ cl_assert_equal_i(num_commits, 13);
+ cl_assert_equal_i(error, GIT_ITEROVER);
+
+ git__free(roots);
+ git_str_dispose(&path);
+ git_revwalk_free(walk);
+ git_repository_free(repo);
+}
+
+void test_online_shallow__unshallow(void)
+{
+ git_str path = GIT_STR_INIT;
+ git_repository *repo;
+ git_revwalk *walk;
+ git_clone_options clone_opts = GIT_CLONE_OPTIONS_INIT;
+ git_fetch_options fetch_opts = GIT_FETCH_OPTIONS_INIT;
+ git_remote *origin = NULL;
+ git_oid oid;
+ size_t num_commits = 0;
+ int error = 0;
+
+ clone_opts.fetch_opts.depth = 5;
+ clone_opts.remote_cb = remote_single_branch;
+
+ git_str_joinpath(&path, clar_sandbox_path(), "unshallow");
+ cl_git_pass(git_clone(&repo, "https://github.com/libgit2/TestGitRepository", git_str_cstr(&path), &clone_opts));
+ cl_assert_equal_b(true, git_repository_is_shallow(repo));
+
+ fetch_opts.depth = GIT_FETCH_DEPTH_UNSHALLOW;
+ cl_git_pass(git_remote_lookup(&origin, repo, "origin"));
+
+ cl_git_pass(git_remote_fetch(origin, NULL, &fetch_opts, NULL));
+ cl_assert_equal_b(false, git_repository_is_shallow(repo));
+
+ git_revwalk_new(&walk, repo);
+ git_revwalk_push_head(walk);
+
+ while ((error = git_revwalk_next(&oid, walk)) == GIT_OK) {
+ num_commits++;
+ }
+
+ cl_assert_equal_i(num_commits, 21);
+ cl_assert_equal_i(error, GIT_ITEROVER);
+
+ git_remote_free(origin);
+ git_str_dispose(&path);
+ git_revwalk_free(walk);
+ git_repository_free(repo);
+}
+
+void test_online_shallow__deepen_full(void)
+{
+ git_str path = GIT_STR_INIT;
+ git_repository *repo;
+ git_revwalk *walk;
+ git_clone_options clone_opts = GIT_CLONE_OPTIONS_INIT;
+ git_fetch_options fetch_opts = GIT_FETCH_OPTIONS_INIT;
+ git_remote *origin = NULL;
+ git_oid oid;
+ git_oid *roots;
+ size_t roots_len;
+ size_t num_commits = 0;
+ int error = 0;
+
+ clone_opts.fetch_opts.depth = 7;
+ clone_opts.remote_cb = remote_single_branch;
+
+ git_str_joinpath(&path, clar_sandbox_path(), "deepen_full");
+ cl_git_pass(git_clone(&repo, "https://github.com/libgit2/TestGitRepository", git_str_cstr(&path), &clone_opts));
+ cl_assert_equal_b(true, git_repository_is_shallow(repo));
+
+ fetch_opts.depth = 8;
+ cl_git_pass(git_remote_lookup(&origin, repo, "origin"));
+ cl_git_pass(git_remote_fetch(origin, NULL, &fetch_opts, NULL));
+ cl_assert_equal_b(false, git_repository_is_shallow(repo));
+
+ cl_git_pass(git_repository__shallow_roots(&roots, &roots_len, repo));
+ cl_assert_equal_i(0, roots_len);
+
+ git_revwalk_new(&walk, repo);
+ git_revwalk_push_head(walk);
+
+ while ((error = git_revwalk_next(&oid, walk)) == GIT_OK) {
+ num_commits++;
+ }
+
+ cl_assert_equal_i(num_commits, 21);
+ cl_assert_equal_i(error, GIT_ITEROVER);
+
+ git__free(roots);
+ git_remote_free(origin);
+ git_str_dispose(&path);
+ git_revwalk_free(walk);
+ git_repository_free(repo);
+}
+
+void test_online_shallow__deepen_six(void)
+{
+ git_str path = GIT_STR_INIT;
+ git_repository *repo;
+ git_revwalk *walk;
+ git_clone_options clone_opts = GIT_CLONE_OPTIONS_INIT;
+ git_fetch_options fetch_opts = GIT_FETCH_OPTIONS_INIT;
+ git_remote *origin = NULL;
+ git_oid oid;
+ git_oid *roots;
+ size_t roots_len;
+ size_t num_commits = 0;
+ int error = 0;
+
+ clone_opts.fetch_opts.depth = 5;
+ clone_opts.remote_cb = remote_single_branch;
+
+ git_str_joinpath(&path, clar_sandbox_path(), "deepen_6");
+ cl_git_pass(git_clone(&repo, "https://github.com/libgit2/TestGitRepository", git_str_cstr(&path), &clone_opts));
+ cl_assert_equal_b(true, git_repository_is_shallow(repo));
+
+ fetch_opts.depth = 6;
+ cl_git_pass(git_remote_lookup(&origin, repo, "origin"));
+ cl_git_pass(git_remote_fetch(origin, NULL, &fetch_opts, NULL));
+ cl_assert_equal_b(true, git_repository_is_shallow(repo));
+
+ cl_git_pass(git_repository__shallow_roots(&roots, &roots_len, repo));
+ cl_assert_equal_i(4, roots_len);
+ cl_assert_equal_s("58be4659bb571194ed4562d04b359d26216f526e", git_oid_tostr_s(&roots[0]));
+ cl_assert_equal_s("d31f5a60d406e831d056b8ac2538d515100c2df2", git_oid_tostr_s(&roots[1]));
+ cl_assert_equal_s("6462e7d8024396b14d7651e2ec11e2bbf07a05c4", git_oid_tostr_s(&roots[2]));
+ cl_assert_equal_s("2c349335b7f797072cf729c4f3bb0914ecb6dec9", git_oid_tostr_s(&roots[3]));
+
+ git_revwalk_new(&walk, repo);
+ git_revwalk_push_head(walk);
+
+ while ((error = git_revwalk_next(&oid, walk)) == GIT_OK) {
+ num_commits++;
+ }
+
+ cl_assert_equal_i(num_commits, 17);
+ cl_assert_equal_i(error, GIT_ITEROVER);
+
+ git__free(roots);
+ git_remote_free(origin);
+ git_str_dispose(&path);
+ git_revwalk_free(walk);
+ git_repository_free(repo);
+}
+
+void test_online_shallow__shorten_four(void)
+{
+ git_str path = GIT_STR_INIT;
+ git_repository *repo;
+ git_revwalk *walk;
+ git_clone_options clone_opts = GIT_CLONE_OPTIONS_INIT;
+ git_fetch_options fetch_opts = GIT_FETCH_OPTIONS_INIT;
+ git_remote *origin = NULL;
+ git_oid oid;
+ git_oid *roots;
+ size_t roots_len;
+ size_t num_commits = 0;
+ int error = 0;
+
+ clone_opts.fetch_opts.depth = 5;
+ clone_opts.remote_cb = remote_single_branch;
+
+ git_str_joinpath(&path, clar_sandbox_path(), "shorten_4");
+ cl_git_pass(git_clone(&repo, "https://github.com/libgit2/TestGitRepository", git_str_cstr(&path), &clone_opts));
+ cl_assert_equal_b(true, git_repository_is_shallow(repo));
+
+ fetch_opts.depth = 4;
+ cl_git_pass(git_remote_lookup(&origin, repo, "origin"));
+ cl_git_pass(git_remote_fetch(origin, NULL, &fetch_opts, NULL));
+ cl_assert_equal_b(true, git_repository_is_shallow(repo));
+
+ cl_git_pass(git_repository__shallow_roots(&roots, &roots_len, repo));
+ cl_assert_equal_i(6, roots_len);
+ /* roots added during initial clone, not removed as not encountered during fetch */
+ cl_assert_equal_s("c070ad8c08840c8116da865b2d65593a6bb9cd2a", git_oid_tostr_s(&roots[0]));
+ cl_assert_equal_s("0966a434eb1a025db6b71485ab63a3bfbea520b6", git_oid_tostr_s(&roots[1]));
+ cl_assert_equal_s("83834a7afdaa1a1260568567f6ad90020389f664", git_oid_tostr_s(&roots[3]));
+ /* roots added during fetch */
+ cl_assert_equal_s("bab66b48f836ed950c99134ef666436fb07a09a0", git_oid_tostr_s(&roots[2]));
+ cl_assert_equal_s("59706a11bde2b9899a278838ef20a97e8f8795d2", git_oid_tostr_s(&roots[4]));
+ cl_assert_equal_s("d86a2aada2f5e7ccf6f11880bfb9ab404e8a8864", git_oid_tostr_s(&roots[5]));
+
+ git_revwalk_new(&walk, repo);
+ git_revwalk_push_head(walk);
+
+ while ((error = git_revwalk_next(&oid, walk)) == GIT_OK) {
+ num_commits++;
+ }
+
+ cl_assert_equal_i(num_commits, 10);
+ cl_assert_equal_i(error, GIT_ITEROVER);
+
+ git__free(roots);
+ git_remote_free(origin);
+ git_str_dispose(&path);
+ git_revwalk_free(walk);
+ git_repository_free(repo);
+}
+
+void test_online_shallow__preserve_unrelated_roots(void)
+{
+ git_str path = GIT_STR_INIT;
+ git_repository *repo;
+ git_revwalk *walk;
+ git_fetch_options fetch_opts = GIT_FETCH_OPTIONS_INIT;
+ git_remote *origin = NULL;
+ git_strarray refspecs;
+ git_oid oid;
+ git_oid *roots;
+ size_t roots_len;
+ size_t num_commits = 0;
+ int error = 0;
+ git_oid first_oid;
+ git_oid second_oid;
+ git_oid third_oid;
+ char *first_commit = "c070ad8c08840c8116da865b2d65593a6bb9cd2a";
+ char *second_commit = "6e1475206e57110fcef4b92320436c1e9872a322";
+ char *third_commit = "7f822839a2fe9760f386cbbbcb3f92c5fe81def7";
+
+#ifdef GIT_EXPERIMENTAL_SHA256
+ cl_git_pass(git_oid_from_string(&first_oid, first_commit, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&second_oid, second_commit, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&third_oid, third_commit, GIT_OID_SHA1));
+#else
+ cl_git_pass(git_oid_fromstr(&first_oid, first_commit));
+ cl_git_pass(git_oid_fromstr(&second_oid, second_commit));
+ cl_git_pass(git_oid_fromstr(&third_oid, third_commit));
+#endif
+
+ /* setup empty repository without cloning */
+ git_str_joinpath(&path, clar_sandbox_path(), "preserve_unrelated_roots");
+ cl_git_pass(git_repository_init(&repo, git_str_cstr(&path), true));
+ cl_git_pass(git_remote_create(&origin, repo, "origin", "https://github.com/libgit2/TestGitRepository"));
+ cl_assert_equal_b(false, git_repository_is_shallow(repo));
+
+ /* shallow fetch for first commit */
+ fetch_opts.depth = 1;
+ refspecs.strings = &first_commit;
+ refspecs.count = 1;
+ cl_git_pass(git_remote_fetch(origin, &refspecs, &fetch_opts, NULL));
+ cl_assert_equal_b(true, git_repository_is_shallow(repo));
+
+ cl_git_pass(git_repository__shallow_roots(&roots, &roots_len, repo));
+ cl_assert_equal_i(1, roots_len);
+ cl_assert_equal_s("c070ad8c08840c8116da865b2d65593a6bb9cd2a", git_oid_tostr_s(&roots[0]));
+
+ cl_git_pass(git_revwalk_new(&walk, repo));
+ cl_git_pass(git_revwalk_push(walk, &first_oid));
+ while ((error = git_revwalk_next(&oid, walk)) == GIT_OK) {
+ num_commits++;
+ }
+ cl_assert_equal_i(num_commits, 1);
+ cl_assert_equal_i(error, GIT_ITEROVER);
+
+ /* shallow fetch for second commit */
+ fetch_opts.depth = 1;
+ refspecs.strings = &second_commit;
+ refspecs.count = 1;
+ cl_git_pass(git_remote_fetch(origin, &refspecs, &fetch_opts, NULL));
+ cl_assert_equal_b(true, git_repository_is_shallow(repo));
+
+ git__free(roots);
+ cl_git_pass(git_repository__shallow_roots(&roots, &roots_len, repo));
+ cl_assert_equal_i(2, roots_len);
+ cl_assert_equal_s("c070ad8c08840c8116da865b2d65593a6bb9cd2a", git_oid_tostr_s(&roots[0]));
+ cl_assert_equal_s("6e1475206e57110fcef4b92320436c1e9872a322", git_oid_tostr_s(&roots[1]));
+
+ git_revwalk_free(walk);
+ cl_git_pass(git_revwalk_new(&walk, repo));
+ cl_git_pass(git_revwalk_push(walk, &second_oid));
+ num_commits = 0;
+ while ((error = git_revwalk_next(&oid, walk)) == GIT_OK) {
+ num_commits++;
+ }
+ cl_assert_equal_i(error, GIT_ITEROVER);
+ cl_assert_equal_i(num_commits, 1);
+
+ /* fetch full history for third commit, includes first commit which should be removed from shallow roots */
+ fetch_opts.depth = 100;
+ refspecs.strings = &third_commit;
+ refspecs.count = 1;
+ cl_git_pass(git_remote_fetch(origin, &refspecs, &fetch_opts, NULL));
+ cl_assert_equal_b(true, git_repository_is_shallow(repo));
+
+ git__free(roots);
+ cl_git_pass(git_repository__shallow_roots(&roots, &roots_len, repo));
+ cl_assert_equal_i(1, roots_len);
+ cl_assert_equal_s("6e1475206e57110fcef4b92320436c1e9872a322", git_oid_tostr_s(&roots[0]));
+
+ git_revwalk_free(walk);
+ cl_git_pass(git_revwalk_new(&walk, repo));
+ cl_git_pass(git_revwalk_push(walk, &third_oid));
+ num_commits = 0;
+ while ((error = git_revwalk_next(&oid, walk)) == GIT_OK) {
+ num_commits++;
+ }
+ cl_assert_equal_i(error, GIT_ITEROVER);
+ cl_assert_equal_i(num_commits, 12);
+
+ cl_git_pass(git_revwalk_reset(walk));
+ cl_git_pass(git_revwalk_push(walk, &second_oid));
+ num_commits = 0;
+ while ((error = git_revwalk_next(&oid, walk)) == GIT_OK) {
+ num_commits++;
+ }
+ cl_assert_equal_i(error, GIT_ITEROVER);
+ cl_assert_equal_i(num_commits, 1);
+
+ /* unshallow repository without specifying any refspec */
+ fetch_opts.depth = GIT_FETCH_DEPTH_UNSHALLOW;
+ cl_git_pass(git_remote_fetch(origin, NULL, &fetch_opts, NULL));
+ cl_assert_equal_b(false, git_repository_is_shallow(repo));
+
+ git__free(roots);
+ cl_git_pass(git_repository__shallow_roots(&roots, &roots_len, repo));
+ cl_assert_equal_i(0, roots_len);
+
+ git_revwalk_free(walk);
+ cl_git_pass(git_revwalk_new(&walk, repo));
+ cl_git_pass(git_revwalk_push(walk, &first_oid));
+ cl_git_pass(git_revwalk_push(walk, &second_oid));
+ cl_git_pass(git_revwalk_push(walk, &third_oid));
+ num_commits = 0;
+ while ((error = git_revwalk_next(&oid, walk)) == GIT_OK) {
+ num_commits++;
+ }
+ cl_assert_equal_i(error, GIT_ITEROVER);
+ cl_assert_equal_i(num_commits, 18);
+
+ git__free(roots);
+ git_remote_free(origin);
+ git_str_dispose(&path);
+ git_revwalk_free(walk);
+ git_repository_free(repo);
+}
diff --git a/tests/libgit2/pack/filelimit.c b/tests/libgit2/pack/filelimit.c
index fa08485fb92..148c8012c5c 100644
--- a/tests/libgit2/pack/filelimit.c
+++ b/tests/libgit2/pack/filelimit.c
@@ -8,7 +8,7 @@
static size_t expected_open_mwindow_files = 0;
static size_t original_mwindow_file_limit = 0;
-extern git_mutex git__mwindow_mutex;
+extern git_mutex git_mwindow__mutex;
extern git_mwindow_ctl git_mwindow__mem_ctl;
void test_pack_filelimit__initialize_tiny(void)
@@ -120,13 +120,13 @@ void test_pack_filelimit__open_repo_with_multiple_packfiles(void)
++i;
cl_assert_equal_i(commit_count, i);
- cl_git_pass(git_mutex_lock(&git__mwindow_mutex));
+ cl_git_pass(git_mutex_lock(&git_mwindow__mutex));
/*
* Adding an assert while holding a lock will cause the whole process to
* deadlock. Copy the value and do the assert after releasing the lock.
*/
open_windows = ctl->open_windows;
- cl_git_pass(git_mutex_unlock(&git__mwindow_mutex));
+ cl_git_pass(git_mutex_unlock(&git_mwindow__mutex));
cl_assert_equal_i(expected_open_mwindow_files, open_windows);
diff --git a/tests/libgit2/pack/indexer.c b/tests/libgit2/pack/indexer.c
index 9722decafc0..2d1a9d3f273 100644
--- a/tests/libgit2/pack/indexer.c
+++ b/tests/libgit2/pack/indexer.c
@@ -101,7 +101,7 @@ void test_pack_indexer__out_of_order(void)
git_indexer_progress stats = { 0 };
#ifdef GIT_EXPERIMENTAL_SHA256
- cl_git_pass(git_indexer_new(&idx, ".", GIT_OID_SHA1, NULL));
+ cl_git_pass(git_indexer_new(&idx, ".", NULL));
#else
cl_git_pass(git_indexer_new(&idx, ".", 0, NULL, NULL));
#endif
@@ -123,7 +123,7 @@ void test_pack_indexer__missing_trailer(void)
git_indexer_progress stats = { 0 };
#ifdef GIT_EXPERIMENTAL_SHA256
- cl_git_pass(git_indexer_new(&idx, ".", GIT_OID_SHA1, NULL));
+ cl_git_pass(git_indexer_new(&idx, ".", NULL));
#else
cl_git_pass(git_indexer_new(&idx, ".", 0, NULL, NULL));
#endif
@@ -144,7 +144,7 @@ void test_pack_indexer__leaky(void)
git_indexer_progress stats = { 0 };
#ifdef GIT_EXPERIMENTAL_SHA256
- cl_git_pass(git_indexer_new(&idx, ".", GIT_OID_SHA1, NULL));
+ cl_git_pass(git_indexer_new(&idx, ".", NULL));
#else
cl_git_pass(git_indexer_new(&idx, ".", 0, NULL, NULL));
#endif
@@ -173,12 +173,12 @@ void test_pack_indexer__fix_thin(void)
/* Store the missing base into your ODB so the indexer can fix the pack */
cl_git_pass(git_odb_write(&id, odb, base_obj, base_obj_len, GIT_OBJECT_BLOB));
- git_oid__fromstr(&should_id, "e68fe8129b546b101aee9510c5328e7f21ca1d18", GIT_OID_SHA1);
+ git_oid_from_string(&should_id, "e68fe8129b546b101aee9510c5328e7f21ca1d18", GIT_OID_SHA1);
cl_assert_equal_oid(&should_id, &id);
#ifdef GIT_EXPERIMENTAL_SHA256
opts.odb = odb;
- cl_git_pass(git_indexer_new(&idx, ".", GIT_OID_SHA1, &opts));
+ cl_git_pass(git_indexer_new(&idx, ".", &opts));
#else
cl_git_pass(git_indexer_new(&idx, ".", 0, odb, &opts));
#endif
@@ -215,7 +215,7 @@ void test_pack_indexer__fix_thin(void)
cl_git_pass(p_stat(name, &st));
#ifdef GIT_EXPERIMENTAL_SHA256
- cl_git_pass(git_indexer_new(&idx, ".", GIT_OID_SHA1, NULL));
+ cl_git_pass(git_indexer_new(&idx, ".", NULL));
#else
cl_git_pass(git_indexer_new(&idx, ".", 0, NULL, NULL));
#endif
@@ -250,12 +250,13 @@ void test_pack_indexer__corrupt_length(void)
/* Store the missing base into your ODB so the indexer can fix the pack */
cl_git_pass(git_odb_write(&id, odb, base_obj, base_obj_len, GIT_OBJECT_BLOB));
- git_oid__fromstr(&should_id, "e68fe8129b546b101aee9510c5328e7f21ca1d18", GIT_OID_SHA1);
+ git_oid_from_string(&should_id, "e68fe8129b546b101aee9510c5328e7f21ca1d18", GIT_OID_SHA1);
cl_assert_equal_oid(&should_id, &id);
#ifdef GIT_EXPERIMENTAL_SHA256
opts.odb = odb;
- cl_git_pass(git_indexer_new(&idx, ".", GIT_OID_SHA1, &opts));
+ opts.oid_type = GIT_OID_SHA1;
+ cl_git_pass(git_indexer_new(&idx, ".", &opts));
#else
cl_git_pass(git_indexer_new(&idx, ".", 0, odb, &opts));
#endif
@@ -281,7 +282,7 @@ void test_pack_indexer__incomplete_pack_fails_with_strict(void)
opts.verify = 1;
#ifdef GIT_EXPERIMENTAL_SHA256
- cl_git_pass(git_indexer_new(&idx, ".", GIT_OID_SHA1, &opts));
+ cl_git_pass(git_indexer_new(&idx, ".", &opts));
#else
cl_git_pass(git_indexer_new(&idx, ".", 0, NULL, &opts));
#endif
@@ -306,7 +307,7 @@ void test_pack_indexer__out_of_order_with_connectivity_checks(void)
opts.verify = 1;
#ifdef GIT_EXPERIMENTAL_SHA256
- cl_git_pass(git_indexer_new(&idx, ".", GIT_OID_SHA1, &opts));
+ cl_git_pass(git_indexer_new(&idx, ".", &opts));
#else
cl_git_pass(git_indexer_new(&idx, ".", 0, NULL, &opts));
#endif
@@ -354,7 +355,7 @@ void test_pack_indexer__no_tmp_files(void)
cl_assert(git_str_len(&first_tmp_file) == 0);
#ifdef GIT_EXPERIMENTAL_SHA256
- cl_git_pass(git_indexer_new(&idx, ".", GIT_OID_SHA1, NULL));
+ cl_git_pass(git_indexer_new(&idx, ".", NULL));
#else
cl_git_pass(git_indexer_new(&idx, ".", 0, NULL, NULL));
#endif
diff --git a/tests/libgit2/pack/midx.c b/tests/libgit2/pack/midx.c
index f7d680165bc..6384e97be67 100644
--- a/tests/libgit2/pack/midx.c
+++ b/tests/libgit2/pack/midx.c
@@ -16,10 +16,10 @@ void test_pack_midx__parse(void)
cl_git_pass(git_repository_open(&repo, cl_fixture("testrepo.git")));
cl_git_pass(git_str_joinpath(&midx_path, git_repository_path(repo), "objects/pack/multi-pack-index"));
- cl_git_pass(git_midx_open(&idx, git_str_cstr(&midx_path)));
+ cl_git_pass(git_midx_open(&idx, git_str_cstr(&midx_path), GIT_OID_SHA1));
cl_assert_equal_i(git_midx_needs_refresh(idx, git_str_cstr(&midx_path)), 0);
- cl_git_pass(git_oid__fromstr(&id, "5001298e0c09ad9c34e4249bc5801c75e9754fa5", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, "5001298e0c09ad9c34e4249bc5801c75e9754fa5", GIT_OID_SHA1));
cl_git_pass(git_midx_entry_find(&e, idx, &id, GIT_OID_SHA1_HEXSIZE));
cl_assert_equal_oid(&e.sha1, &id);
cl_assert_equal_s(
@@ -39,7 +39,7 @@ void test_pack_midx__lookup(void)
cl_git_pass(git_repository_open(&repo, cl_fixture("testrepo.git")));
- cl_git_pass(git_oid__fromstr(&id, "5001298e0c09ad9c34e4249bc5801c75e9754fa5", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, "5001298e0c09ad9c34e4249bc5801c75e9754fa5", GIT_OID_SHA1));
cl_git_pass(git_commit_lookup_prefix(&commit, repo, &id, GIT_OID_SHA1_HEXSIZE));
cl_assert_equal_s(git_commit_message(commit), "packed commit one\n");
@@ -57,7 +57,12 @@ void test_pack_midx__writer(void)
cl_git_pass(git_repository_open(&repo, cl_fixture("testrepo.git")));
cl_git_pass(git_str_joinpath(&path, git_repository_path(repo), "objects/pack"));
+
+#ifdef GIT_EXPERIMENTAL_SHA256
+ cl_git_pass(git_midx_writer_new(&w, git_str_cstr(&path), NULL));
+#else
cl_git_pass(git_midx_writer_new(&w, git_str_cstr(&path)));
+#endif
cl_git_pass(git_midx_writer_add(w, "pack-d7c6adf9f61318f041845b01440d09aa7a91e1b5.idx"));
cl_git_pass(git_midx_writer_add(w, "pack-d85f5d483273108c9d8dd0e4728ccf0b2982423a.idx"));
diff --git a/tests/libgit2/pack/packbuilder.c b/tests/libgit2/pack/packbuilder.c
index ff3dc1f68aa..2c598b6ee94 100644
--- a/tests/libgit2/pack/packbuilder.c
+++ b/tests/libgit2/pack/packbuilder.c
@@ -42,7 +42,7 @@ void test_pack_packbuilder__cleanup(void)
git_vector_foreach(&_commits, i, o) {
git__free(o);
}
- git_vector_free(&_commits);
+ git_vector_dispose(&_commits);
}
git_packbuilder_free(_packbuilder);
@@ -98,14 +98,11 @@ void test_pack_packbuilder__create_pack(void)
{
git_indexer_progress stats;
git_str buf = GIT_STR_INIT, path = GIT_STR_INIT;
- git_hash_ctx ctx;
- unsigned char hash[GIT_HASH_SHA1_SIZE];
- char hex[(GIT_HASH_SHA1_SIZE * 2) + 1];
seed_packbuilder();
#ifdef GIT_EXPERIMENTAL_SHA256
- cl_git_pass(git_indexer_new(&_indexer, ".", GIT_OID_SHA1, NULL));
+ cl_git_pass(git_indexer_new(&_indexer, ".", NULL));
#else
cl_git_pass(git_indexer_new(&_indexer, ".", 0, NULL, NULL));
#endif
@@ -114,33 +111,13 @@ void test_pack_packbuilder__create_pack(void)
cl_git_pass(git_indexer_commit(_indexer, &stats));
git_str_printf(&path, "pack-%s.pack", git_indexer_name(_indexer));
-
- /*
- * By default, packfiles are created with only one thread.
- * Therefore we can predict the object ordering and make sure
- * we create exactly the same pack as git.git does when *not*
- * reusing existing deltas (as libgit2).
- *
- * $ cd tests/resources/testrepo.git
- * $ git rev-list --objects HEAD | \
- * git pack-objects -q --no-reuse-delta --threads=1 pack
- * $ sha1sum pack-7f5fa362c664d68ba7221259be1cbd187434b2f0.pack
- * 5d410bdf97cf896f9007681b92868471d636954b
- *
- */
+ cl_assert(git_fs_path_exists(path.ptr));
cl_git_pass(git_futils_readbuffer(&buf, git_str_cstr(&path)));
-
- cl_git_pass(git_hash_ctx_init(&ctx, GIT_HASH_ALGORITHM_SHA1));
- cl_git_pass(git_hash_update(&ctx, buf.ptr, buf.size));
- cl_git_pass(git_hash_final(hash, &ctx));
- git_hash_ctx_cleanup(&ctx);
+ cl_assert(buf.size > 256);
git_str_dispose(&path);
git_str_dispose(&buf);
-
- git_hash_fmt(hex, hash, GIT_HASH_SHA1_SIZE);
- cl_assert_equal_s(hex, "5d410bdf97cf896f9007681b92868471d636954b");
}
void test_pack_packbuilder__get_name(void)
@@ -148,22 +125,49 @@ void test_pack_packbuilder__get_name(void)
seed_packbuilder();
cl_git_pass(git_packbuilder_write(_packbuilder, ".", 0, NULL, NULL));
- cl_assert_equal_s("7f5fa362c664d68ba7221259be1cbd187434b2f0", git_packbuilder_name(_packbuilder));
+ cl_assert(git_packbuilder_name(_packbuilder) != NULL);
+}
+
+static void get_packfile_path(git_str *out, git_packbuilder *pb)
+{
+ git_str_puts(out, "pack-");
+ git_str_puts(out, git_packbuilder_name(pb));
+ git_str_puts(out, ".pack");
+}
+
+static void get_index_path(git_str *out, git_packbuilder *pb)
+{
+ git_str_puts(out, "pack-");
+ git_str_puts(out, git_packbuilder_name(pb));
+ git_str_puts(out, ".idx");
}
void test_pack_packbuilder__write_default_path(void)
{
+ git_str idx = GIT_STR_INIT, pack = GIT_STR_INIT;
+
seed_packbuilder();
cl_git_pass(git_packbuilder_write(_packbuilder, NULL, 0, NULL, NULL));
- cl_assert(git_fs_path_exists("objects/pack/pack-7f5fa362c664d68ba7221259be1cbd187434b2f0.idx"));
- cl_assert(git_fs_path_exists("objects/pack/pack-7f5fa362c664d68ba7221259be1cbd187434b2f0.pack"));
+
+ git_str_puts(&idx, "objects/pack/");
+ get_index_path(&idx, _packbuilder);
+
+ git_str_puts(&pack, "objects/pack/");
+ get_packfile_path(&pack, _packbuilder);
+
+ cl_assert(git_fs_path_exists(idx.ptr));
+ cl_assert(git_fs_path_exists(pack.ptr));
+
+ git_str_dispose(&idx);
+ git_str_dispose(&pack);
}
static void test_write_pack_permission(mode_t given, mode_t expected)
{
struct stat statbuf;
mode_t mask, os_mask;
+ git_str idx = GIT_STR_INIT, pack = GIT_STR_INIT;
seed_packbuilder();
@@ -181,11 +185,17 @@ static void test_write_pack_permission(mode_t given, mode_t expected)
mask = p_umask(0);
p_umask(mask);
- cl_git_pass(p_stat("pack-7f5fa362c664d68ba7221259be1cbd187434b2f0.idx", &statbuf));
+ get_index_path(&idx, _packbuilder);
+ get_packfile_path(&pack, _packbuilder);
+
+ cl_git_pass(p_stat(idx.ptr, &statbuf));
cl_assert_equal_i(statbuf.st_mode & os_mask, (expected & ~mask) & os_mask);
- cl_git_pass(p_stat("pack-7f5fa362c664d68ba7221259be1cbd187434b2f0.pack", &statbuf));
+ cl_git_pass(p_stat(pack.ptr, &statbuf));
cl_assert_equal_i(statbuf.st_mode & os_mask, (expected & ~mask) & os_mask);
+
+ git_str_dispose(&idx);
+ git_str_dispose(&pack);
}
void test_pack_packbuilder__permissions_standard(void)
@@ -251,7 +261,7 @@ void test_pack_packbuilder__foreach(void)
seed_packbuilder();
#ifdef GIT_EXPERIMENTAL_SHA256
- cl_git_pass(git_indexer_new(&idx, ".", GIT_OID_SHA1, NULL));
+ cl_git_pass(git_indexer_new(&idx, ".", NULL));
#else
cl_git_pass(git_indexer_new(&idx, ".", 0, NULL, NULL));
#endif
@@ -275,7 +285,7 @@ void test_pack_packbuilder__foreach_with_cancel(void)
seed_packbuilder();
#ifdef GIT_EXPERIMENTAL_SHA256
- cl_git_pass(git_indexer_new(&idx, ".", GIT_OID_SHA1, NULL));
+ cl_git_pass(git_indexer_new(&idx, ".", NULL));
#else
cl_git_pass(git_indexer_new(&idx, ".", 0, NULL, NULL));
#endif
diff --git a/tests/libgit2/pack/sharing.c b/tests/libgit2/pack/sharing.c
index 2e2042d2bc9..6524a5356fd 100644
--- a/tests/libgit2/pack/sharing.c
+++ b/tests/libgit2/pack/sharing.c
@@ -1,36 +1,31 @@
#include "clar_libgit2.h"
#include <git2.h>
-#include "strmap.h"
#include "mwindow.h"
#include "pack.h"
+#include "hashmap.h"
-extern git_strmap *git__pack_cache;
+extern git_mwindow_packmap git_mwindow__pack_cache;
void test_pack_sharing__open_two_repos(void)
{
git_repository *repo1, *repo2;
git_object *obj1, *obj2;
git_oid id;
- size_t pos;
- void *data;
- int error;
+ struct git_pack_file *pack;
+ git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
cl_git_pass(git_repository_open(&repo1, cl_fixture("testrepo.git")));
cl_git_pass(git_repository_open(&repo2, cl_fixture("testrepo.git")));
- git_oid__fromstr(&id, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1);
+ git_oid_from_string(&id, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1);
cl_git_pass(git_object_lookup(&obj1, repo1, &id, GIT_OBJECT_ANY));
cl_git_pass(git_object_lookup(&obj2, repo2, &id, GIT_OBJECT_ANY));
- pos = 0;
- while ((error = git_strmap_iterate(&data, git__pack_cache, &pos, NULL)) == 0) {
- struct git_pack_file *pack = (struct git_pack_file *) data;
-
+ while (git_mwindow_packmap_iterate(&iter, NULL, &pack, &git_mwindow__pack_cache) == 0)
cl_assert_equal_i(2, pack->refcount.val);
- }
- cl_assert_equal_i(3, git_strmap_size(git__pack_cache));
+ cl_assert_equal_i(3, git_mwindow_packmap_size(&git_mwindow__pack_cache));
git_object_free(obj1);
git_object_free(obj2);
@@ -38,5 +33,5 @@ void test_pack_sharing__open_two_repos(void)
git_repository_free(repo2);
/* we don't want to keep the packs open after the repos go away */
- cl_assert_equal_i(0, git_strmap_size(git__pack_cache));
+ cl_assert_equal_i(0, git_mwindow_packmap_size(&git_mwindow__pack_cache));
}
diff --git a/tests/libgit2/perf/helper__perf__do_merge.c b/tests/libgit2/perf/helper__perf__do_merge.c
index eb10524ecc4..ce36a95aad4 100644
--- a/tests/libgit2/perf/helper__perf__do_merge.c
+++ b/tests/libgit2/perf/helper__perf__do_merge.c
@@ -26,14 +26,13 @@ void perf__do_merge(const char *fixture,
perf__timer__start(&t_total);
- checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE;
clone_opts.checkout_opts = checkout_opts;
perf__timer__start(&t_clone);
cl_git_pass(git_clone(&g_repo, fixture, test_name, &clone_opts));
perf__timer__stop(&t_clone);
-
- git_oid__fromstr(&oid_a, id_a, GIT_OID_SHA1);
+
+ git_oid_from_string(&oid_a, id_a, GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit_a, g_repo, &oid_a));
cl_git_pass(git_branch_create(&ref_branch_a, g_repo,
"A", commit_a,
@@ -45,7 +44,7 @@ void perf__do_merge(const char *fixture,
cl_git_pass(git_repository_set_head(g_repo, git_reference_name(ref_branch_a)));
- git_oid__fromstr(&oid_b, id_b, GIT_OID_SHA1);
+ git_oid_from_string(&oid_b, id_b, GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit_b, g_repo, &oid_b));
cl_git_pass(git_branch_create(&ref_branch_b, g_repo,
"B", commit_b,
diff --git a/tests/libgit2/rebase/abort.c b/tests/libgit2/rebase/abort.c
index da0dfe893a1..3bd4060ecce 100644
--- a/tests/libgit2/rebase/abort.c
+++ b/tests/libgit2/rebase/abort.c
@@ -128,8 +128,8 @@ void test_rebase_abort__merge_by_id(void)
git_oid branch_id, onto_id;
git_annotated_commit *branch_head, *onto_head;
- cl_git_pass(git_oid__fromstr(&branch_id, "b146bd7608eac53d9bf9e1a6963543588b555c64", GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&onto_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&branch_id, "b146bd7608eac53d9bf9e1a6963543588b555c64", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&onto_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&branch_head, repo, &branch_id));
cl_git_pass(git_annotated_commit_lookup(&onto_head, repo, &onto_id));
@@ -170,8 +170,8 @@ void test_rebase_abort__merge_by_id_immediately_after_init(void)
git_oid branch_id, onto_id;
git_annotated_commit *branch_head, *onto_head;
- cl_git_pass(git_oid__fromstr(&branch_id, "b146bd7608eac53d9bf9e1a6963543588b555c64", GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&onto_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&branch_id, "b146bd7608eac53d9bf9e1a6963543588b555c64", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&onto_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&branch_head, repo, &branch_id));
cl_git_pass(git_annotated_commit_lookup(&onto_head, repo, &onto_id));
@@ -195,8 +195,8 @@ void test_rebase_abort__detached_head(void)
git_signature *signature;
git_annotated_commit *branch_head, *onto_head;
- git_oid__fromstr(&branch_id, "b146bd7608eac53d9bf9e1a6963543588b555c64", GIT_OID_SHA1);
- git_oid__fromstr(&onto_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1);
+ git_oid_from_string(&branch_id, "b146bd7608eac53d9bf9e1a6963543588b555c64", GIT_OID_SHA1);
+ git_oid_from_string(&onto_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1);
cl_git_pass(git_annotated_commit_lookup(&branch_head, repo, &branch_id));
cl_git_pass(git_annotated_commit_lookup(&onto_head, repo, &onto_id));
diff --git a/tests/libgit2/rebase/inmemory.c b/tests/libgit2/rebase/inmemory.c
index 287dd991119..9646be10323 100644
--- a/tests/libgit2/rebase/inmemory.c
+++ b/tests/libgit2/rebase/inmemory.c
@@ -74,7 +74,7 @@ void test_rebase_inmemory__can_resolve_conflicts(void)
cl_git_pass(git_rebase_next(&rebase_operation, rebase));
- git_oid__fromstr(&pick_id, "33f915f9e4dbd9f4b24430e48731a59b45b15500", GIT_OID_SHA1);
+ git_oid_from_string(&pick_id, "33f915f9e4dbd9f4b24430e48731a59b45b15500", GIT_OID_SHA1);
cl_assert_equal_i(GIT_REBASE_OPERATION_PICK, rebase_operation->type);
cl_assert_equal_oid(&pick_id, &rebase_operation->id);
@@ -95,14 +95,14 @@ void test_rebase_inmemory__can_resolve_conflicts(void)
/* ensure that we can work with the in-memory index to resolve the conflict */
resolution.path = "asparagus.txt";
resolution.mode = GIT_FILEMODE_BLOB;
- git_oid__fromstr(&resolution.id, "414dfc71ead79c07acd4ea47fecf91f289afc4b9", GIT_OID_SHA1);
+ git_oid_from_string(&resolution.id, "414dfc71ead79c07acd4ea47fecf91f289afc4b9", GIT_OID_SHA1);
cl_git_pass(git_index_conflict_remove(rebase_index, "asparagus.txt"));
cl_git_pass(git_index_add(rebase_index, &resolution));
/* and finally create a commit for the resolved rebase operation */
cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature, NULL, NULL));
- cl_git_pass(git_oid__fromstr(&expected_commit_id, "db7af47222181e548810da2ab5fec0e9357c5637", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected_commit_id, "db7af47222181e548810da2ab5fec0e9357c5637", GIT_OID_SHA1));
cl_assert_equal_oid(&commit_id, &expected_commit_id);
git_status_list_free(status_list);
@@ -156,7 +156,7 @@ void test_rebase_inmemory__no_common_ancestor(void)
cl_git_pass(git_rebase_finish(rebase, signature));
- git_oid__fromstr(&expected_final_id, "71e7ee8d4fe7d8bf0d107355197e0a953dfdb7f3", GIT_OID_SHA1);
+ git_oid_from_string(&expected_final_id, "71e7ee8d4fe7d8bf0d107355197e0a953dfdb7f3", GIT_OID_SHA1);
cl_assert_equal_oid(&expected_final_id, &commit_id);
git_annotated_commit_free(branch_head);
@@ -178,7 +178,7 @@ void test_rebase_inmemory__with_directories(void)
opts.inmemory = true;
- git_oid__fromstr(&tree_id, "a4d6d9c3d57308fd8e320cf2525bae8f1adafa57", GIT_OID_SHA1);
+ git_oid_from_string(&tree_id, "a4d6d9c3d57308fd8e320cf2525bae8f1adafa57", GIT_OID_SHA1);
cl_git_pass(git_reference_lookup(&branch_ref, repo, "refs/heads/deep_gravy"));
cl_git_pass(git_reference_lookup(&upstream_ref, repo, "refs/heads/veal"));
diff --git a/tests/libgit2/rebase/iterator.c b/tests/libgit2/rebase/iterator.c
index 79e9f3e58b9..ab930bde063 100644
--- a/tests/libgit2/rebase/iterator.c
+++ b/tests/libgit2/rebase/iterator.c
@@ -30,11 +30,11 @@ static void test_operations(git_rebase *rebase, size_t expected_current)
git_oid expected_oid[5];
git_rebase_operation *operation;
- git_oid__fromstr(&expected_oid[0], "da9c51a23d02d931a486f45ad18cda05cf5d2b94", GIT_OID_SHA1);
- git_oid__fromstr(&expected_oid[1], "8d1f13f93c4995760ac07d129246ac1ff64c0be9", GIT_OID_SHA1);
- git_oid__fromstr(&expected_oid[2], "3069cc907e6294623e5917ef6de663928c1febfb", GIT_OID_SHA1);
- git_oid__fromstr(&expected_oid[3], "588e5d2f04d49707fe4aab865e1deacaf7ef6787", GIT_OID_SHA1);
- git_oid__fromstr(&expected_oid[4], "b146bd7608eac53d9bf9e1a6963543588b555c64", GIT_OID_SHA1);
+ git_oid_from_string(&expected_oid[0], "da9c51a23d02d931a486f45ad18cda05cf5d2b94", GIT_OID_SHA1);
+ git_oid_from_string(&expected_oid[1], "8d1f13f93c4995760ac07d129246ac1ff64c0be9", GIT_OID_SHA1);
+ git_oid_from_string(&expected_oid[2], "3069cc907e6294623e5917ef6de663928c1febfb", GIT_OID_SHA1);
+ git_oid_from_string(&expected_oid[3], "588e5d2f04d49707fe4aab865e1deacaf7ef6787", GIT_OID_SHA1);
+ git_oid_from_string(&expected_oid[4], "b146bd7608eac53d9bf9e1a6963543588b555c64", GIT_OID_SHA1);
cl_assert_equal_i(expected_count, git_rebase_operation_entrycount(rebase));
cl_assert_equal_i(expected_current, git_rebase_operation_current(rebase));
@@ -78,7 +78,7 @@ static void test_iterator(bool inmemory)
NULL, NULL));
test_operations(rebase, 0);
- git_oid__fromstr(&expected_id, "776e4c48922799f903f03f5f6e51da8b01e4cce0", GIT_OID_SHA1);
+ git_oid_from_string(&expected_id, "776e4c48922799f903f03f5f6e51da8b01e4cce0", GIT_OID_SHA1);
cl_assert_equal_oid(&expected_id, &commit_id);
cl_git_pass(git_rebase_next(&rebase_operation, rebase));
@@ -86,7 +86,7 @@ static void test_iterator(bool inmemory)
NULL, NULL));
test_operations(rebase, 1);
- git_oid__fromstr(&expected_id, "ba1f9b4fd5cf8151f7818be2111cc0869f1eb95a", GIT_OID_SHA1);
+ git_oid_from_string(&expected_id, "ba1f9b4fd5cf8151f7818be2111cc0869f1eb95a", GIT_OID_SHA1);
cl_assert_equal_oid(&expected_id, &commit_id);
cl_git_pass(git_rebase_next(&rebase_operation, rebase));
@@ -94,7 +94,7 @@ static void test_iterator(bool inmemory)
NULL, NULL));
test_operations(rebase, 2);
- git_oid__fromstr(&expected_id, "948b12fe18b84f756223a61bece4c307787cd5d4", GIT_OID_SHA1);
+ git_oid_from_string(&expected_id, "948b12fe18b84f756223a61bece4c307787cd5d4", GIT_OID_SHA1);
cl_assert_equal_oid(&expected_id, &commit_id);
if (!inmemory) {
@@ -107,7 +107,7 @@ static void test_iterator(bool inmemory)
NULL, NULL));
test_operations(rebase, 3);
- git_oid__fromstr(&expected_id, "d9d5d59d72c9968687f9462578d79878cd80e781", GIT_OID_SHA1);
+ git_oid_from_string(&expected_id, "d9d5d59d72c9968687f9462578d79878cd80e781", GIT_OID_SHA1);
cl_assert_equal_oid(&expected_id, &commit_id);
cl_git_pass(git_rebase_next(&rebase_operation, rebase));
@@ -115,7 +115,7 @@ static void test_iterator(bool inmemory)
NULL, NULL));
test_operations(rebase, 4);
- git_oid__fromstr(&expected_id, "9cf383c0a125d89e742c5dec58ed277dd07588b3", GIT_OID_SHA1);
+ git_oid_from_string(&expected_id, "9cf383c0a125d89e742c5dec58ed277dd07588b3", GIT_OID_SHA1);
cl_assert_equal_oid(&expected_id, &commit_id);
cl_git_fail(error = git_rebase_next(&rebase_operation, rebase));
diff --git a/tests/libgit2/rebase/merge.c b/tests/libgit2/rebase/merge.c
index 870c3ea2fd6..615b986b971 100644
--- a/tests/libgit2/rebase/merge.c
+++ b/tests/libgit2/rebase/merge.c
@@ -46,8 +46,8 @@ void test_rebase_merge__next(void)
git_oid pick_id, file1_id;
git_oid master_id, beef_id;
- git_oid__fromstr(&master_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1);
- git_oid__fromstr(&beef_id, "b146bd7608eac53d9bf9e1a6963543588b555c64", GIT_OID_SHA1);
+ git_oid_from_string(&master_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1);
+ git_oid_from_string(&beef_id, "b146bd7608eac53d9bf9e1a6963543588b555c64", GIT_OID_SHA1);
cl_git_pass(git_reference_lookup(&branch_ref, repo, "refs/heads/beef"));
cl_git_pass(git_reference_lookup(&upstream_ref, repo, "refs/heads/master"));
@@ -65,7 +65,7 @@ void test_rebase_merge__next(void)
cl_git_pass(git_rebase_next(&rebase_operation, rebase));
- git_oid__fromstr(&pick_id, "da9c51a23d02d931a486f45ad18cda05cf5d2b94", GIT_OID_SHA1);
+ git_oid_from_string(&pick_id, "da9c51a23d02d931a486f45ad18cda05cf5d2b94", GIT_OID_SHA1);
cl_assert_equal_i(GIT_REBASE_OPERATION_PICK, rebase_operation->type);
cl_assert_equal_oid(&pick_id, &rebase_operation->id);
@@ -78,7 +78,7 @@ void test_rebase_merge__next(void)
cl_assert_equal_s("beef.txt", status_entry->head_to_index->new_file.path);
- git_oid__fromstr(&file1_id, "8d95ea62e621f1d38d230d9e7d206e41096d76af", GIT_OID_SHA1);
+ git_oid_from_string(&file1_id, "8d95ea62e621f1d38d230d9e7d206e41096d76af", GIT_OID_SHA1);
cl_assert_equal_oid(&file1_id, &status_entry->head_to_index->new_file.id);
git_status_list_free(status_list);
@@ -129,7 +129,7 @@ void test_rebase_merge__next_with_conflicts(void)
cl_git_pass(git_rebase_next(&rebase_operation, rebase));
- git_oid__fromstr(&pick_id, "33f915f9e4dbd9f4b24430e48731a59b45b15500", GIT_OID_SHA1);
+ git_oid_from_string(&pick_id, "33f915f9e4dbd9f4b24430e48731a59b45b15500", GIT_OID_SHA1);
cl_assert_equal_i(GIT_REBASE_OPERATION_PICK, rebase_operation->type);
cl_assert_equal_oid(&pick_id, &rebase_operation->id);
@@ -230,11 +230,11 @@ void test_rebase_merge__commit(void)
cl_git_pass(git_commit_lookup(&commit, repo, &commit_id));
- git_oid__fromstr(&parent_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1);
+ git_oid_from_string(&parent_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1);
cl_assert_equal_i(1, git_commit_parentcount(commit));
cl_assert_equal_oid(&parent_id, git_commit_parent_id(commit, 0));
- git_oid__fromstr(&tree_id, "4461379789c777d2a6c1f2ee0e9d6c86731b9992", GIT_OID_SHA1);
+ git_oid_from_string(&tree_id, "4461379789c777d2a6c1f2ee0e9d6c86731b9992", GIT_OID_SHA1);
cl_assert_equal_oid(&tree_id, git_commit_tree_id(commit));
cl_assert_equal_s(NULL, git_commit_message_encoding(commit));
@@ -275,8 +275,8 @@ void test_rebase_merge__commit_with_id(void)
git_reflog *reflog;
const git_reflog_entry *reflog_entry;
- cl_git_pass(git_oid__fromstr(&branch_id, "b146bd7608eac53d9bf9e1a6963543588b555c64", GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&upstream_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&branch_id, "b146bd7608eac53d9bf9e1a6963543588b555c64", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&upstream_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&branch_head, repo, &branch_id));
cl_git_pass(git_annotated_commit_lookup(&upstream_head, repo, &upstream_id));
@@ -289,11 +289,11 @@ void test_rebase_merge__commit_with_id(void)
cl_git_pass(git_commit_lookup(&commit, repo, &commit_id));
- git_oid__fromstr(&parent_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1);
+ git_oid_from_string(&parent_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1);
cl_assert_equal_i(1, git_commit_parentcount(commit));
cl_assert_equal_oid(&parent_id, git_commit_parent_id(commit, 0));
- git_oid__fromstr(&tree_id, "4461379789c777d2a6c1f2ee0e9d6c86731b9992", GIT_OID_SHA1);
+ git_oid_from_string(&tree_id, "4461379789c777d2a6c1f2ee0e9d6c86731b9992", GIT_OID_SHA1);
cl_assert_equal_oid(&tree_id, git_commit_tree_id(commit));
cl_assert_equal_s(NULL, git_commit_message_encoding(commit));
@@ -551,8 +551,8 @@ void test_rebase_merge__finish_with_ids(void)
const git_reflog_entry *reflog_entry;
int error;
- cl_git_pass(git_oid__fromstr(&branch_id, "d616d97082eb7bb2dc6f180a7cca940993b7a56f", GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&upstream_id, "f87d14a4a236582a0278a916340a793714256864", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&branch_id, "d616d97082eb7bb2dc6f180a7cca940993b7a56f", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&upstream_id, "f87d14a4a236582a0278a916340a793714256864", GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&branch_head, repo, &branch_id));
cl_git_pass(git_annotated_commit_lookup(&upstream_head, repo, &upstream_id));
@@ -627,7 +627,7 @@ void test_rebase_merge__no_common_ancestor(void)
cl_git_pass(git_rebase_finish(rebase, signature));
- git_oid__fromstr(&expected_final_id, "71e7ee8d4fe7d8bf0d107355197e0a953dfdb7f3", GIT_OID_SHA1);
+ git_oid_from_string(&expected_final_id, "71e7ee8d4fe7d8bf0d107355197e0a953dfdb7f3", GIT_OID_SHA1);
cl_assert_equal_oid(&expected_final_id, &commit_id);
git_annotated_commit_free(branch_head);
@@ -823,7 +823,7 @@ void test_rebase_merge__with_directories(void)
git_oid commit_id, tree_id;
git_commit *commit;
- git_oid__fromstr(&tree_id, "a4d6d9c3d57308fd8e320cf2525bae8f1adafa57", GIT_OID_SHA1);
+ git_oid_from_string(&tree_id, "a4d6d9c3d57308fd8e320cf2525bae8f1adafa57", GIT_OID_SHA1);
cl_git_pass(git_reference_lookup(&branch_ref, repo, "refs/heads/deep_gravy"));
cl_git_pass(git_reference_lookup(&upstream_ref, repo, "refs/heads/veal"));
diff --git a/tests/libgit2/rebase/setup.c b/tests/libgit2/rebase/setup.c
index ac0d087ea6e..10cc306de34 100644
--- a/tests/libgit2/rebase/setup.c
+++ b/tests/libgit2/rebase/setup.c
@@ -74,7 +74,7 @@ void test_rebase_setup__merge(void)
cl_assert_equal_i(GIT_REPOSITORY_STATE_REBASE_MERGE, git_repository_state(repo));
- git_oid__fromstr(&head_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1);
+ git_oid_from_string(&head_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1);
cl_git_pass(git_repository_head(&head, repo));
cl_git_pass(git_reference_peel((git_object **)&head_commit, head, GIT_OBJECT_COMMIT));
cl_assert_equal_oid(&head_id, git_commit_id(head_commit));
@@ -120,7 +120,7 @@ void test_rebase_setup__merge_root(void)
cl_git_pass(git_rebase_init(&rebase, repo, branch_head, NULL, onto_head, NULL));
- git_oid__fromstr(&head_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1);
+ git_oid_from_string(&head_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1);
cl_git_pass(git_repository_head(&head, repo));
cl_git_pass(git_reference_peel((git_object **)&head_commit, head, GIT_OBJECT_COMMIT));
cl_assert_equal_oid(&head_id, git_commit_id(head_commit));
@@ -170,7 +170,7 @@ void test_rebase_setup__merge_onto_and_upstream(void)
cl_git_pass(git_rebase_init(&rebase, repo, branch1_head, branch2_head, onto_head, NULL));
- git_oid__fromstr(&head_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1);
+ git_oid_from_string(&head_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1);
cl_git_pass(git_repository_head(&head, repo));
cl_git_pass(git_reference_peel((git_object **)&head_commit, head, GIT_OBJECT_COMMIT));
cl_assert_equal_oid(&head_id, git_commit_id(head_commit));
@@ -224,7 +224,7 @@ void test_rebase_setup__merge_onto_upstream_and_branch(void)
cl_git_pass(git_rebase_init(&rebase, repo, branch_head, upstream_head, onto_head, NULL));
- git_oid__fromstr(&head_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1);
+ git_oid_from_string(&head_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1);
cl_git_pass(git_repository_head(&head, repo));
cl_git_pass(git_reference_peel((git_object **)&head_commit, head, GIT_OBJECT_COMMIT));
cl_assert_equal_oid(&head_id, git_commit_id(head_commit));
@@ -272,9 +272,9 @@ void test_rebase_setup__merge_onto_upstream_and_branch_by_id(void)
cl_git_pass(git_repository_set_head(repo, "refs/heads/beef"));
cl_git_pass(git_checkout_head(repo, &checkout_opts));
- cl_git_pass(git_oid__fromstr(&upstream_id, "f87d14a4a236582a0278a916340a793714256864", GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&branch_id, "d616d97082eb7bb2dc6f180a7cca940993b7a56f", GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&onto_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&upstream_id, "f87d14a4a236582a0278a916340a793714256864", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&branch_id, "d616d97082eb7bb2dc6f180a7cca940993b7a56f", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&onto_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&upstream_head, repo, &upstream_id));
cl_git_pass(git_annotated_commit_lookup(&branch_head, repo, &branch_id));
@@ -282,7 +282,7 @@ void test_rebase_setup__merge_onto_upstream_and_branch_by_id(void)
cl_git_pass(git_rebase_init(&rebase, repo, branch_head, upstream_head, onto_head, NULL));
- git_oid__fromstr(&head_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1);
+ git_oid_from_string(&head_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1);
cl_git_pass(git_repository_head(&head, repo));
cl_git_pass(git_reference_peel((git_object **)&head_commit, head, GIT_OBJECT_COMMIT));
cl_assert_equal_oid(&head_id, git_commit_id(head_commit));
@@ -328,7 +328,7 @@ void test_rebase_setup__branch_with_merges(void)
cl_assert_equal_i(GIT_REPOSITORY_STATE_REBASE_MERGE, git_repository_state(repo));
- git_oid__fromstr(&head_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1);
+ git_oid_from_string(&head_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1);
cl_git_pass(git_repository_head(&head, repo));
cl_git_pass(git_reference_peel((git_object **)&head_commit, head, GIT_OBJECT_COMMIT));
cl_assert_equal_oid(&head_id, git_commit_id(head_commit));
@@ -376,7 +376,7 @@ void test_rebase_setup__orphan_branch(void)
cl_assert_equal_i(GIT_REPOSITORY_STATE_REBASE_MERGE, git_repository_state(repo));
- git_oid__fromstr(&head_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1);
+ git_oid_from_string(&head_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1);
cl_git_pass(git_repository_head(&head, repo));
cl_git_pass(git_reference_peel((git_object **)&head_commit, head, GIT_OBJECT_COMMIT));
cl_assert_equal_oid(&head_id, git_commit_id(head_commit));
@@ -427,7 +427,7 @@ void test_rebase_setup__merge_null_branch_uses_HEAD(void)
cl_assert_equal_i(GIT_REPOSITORY_STATE_REBASE_MERGE, git_repository_state(repo));
- git_oid__fromstr(&head_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1);
+ git_oid_from_string(&head_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1);
cl_git_pass(git_repository_head(&head, repo));
cl_git_pass(git_reference_peel((git_object **)&head_commit, head, GIT_OBJECT_COMMIT));
cl_assert_equal_oid(&head_id, git_commit_id(head_commit));
@@ -465,7 +465,7 @@ void test_rebase_setup__merge_from_detached(void)
cl_git_pass(git_reference_lookup(&upstream_ref, repo, "refs/heads/master"));
- cl_git_pass(git_oid__fromstr(&branch_id, "b146bd7608eac53d9bf9e1a6963543588b555c64", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&branch_id, "b146bd7608eac53d9bf9e1a6963543588b555c64", GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_lookup(&branch_head, repo, &branch_id));
cl_git_pass(git_annotated_commit_from_ref(&upstream_head, repo, upstream_ref));
@@ -474,7 +474,7 @@ void test_rebase_setup__merge_from_detached(void)
cl_assert_equal_i(GIT_REPOSITORY_STATE_REBASE_MERGE, git_repository_state(repo));
- git_oid__fromstr(&head_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1);
+ git_oid_from_string(&head_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1);
cl_git_pass(git_repository_head(&head, repo));
cl_git_pass(git_reference_peel((git_object **)&head_commit, head, GIT_OBJECT_COMMIT));
cl_assert_equal_oid(&head_id, git_commit_id(head_commit));
@@ -513,7 +513,7 @@ void test_rebase_setup__merge_branch_by_id(void)
cl_git_pass(git_reference_lookup(&branch_ref, repo, "refs/heads/beef"));
- cl_git_pass(git_oid__fromstr(&upstream_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&upstream_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1));
cl_git_pass(git_annotated_commit_from_ref(&branch_head, repo, branch_ref));
cl_git_pass(git_annotated_commit_lookup(&upstream_head, repo, &upstream_id));
@@ -522,7 +522,7 @@ void test_rebase_setup__merge_branch_by_id(void)
cl_assert_equal_i(GIT_REPOSITORY_STATE_REBASE_MERGE, git_repository_state(repo));
- git_oid__fromstr(&head_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1);
+ git_oid_from_string(&head_id, "efad0b11c47cb2f0220cbd6f5b0f93bb99064b00", GIT_OID_SHA1);
cl_git_pass(git_repository_head(&head, repo));
cl_git_pass(git_reference_peel((git_object **)&head_commit, head, GIT_OBJECT_COMMIT));
cl_assert_equal_oid(&head_id, git_commit_id(head_commit));
diff --git a/tests/libgit2/rebase/sign.c b/tests/libgit2/rebase/sign.c
index 69bb1c6f998..869f5674a61 100644
--- a/tests/libgit2/rebase/sign.c
+++ b/tests/libgit2/rebase/sign.c
@@ -70,7 +70,7 @@ committer Rebaser <rebaser@rebaser.rb> 1405694510 +0000\n";
cl_git_pass(git_rebase_next(&rebase_operation, rebase));
cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature, NULL, NULL));
- git_oid__fromstr(&expected_id, "129183968a65abd6c52da35bff43325001bfc630", GIT_OID_SHA1);
+ git_oid_from_string(&expected_id, "129183968a65abd6c52da35bff43325001bfc630", GIT_OID_SHA1);
cl_assert_equal_oid(&expected_id, &commit_id);
cl_git_pass(git_commit_lookup(&commit, repo, &commit_id));
@@ -178,7 +178,7 @@ gpgsig -----BEGIN PGP SIGNATURE-----\n\
cl_git_pass(git_rebase_next(&rebase_operation, rebase));
cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature, NULL, NULL));
- git_oid__fromstr(&expected_id, "bf78348e45c8286f52b760f1db15cb6da030f2ef", GIT_OID_SHA1);
+ git_oid_from_string(&expected_id, "bf78348e45c8286f52b760f1db15cb6da030f2ef", GIT_OID_SHA1);
cl_assert_equal_oid(&expected_id, &commit_id);
cl_git_pass(git_commit_lookup(&commit, repo, &commit_id));
@@ -300,7 +300,7 @@ committer Rebaser <rebaser@rebaser.rb> 1405694510 +0000\n";
cl_git_pass(git_rebase_next(&rebase_operation, rebase));
cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature, NULL, NULL));
- git_oid__fromstr(&expected_id, "129183968a65abd6c52da35bff43325001bfc630", GIT_OID_SHA1);
+ git_oid_from_string(&expected_id, "129183968a65abd6c52da35bff43325001bfc630", GIT_OID_SHA1);
cl_assert_equal_oid(&expected_id, &commit_id);
cl_git_pass(git_commit_lookup(&commit, repo, &commit_id));
@@ -398,7 +398,7 @@ gpgsig -----BEGIN PGP SIGNATURE-----\n\
cl_git_pass(git_rebase_next(&rebase_operation, rebase));
cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature, NULL, NULL));
- git_oid__fromstr(&expected_id, "bf78348e45c8286f52b760f1db15cb6da030f2ef", GIT_OID_SHA1);
+ git_oid_from_string(&expected_id, "bf78348e45c8286f52b760f1db15cb6da030f2ef", GIT_OID_SHA1);
cl_assert_equal_oid(&expected_id, &commit_id);
cl_git_pass(git_commit_lookup(&commit, repo, &commit_id));
@@ -473,7 +473,7 @@ magicsig magic word: pretty please\n";
cl_git_pass(git_rebase_next(&rebase_operation, rebase));
cl_git_pass(git_rebase_commit(&commit_id, rebase, NULL, signature, NULL, NULL));
- git_oid__fromstr(&expected_id, "f46a4a8d26ae411b02aa61b7d69576627f4a1e1c", GIT_OID_SHA1);
+ git_oid_from_string(&expected_id, "f46a4a8d26ae411b02aa61b7d69576627f4a1e1c", GIT_OID_SHA1);
cl_assert_equal_oid(&expected_id, &commit_id);
cl_git_pass(git_commit_lookup(&commit, repo, &commit_id));
diff --git a/tests/libgit2/refs/basic.c b/tests/libgit2/refs/basic.c
index 5e41ca07443..b1f770b99a8 100644
--- a/tests/libgit2/refs/basic.c
+++ b/tests/libgit2/refs/basic.c
@@ -53,7 +53,7 @@ void test_refs_basic__longpaths(void)
git_reference *one = NULL, *two = NULL;
git_oid id;
- cl_git_pass(git_oid__fromstr(&id, "099fabac3a9ea935598528c27f866e34089c2eff", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, "099fabac3a9ea935598528c27f866e34089c2eff", GIT_OID_SHA1));
base = git_repository_path(g_repo);
base_len = git_utf8_char_length(base, strlen(base));
diff --git a/tests/libgit2/refs/branches/delete.c b/tests/libgit2/refs/branches/delete.c
index 6b3d507a869..2c28dd294fa 100644
--- a/tests/libgit2/refs/branches/delete.c
+++ b/tests/libgit2/refs/branches/delete.c
@@ -14,7 +14,7 @@ void test_refs_branches_delete__initialize(void)
repo = cl_git_sandbox_init("testrepo.git");
- cl_git_pass(git_oid__fromstr(&id, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1));
cl_git_pass(git_reference_create(&fake_remote, repo, "refs/remotes/nulltoken/master", &id, 0, NULL));
}
@@ -92,6 +92,21 @@ void test_refs_branches_delete__can_delete_a_local_branch(void)
git_reference_free(branch);
}
+void test_refs_branches_delete__can_delete_a_local_branch_with_multivar(void)
+{
+ git_reference *branch;
+ git_config *cfg;
+
+ cl_git_pass(git_repository_config(&cfg, repo));
+ cl_git_pass(git_config_set_multivar(
+ cfg, "branch.br2.gitpublishto", "^$", "example1@example.com"));
+ cl_git_pass(git_config_set_multivar(
+ cfg, "branch.br2.gitpublishto", "^$", "example2@example.com"));
+ cl_git_pass(git_branch_lookup(&branch, repo, "br2", GIT_BRANCH_LOCAL));
+ cl_git_pass(git_branch_delete(branch));
+ git_reference_free(branch);
+}
+
void test_refs_branches_delete__can_delete_a_remote_branch(void)
{
git_reference *branch;
@@ -157,7 +172,7 @@ void test_refs_branches_delete__removes_empty_folders(void)
git_str reflog_folder = GIT_STR_INIT;
/* Create a new branch with a nested name */
- cl_git_pass(git_oid__fromstr(&commit_id, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&commit_id, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1));
cl_git_pass(git_commit_lookup(&commit, repo, &commit_id));
cl_git_pass(git_branch_create(&branch, repo, "some/deep/ref", commit, 0));
git_commit_free(commit);
diff --git a/tests/libgit2/refs/branches/iterator.c b/tests/libgit2/refs/branches/iterator.c
index a295d553b80..e4913642888 100644
--- a/tests/libgit2/refs/branches/iterator.c
+++ b/tests/libgit2/refs/branches/iterator.c
@@ -11,7 +11,7 @@ void test_refs_branches_iterator__initialize(void)
cl_fixture_sandbox("testrepo.git");
cl_git_pass(git_repository_open(&repo, "testrepo.git"));
- cl_git_pass(git_oid__fromstr(&id, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1));
cl_git_pass(git_reference_create(&fake_remote, repo, "refs/remotes/nulltoken/master", &id, 0, NULL));
}
diff --git a/tests/libgit2/refs/branches/move.c b/tests/libgit2/refs/branches/move.c
index 46a5082d2fd..4cfb7b83ae6 100644
--- a/tests/libgit2/refs/branches/move.c
+++ b/tests/libgit2/refs/branches/move.c
@@ -210,3 +210,41 @@ void test_refs_branches_move__can_move_with_unicode(void)
git_reference_free(original_ref);
git_reference_free(new_ref);
}
+
+void test_refs_branches_move__moves_reflog_correctly(void)
+{
+ git_reference *original_ref, *new_ref;
+ git_reflog *original_reflog, *new_reflog;
+
+ cl_git_pass(git_reference_lookup(&original_ref, repo, "refs/heads/br2"));
+
+ cl_git_pass(git_reflog_read(&original_reflog, repo, "refs/heads/br2"));
+ cl_assert_equal_i(2, git_reflog_entrycount(original_reflog));
+
+ cl_git_pass(git_branch_move(&new_ref, original_ref, NEW_BRANCH_NAME, 0));
+ cl_assert_equal_s(GIT_REFS_HEADS_DIR NEW_BRANCH_NAME, git_reference_name(new_ref));
+
+ cl_git_pass(git_reflog_read(&new_reflog, repo, GIT_REFS_HEADS_DIR NEW_BRANCH_NAME));
+ cl_assert_equal_i(3, git_reflog_entrycount(new_reflog));
+
+ git_reference_free(original_ref);
+ git_reference_free(new_ref);
+ git_reflog_free(original_reflog);
+ git_reflog_free(new_reflog);
+}
+
+void test_refs_branches_move__failed_move_restores_reflog(void)
+{
+ git_reference *original_ref, *new_ref;
+ git_reflog *recovered_reflog;
+
+ cl_git_pass(git_reference_lookup(&original_ref, repo, "refs/heads/br2"));
+
+ cl_assert_equal_i(GIT_EINVALIDSPEC, git_branch_move(&new_ref, original_ref, "Inv@{id", 0));
+
+ cl_git_pass(git_reflog_read(&recovered_reflog, repo, "refs/heads/br2"));
+ cl_assert_equal_i(2, git_reflog_entrycount(recovered_reflog));
+
+ git_reference_free(original_ref);
+ git_reflog_free(recovered_reflog);
+}
diff --git a/tests/libgit2/refs/cmp.c b/tests/libgit2/refs/cmp.c
new file mode 100644
index 00000000000..78d90b04a98
--- /dev/null
+++ b/tests/libgit2/refs/cmp.c
@@ -0,0 +1,27 @@
+#include "clar_libgit2.h"
+#include "refs.h"
+
+static git_repository *g_repo;
+
+void test_refs_cmp__initialize(void)
+{
+ g_repo = cl_git_sandbox_init("testrepo2");
+}
+
+void test_refs_cmp__cleanup(void)
+{
+ cl_git_sandbox_cleanup();
+}
+
+void test_refs_cmp__symbolic(void)
+{
+ git_reference *one, *two;
+
+ cl_git_pass(git_reference_lookup(&one, g_repo, "refs/heads/symbolic-one"));
+ cl_git_pass(git_reference_lookup(&two, g_repo, "refs/heads/symbolic-two"));
+
+ cl_assert(git_reference_cmp(one, two) != 0);
+
+ git_reference_free(one);
+ git_reference_free(two);
+}
diff --git a/tests/libgit2/refs/create.c b/tests/libgit2/refs/create.c
index 1dafcf61a8f..aca6ecd63b5 100644
--- a/tests/libgit2/refs/create.c
+++ b/tests/libgit2/refs/create.c
@@ -34,7 +34,7 @@ void test_refs_create__symbolic(void)
const char *new_head_tracker = "ANOTHER_HEAD_TRACKER";
- git_oid__fromstr(&id, current_master_tip, GIT_OID_SHA1);
+ git_oid_from_string(&id, current_master_tip, GIT_OID_SHA1);
/* Create and write the new symbolic reference */
cl_git_pass(git_reference_symbolic_create(&new_reference, g_repo, new_head_tracker, current_head_target, 0, NULL));
@@ -77,7 +77,7 @@ void test_refs_create__symbolic_with_arbitrary_content(void)
const char *new_head_tracker = "ANOTHER_HEAD_TRACKER";
const char *arbitrary_target = "ARBITRARY DATA";
- git_oid__fromstr(&id, current_master_tip, GIT_OID_SHA1);
+ git_oid_from_string(&id, current_master_tip, GIT_OID_SHA1);
/* Attempt to create symbolic ref with arbitrary data in target
* fails by default
@@ -124,7 +124,7 @@ void test_refs_create__deep_symbolic(void)
const char *new_head_tracker = "deep/rooted/tracker";
- git_oid__fromstr(&id, current_master_tip, GIT_OID_SHA1);
+ git_oid_from_string(&id, current_master_tip, GIT_OID_SHA1);
cl_git_pass(git_reference_symbolic_create(&new_reference, g_repo, new_head_tracker, current_head_target, 0, NULL));
cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, new_head_tracker));
@@ -145,7 +145,7 @@ void test_refs_create__oid(void)
const char *new_head = "refs/heads/new-head";
- git_oid__fromstr(&id, current_master_tip, GIT_OID_SHA1);
+ git_oid_from_string(&id, current_master_tip, GIT_OID_SHA1);
/* Create and write the new object id reference */
cl_git_pass(git_reference_create(&new_reference, g_repo, new_head, &id, 0, NULL));
@@ -180,7 +180,7 @@ void test_refs_create__oid_unknown_succeeds_without_strict(void)
const char *new_head = "refs/heads/new-head";
- git_oid__fromstr(&id, "deadbeef3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1);
+ git_oid_from_string(&id, "deadbeef3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1);
cl_git_pass(git_libgit2_opts(GIT_OPT_ENABLE_STRICT_OBJECT_CREATION, 0));
@@ -201,7 +201,7 @@ void test_refs_create__oid_unknown_fails_by_default(void)
const char *new_head = "refs/heads/new-head";
- git_oid__fromstr(&id, "deadbeef3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1);
+ git_oid_from_string(&id, "deadbeef3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1);
/* Create and write the new object id reference */
cl_git_fail(git_reference_create(&new_reference, g_repo, new_head, &id, 0, NULL));
@@ -215,7 +215,7 @@ void test_refs_create__propagate_eexists(void)
git_oid oid;
/* Make sure it works for oid and for symbolic both */
- cl_git_pass(git_oid__fromstr(&oid, current_master_tip, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, current_master_tip, GIT_OID_SHA1));
cl_git_fail_with(GIT_EEXISTS, git_reference_create(NULL, g_repo, current_head_target, &oid, false, NULL));
cl_git_fail_with(GIT_EEXISTS, git_reference_symbolic_create(NULL, g_repo, "HEAD", current_head_target, false, NULL));
}
@@ -227,7 +227,7 @@ void test_refs_create__existing_dir_propagates_edirectory(void)
const char *dir_head = "refs/heads/new-dir/new-head",
*fail_head = "refs/heads/new-dir";
- git_oid__fromstr(&id, current_master_tip, GIT_OID_SHA1);
+ git_oid_from_string(&id, current_master_tip, GIT_OID_SHA1);
/* Create and write the new object id reference */
cl_git_pass(git_reference_create(&new_reference, g_repo, dir_head, &id, 1, NULL));
@@ -242,7 +242,7 @@ static void test_invalid_name(const char *name)
git_reference *new_reference;
git_oid id;
- git_oid__fromstr(&id, current_master_tip, GIT_OID_SHA1);
+ git_oid_from_string(&id, current_master_tip, GIT_OID_SHA1);
cl_assert_equal_i(GIT_EINVALIDSPEC, git_reference_create(
&new_reference, g_repo, name, &id, 0, NULL));
@@ -272,7 +272,7 @@ static void test_win32_name(const char *name)
git_oid id;
int ret;
- git_oid__fromstr(&id, current_master_tip, GIT_OID_SHA1);
+ git_oid_from_string(&id, current_master_tip, GIT_OID_SHA1);
ret = git_reference_create(&new_reference, g_repo, name, &id, 0, NULL);
@@ -314,7 +314,7 @@ static void count_fsyncs(size_t *create_count, size_t *compress_count)
p_fsync__cnt = 0;
- git_oid__fromstr(&id, current_master_tip, GIT_OID_SHA1);
+ git_oid_from_string(&id, current_master_tip, GIT_OID_SHA1);
cl_git_pass(git_reference_create(&ref, g_repo, "refs/heads/fsync_test", &id, 0, "log message"));
git_reference_free(ref);
diff --git a/tests/libgit2/refs/delete.c b/tests/libgit2/refs/delete.c
index edb521f4a2f..b420bb157a9 100644
--- a/tests/libgit2/refs/delete.c
+++ b/tests/libgit2/refs/delete.c
@@ -63,7 +63,7 @@ void test_refs_delete__packed_only(void)
git_oid id;
const char *new_ref = "refs/heads/new_ref";
- git_oid__fromstr(&id, current_master_tip, GIT_OID_SHA1);
+ git_oid_from_string(&id, current_master_tip, GIT_OID_SHA1);
/* Create and write the new object id reference */
cl_git_pass(git_reference_create(&ref, g_repo, new_ref, &id, 0, NULL));
diff --git a/tests/libgit2/refs/foreachglob.c b/tests/libgit2/refs/foreachglob.c
index a586ca08c30..4f0b91325f1 100644
--- a/tests/libgit2/refs/foreachglob.c
+++ b/tests/libgit2/refs/foreachglob.c
@@ -11,7 +11,7 @@ void test_refs_foreachglob__initialize(void)
cl_fixture_sandbox("testrepo.git");
cl_git_pass(git_repository_open(&repo, "testrepo.git"));
- cl_git_pass(git_oid__fromstr(&id, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1));
cl_git_pass(git_reference_create(&fake_remote, repo, "refs/remotes/nulltoken/master", &id, 0, NULL));
}
diff --git a/tests/libgit2/refs/iterator.c b/tests/libgit2/refs/iterator.c
index f40d35d1171..d79d968a588 100644
--- a/tests/libgit2/refs/iterator.c
+++ b/tests/libgit2/refs/iterator.c
@@ -2,6 +2,7 @@
#include "refs.h"
#include "vector.h"
#include "odb.h"
+#include "repository.h"
static git_repository *repo;
@@ -95,7 +96,7 @@ static void assert_all_refnames_match(const char **expected, git_vector *names)
}
cl_assert(expected[i] == NULL);
- git_vector_free(names);
+ git_vector_dispose(names);
}
void test_refs_iterator__list(void)
@@ -127,7 +128,7 @@ void test_refs_iterator__empty(void)
git_reference *ref;
git_repository *empty;
- cl_git_pass(git_odb__new(&odb, NULL));
+ cl_git_pass(git_odb_new(&odb));
cl_git_pass(git_repository_wrap_odb(&empty, odb));
cl_git_pass(git_reference_iterator_new(&iter, empty));
@@ -221,7 +222,7 @@ void test_refs_iterator__foreach_name(void)
git__free(name);
}
- git_vector_free(&output);
+ git_vector_dispose(&output);
}
static int refs_foreach_name_cancel_cb(const char *name, void *payload)
diff --git a/tests/libgit2/refs/lookup.c b/tests/libgit2/refs/lookup.c
index 2b8be77f830..16684ce60ca 100644
--- a/tests/libgit2/refs/lookup.c
+++ b/tests/libgit2/refs/lookup.c
@@ -43,7 +43,7 @@ void test_refs_lookup__oid(void)
git_oid tag, expected;
cl_git_pass(git_reference_name_to_id(&tag, g_repo, "refs/tags/point_to_blob"));
- cl_git_pass(git_oid__fromstr(&expected, "1385f264afb75a56a5bec74243be9b367ba4ca08", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected, "1385f264afb75a56a5bec74243be9b367ba4ca08", GIT_OID_SHA1));
cl_assert_equal_oid(&expected, &tag);
}
diff --git a/tests/libgit2/refs/normalize.c b/tests/libgit2/refs/normalize.c
index ff815002c20..c2f5684ef17 100644
--- a/tests/libgit2/refs/normalize.c
+++ b/tests/libgit2/refs/normalize.c
@@ -229,8 +229,6 @@ void test_refs_normalize__jgit_suite(void)
GIT_REFERENCE_FORMAT_ALLOW_ONELEVEL, "refs/heads/master^");
ensure_refname_invalid(
GIT_REFERENCE_FORMAT_ALLOW_ONELEVEL, "refs/heads/^master");
- ensure_refname_invalid(
- GIT_REFERENCE_FORMAT_ALLOW_ONELEVEL, "^refs/heads/master");
ensure_refname_invalid(
GIT_REFERENCE_FORMAT_ALLOW_ONELEVEL, "refs/heads/master~");
@@ -399,3 +397,13 @@ void test_refs_normalize__refspec_pattern(void)
ensure_refname_invalid(
ONE_LEVEL_AND_REFSPEC, "*/*/foo");
}
+
+void test_refs_normalize__negative_refspec_pattern(void)
+{
+ ensure_refname_normalized(
+ GIT_REFERENCE_FORMAT_REFSPEC_PATTERN, "^foo/bar", "^foo/bar");
+ ensure_refname_normalized(
+ GIT_REFERENCE_FORMAT_REFSPEC_PATTERN, "^foo/bar/*", "^foo/bar/*");
+ ensure_refname_invalid(
+ GIT_REFERENCE_FORMAT_REFSPEC_PATTERN, "foo/^bar");
+}
diff --git a/tests/libgit2/refs/peel.c b/tests/libgit2/refs/peel.c
index fefd2d26030..7de0508f02f 100644
--- a/tests/libgit2/refs/peel.c
+++ b/tests/libgit2/refs/peel.c
@@ -32,7 +32,7 @@ static void assert_peel_generic(
cl_git_pass(git_reference_peel(&peeled, ref, requested_type));
- cl_git_pass(git_oid__fromstr(&expected_oid, expected_sha, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected_oid, expected_sha, GIT_OID_SHA1));
cl_assert_equal_oid(&expected_oid, git_object_id(peeled));
cl_assert_equal_i(expected_type, git_object_type(peeled));
diff --git a/tests/libgit2/refs/races.c b/tests/libgit2/refs/races.c
index bf46b760eac..243e04f65c8 100644
--- a/tests/libgit2/refs/races.c
+++ b/tests/libgit2/refs/races.c
@@ -27,8 +27,8 @@ void test_refs_races__create_matching_zero_old(void)
git_reference *ref;
git_oid id, zero_id;
- git_oid__fromstr(&id, commit_id, GIT_OID_SHA1);
- git_oid__fromstr(&zero_id, "0000000000000000000000000000000000000000", GIT_OID_SHA1);
+ git_oid_from_string(&id, commit_id, GIT_OID_SHA1);
+ git_oid_from_string(&zero_id, "0000000000000000000000000000000000000000", GIT_OID_SHA1);
cl_git_fail(git_reference_create_matching(&ref, g_repo, refname, &id, 1, &zero_id, NULL));
git_reference_free(ref);
@@ -45,8 +45,8 @@ void test_refs_races__create_matching(void)
git_reference *ref, *ref2, *ref3;
git_oid id, other_id;
- git_oid__fromstr(&id, commit_id, GIT_OID_SHA1);
- git_oid__fromstr(&other_id, other_commit_id, GIT_OID_SHA1);
+ git_oid_from_string(&id, commit_id, GIT_OID_SHA1);
+ git_oid_from_string(&other_id, other_commit_id, GIT_OID_SHA1);
cl_git_fail_with(GIT_EMODIFIED, git_reference_create_matching(&ref, g_repo, refname, &other_id, 1, &other_id, NULL));
@@ -64,8 +64,8 @@ void test_refs_races__symbolic_create_matching(void)
git_reference *ref, *ref2, *ref3;
git_oid id, other_id;
- git_oid__fromstr(&id, commit_id, GIT_OID_SHA1);
- git_oid__fromstr(&other_id, other_commit_id, GIT_OID_SHA1);
+ git_oid_from_string(&id, commit_id, GIT_OID_SHA1);
+ git_oid_from_string(&other_id, other_commit_id, GIT_OID_SHA1);
cl_git_fail_with(GIT_EMODIFIED, git_reference_symbolic_create_matching(&ref, g_repo, "HEAD", other_refname, 1, other_refname, NULL));
@@ -83,8 +83,8 @@ void test_refs_races__delete(void)
git_reference *ref, *ref2;
git_oid id, other_id;
- git_oid__fromstr(&id, commit_id, GIT_OID_SHA1);
- git_oid__fromstr(&other_id, other_commit_id, GIT_OID_SHA1);
+ git_oid_from_string(&id, commit_id, GIT_OID_SHA1);
+ git_oid_from_string(&other_id, other_commit_id, GIT_OID_SHA1);
/* We can delete a value that matches */
cl_git_pass(git_reference_lookup(&ref, g_repo, refname));
@@ -116,8 +116,8 @@ void test_refs_races__switch_oid_to_symbolic(void)
git_reference *ref, *ref2, *ref3;
git_oid id, other_id;
- git_oid__fromstr(&id, commit_id, GIT_OID_SHA1);
- git_oid__fromstr(&other_id, other_commit_id, GIT_OID_SHA1);
+ git_oid_from_string(&id, commit_id, GIT_OID_SHA1);
+ git_oid_from_string(&other_id, other_commit_id, GIT_OID_SHA1);
/* Removing a direct ref when it's currently symbolic should fail */
cl_git_pass(git_reference_lookup(&ref, g_repo, refname));
@@ -145,8 +145,8 @@ void test_refs_races__switch_symbolic_to_oid(void)
git_reference *ref, *ref2, *ref3;
git_oid id, other_id;
- git_oid__fromstr(&id, commit_id, GIT_OID_SHA1);
- git_oid__fromstr(&other_id, other_commit_id, GIT_OID_SHA1);
+ git_oid_from_string(&id, commit_id, GIT_OID_SHA1);
+ git_oid_from_string(&other_id, other_commit_id, GIT_OID_SHA1);
/* Removing a symbolic ref when it's currently direct should fail */
cl_git_pass(git_reference_lookup(&ref, g_repo, "refs/symref"));
diff --git a/tests/libgit2/refs/read.c b/tests/libgit2/refs/read.c
index 7253cf1373c..5bfe781e3aa 100644
--- a/tests/libgit2/refs/read.c
+++ b/tests/libgit2/refs/read.c
@@ -82,7 +82,7 @@ void test_refs_read__symbolic(void)
cl_assert(object != NULL);
cl_assert(git_object_type(object) == GIT_OBJECT_COMMIT);
- git_oid__fromstr(&id, current_master_tip, GIT_OID_SHA1);
+ git_oid_from_string(&id, current_master_tip, GIT_OID_SHA1);
cl_assert_equal_oid(&id, git_object_id(object));
git_object_free(object);
@@ -110,7 +110,7 @@ void test_refs_read__nested_symbolic(void)
cl_assert(object != NULL);
cl_assert(git_object_type(object) == GIT_OBJECT_COMMIT);
- git_oid__fromstr(&id, current_master_tip, GIT_OID_SHA1);
+ git_oid_from_string(&id, current_master_tip, GIT_OID_SHA1);
cl_assert_equal_oid(&id, git_object_id(object));
git_object_free(object);
diff --git a/tests/libgit2/refs/reflog/messages.c b/tests/libgit2/refs/reflog/messages.c
index 647c00d0dfd..b9a10f9b818 100644
--- a/tests/libgit2/refs/reflog/messages.c
+++ b/tests/libgit2/refs/reflog/messages.c
@@ -87,7 +87,7 @@ void test_refs_reflog_messages__detaching_writes_reflog(void)
const char *msg;
msg = "checkout: moving from master to e90810b8df3e80c413d903f631643c716887138d";
- git_oid__fromstr(&id, "e90810b8df3e80c413d903f631643c716887138d", GIT_OID_SHA1);
+ git_oid_from_string(&id, "e90810b8df3e80c413d903f631643c716887138d", GIT_OID_SHA1);
cl_git_pass(git_repository_set_head_detached(g_repo, &id));
cl_reflog_check_entry(g_repo, GIT_HEAD_FILE, 0,
"a65fedf39aefe402d3bb6e24df4d4f5fe4547750",
@@ -109,7 +109,7 @@ void test_refs_reflog_messages__orphan_branch_does_not_count(void)
/* Have something known */
msg = "checkout: moving from master to e90810b8df3e80c413d903f631643c716887138d";
- git_oid__fromstr(&id, "e90810b8df3e80c413d903f631643c716887138d", GIT_OID_SHA1);
+ git_oid_from_string(&id, "e90810b8df3e80c413d903f631643c716887138d", GIT_OID_SHA1);
cl_git_pass(git_repository_set_head_detached(g_repo, &id));
cl_reflog_check_entry(g_repo, GIT_HEAD_FILE, 0,
"a65fedf39aefe402d3bb6e24df4d4f5fe4547750",
@@ -280,7 +280,7 @@ void test_refs_reflog_messages__newline_gets_replaced(void)
git_oid oid;
cl_git_pass(git_signature_now(&signature, "me", "foo@example.com"));
- cl_git_pass(git_oid__fromstr(&oid, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1));
cl_git_pass(git_reflog_read(&reflog, g_repo, "HEAD"));
cl_assert_equal_sz(7, git_reflog_entrycount(reflog));
diff --git a/tests/libgit2/refs/reflog/reflog.c b/tests/libgit2/refs/reflog/reflog.c
index 774ec6c93b2..674b809a362 100644
--- a/tests/libgit2/refs/reflog/reflog.c
+++ b/tests/libgit2/refs/reflog/reflog.c
@@ -80,7 +80,7 @@ void test_refs_reflog_reflog__append_then_read(void)
git_reflog *reflog;
/* Create a new branch pointing at the HEAD */
- git_oid__fromstr(&oid, current_master_tip, GIT_OID_SHA1);
+ git_oid_from_string(&oid, current_master_tip, GIT_OID_SHA1);
cl_git_pass(git_reference_create(&ref, g_repo, new_ref, &oid, 0, NULL));
git_reference_free(ref);
@@ -147,7 +147,7 @@ void test_refs_reflog_reflog__removes_empty_reflog_dir(void)
git_oid id;
/* Create a new branch pointing at the HEAD */
- git_oid__fromstr(&id, current_master_tip, GIT_OID_SHA1);
+ git_oid_from_string(&id, current_master_tip, GIT_OID_SHA1);
cl_git_pass(git_reference_create(&ref, g_repo, "refs/heads/new-dir/new-head", &id, 0, NULL));
git_str_joinpath(&log_path, git_repository_path(g_repo), GIT_REFLOG_DIR);
@@ -159,7 +159,7 @@ void test_refs_reflog_reflog__removes_empty_reflog_dir(void)
git_reference_free(ref);
/* new ref creation should succeed since new-dir is empty */
- git_oid__fromstr(&id, current_master_tip, GIT_OID_SHA1);
+ git_oid_from_string(&id, current_master_tip, GIT_OID_SHA1);
cl_git_pass(git_reference_create(&ref, g_repo, "refs/heads/new-dir", &id, 0, NULL));
git_reference_free(ref);
@@ -173,7 +173,7 @@ void test_refs_reflog_reflog__fails_gracefully_on_nonempty_reflog_dir(void)
git_oid id;
/* Create a new branch pointing at the HEAD */
- git_oid__fromstr(&id, current_master_tip, GIT_OID_SHA1);
+ git_oid_from_string(&id, current_master_tip, GIT_OID_SHA1);
cl_git_pass(git_reference_create(&ref, g_repo, "refs/heads/new-dir/new-head", &id, 0, NULL));
git_reference_free(ref);
@@ -186,7 +186,7 @@ void test_refs_reflog_reflog__fails_gracefully_on_nonempty_reflog_dir(void)
cl_must_pass(p_unlink("testrepo.git/refs/heads/new-dir/new-head"));
/* new ref creation should fail since new-dir contains reflogs still */
- git_oid__fromstr(&id, current_master_tip, GIT_OID_SHA1);
+ git_oid_from_string(&id, current_master_tip, GIT_OID_SHA1);
cl_git_fail_with(GIT_EDIRECTORY, git_reference_create(&ref, g_repo, "refs/heads/new-dir", &id, 0, NULL));
git_reference_free(ref);
@@ -235,7 +235,7 @@ void test_refs_reflog_reflog__reading_a_reflog_with_invalid_format_succeeds(void
char *star;
/* Create a new branch. */
- cl_git_pass(git_oid__fromstr(&id, current_master_tip, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, current_master_tip, GIT_OID_SHA1));
cl_git_pass(git_reference_create(&ref, g_repo, refname, &id, 1, refmessage));
/*
@@ -298,7 +298,7 @@ void test_refs_reflog_reflog__write_only_std_locations(void)
git_reference *ref;
git_oid id;
- git_oid__fromstr(&id, current_master_tip, GIT_OID_SHA1);
+ git_oid_from_string(&id, current_master_tip, GIT_OID_SHA1);
cl_git_pass(git_reference_create(&ref, g_repo, "refs/heads/foo", &id, 1, NULL));
git_reference_free(ref);
@@ -318,7 +318,7 @@ void test_refs_reflog_reflog__write_when_explicitly_active(void)
git_reference *ref;
git_oid id;
- git_oid__fromstr(&id, current_master_tip, GIT_OID_SHA1);
+ git_oid_from_string(&id, current_master_tip, GIT_OID_SHA1);
git_reference_ensure_log(g_repo, "refs/tags/foo");
cl_git_pass(git_reference_create(&ref, g_repo, "refs/tags/foo", &id, 1, NULL));
@@ -338,7 +338,7 @@ void test_refs_reflog_reflog__append_to_HEAD_when_changing_current_branch(void)
git_reflog_free(log);
/* Move it back */
- git_oid__fromstr(&id, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1);
+ git_oid_from_string(&id, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1);
cl_git_pass(git_reference_create(&ref, g_repo, "refs/heads/master", &id, 1, NULL));
git_reference_free(ref);
@@ -390,7 +390,7 @@ static void assert_no_reflog_update(void)
git_reflog_free(log);
/* Move it back */
- git_oid__fromstr(&id, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1);
+ git_oid_from_string(&id, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1);
cl_git_pass(git_reference_create(&ref, g_repo, "refs/heads/master", &id, 1, NULL));
git_reference_free(ref);
@@ -431,7 +431,7 @@ void test_refs_reflog_reflog__logallrefupdates_bare_set_always(void)
cl_git_pass(git_config_set_string(config, "core.logallrefupdates", "always"));
git_config_free(config);
- git_oid__fromstr(&id, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1);
+ git_oid_from_string(&id, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1);
cl_git_pass(git_reference_create(&ref, g_repo, "refs/bork", &id, 1, "message"));
cl_git_pass(git_reflog_read(&log, g_repo, "refs/bork"));
diff --git a/tests/libgit2/refs/reflog/reflog_helpers.c b/tests/libgit2/refs/reflog/reflog_helpers.c
index 6a7e706d6c6..56051d256c6 100644
--- a/tests/libgit2/refs/reflog/reflog_helpers.c
+++ b/tests/libgit2/refs/reflog/reflog_helpers.c
@@ -53,7 +53,7 @@ void cl_reflog_check_entry_(git_repository *repo, const char *reflog, size_t idx
git_object_free(obj);
} else {
git_oid *oid = git__calloc(1, sizeof(*oid));
- git_oid__fromstr(oid, old_spec, GIT_OID_SHA1);
+ git_oid_from_string(oid, old_spec, GIT_OID_SHA1);
if (git_oid_cmp(oid, git_reflog_entry_id_old(entry)) != 0) {
git_object__write_oid_header(&result, "\tOld OID: \"", oid);
git_object__write_oid_header(&result, "\" != \"", git_reflog_entry_id_old(entry));
@@ -73,7 +73,7 @@ void cl_reflog_check_entry_(git_repository *repo, const char *reflog, size_t idx
git_object_free(obj);
} else {
git_oid *oid = git__calloc(1, sizeof(*oid));
- git_oid__fromstr(oid, new_spec, GIT_OID_SHA1);
+ git_oid_from_string(oid, new_spec, GIT_OID_SHA1);
if (git_oid_cmp(oid, git_reflog_entry_id_new(entry)) != 0) {
git_object__write_oid_header(&result, "\tNew OID: \"", oid);
git_object__write_oid_header(&result, "\" != \"", git_reflog_entry_id_new(entry));
diff --git a/tests/libgit2/refs/revparse.c b/tests/libgit2/refs/revparse.c
index d2f464840a0..9bc3bd10e4c 100644
--- a/tests/libgit2/refs/revparse.c
+++ b/tests/libgit2/refs/revparse.c
@@ -747,6 +747,25 @@ void test_refs_revparse__try_to_retrieve_branch_before_abbrev_sha(void)
cl_git_sandbox_cleanup();
}
+void test_refs_revparse__at_at_end_of_refname(void)
+{
+ git_repository *repo;
+ git_reference *branch;
+ git_object *target;
+
+ repo = cl_git_sandbox_init("testrepo.git");
+
+ cl_git_pass(git_revparse_single(&target, repo, "HEAD"));
+ cl_git_pass(git_branch_create(&branch, repo, "master@", (git_commit *)target, 0));
+ git_object_free(target);
+
+ test_id_inrepo("master@", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", NULL, GIT_REVSPEC_SINGLE, repo);
+
+ cl_git_fail_with(GIT_ENOTFOUND, git_revparse_single(&target, repo, "foo@"));
+
+ git_reference_free(branch);
+ cl_git_sandbox_cleanup();
+}
void test_refs_revparse__range(void)
{
diff --git a/tests/libgit2/refs/transactions.c b/tests/libgit2/refs/transactions.c
index 98ae6f73ae2..17c0b22ed21 100644
--- a/tests/libgit2/refs/transactions.c
+++ b/tests/libgit2/refs/transactions.c
@@ -21,7 +21,7 @@ void test_refs_transactions__single_ref_oid(void)
git_reference *ref;
git_oid id;
- git_oid__fromstr(&id, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1);
+ git_oid_from_string(&id, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1);
cl_git_pass(git_transaction_lock_ref(g_tx, "refs/heads/master"));
cl_git_pass(git_transaction_set_target(g_tx, "refs/heads/master", &id, NULL, NULL));
@@ -52,7 +52,7 @@ void test_refs_transactions__single_ref_mix_types(void)
git_reference *ref;
git_oid id;
- git_oid__fromstr(&id, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1);
+ git_oid_from_string(&id, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1);
cl_git_pass(git_transaction_lock_ref(g_tx, "refs/heads/master"));
cl_git_pass(git_transaction_lock_ref(g_tx, "HEAD"));
@@ -90,7 +90,7 @@ void test_refs_transactions__single_create(void)
cl_git_pass(git_transaction_lock_ref(g_tx, name));
- git_oid__fromstr(&id, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1);
+ git_oid_from_string(&id, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1);
cl_git_pass(git_transaction_set_target(g_tx, name, &id, NULL, NULL));
cl_git_pass(git_transaction_commit(g_tx));
@@ -104,7 +104,7 @@ void test_refs_transactions__unlocked_set(void)
git_oid id;
cl_git_pass(git_transaction_lock_ref(g_tx, "refs/heads/master"));
- git_oid__fromstr(&id, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1);
+ git_oid_from_string(&id, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1);
cl_git_fail_with(GIT_ENOTFOUND, git_transaction_set_target(g_tx, "refs/heads/foo", &id, NULL, NULL));
cl_git_pass(git_transaction_commit(g_tx));
}
@@ -122,7 +122,7 @@ void test_refs_transactions__error_on_locking_locked_ref(void)
cl_git_pass(git_transaction_lock_ref(g_tx_with_lock, "refs/heads/master"));
/* lock reference for set_target */
- cl_git_pass(git_oid__fromstr(&id, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&id, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1));
cl_git_fail_with(GIT_ELOCKED, git_transaction_lock_ref(g_tx, "refs/heads/master"));
cl_git_fail_with(GIT_ENOTFOUND, git_transaction_set_target(g_tx, "refs/heads/master", &id, NULL, NULL));
diff --git a/tests/libgit2/refs/unicode.c b/tests/libgit2/refs/unicode.c
index a279d5006b3..5c69bc7c2bc 100644
--- a/tests/libgit2/refs/unicode.c
+++ b/tests/libgit2/refs/unicode.c
@@ -36,7 +36,7 @@ void test_refs_unicode__create_and_lookup(void)
cl_assert_equal_s(REFNAME, git_reference_name(ref2));
git_reference_free(ref2);
-#if GIT_USE_ICONV
+#if GIT_I18N_ICONV
/* Lookup reference by decomposed unicode name */
#define REFNAME_DECOMPOSED "refs/heads/" "A" "\314\212" "ngstro" "\314\210" "m"
diff --git a/tests/libgit2/remote/fetch.c b/tests/libgit2/remote/fetch.c
index 85e99206fdc..6b7cec923f0 100644
--- a/tests/libgit2/remote/fetch.c
+++ b/tests/libgit2/remote/fetch.c
@@ -10,8 +10,11 @@ static char* repo2_path;
static const char *REPO1_REFNAME = "refs/heads/main";
static const char *REPO2_REFNAME = "refs/remotes/repo1/main";
+static const char *REPO1_UNDERSCORE_REFNAME = "refs/heads/_branch";
+static const char *REPO2_UNDERSCORE_REFNAME = "refs/remotes/repo1/_branch";
static char *FORCE_FETCHSPEC = "+refs/heads/main:refs/remotes/repo1/main";
static char *NON_FORCE_FETCHSPEC = "refs/heads/main:refs/remotes/repo1/main";
+static char *NEGATIVE_SPEC = "^refs/heads/_*";
void test_remote_fetch__initialize(void) {
git_config *c;
@@ -40,10 +43,10 @@ void test_remote_fetch__cleanup(void) {
git_repository_free(repo2);
cl_git_pass(git_futils_rmdir_r(repo1_path, NULL, GIT_RMDIR_REMOVE_FILES));
- free(repo1_path);
+ git__free(repo1_path);
cl_git_pass(git_futils_rmdir_r(repo2_path, NULL, GIT_RMDIR_REMOVE_FILES));
- free(repo2_path);
+ git__free(repo2_path);
}
@@ -75,6 +78,7 @@ static void do_time_travelling_fetch(git_oid *commit1id, git_oid *commit2id,
/* create two commits in repo 1 and a reference to them */
{
git_oid empty_tree_id;
+ git_commit *commit1;
git_tree *empty_tree;
git_signature *sig;
git_treebuilder *tb;
@@ -84,10 +88,12 @@ static void do_time_travelling_fetch(git_oid *commit1id, git_oid *commit2id,
cl_git_pass(git_signature_default(&sig, repo1));
cl_git_pass(git_commit_create(commit1id, repo1, REPO1_REFNAME, sig,
sig, NULL, "one", empty_tree, 0, NULL));
+ cl_git_pass(git_commit_lookup(&commit1, repo1, commit1id));
cl_git_pass(git_commit_create_v(commit2id, repo1, REPO1_REFNAME, sig,
- sig, NULL, "two", empty_tree, 1, commit1id));
+ sig, NULL, "two", empty_tree, 1, commit1));
git_tree_free(empty_tree);
+ git_commit_free(commit1);
git_signature_free(sig);
git_treebuilder_free(tb);
}
@@ -167,3 +173,61 @@ void test_remote_fetch__do_update_refs_if_not_descendant_and_force(void) {
git_reference_free(ref);
}
+
+/**
+ * This checks that negative refspecs are respected when fetching. We create a
+ * repository with a '_' prefixed reference. A second repository is configured
+ * with a negative refspec to ignore any refs prefixed with '_' and fetch the
+ * first repository into the second.
+ *
+ * @param commit1id A pointer to an OID which will be populated with the first
+ * commit.
+ */
+static void do_fetch_repo_with_ref_matching_negative_refspec(git_oid *commit1id) {
+ /* create a commit in repo 1 and a reference to it with '_' prefix */
+ {
+ git_oid empty_tree_id;
+ git_tree *empty_tree;
+ git_signature *sig;
+ git_treebuilder *tb;
+ cl_git_pass(git_treebuilder_new(&tb, repo1, NULL));
+ cl_git_pass(git_treebuilder_write(&empty_tree_id, tb));
+ cl_git_pass(git_tree_lookup(&empty_tree, repo1, &empty_tree_id));
+ cl_git_pass(git_signature_default(&sig, repo1));
+ cl_git_pass(git_commit_create(commit1id, repo1, REPO1_UNDERSCORE_REFNAME, sig,
+ sig, NULL, "one", empty_tree, 0, NULL));
+
+ git_tree_free(empty_tree);
+ git_signature_free(sig);
+ git_treebuilder_free(tb);
+ }
+
+ /* fetch the remote with negative refspec for references prefixed with '_' */
+ {
+ char *refspec_strs = { NEGATIVE_SPEC };
+ git_strarray refspecs = { &refspec_strs, 1 };
+
+ git_remote *remote;
+
+ cl_git_pass(git_remote_create_anonymous(&remote, repo2,
+ git_repository_path(repo1)));
+ cl_git_pass(git_remote_fetch(remote, &refspecs, NULL, "some message"));
+
+ git_remote_free(remote);
+ }
+}
+
+void test_remote_fetch__skip_negative_refspec_match(void) {
+ git_oid commit1id;
+ git_reference *ref1;
+ git_reference *ref2;
+
+ do_fetch_repo_with_ref_matching_negative_refspec(&commit1id);
+
+ /* assert that the reference in exists in repo1 but not in repo2 */
+ cl_git_pass(git_reference_lookup(&ref1, repo1, REPO1_UNDERSCORE_REFNAME));
+ cl_assert_equal_b(git_reference_lookup(&ref2, repo2, REPO2_UNDERSCORE_REFNAME), GIT_ENOTFOUND);
+
+ git_reference_free(ref1);
+ git_reference_free(ref2);
+}
diff --git a/tests/libgit2/repo/discover.c b/tests/libgit2/repo/discover.c
index 523fdf8e395..983d75e3ae5 100644
--- a/tests/libgit2/repo/discover.c
+++ b/tests/libgit2/repo/discover.c
@@ -122,7 +122,10 @@ void test_repo_discover__cleanup(void)
void test_repo_discover__discovering_repo_with_exact_path_succeeds(void)
{
cl_git_pass(git_repository_discover(&discovered, DISCOVER_FOLDER, 0, ceiling_dirs.ptr));
+ git_buf_dispose(&discovered);
+
cl_git_pass(git_repository_discover(&discovered, SUB_REPOSITORY_FOLDER, 0, ceiling_dirs.ptr));
+ git_buf_dispose(&discovered);
}
void test_repo_discover__discovering_nonexistent_dir_fails(void)
diff --git a/tests/libgit2/repo/env.c b/tests/libgit2/repo/env.c
index 790ffd40f0f..c9e60d901bf 100644
--- a/tests/libgit2/repo/env.c
+++ b/tests/libgit2/repo/env.c
@@ -31,6 +31,10 @@ void test_repo_env__cleanup(void)
if (git_fs_path_isdir("peeled.git"))
git_futils_rmdir_r("peeled.git", NULL, GIT_RMDIR_REMOVE_FILES);
+ cl_fixture_cleanup("test_workdir");
+ cl_fixture_cleanup("test_global_conf");
+ cl_fixture_cleanup("test_system_conf");
+
clear_git_env();
}
@@ -95,9 +99,9 @@ static void env_check_objects_(bool a, bool t, bool p, const char *file, const c
git_repository *repo;
git_oid oid_a, oid_t, oid_p;
git_object *object;
- cl_git_pass(git_oid__fromstr(&oid_a, "45141a79a77842c59a63229403220a4e4be74e3d", GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&oid_t, "1385f264afb75a56a5bec74243be9b367ba4ca08", GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&oid_p, "0df1a5865c8abfc09f1f2182e6a31be550e99f07", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid_a, "45141a79a77842c59a63229403220a4e4be74e3d", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid_t, "1385f264afb75a56a5bec74243be9b367ba4ca08", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid_p, "0df1a5865c8abfc09f1f2182e6a31be550e99f07", GIT_OID_SHA1));
cl_git_expect(git_repository_open_ext(&repo, "attr", GIT_REPOSITORY_OPEN_FROM_ENV, NULL), 0, file, func, line);
if (a) {
@@ -275,3 +279,91 @@ void test_repo_env__open(void)
clear_git_env();
}
+
+void test_repo_env__work_tree(void)
+{
+ git_repository *repo;
+ const char *test_path;
+
+ cl_fixture_sandbox("attr");
+ cl_git_pass(p_rename("attr/.gitted", "attr/.git"));
+
+ cl_must_pass(p_mkdir("test_workdir", 0777));
+ test_path = cl_git_sandbox_path(1, "test_workdir", NULL);
+
+ cl_setenv("GIT_WORK_TREE", test_path);
+ cl_git_pass(git_repository_open_ext(&repo, "attr", GIT_REPOSITORY_OPEN_FROM_ENV, NULL));
+ cl_assert_equal_s(test_path, git_repository_workdir(repo));
+ git_repository_free(repo);
+ cl_setenv("GIT_WORK_TREE", NULL);
+}
+
+void test_repo_env__commondir(void)
+{
+ git_repository *repo;
+ const char *test_path;
+
+ cl_fixture_sandbox("attr");
+ cl_git_pass(p_rename("attr/.gitted", "attr/.git"));
+
+ cl_fixture_sandbox("testrepo.git");
+ cl_git_pass(p_rename("testrepo.git", "test_commondir"));
+
+ test_path = cl_git_sandbox_path(1, "test_commondir", NULL);
+
+ cl_setenv("GIT_COMMON_DIR", test_path);
+ cl_git_pass(git_repository_open_ext(&repo, "attr", GIT_REPOSITORY_OPEN_FROM_ENV, NULL));
+ cl_assert_equal_s(test_path, git_repository_commondir(repo));
+ git_repository_free(repo);
+ cl_setenv("GIT_COMMON_DIR", NULL);
+}
+
+void test_repo_env__config(void)
+{
+ git_repository *repo;
+ git_config *config;
+ const char *system_path, *global_path;
+ int s, g;
+
+ cl_fixture_sandbox("attr");
+ cl_git_pass(p_rename("attr/.gitted", "attr/.git"));
+
+ cl_git_rewritefile("test_system_conf", "[tttest]\n\tsys = true\n");
+ cl_git_rewritefile("test_global_conf", "[tttest]\n\tglb = true\n");
+
+ system_path = cl_git_sandbox_path(0, "test_system_conf", NULL);
+ cl_setenv("GIT_CONFIG_SYSTEM", system_path);
+
+ global_path = cl_git_sandbox_path(0, "test_global_conf", NULL);
+ cl_setenv("GIT_CONFIG_GLOBAL", global_path);
+
+ /* Ensure we can override the system and global files */
+
+ cl_git_pass(git_repository_open_ext(&repo, "attr", GIT_REPOSITORY_OPEN_FROM_ENV, NULL));
+ cl_git_pass(git_repository_config(&config, repo));
+
+ cl_git_pass(git_config_get_bool(&s, config, "tttest.sys"));
+ cl_assert_equal_i(1, s);
+ cl_git_pass(git_config_get_bool(&g, config, "tttest.glb"));
+ cl_assert_equal_i(1, g);
+
+ git_config_free(config);
+ git_repository_free(repo);
+
+ /* Further ensure we can ignore the system file. */
+ cl_setenv("GIT_CONFIG_NOSYSTEM", "TrUe");
+
+ cl_git_pass(git_repository_open_ext(&repo, "attr", GIT_REPOSITORY_OPEN_FROM_ENV, NULL));
+ cl_git_pass(git_repository_config(&config, repo));
+
+ cl_git_fail_with(GIT_ENOTFOUND, git_config_get_bool(&s, config, "tttest.sys"));
+ cl_git_pass(git_config_get_bool(&g, config, "tttest.glb"));
+ cl_assert_equal_i(1, g);
+
+ git_config_free(config);
+ git_repository_free(repo);
+
+ cl_setenv("GIT_CONFIG_NOSYSTEM", NULL);
+ cl_setenv("GIT_CONFIG_SYSTEM", NULL);
+ cl_setenv("GIT_CONFIG_GLOBAL", NULL);
+}
diff --git a/tests/libgit2/repo/extensions.c b/tests/libgit2/repo/extensions.c
index 105cdae12f4..cb62c53a8eb 100644
--- a/tests/libgit2/repo/extensions.c
+++ b/tests/libgit2/repo/extensions.c
@@ -70,3 +70,13 @@ void test_repo_extensions__adds_extension(void)
cl_assert(git__suffixcmp(git_repository_path(extended), "/") == 0);
git_repository_free(extended);
}
+
+void test_repo_extensions__preciousobjects(void)
+{
+ git_repository *extended = NULL;
+
+ cl_repo_set_string(repo, "extensions.preciousObjects", "true");
+
+ cl_git_pass(git_repository_open(&extended, "empty_bare.git"));
+ git_repository_free(extended);
+}
diff --git a/tests/libgit2/repo/getters.c b/tests/libgit2/repo/getters.c
index d401bb8327f..b1b41690fc4 100644
--- a/tests/libgit2/repo/getters.c
+++ b/tests/libgit2/repo/getters.c
@@ -51,3 +51,63 @@ void test_repo_getters__retrieving_the_odb_honors_the_refcount(void)
git_odb_free(odb);
}
+
+void test_repo_getters__commit_parents(void)
+{
+ git_repository *repo;
+ git_commitarray parents;
+ git_oid first_parent;
+ git_oid merge_parents[4];
+
+ git_oid_from_string(&first_parent, "099fabac3a9ea935598528c27f866e34089c2eff", GIT_OID_SHA1);
+
+ /* A commit on a new repository has no parents */
+
+ cl_git_pass(git_repository_init(&repo, "new_repo", false));
+ cl_git_pass(git_repository_commit_parents(&parents, repo));
+
+ cl_assert_equal_sz(0, parents.count);
+ cl_assert_equal_p(NULL, parents.commits);
+
+ git_commitarray_dispose(&parents);
+ git_repository_free(repo);
+
+ /* A standard commit has one parent */
+
+ repo = cl_git_sandbox_init("testrepo");
+ cl_git_pass(git_repository_commit_parents(&parents, repo));
+
+ cl_assert_equal_sz(1, parents.count);
+ cl_assert_equal_oid(&first_parent, git_commit_id(parents.commits[0]));
+
+ git_commitarray_dispose(&parents);
+
+ /* A merge commit has multiple parents */
+
+ cl_git_rewritefile("testrepo/.git/MERGE_HEAD",
+ "8496071c1b46c854b31185ea97743be6a8774479\n"
+ "5b5b025afb0b4c913b4c338a42934a3863bf3644\n"
+ "4a202b346bb0fb0db7eff3cffeb3c70babbd2045\n"
+ "9fd738e8f7967c078dceed8190330fc8648ee56a\n");
+
+ cl_git_pass(git_repository_commit_parents(&parents, repo));
+
+ cl_assert_equal_sz(5, parents.count);
+
+ cl_assert_equal_oid(&first_parent, git_commit_id(parents.commits[0]));
+
+ git_oid_from_string(&merge_parents[0], "8496071c1b46c854b31185ea97743be6a8774479", GIT_OID_SHA1);
+ cl_assert_equal_oid(&merge_parents[0], git_commit_id(parents.commits[1]));
+ git_oid_from_string(&merge_parents[1], "5b5b025afb0b4c913b4c338a42934a3863bf3644", GIT_OID_SHA1);
+ cl_assert_equal_oid(&merge_parents[1], git_commit_id(parents.commits[2]));
+ git_oid_from_string(&merge_parents[2], "4a202b346bb0fb0db7eff3cffeb3c70babbd2045", GIT_OID_SHA1);
+ cl_assert_equal_oid(&merge_parents[2], git_commit_id(parents.commits[3]));
+ git_oid_from_string(&merge_parents[3], "9fd738e8f7967c078dceed8190330fc8648ee56a", GIT_OID_SHA1);
+ cl_assert_equal_oid(&merge_parents[3], git_commit_id(parents.commits[4]));
+
+ git_commitarray_dispose(&parents);
+
+ git_repository_free(repo);
+
+ cl_fixture_cleanup("testrepo");
+}
diff --git a/tests/libgit2/repo/hashfile.c b/tests/libgit2/repo/hashfile.c
index f053cb950d4..64b8dfa460c 100644
--- a/tests/libgit2/repo/hashfile.c
+++ b/tests/libgit2/repo/hashfile.c
@@ -34,7 +34,7 @@ void test_repo_hashfile__simple(void)
/* hash with invalid type */
cl_git_fail(git_odb__hashfile(&a, full.ptr, GIT_OBJECT_ANY, GIT_OID_SHA1));
- cl_git_fail(git_repository_hashfile(&b, _repo, full.ptr, GIT_OBJECT_OFS_DELTA, NULL));
+ cl_git_fail(git_repository_hashfile(&b, _repo, full.ptr, 6, NULL));
git_str_dispose(&full);
}
diff --git a/tests/libgit2/repo/head.c b/tests/libgit2/repo/head.c
index c886c3f79d0..7dea91efeb7 100644
--- a/tests/libgit2/repo/head.c
+++ b/tests/libgit2/repo/head.c
@@ -99,7 +99,7 @@ void test_repo_head__set_head_detached_Return_ENOTFOUND_when_the_object_doesnt_e
{
git_oid oid;
- cl_git_pass(git_oid__fromstr(&oid, "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef", GIT_OID_SHA1));
cl_assert_equal_i(GIT_ENOTFOUND, git_repository_set_head_detached(repo, &oid));
}
diff --git a/tests/libgit2/repo/init.c b/tests/libgit2/repo/init.c
index d78ec063cd2..063c4fc7c1c 100644
--- a/tests/libgit2/repo/init.c
+++ b/tests/libgit2/repo/init.c
@@ -328,7 +328,7 @@ void test_repo_init__symlinks_posix_detected(void)
void test_repo_init__detect_precompose_unicode_required(void)
{
-#ifdef GIT_USE_ICONV
+#ifdef GIT_I18N_ICONV
char *composed = "ḱṷṓn", *decomposed = "kÌuÌoÌ„Ìn";
struct stat st;
bool found_with_nfd;
@@ -425,8 +425,7 @@ void test_repo_init__extended_1(void)
struct stat st;
git_repository_init_options opts = GIT_REPOSITORY_INIT_OPTIONS_INIT;
- opts.flags = GIT_REPOSITORY_INIT_MKPATH |
- GIT_REPOSITORY_INIT_NO_DOTGIT_DIR;
+ opts.flags = GIT_REPOSITORY_INIT_MKPATH;
opts.mode = GIT_REPOSITORY_INIT_SHARED_GROUP;
opts.workdir_path = "../c_wd";
opts.description = "Awesomest test repository evah";
@@ -466,16 +465,18 @@ void test_repo_init__extended_1(void)
void test_repo_init__relative_gitdir(void)
{
git_repository_init_options opts = GIT_REPOSITORY_INIT_OPTIONS_INIT;
+ git_str head_content = GIT_STR_INIT;
git_str dot_git_content = GIT_STR_INIT;
opts.workdir_path = "../c_wd";
opts.flags =
GIT_REPOSITORY_INIT_MKPATH |
- GIT_REPOSITORY_INIT_RELATIVE_GITLINK |
- GIT_REPOSITORY_INIT_NO_DOTGIT_DIR;
+ GIT_REPOSITORY_INIT_RELATIVE_GITLINK;
/* make the directory first, then it should succeed */
cl_git_pass(git_repository_init_ext(&g_repo, "root/b/my_repository", &opts));
+ cl_git_pass(git_futils_readbuffer(&head_content, "root/b/my_repository/HEAD"));
+ cl_assert_equal_s("ref: refs/heads/master\n", head_content.ptr);
cl_assert(!git__suffixcmp(git_repository_workdir(g_repo), "root/b/c_wd/"));
cl_assert(!git__suffixcmp(git_repository_path(g_repo), "root/b/my_repository/"));
@@ -489,8 +490,9 @@ void test_repo_init__relative_gitdir(void)
/* Verify gitlink */
cl_git_pass(git_futils_readbuffer(&dot_git_content, "root/b/c_wd/.git"));
- cl_assert_equal_s("gitdir: ../my_repository/", dot_git_content.ptr);
+ cl_assert_equal_s("gitdir: ../my_repository/\n", dot_git_content.ptr);
+ git_str_dispose(&head_content);
git_str_dispose(&dot_git_content);
cleanup_repository("root");
}
@@ -507,8 +509,7 @@ void test_repo_init__relative_gitdir_2(void)
opts.workdir_path = full_path.ptr;
opts.flags =
GIT_REPOSITORY_INIT_MKPATH |
- GIT_REPOSITORY_INIT_RELATIVE_GITLINK |
- GIT_REPOSITORY_INIT_NO_DOTGIT_DIR;
+ GIT_REPOSITORY_INIT_RELATIVE_GITLINK;
/* make the directory first, then it should succeed */
cl_git_pass(git_repository_init_ext(&g_repo, "root/b/my_repository", &opts));
@@ -526,7 +527,7 @@ void test_repo_init__relative_gitdir_2(void)
/* Verify gitlink */
cl_git_pass(git_futils_readbuffer(&dot_git_content, "root/b/c_wd/.git"));
- cl_assert_equal_s("gitdir: ../my_repository/", dot_git_content.ptr);
+ cl_assert_equal_s("gitdir: ../my_repository/\n", dot_git_content.ptr);
git_str_dispose(&dot_git_content);
cleanup_repository("root");
@@ -755,3 +756,28 @@ void test_repo_init__longpath(void)
git_str_dispose(&path);
#endif
}
+
+void test_repo_init__absolute_path_with_backslashes(void)
+{
+#ifdef GIT_WIN32
+ git_repository_init_options initopts = GIT_REPOSITORY_INIT_OPTIONS_INIT;
+ git_str path = GIT_STR_INIT;
+ char *c;
+
+ cl_set_cleanup(&cleanup_repository, "path");
+
+ cl_git_pass(git_str_joinpath(&path, clar_sandbox_path(), "path/to/newrepo"));
+
+ for (c = path.ptr; *c; c++) {
+ if (*c == '/')
+ *c = '\\';
+ }
+
+ initopts.flags |= GIT_REPOSITORY_INIT_MKDIR | GIT_REPOSITORY_INIT_MKPATH;
+
+ cl_git_pass(git_repository_init_ext(&g_repo, path.ptr, &initopts));
+ git_str_dispose(&path);
+#else
+ clar__skip();
+#endif
+}
diff --git a/tests/libgit2/repo/new.c b/tests/libgit2/repo/new.c
index d77e903f670..92a5a8cfa50 100644
--- a/tests/libgit2/repo/new.c
+++ b/tests/libgit2/repo/new.c
@@ -1,11 +1,15 @@
#include "clar_libgit2.h"
#include "git2/sys/repository.h"
+#include "repository.h"
void test_repo_new__has_nothing(void)
{
git_repository *repo;
+ git_repository_new_options repo_opts = GIT_REPOSITORY_NEW_OPTIONS_INIT;
- cl_git_pass(git_repository_new(&repo));
+ repo_opts.oid_type = GIT_OID_SHA1;
+
+ cl_git_pass(git_repository_new_ext(&repo, &repo_opts));
cl_assert_equal_b(true, git_repository_is_bare(repo));
cl_assert_equal_p(NULL, git_repository_path(repo));
cl_assert_equal_p(NULL, git_repository_workdir(repo));
@@ -16,7 +20,11 @@ void test_repo_new__is_bare_until_workdir_set(void)
{
git_repository *repo;
- cl_git_pass(git_repository_new(&repo));
+ git_repository_new_options repo_opts = GIT_REPOSITORY_NEW_OPTIONS_INIT;
+
+ repo_opts.oid_type = GIT_OID_SHA1;
+
+ cl_git_pass(git_repository_new_ext(&repo, &repo_opts));
cl_assert_equal_b(true, git_repository_is_bare(repo));
cl_git_pass(git_repository_set_workdir(repo, clar_sandbox_path(), 0));
@@ -25,3 +33,32 @@ void test_repo_new__is_bare_until_workdir_set(void)
git_repository_free(repo);
}
+void test_repo_new__sha1(void)
+{
+ git_repository *repo;
+ git_repository_new_options repo_opts = GIT_REPOSITORY_NEW_OPTIONS_INIT;
+
+ repo_opts.oid_type = GIT_OID_SHA1;
+
+ cl_git_pass(git_repository_new_ext(&repo, &repo_opts));
+ cl_assert_equal_i(GIT_OID_SHA1, git_repository_oid_type(repo));
+
+ git_repository_free(repo);
+}
+
+void test_repo_new__sha256(void)
+{
+#ifndef GIT_EXPERIMENTAL_SHA256
+ cl_skip();
+#else
+ git_repository *repo;
+ git_repository_new_options repo_opts = GIT_REPOSITORY_NEW_OPTIONS_INIT;
+
+ repo_opts.oid_type = GIT_OID_SHA256;
+
+ cl_git_pass(git_repository_new_ext(&repo, &repo_opts));
+ cl_assert_equal_i(GIT_OID_SHA256, git_repository_oid_type(repo));
+
+ git_repository_free(repo);
+#endif
+}
diff --git a/tests/libgit2/repo/open.c b/tests/libgit2/repo/open.c
index 3d1a0620b12..d58551343e1 100644
--- a/tests/libgit2/repo/open.c
+++ b/tests/libgit2/repo/open.c
@@ -316,7 +316,7 @@ static void unposix_path(git_str *path)
src = tgt = path->ptr;
/* convert "/d/..." to "d:\..." */
- if (src[0] == '/' && isalpha(src[1]) && src[2] == '/') {
+ if (src[0] == '/' && git__isalpha(src[1]) && src[2] == '/') {
*tgt++ = src[1];
*tgt++ = ':';
*tgt++ = '\\';
@@ -533,15 +533,21 @@ void test_repo_open__validates_bare_repo_ownership(void)
cl_git_fail_with(GIT_EOWNER, git_repository_open(&repo, "testrepo.git"));
}
-void test_repo_open__can_allowlist_dirs_with_problematic_ownership(void)
+static int test_safe_path(const char *path)
{
git_repository *repo;
git_str config_path = GIT_STR_INIT,
config_filename = GIT_STR_INIT,
config_data = GIT_STR_INIT;
+ int error;
cl_git_pass(git_libgit2_opts(GIT_OPT_SET_OWNER_VALIDATION, 1));
+ /*
+ * Sandbox the fixture, and ensure that when we fake an owner
+ * of "other" that the repository cannot be opened (and fails
+ * with `GIT_EOWNER`).
+ */
cl_fixture_sandbox("empty_standard_repo");
cl_git_pass(cl_rename("empty_standard_repo/.gitted", "empty_standard_repo/.git"));
@@ -555,81 +561,179 @@ void test_repo_open__can_allowlist_dirs_with_problematic_ownership(void)
git_str_joinpath(&config_filename, config_path.ptr, ".gitconfig");
+ git_str_clear(&config_data);
git_str_printf(&config_data,
"[foo]\n" \
"\tbar = Foobar\n" \
"\tbaz = Baz!\n" \
"[safe]\n" \
- "\tdirectory = /non/existent/path\n" \
- "\tdirectory = /\n" \
- "\tdirectory = c:\\\\temp\n" \
- "\tdirectory = %s/%s\n" \
- "\tdirectory = /tmp\n" \
+ "\tdirectory = %s\n" \
"[bar]\n" \
"\tfoo = barfoo\n",
- clar_sandbox_path(), "empty_standard_repo");
+ path);
cl_git_rewritefile(config_filename.ptr, config_data.ptr);
- cl_git_pass(git_repository_open(&repo, "empty_standard_repo"));
+ error = git_repository_open(&repo, "empty_standard_repo");
git_repository_free(repo);
git_str_dispose(&config_path);
git_str_dispose(&config_filename);
git_str_dispose(&config_data);
+
+ return error;
}
-void test_repo_open__can_wildcard_allowlist_with_problematic_ownership(void)
+static int test_bare_safe_path(const char *path)
{
git_repository *repo;
- git_str config_path = GIT_STR_INIT, config_filename = GIT_STR_INIT;
+ git_str config_path = GIT_STR_INIT,
+ config_filename = GIT_STR_INIT,
+ config_data = GIT_STR_INIT;
+ int error;
cl_git_pass(git_libgit2_opts(GIT_OPT_SET_OWNER_VALIDATION, 1));
- cl_fixture_sandbox("empty_standard_repo");
- cl_git_pass(cl_rename(
- "empty_standard_repo/.gitted", "empty_standard_repo/.git"));
+ cl_fixture_sandbox("testrepo.git");
git_fs_path__set_owner(GIT_FS_PATH_OWNER_OTHER);
- cl_git_fail_with(
- GIT_EOWNER, git_repository_open(&repo, "empty_standard_repo"));
+ cl_git_fail_with(GIT_EOWNER, git_repository_open(&repo, "testrepo.git"));
/* Add safe.directory options to the global configuration */
git_str_joinpath(&config_path, clar_sandbox_path(), "__global_config");
cl_must_pass(p_mkdir(config_path.ptr, 0777));
- git_libgit2_opts(
- GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL,
- config_path.ptr);
+ git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, config_path.ptr);
git_str_joinpath(&config_filename, config_path.ptr, ".gitconfig");
- cl_git_rewritefile(config_filename.ptr, "[foo]\n"
- "\tbar = Foobar\n"
- "\tbaz = Baz!\n"
- "[safe]\n"
- "\tdirectory = *\n"
- "[bar]\n"
- "\tfoo = barfoo\n");
+ git_str_printf(&config_data,
+ "[foo]\n" \
+ "\tbar = Foobar\n" \
+ "\tbaz = Baz!\n" \
+ "[safe]\n" \
+ "\tdirectory = /non/existent/path\n" \
+ "\tdirectory = /\n" \
+ "\tdirectory = c:\\\\temp\n" \
+ "\tdirectory = %s\n" \
+ "\tdirectory = /tmp\n" \
+ "[bar]\n" \
+ "\tfoo = barfoo\n",
+ path);
+ cl_git_rewritefile(config_filename.ptr, config_data.ptr);
- cl_git_pass(git_repository_open(&repo, "empty_standard_repo"));
+ error = git_repository_open(&repo, "testrepo.git");
git_repository_free(repo);
git_str_dispose(&config_path);
git_str_dispose(&config_filename);
+ git_str_dispose(&config_data);
+
+ return error;
+}
+
+void test_repo_open__can_allowlist_dirs_with_problematic_ownership(void)
+{
+ git_str path = GIT_STR_INIT;
+
+ cl_git_pass(git_str_printf(&path, "%s/%s",
+ clar_sandbox_path(), "empty_standard_repo"));
+ cl_git_pass(test_safe_path(path.ptr));
+ git_str_dispose(&path);
+}
+
+void test_repo_open__safe_directory_fails_with_trailing_slash(void)
+{
+ git_str path = GIT_STR_INIT;
+
+ /*
+ * "/tmp/foo/" is not permitted; safe path must be specified
+ * as "/tmp/foo"
+ */
+ cl_git_pass(git_str_printf(&path, "%s/%s/",
+ clar_sandbox_path(), "empty_standard_repo"));
+ cl_git_fail_with(GIT_EOWNER, test_safe_path(path.ptr));
+ git_str_dispose(&path);
+}
+
+void test_repo_open__can_wildcard_allowlist_with_problematic_ownership(void)
+{
+ cl_git_pass(test_safe_path("*"));
}
void test_repo_open__can_allowlist_bare_gitdir(void)
{
+ git_str path = GIT_STR_INIT;
+
+ cl_git_pass(git_str_printf(&path, "%s/%s",
+ clar_sandbox_path(), "testrepo.git"));
+ cl_git_pass(test_bare_safe_path(path.ptr));
+ git_str_dispose(&path);
+}
+
+void test_repo_open__can_wildcard_allowlist_bare_gitdir(void)
+{
+ cl_git_pass(test_bare_safe_path("*"));
+}
+
+void test_repo_open__can_handle_prefixed_safe_paths(void)
+{
+#ifndef GIT_WIN32
+ git_str path = GIT_STR_INIT;
+
+ /*
+ * Using "%(prefix)/" becomes "%(prefix)//tmp/foo" - so
+ * "%(prefix)/" is stripped and means the literal path
+ * follows.
+ */
+ cl_git_pass(git_str_printf(&path, "%%(prefix)/%s/%s",
+ clar_sandbox_path(), "empty_standard_repo"));
+ cl_git_pass(test_safe_path(path.ptr));
+ git_str_dispose(&path);
+#endif
+}
+
+void test_repo_open__prefixed_safe_paths_must_have_two_slashes(void)
+{
+ git_str path = GIT_STR_INIT;
+
+ /*
+ * Using "%(prefix)" becomes "%(prefix)/tmp/foo" - so it's
+ * actually trying to look in the git prefix, for example,
+ * "/usr/local/tmp/foo", which we don't actually support.
+ */
+ cl_git_pass(git_str_printf(&path, "%%(prefix)%s/%s",
+ clar_sandbox_path(), "empty_standard_repo"));
+ cl_git_fail_with(GIT_EOWNER, test_safe_path(path.ptr));
+ git_str_dispose(&path);
+}
+
+void test_repo_open__can_handle_win32_prefixed_safe_paths(void)
+{
+#ifdef GIT_WIN32
git_repository *repo;
- git_str config_path = GIT_STR_INIT,
+ git_str unc_path = GIT_STR_INIT,
+ config_path = GIT_STR_INIT,
config_filename = GIT_STR_INIT,
config_data = GIT_STR_INIT;
cl_git_pass(git_libgit2_opts(GIT_OPT_SET_OWNER_VALIDATION, 1));
- cl_fixture_sandbox("testrepo.git");
+ cl_fixture_sandbox("empty_standard_repo");
+ cl_git_pass(cl_rename("empty_standard_repo/.gitted", "empty_standard_repo/.git"));
+
+ /*
+ * On Windows, we can generally map a local drive to a UNC path;
+ * for example C:\Foo\Bar becomes //localhost/C$/Foo/bar
+ */
+ cl_git_pass(git_str_printf(&unc_path, "//localhost/%s/%s",
+ clar_sandbox_path(), "empty_standard_repo"));
+
+ if (unc_path.ptr[13] != ':' || unc_path.ptr[14] != '/')
+ cl_skip();
+
+ unc_path.ptr[13] = '$';
git_fs_path__set_owner(GIT_FS_PATH_OWNER_OTHER);
- cl_git_fail_with(GIT_EOWNER, git_repository_open(&repo, "testrepo.git"));
+ cl_git_fail_with(GIT_EOWNER, git_repository_open(&repo, unc_path.ptr));
/* Add safe.directory options to the global configuration */
git_str_joinpath(&config_path, clar_sandbox_path(), "__global_config");
@@ -638,64 +742,74 @@ void test_repo_open__can_allowlist_bare_gitdir(void)
git_str_joinpath(&config_filename, config_path.ptr, ".gitconfig");
+ /* The blank resets our sandbox directory and opening fails */
+
git_str_printf(&config_data,
- "[foo]\n" \
- "\tbar = Foobar\n" \
- "\tbaz = Baz!\n" \
- "[safe]\n" \
- "\tdirectory = /non/existent/path\n" \
- "\tdirectory = /\n" \
- "\tdirectory = c:\\\\temp\n" \
- "\tdirectory = %s/%s\n" \
- "\tdirectory = /tmp\n" \
- "[bar]\n" \
- "\tfoo = barfoo\n",
- clar_sandbox_path(), "testrepo.git");
+ "[safe]\n\tdirectory = %%(prefix)/%s\n",
+ unc_path.ptr);
cl_git_rewritefile(config_filename.ptr, config_data.ptr);
- cl_git_pass(git_repository_open(&repo, "testrepo.git"));
+ cl_git_pass(git_repository_open(&repo, unc_path.ptr));
git_repository_free(repo);
git_str_dispose(&config_path);
git_str_dispose(&config_filename);
git_str_dispose(&config_data);
+ git_str_dispose(&unc_path);
+#endif
}
-void test_repo_open__can_wildcard_allowlist_bare_gitdir(void)
+void test_repo_open__can_handle_win32_unc_safe_paths(void)
{
+#ifdef GIT_WIN32
git_repository *repo;
- git_str config_path = GIT_STR_INIT, config_filename = GIT_STR_INIT;
+ git_str unc_path = GIT_STR_INIT,
+ config_path = GIT_STR_INIT,
+ config_filename = GIT_STR_INIT,
+ config_data = GIT_STR_INIT;
cl_git_pass(git_libgit2_opts(GIT_OPT_SET_OWNER_VALIDATION, 1));
- cl_fixture_sandbox("testrepo.git");
+ cl_fixture_sandbox("empty_standard_repo");
+ cl_git_pass(cl_rename("empty_standard_repo/.gitted", "empty_standard_repo/.git"));
+
+ /*
+ * On Windows, we can generally map a local drive to a UNC path;
+ * for example C:\Foo\Bar becomes //localhost/C$/Foo/bar
+ */
+ cl_git_pass(git_str_printf(&unc_path, "//localhost/%s/%s",
+ clar_sandbox_path(), "empty_standard_repo"));
+
+ if (unc_path.ptr[13] != ':' || unc_path.ptr[14] != '/')
+ cl_skip();
+
+ unc_path.ptr[13] = '$';
git_fs_path__set_owner(GIT_FS_PATH_OWNER_OTHER);
- cl_git_fail_with(
- GIT_EOWNER, git_repository_open(&repo, "testrepo.git"));
+ cl_git_fail_with(GIT_EOWNER, git_repository_open(&repo, unc_path.ptr));
/* Add safe.directory options to the global configuration */
git_str_joinpath(&config_path, clar_sandbox_path(), "__global_config");
cl_must_pass(p_mkdir(config_path.ptr, 0777));
- git_libgit2_opts(
- GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL,
- config_path.ptr);
+ git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, config_path.ptr);
git_str_joinpath(&config_filename, config_path.ptr, ".gitconfig");
- cl_git_rewritefile(config_filename.ptr, "[foo]\n"
- "\tbar = Foobar\n"
- "\tbaz = Baz!\n"
- "[safe]\n"
- "\tdirectory = *\n"
- "[bar]\n"
- "\tfoo = barfoo\n");
+ /* The blank resets our sandbox directory and opening fails */
- cl_git_pass(git_repository_open(&repo, "testrepo.git"));
+ git_str_printf(&config_data,
+ "[safe]\n\tdirectory = %s\n",
+ unc_path.ptr);
+ cl_git_rewritefile(config_filename.ptr, config_data.ptr);
+
+ cl_git_pass(git_repository_open(&repo, unc_path.ptr));
git_repository_free(repo);
git_str_dispose(&config_path);
git_str_dispose(&config_filename);
+ git_str_dispose(&config_data);
+ git_str_dispose(&unc_path);
+#endif
}
void test_repo_open__can_reset_safe_directory_list(void)
diff --git a/tests/libgit2/repo/pathspec.c b/tests/libgit2/repo/pathspec.c
index 5b86662bcfb..0efc2a372f0 100644
--- a/tests/libgit2/repo/pathspec.c
+++ b/tests/libgit2/repo/pathspec.c
@@ -383,3 +383,33 @@ void test_repo_pathspec__in_memory(void)
git_pathspec_free(ps);
}
+
+void test_repo_pathspec__starstar(void)
+{
+ static char *strings[] = { "**/foo", "**/bar/baz" };
+ git_strarray s = { strings, ARRAY_SIZE(strings) };
+ git_pathspec *ps;
+
+ cl_git_pass(git_pathspec_new(&ps, &s));
+
+ /* "**" "/foo" does *not* match top-level "foo" */
+ cl_assert(!git_pathspec_matches_path(ps, 0, "foo"));
+ cl_assert(!git_pathspec_matches_path(ps, 0, "fooz"));
+ cl_assert(!git_pathspec_matches_path(ps, 0, "bar"));
+
+ cl_assert(git_pathspec_matches_path(ps, 0, "asdf/foo"));
+ cl_assert(!git_pathspec_matches_path(ps, 0, "asdf/fooz"));
+ cl_assert(git_pathspec_matches_path(ps, 0, "a/b/c/foo"));
+ cl_assert(!git_pathspec_matches_path(ps, 0, "a/b/c/fooz"));
+
+ cl_assert(git_pathspec_matches_path(ps, 0, "bar/foo"));
+ cl_assert(!git_pathspec_matches_path(ps, 0, "bar/baz"));
+ cl_assert(!git_pathspec_matches_path(ps, 0, "bar/foo/baz"));
+
+ cl_assert(!git_pathspec_matches_path(ps, GIT_PATHSPEC_NO_GLOB, "asdf/foo"));
+ cl_assert(!git_pathspec_matches_path(ps, GIT_PATHSPEC_NO_GLOB, "a/b/c/foo"));
+ cl_assert(!git_pathspec_matches_path(ps, GIT_PATHSPEC_NO_GLOB, "bar/foo"));
+ cl_assert(!git_pathspec_matches_path(ps, GIT_PATHSPEC_NO_GLOB, "bar/baz"));
+
+ git_pathspec_free(ps);
+}
diff --git a/tests/libgit2/repo/setters.c b/tests/libgit2/repo/setters.c
index 66ec7706c2b..8e2946d4d58 100644
--- a/tests/libgit2/repo/setters.c
+++ b/tests/libgit2/repo/setters.c
@@ -1,6 +1,7 @@
#include "clar_libgit2.h"
#include "git2/sys/repository.h"
+#include "index.h"
#include "odb.h"
#include "posix.h"
#include "util.h"
@@ -55,7 +56,7 @@ void test_repo_setters__setting_a_workdir_creates_a_gitlink(void)
cl_git_pass(git_futils_readbuffer(&content, "./new_workdir/.git"));
cl_assert(git__prefixcmp(git_str_cstr(&content), "gitdir: ") == 0);
- cl_assert(git__suffixcmp(git_str_cstr(&content), "testrepo.git/") == 0);
+ cl_assert(git__suffixcmp(git_str_cstr(&content), "testrepo.git/\n") == 0);
git_str_dispose(&content);
cl_git_pass(git_repository_config(&cfg, repo));
@@ -69,8 +70,11 @@ void test_repo_setters__setting_a_workdir_creates_a_gitlink(void)
void test_repo_setters__setting_a_new_index_on_a_repo_which_has_already_loaded_one_properly_honors_the_refcount(void)
{
git_index *new_index;
+ git_index_options index_opts = GIT_INDEX_OPTIONS_INIT;
- cl_git_pass(git_index_open(&new_index, "./my-index"));
+ index_opts.oid_type = GIT_OID_SHA1;
+
+ cl_git_pass(git_index_open_ext(&new_index, "./my-index", &index_opts));
cl_assert(((git_refcount *)new_index)->refcount.val == 1);
git_repository_set_index(repo, new_index);
@@ -91,7 +95,7 @@ void test_repo_setters__setting_a_new_odb_on_a_repo_which_already_loaded_one_pro
{
git_odb *new_odb;
- cl_git_pass(git_odb__open(&new_odb, "./testrepo.git/objects", NULL));
+ cl_git_pass(git_odb_open(&new_odb, "./testrepo.git/objects"));
cl_assert(((git_refcount *)new_odb)->refcount.val == 1);
git_repository_set_odb(repo, new_odb);
diff --git a/tests/libgit2/repo/shallow.c b/tests/libgit2/repo/shallow.c
index adb7a9e44b5..a3e3036c533 100644
--- a/tests/libgit2/repo/shallow.c
+++ b/tests/libgit2/repo/shallow.c
@@ -35,5 +35,5 @@ void test_repo_shallow__clears_errors(void)
{
g_repo = cl_git_sandbox_init("testrepo.git");
cl_assert_equal_i(0, git_repository_is_shallow(g_repo));
- cl_assert_equal_p(NULL, git_error_last());
+ cl_assert_equal_i(GIT_ERROR_NONE, git_error_last()->klass);
}
diff --git a/tests/libgit2/repo/template.c b/tests/libgit2/repo/template.c
index e8fe266cfc3..2b1ecf88c4a 100644
--- a/tests/libgit2/repo/template.c
+++ b/tests/libgit2/repo/template.c
@@ -228,8 +228,7 @@ void test_repo_template__extended_with_template_and_shared_mode(void)
const char *repo_path;
int filemode;
- opts.flags = GIT_REPOSITORY_INIT_MKPATH |
- GIT_REPOSITORY_INIT_EXTERNAL_TEMPLATE;
+ opts.flags = GIT_REPOSITORY_INIT_MKPATH;
opts.template_path = "template";
opts.mode = GIT_REPOSITORY_INIT_SHARED_GROUP;
diff --git a/tests/libgit2/reset/hard.c b/tests/libgit2/reset/hard.c
index 0b6342cb2f8..db1ea471352 100644
--- a/tests/libgit2/reset/hard.c
+++ b/tests/libgit2/reset/hard.c
@@ -3,6 +3,7 @@
#include "reset_helpers.h"
#include "path.h"
#include "futils.h"
+#include "index.h"
static git_repository *repo;
static git_object *target;
@@ -122,9 +123,9 @@ static void unmerged_index_init(git_index *index, int entries)
int write_theirs = 4;
git_oid ancestor, ours, theirs;
- git_oid__fromstr(&ancestor, "452e4244b5d083ddf0460acf1ecc74db9dcfa11a", GIT_OID_SHA1);
- git_oid__fromstr(&ours, "32504b727382542f9f089e24fddac5e78533e96c", GIT_OID_SHA1);
- git_oid__fromstr(&theirs, "061d42a44cacde5726057b67558821d95db96f19", GIT_OID_SHA1);
+ git_oid_from_string(&ancestor, "452e4244b5d083ddf0460acf1ecc74db9dcfa11a", GIT_OID_SHA1);
+ git_oid_from_string(&ours, "32504b727382542f9f089e24fddac5e78533e96c", GIT_OID_SHA1);
+ git_oid_from_string(&theirs, "061d42a44cacde5726057b67558821d95db96f19", GIT_OID_SHA1);
cl_git_rewritefile("status/conflicting_file", "conflicting file\n");
@@ -246,13 +247,14 @@ void test_reset_hard__switch_file_to_dir(void)
git_signature *sig;
git_oid src_tree_id, tgt_tree_id;
git_oid src_id, tgt_id;
+ git_index_options index_opts = GIT_INDEX_OPTIONS_INIT;
cl_git_pass(git_repository_odb(&odb, repo));
cl_git_pass(git_odb_write(&entry.id, odb, "", 0, GIT_OBJECT_BLOB));
git_odb_free(odb);
entry.mode = GIT_FILEMODE_BLOB;
- cl_git_pass(git_index_new(&idx));
+ cl_git_pass(git_index_new_ext(&idx, &index_opts));
cl_git_pass(git_signature_now(&sig, "foo", "bar"));
/* Create the old tree */
diff --git a/tests/libgit2/revert/bare.c b/tests/libgit2/revert/bare.c
index db443024ed6..eb811898796 100644
--- a/tests/libgit2/revert/bare.c
+++ b/tests/libgit2/revert/bare.c
@@ -34,10 +34,10 @@ void test_revert_bare__automerge(void)
{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 0, "file6.txt" },
};
- git_oid__fromstr(&head_oid, "72333f47d4e83616630ff3b0ffe4c0faebcc3c45", GIT_OID_SHA1);
+ git_oid_from_string(&head_oid, "72333f47d4e83616630ff3b0ffe4c0faebcc3c45", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&head_commit, repo, &head_oid));
- git_oid__fromstr(&revert_oid, "d1d403d22cbe24592d725f442835cf46fe60c8ac", GIT_OID_SHA1);
+ git_oid_from_string(&revert_oid, "d1d403d22cbe24592d725f442835cf46fe60c8ac", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&revert_commit, repo, &revert_oid));
cl_git_pass(git_revert_commit(&index, repo, revert_commit, head_commit, 0, NULL));
@@ -64,7 +64,7 @@ void test_revert_bare__conflicts(void)
{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 0, "file6.txt" },
};
- git_oid__fromstr(&revert_oid, "72333f47d4e83616630ff3b0ffe4c0faebcc3c45", GIT_OID_SHA1);
+ git_oid_from_string(&revert_oid, "72333f47d4e83616630ff3b0ffe4c0faebcc3c45", GIT_OID_SHA1);
cl_git_pass(git_repository_head(&head_ref, repo));
cl_git_pass(git_reference_peel((git_object **)&head_commit, head_ref, GIT_OBJECT_COMMIT));
@@ -91,10 +91,10 @@ void test_revert_bare__orphan(void)
{ 0100644, "296a6d3be1dff05c5d1f631d2459389fa7b619eb", 0, "file-mainline.txt" },
};
- git_oid__fromstr(&head_oid, "39467716290f6df775a91cdb9a4eb39295018145", GIT_OID_SHA1);
+ git_oid_from_string(&head_oid, "39467716290f6df775a91cdb9a4eb39295018145", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&head_commit, repo, &head_oid));
- git_oid__fromstr(&revert_oid, "ebb03002cee5d66c7732dd06241119fe72ab96a5", GIT_OID_SHA1);
+ git_oid_from_string(&revert_oid, "ebb03002cee5d66c7732dd06241119fe72ab96a5", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&revert_commit, repo, &revert_oid));
cl_git_pass(git_revert_commit(&index, repo, revert_commit, head_commit, 0, NULL));
diff --git a/tests/libgit2/revert/rename.c b/tests/libgit2/revert/rename.c
index be7a9804143..ab9303bc4eb 100644
--- a/tests/libgit2/revert/rename.c
+++ b/tests/libgit2/revert/rename.c
@@ -36,7 +36,7 @@ void test_revert_rename__automerge(void)
cl_git_pass(git_repository_head(&head_ref, repo));
cl_git_pass(git_reference_peel((git_object **)&head_commit, head_ref, GIT_OBJECT_COMMIT));
- cl_git_pass(git_oid__fromstr(&revert_oid, "7b4d7c3789b3581973c04087cb774c3c3576de2f", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&revert_oid, "7b4d7c3789b3581973c04087cb774c3c3576de2f", GIT_OID_SHA1));
cl_git_pass(git_commit_lookup(&revert_commit, repo, &revert_oid));
cl_git_pass(git_revert_commit(&index, repo, revert_commit, head_commit, 0, NULL));
diff --git a/tests/libgit2/revert/workdir.c b/tests/libgit2/revert/workdir.c
index 3e790b77f78..15bada85c1d 100644
--- a/tests/libgit2/revert/workdir.c
+++ b/tests/libgit2/revert/workdir.c
@@ -45,11 +45,11 @@ void test_revert_workdir__automerge(void)
{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 0, "file6.txt" },
};
- git_oid__fromstr(&head_oid, "72333f47d4e83616630ff3b0ffe4c0faebcc3c45", GIT_OID_SHA1);
+ git_oid_from_string(&head_oid, "72333f47d4e83616630ff3b0ffe4c0faebcc3c45", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL));
- git_oid__fromstr(&revert_oid, "d1d403d22cbe24592d725f442835cf46fe60c8ac", GIT_OID_SHA1);
+ git_oid_from_string(&revert_oid, "d1d403d22cbe24592d725f442835cf46fe60c8ac", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
cl_git_pass(git_revert(repo, commit, NULL));
@@ -76,7 +76,7 @@ void test_revert_workdir__conflicts(void)
{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 0, "file6.txt" },
};
- git_oid__fromstr(&revert_oid, "72333f47d4e83616630ff3b0ffe4c0faebcc3c45", GIT_OID_SHA1);
+ git_oid_from_string(&revert_oid, "72333f47d4e83616630ff3b0ffe4c0faebcc3c45", GIT_OID_SHA1);
cl_git_pass(git_repository_head(&head_ref, repo));
cl_git_pass(git_reference_peel((git_object **)&head, head_ref, GIT_OBJECT_COMMIT));
@@ -141,11 +141,11 @@ void test_revert_workdir__orphan(void)
{ 0100644, "296a6d3be1dff05c5d1f631d2459389fa7b619eb", 0, "file-mainline.txt" },
};
- git_oid__fromstr(&head_oid, "39467716290f6df775a91cdb9a4eb39295018145", GIT_OID_SHA1);
+ git_oid_from_string(&head_oid, "39467716290f6df775a91cdb9a4eb39295018145", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL));
- git_oid__fromstr(&revert_oid, "ebb03002cee5d66c7732dd06241119fe72ab96a5", GIT_OID_SHA1);
+ git_oid_from_string(&revert_oid, "ebb03002cee5d66c7732dd06241119fe72ab96a5", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
cl_git_pass(git_revert(repo, commit, NULL));
@@ -224,11 +224,11 @@ void test_revert_workdir__again_after_automerge(void)
{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 0, "file6.txt" },
};
- git_oid__fromstr(&head_oid, "72333f47d4e83616630ff3b0ffe4c0faebcc3c45", GIT_OID_SHA1);
+ git_oid_from_string(&head_oid, "72333f47d4e83616630ff3b0ffe4c0faebcc3c45", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL));
- git_oid__fromstr(&revert_oid, "d1d403d22cbe24592d725f442835cf46fe60c8ac", GIT_OID_SHA1);
+ git_oid_from_string(&revert_oid, "d1d403d22cbe24592d725f442835cf46fe60c8ac", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
cl_git_pass(git_revert(repo, commit, NULL));
@@ -272,11 +272,11 @@ void test_revert_workdir__again_after_edit(void)
cl_git_pass(git_repository_head(&head_ref, repo));
- cl_git_pass(git_oid__fromstr(&orig_head_oid, "399fb3aba3d9d13f7d40a9254ce4402067ef3149", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&orig_head_oid, "399fb3aba3d9d13f7d40a9254ce4402067ef3149", GIT_OID_SHA1));
cl_git_pass(git_commit_lookup(&orig_head, repo, &orig_head_oid));
cl_git_pass(git_reset(repo, (git_object *)orig_head, GIT_RESET_HARD, NULL));
- cl_git_pass(git_oid__fromstr(&revert_oid, "2d440f2b3147d3dc7ad1085813478d6d869d5a4d", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&revert_oid, "2d440f2b3147d3dc7ad1085813478d6d869d5a4d", GIT_OID_SHA1));
cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
cl_git_pass(git_revert(repo, commit, NULL));
@@ -321,11 +321,11 @@ void test_revert_workdir__again_after_edit_two(void)
cl_git_pass(git_repository_config(&config, repo));
cl_git_pass(git_config_set_bool(config, "core.autocrlf", 0));
- cl_git_pass(git_oid__fromstr(&head_commit_oid, "75ec9929465623f17ff3ad68c0438ea56faba815", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&head_commit_oid, "75ec9929465623f17ff3ad68c0438ea56faba815", GIT_OID_SHA1));
cl_git_pass(git_commit_lookup(&head_commit, repo, &head_commit_oid));
cl_git_pass(git_reset(repo, (git_object *)head_commit, GIT_RESET_HARD, NULL));
- cl_git_pass(git_oid__fromstr(&revert_commit_oid, "97e52d5e81f541080cd6b92829fb85bc4d81d90b", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&revert_commit_oid, "97e52d5e81f541080cd6b92829fb85bc4d81d90b", GIT_OID_SHA1));
cl_git_pass(git_commit_lookup(&revert_commit, repo, &revert_commit_oid));
cl_git_pass(git_revert(repo, revert_commit, NULL));
@@ -374,13 +374,13 @@ void test_revert_workdir__conflict_use_ours(void)
{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 0, "file6.txt" },
};
- opts.checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_USE_OURS;
+ opts.checkout_opts.checkout_strategy = GIT_CHECKOUT_USE_OURS;
- git_oid__fromstr(&head_oid, "72333f47d4e83616630ff3b0ffe4c0faebcc3c45", GIT_OID_SHA1);
+ git_oid_from_string(&head_oid, "72333f47d4e83616630ff3b0ffe4c0faebcc3c45", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL));
- git_oid__fromstr(&revert_oid, "d1d403d22cbe24592d725f442835cf46fe60c8ac", GIT_OID_SHA1);
+ git_oid_from_string(&revert_oid, "d1d403d22cbe24592d725f442835cf46fe60c8ac", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
cl_git_pass(git_revert(repo, commit, &opts));
@@ -412,11 +412,11 @@ void test_revert_workdir__rename_1_of_2(void)
opts.merge_opts.flags |= GIT_MERGE_FIND_RENAMES;
opts.merge_opts.rename_threshold = 50;
- git_oid__fromstr(&head_oid, "cef56612d71a6af8d8015691e4865f7fece905b5", GIT_OID_SHA1);
+ git_oid_from_string(&head_oid, "cef56612d71a6af8d8015691e4865f7fece905b5", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL));
- git_oid__fromstr(&revert_oid, "55568c8de5322ff9a95d72747a239cdb64a19965", GIT_OID_SHA1);
+ git_oid_from_string(&revert_oid, "55568c8de5322ff9a95d72747a239cdb64a19965", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
cl_git_pass(git_revert(repo, commit, &opts));
@@ -446,11 +446,11 @@ void test_revert_workdir__rename(void)
opts.merge_opts.flags |= GIT_MERGE_FIND_RENAMES;
opts.merge_opts.rename_threshold = 50;
- git_oid__fromstr(&head_oid, "55568c8de5322ff9a95d72747a239cdb64a19965", GIT_OID_SHA1);
+ git_oid_from_string(&head_oid, "55568c8de5322ff9a95d72747a239cdb64a19965", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL));
- git_oid__fromstr(&revert_oid, "0aa8c7e40d342fff78d60b29a4ba8e993ed79c51", GIT_OID_SHA1);
+ git_oid_from_string(&revert_oid, "0aa8c7e40d342fff78d60b29a4ba8e993ed79c51", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
cl_git_pass(git_revert(repo, commit, &opts));
@@ -512,7 +512,7 @@ void test_revert_workdir__merge_fails_without_mainline_specified(void)
git_commit *head;
git_oid head_oid;
- git_oid__fromstr(&head_oid, "5acdc74af27172ec491d213ee36cea7eb9ef2579", GIT_OID_SHA1);
+ git_oid_from_string(&head_oid, "5acdc74af27172ec491d213ee36cea7eb9ef2579", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL));
@@ -539,7 +539,7 @@ void test_revert_workdir__merge_first_parent(void)
opts.mainline = 1;
- git_oid__fromstr(&head_oid, "5acdc74af27172ec491d213ee36cea7eb9ef2579", GIT_OID_SHA1);
+ git_oid_from_string(&head_oid, "5acdc74af27172ec491d213ee36cea7eb9ef2579", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL));
@@ -564,7 +564,7 @@ void test_revert_workdir__merge_second_parent(void)
opts.mainline = 2;
- git_oid__fromstr(&head_oid, "5acdc74af27172ec491d213ee36cea7eb9ef2579", GIT_OID_SHA1);
+ git_oid_from_string(&head_oid, "5acdc74af27172ec491d213ee36cea7eb9ef2579", GIT_OID_SHA1);
cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL));
diff --git a/tests/libgit2/revwalk/basic.c b/tests/libgit2/revwalk/basic.c
index 41090a1dac8..b4cf76d262e 100644
--- a/tests/libgit2/revwalk/basic.c
+++ b/tests/libgit2/revwalk/basic.c
@@ -139,7 +139,7 @@ void test_revwalk_basic__sorting_modes(void)
revwalk_basic_setup_walk(NULL);
- git_oid__fromstr(&id, commit_head, GIT_OID_SHA1);
+ git_oid_from_string(&id, commit_head, GIT_OID_SHA1);
cl_git_pass(test_walk(_walk, &id, GIT_SORT_TIME, commit_sorting_time, 1));
cl_git_pass(test_walk(_walk, &id, GIT_SORT_TOPOLOGICAL, commit_sorting_topo, 2));
@@ -221,7 +221,7 @@ void test_revwalk_basic__sorted_after_reset(void)
revwalk_basic_setup_walk(NULL);
- git_oid__fromstr(&oid, commit_head, GIT_OID_SHA1);
+ git_oid_from_string(&oid, commit_head, GIT_OID_SHA1);
/* push, sort, and test the walk */
cl_git_pass(git_revwalk_push(_walk, &oid));
@@ -299,7 +299,7 @@ void test_revwalk_basic__multiple_push_1(void)
cl_git_pass(git_revwalk_hide_ref(_walk, "refs/heads/packed-test"));
- cl_git_pass(git_oid__fromstr(&oid, "5b5b025afb0b4c913b4c338a42934a3863bf3644", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, "5b5b025afb0b4c913b4c338a42934a3863bf3644", GIT_OID_SHA1));
cl_git_pass(git_revwalk_push(_walk, &oid));
while (git_revwalk_next(&oid, _walk) == 0)
@@ -333,7 +333,7 @@ void test_revwalk_basic__multiple_push_2(void)
revwalk_basic_setup_walk(NULL);
- cl_git_pass(git_oid__fromstr(&oid, "5b5b025afb0b4c913b4c338a42934a3863bf3644", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, "5b5b025afb0b4c913b4c338a42934a3863bf3644", GIT_OID_SHA1));
cl_git_pass(git_revwalk_push(_walk, &oid));
cl_git_pass(git_revwalk_hide_ref(_walk, "refs/heads/packed-test"));
@@ -352,7 +352,7 @@ void test_revwalk_basic__disallow_non_commit(void)
revwalk_basic_setup_walk(NULL);
- cl_git_pass(git_oid__fromstr(&oid, "521d87c1ec3aef9824daf6d96cc0ae3710766d91", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, "521d87c1ec3aef9824daf6d96cc0ae3710766d91", GIT_OID_SHA1));
cl_git_fail(git_revwalk_push(_walk, &oid));
}
@@ -362,7 +362,7 @@ void test_revwalk_basic__hide_then_push(void)
int i = 0;
revwalk_basic_setup_walk(NULL);
- cl_git_pass(git_oid__fromstr(&oid, "5b5b025afb0b4c913b4c338a42934a3863bf3644", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, "5b5b025afb0b4c913b4c338a42934a3863bf3644", GIT_OID_SHA1));
cl_git_pass(git_revwalk_hide(_walk, &oid));
cl_git_pass(git_revwalk_push(_walk, &oid));
@@ -376,7 +376,7 @@ void test_revwalk_basic__hide_then_push(void)
void test_revwalk_basic__topo_crash(void)
{
git_oid oid;
- git_oid__fromstr(&oid, "5b5b025afb0b4c913b4c338a42934a3863bf3644", GIT_OID_SHA1);
+ git_oid_from_string(&oid, "5b5b025afb0b4c913b4c338a42934a3863bf3644", GIT_OID_SHA1);
revwalk_basic_setup_walk(NULL);
git_revwalk_sorting(_walk, GIT_SORT_TOPOLOGICAL);
@@ -395,8 +395,8 @@ void test_revwalk_basic__from_new_to_old(void)
revwalk_basic_setup_walk(NULL);
git_revwalk_sorting(_walk, GIT_SORT_TIME);
- cl_git_pass(git_oid__fromstr(&to_oid, "5b5b025afb0b4c913b4c338a42934a3863bf3644", GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&from_oid, "a4a7dce85cf63874e984719f4fdd239f5145052f", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&to_oid, "5b5b025afb0b4c913b4c338a42934a3863bf3644", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&from_oid, "a4a7dce85cf63874e984719f4fdd239f5145052f", GIT_OID_SHA1));
cl_git_pass(git_revwalk_push(_walk, &to_oid));
cl_git_pass(git_revwalk_hide(_walk, &from_oid));
@@ -496,7 +496,7 @@ void test_revwalk_basic__mimic_git_rev_list(void)
cl_git_pass(git_revwalk_push_ref(_walk, "refs/heads/br2"));
cl_git_pass(git_revwalk_push_ref(_walk, "refs/heads/master"));
- cl_git_pass(git_oid__fromstr(&oid, "e90810b8df3e80c413d903f631643c716887138d", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, "e90810b8df3e80c413d903f631643c716887138d", GIT_OID_SHA1));
cl_git_pass(git_revwalk_push(_walk, &oid));
cl_git_pass(git_revwalk_next(&oid, _walk));
@@ -580,10 +580,10 @@ void test_revwalk_basic__old_hidden_commit_one(void)
revwalk_basic_setup_walk("testrepo.git");
- cl_git_pass(git_oid__fromstr(&new_id, "bd758010071961f28336333bc41e9c64c9a64866", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&new_id, "bd758010071961f28336333bc41e9c64c9a64866", GIT_OID_SHA1));
cl_git_pass(git_revwalk_push(_walk, &new_id));
- cl_git_pass(git_oid__fromstr(&old_id, "8e73b769e97678d684b809b163bebdae2911720f", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&old_id, "8e73b769e97678d684b809b163bebdae2911720f", GIT_OID_SHA1));
cl_git_pass(git_revwalk_hide(_walk, &old_id));
cl_git_pass(git_revwalk_next(&oid, _walk));
@@ -604,10 +604,10 @@ void test_revwalk_basic__old_hidden_commit_two(void)
revwalk_basic_setup_walk("testrepo.git");
- cl_git_pass(git_oid__fromstr(&new_id, "bd758010071961f28336333bc41e9c64c9a64866", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&new_id, "bd758010071961f28336333bc41e9c64c9a64866", GIT_OID_SHA1));
cl_git_pass(git_revwalk_push(_walk, &new_id));
- cl_git_pass(git_oid__fromstr(&old_id, "b91e763008b10db366442469339f90a2b8400d0a", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&old_id, "b91e763008b10db366442469339f90a2b8400d0a", GIT_OID_SHA1));
cl_git_pass(git_revwalk_hide(_walk, &old_id));
cl_git_pass(git_revwalk_next(&oid, _walk));
diff --git a/tests/libgit2/revwalk/hidecb.c b/tests/libgit2/revwalk/hidecb.c
index 2100a54f26c..132b6a837ba 100644
--- a/tests/libgit2/revwalk/hidecb.c
+++ b/tests/libgit2/revwalk/hidecb.c
@@ -32,10 +32,10 @@ void test_revwalk_hidecb__initialize(void)
int i;
cl_git_pass(git_repository_open(&_repo, cl_fixture("testrepo.git")));
- cl_git_pass(git_oid__fromstr(&_head_id, commit_head, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&_head_id, commit_head, GIT_OID_SHA1));
for (i = 0; i < commit_count; i++)
- cl_git_pass(git_oid__fromstr(&commit_ids[i], commit_strs[i], GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&commit_ids[i], commit_strs[i], GIT_OID_SHA1));
}
diff --git a/tests/libgit2/revwalk/mergebase.c b/tests/libgit2/revwalk/mergebase.c
index d413a1f6edb..1d7f6908a47 100644
--- a/tests/libgit2/revwalk/mergebase.c
+++ b/tests/libgit2/revwalk/mergebase.c
@@ -25,9 +25,9 @@ void test_revwalk_mergebase__single1(void)
git_oid result, one, two, expected;
size_t ahead, behind;
- cl_git_pass(git_oid__fromstr(&one, "c47800c7266a2be04c571c04d5a6614691ea99bd ", GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&two, "9fd738e8f7967c078dceed8190330fc8648ee56a", GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&expected, "5b5b025afb0b4c913b4c338a42934a3863bf3644", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&one, "c47800c7266a2be04c571c04d5a6614691ea99bd", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&two, "9fd738e8f7967c078dceed8190330fc8648ee56a", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected, "5b5b025afb0b4c913b4c338a42934a3863bf3644", GIT_OID_SHA1));
cl_git_pass(git_merge_base(&result, _repo, &one, &two));
cl_assert_equal_oid(&expected, &result);
@@ -46,9 +46,9 @@ void test_revwalk_mergebase__single2(void)
git_oid result, one, two, expected;
size_t ahead, behind;
- cl_git_pass(git_oid__fromstr(&one, "763d71aadf09a7951596c9746c024e7eece7c7af", GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&two, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&expected, "c47800c7266a2be04c571c04d5a6614691ea99bd", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&one, "763d71aadf09a7951596c9746c024e7eece7c7af", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&two, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected, "c47800c7266a2be04c571c04d5a6614691ea99bd", GIT_OID_SHA1));
cl_git_pass(git_merge_base(&result, _repo, &one, &two));
cl_assert_equal_oid(&expected, &result);
@@ -67,9 +67,9 @@ void test_revwalk_mergebase__merged_branch(void)
git_oid result, one, two, expected;
size_t ahead, behind;
- cl_git_pass(git_oid__fromstr(&one, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&two, "9fd738e8f7967c078dceed8190330fc8648ee56a", GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&expected, "9fd738e8f7967c078dceed8190330fc8648ee56a", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&one, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&two, "9fd738e8f7967c078dceed8190330fc8648ee56a", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected, "9fd738e8f7967c078dceed8190330fc8648ee56a", GIT_OID_SHA1));
cl_git_pass(git_merge_base(&result, _repo, &one, &two));
cl_assert_equal_oid(&expected, &result);
@@ -91,8 +91,8 @@ void test_revwalk_mergebase__two_way_merge(void)
git_oid one, two;
size_t ahead, behind;
- cl_git_pass(git_oid__fromstr(&one, "9b219343610c88a1187c996d0dc58330b55cee28", GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&two, "a953a018c5b10b20c86e69fef55ebc8ad4c5a417", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&one, "9b219343610c88a1187c996d0dc58330b55cee28", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&two, "a953a018c5b10b20c86e69fef55ebc8ad4c5a417", GIT_OID_SHA1));
cl_git_pass(git_graph_ahead_behind(&ahead, &behind, _repo2, &one, &two));
cl_assert_equal_sz(ahead, 8);
@@ -110,8 +110,8 @@ void test_revwalk_mergebase__no_common_ancestor_returns_ENOTFOUND(void)
size_t ahead, behind;
int error;
- cl_git_pass(git_oid__fromstr(&one, "763d71aadf09a7951596c9746c024e7eece7c7af", GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&two, "e90810b8df3e80c413d903f631643c716887138d", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&one, "763d71aadf09a7951596c9746c024e7eece7c7af", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&two, "e90810b8df3e80c413d903f631643c716887138d", GIT_OID_SHA1));
error = git_merge_base(&result, _repo, &one, &two);
cl_git_fail(error);
@@ -127,9 +127,9 @@ void test_revwalk_mergebase__prefer_youngest_merge_base(void)
{
git_oid result, one, two, expected;
- cl_git_pass(git_oid__fromstr(&one, "a4a7dce85cf63874e984719f4fdd239f5145052f", GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&two, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&expected, "c47800c7266a2be04c571c04d5a6614691ea99bd", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&one, "a4a7dce85cf63874e984719f4fdd239f5145052f", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&two, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected, "c47800c7266a2be04c571c04d5a6614691ea99bd", GIT_OID_SHA1));
cl_git_pass(git_merge_base(&result, _repo, &one, &two));
cl_assert_equal_oid(&expected, &result);
@@ -140,10 +140,10 @@ void test_revwalk_mergebase__multiple_merge_bases(void)
git_oid one, two, expected1, expected2;
git_oidarray result = {NULL, 0};
- cl_git_pass(git_oid__fromstr(&one, "a4a7dce85cf63874e984719f4fdd239f5145052f", GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&two, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&expected1, "c47800c7266a2be04c571c04d5a6614691ea99bd", GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&expected2, "9fd738e8f7967c078dceed8190330fc8648ee56a", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&one, "a4a7dce85cf63874e984719f4fdd239f5145052f", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&two, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected1, "c47800c7266a2be04c571c04d5a6614691ea99bd", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected2, "9fd738e8f7967c078dceed8190330fc8648ee56a", GIT_OID_SHA1));
cl_git_pass(git_merge_bases(&result, _repo, &one, &two));
cl_assert_equal_i(2, result.count);
@@ -160,10 +160,10 @@ void test_revwalk_mergebase__multiple_merge_bases_many_commits(void)
git_oid *input = git__malloc(sizeof(git_oid) * 2);
- cl_git_pass(git_oid__fromstr(&input[0], "a4a7dce85cf63874e984719f4fdd239f5145052f", GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&input[1], "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&expected1, "c47800c7266a2be04c571c04d5a6614691ea99bd", GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&expected2, "9fd738e8f7967c078dceed8190330fc8648ee56a", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&input[0], "a4a7dce85cf63874e984719f4fdd239f5145052f", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&input[1], "be3563ae3f795b2b4353bcce3a527ad0a4f7f644", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected1, "c47800c7266a2be04c571c04d5a6614691ea99bd", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected2, "9fd738e8f7967c078dceed8190330fc8648ee56a", GIT_OID_SHA1));
cl_git_pass(git_merge_bases_many(&result, _repo, 2, input));
cl_assert_equal_i(2, result.count);
@@ -178,8 +178,8 @@ void test_revwalk_mergebase__no_off_by_one_missing(void)
{
git_oid result, one, two;
- cl_git_pass(git_oid__fromstr(&one, "1a443023183e3f2bfbef8ac923cd81c1018a18fd", GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&two, "9f13f7d0a9402c681f91dc590cf7b5470e6a77d2", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&one, "1a443023183e3f2bfbef8ac923cd81c1018a18fd", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&two, "9f13f7d0a9402c681f91dc590cf7b5470e6a77d2", GIT_OID_SHA1));
cl_git_pass(git_merge_base(&result, _repo, &one, &two));
}
@@ -201,7 +201,7 @@ static void assert_mergebase_many(const char *expected_sha, int count, ...)
for (i = 0; i < count; ++i) {
partial_oid = va_arg(ap, char *);
- cl_git_pass(git_oid__fromstrn(&oid, partial_oid, strlen(partial_oid), GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&oid, partial_oid, strlen(partial_oid), GIT_OID_SHA1));
cl_git_pass(git_object_lookup_prefix(&object, _repo, &oid, strlen(partial_oid), GIT_OBJECT_COMMIT));
git_oid_cpy(&oids[i], git_object_id(object));
@@ -214,7 +214,7 @@ static void assert_mergebase_many(const char *expected_sha, int count, ...)
cl_assert_equal_i(GIT_ENOTFOUND, git_merge_base_many(&oid, _repo, count, oids));
else {
cl_git_pass(git_merge_base_many(&oid, _repo, count, oids));
- cl_git_pass(git_oid__fromstr(&expected, expected_sha, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected, expected_sha, GIT_OID_SHA1));
cl_assert_equal_oid(&expected, &oid);
}
@@ -265,7 +265,7 @@ static void assert_mergebase_octopus(const char *expected_sha, int count, ...)
for (i = 0; i < count; ++i) {
partial_oid = va_arg(ap, char *);
- cl_git_pass(git_oid__fromstrn(&oid, partial_oid, strlen(partial_oid), GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_prefix(&oid, partial_oid, strlen(partial_oid), GIT_OID_SHA1));
cl_git_pass(git_object_lookup_prefix(&object, _repo, &oid, strlen(partial_oid), GIT_OBJECT_COMMIT));
git_oid_cpy(&oids[i], git_object_id(object));
@@ -278,7 +278,7 @@ static void assert_mergebase_octopus(const char *expected_sha, int count, ...)
cl_assert_equal_i(GIT_ENOTFOUND, git_merge_base_octopus(&oid, _repo, count, oids));
else {
cl_git_pass(git_merge_base_octopus(&oid, _repo, count, oids));
- cl_git_pass(git_oid__fromstr(&expected, expected_sha, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&expected, expected_sha, GIT_OID_SHA1));
cl_assert_equal_oid(&expected, &oid);
}
@@ -501,9 +501,9 @@ void test_revwalk_mergebase__remove_redundant(void)
cl_git_pass(git_repository_open(&repo, cl_fixture("redundant.git")));
- cl_git_pass(git_oid__fromstr(&one, "d89137c93ba1ee749214ff4ce52ae9137bc833f9", GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&two, "91f4b95df4a59504a9813ba66912562931d990e3", GIT_OID_SHA1));
- cl_git_pass(git_oid__fromstr(&base, "6cb1f2352d974e1c5a776093017e8772416ac97a", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&one, "d89137c93ba1ee749214ff4ce52ae9137bc833f9", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&two, "91f4b95df4a59504a9813ba66912562931d990e3", GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&base, "6cb1f2352d974e1c5a776093017e8772416ac97a", GIT_OID_SHA1));
cl_git_pass(git_merge_bases(&result, repo, &one, &two));
cl_assert_equal_i(1, result.count);
diff --git a/tests/libgit2/revwalk/simplify.c b/tests/libgit2/revwalk/simplify.c
index 824496d7eb9..70c1a666124 100644
--- a/tests/libgit2/revwalk/simplify.c
+++ b/tests/libgit2/revwalk/simplify.c
@@ -32,13 +32,13 @@ void test_revwalk_simplify__first_parent(void)
int i, error;
for (i = 0; i < 4; i++) {
- git_oid__fromstr(&expected[i], expected_str[i], GIT_OID_SHA1);
+ git_oid_from_string(&expected[i], expected_str[i], GIT_OID_SHA1);
}
repo = cl_git_sandbox_init("testrepo.git");
cl_git_pass(git_revwalk_new(&walk, repo));
- git_oid__fromstr(&id, commit_head, GIT_OID_SHA1);
+ git_oid_from_string(&id, commit_head, GIT_OID_SHA1);
cl_git_pass(git_revwalk_push(walk, &id));
git_revwalk_sorting(walk, GIT_SORT_TOPOLOGICAL);
git_revwalk_simplify_first_parent(walk);
diff --git a/tests/libgit2/status/renames.c b/tests/libgit2/status/renames.c
index d5cf87d07e9..f31e3be9f34 100644
--- a/tests/libgit2/status/renames.c
+++ b/tests/libgit2/status/renames.c
@@ -584,7 +584,7 @@ void test_status_renames__zero_byte_file_does_not_fail(void)
git_status_list_free(statuslist);
}
-#ifdef GIT_USE_ICONV
+#ifdef GIT_I18N_ICONV
static char *nfc = "\xC3\x85\x73\x74\x72\xC3\xB6\x6D";
static char *nfd = "\x41\xCC\x8A\x73\x74\x72\x6F\xCC\x88\x6D";
#endif
@@ -597,7 +597,7 @@ static char *nfd = "\x41\xCC\x8A\x73\x74\x72\x6F\xCC\x88\x6D";
*/
void test_status_renames__precomposed_unicode_rename(void)
{
-#ifdef GIT_USE_ICONV
+#ifdef GIT_I18N_ICONV
git_status_list *statuslist;
git_status_options opts = GIT_STATUS_OPTIONS_INIT;
struct status_entry expected0[] = {
@@ -649,7 +649,7 @@ void test_status_renames__precomposed_unicode_rename(void)
void test_status_renames__precomposed_unicode_toggle_is_rename(void)
{
-#ifdef GIT_USE_ICONV
+#ifdef GIT_I18N_ICONV
git_status_list *statuslist;
git_status_options opts = GIT_STATUS_OPTIONS_INIT;
struct status_entry expected0[] = {
diff --git a/tests/libgit2/status/single.c b/tests/libgit2/status/single.c
index b9659a0315d..d217064b582 100644
--- a/tests/libgit2/status/single.c
+++ b/tests/libgit2/status/single.c
@@ -18,7 +18,7 @@ void test_status_single__hash_single_file(void)
git_oid expected_id, actual_id;
/* initialization */
- git_oid__fromstr(&expected_id, file_hash, GIT_OID_SHA1);
+ git_oid_from_string(&expected_id, file_hash, GIT_OID_SHA1);
cl_git_mkfile(file_name, file_contents);
cl_set_cleanup(&cleanup__remove_file, (void *)file_name);
@@ -36,7 +36,7 @@ void test_status_single__hash_single_empty_file(void)
git_oid expected_id, actual_id;
/* initialization */
- git_oid__fromstr(&expected_id, file_hash, GIT_OID_SHA1);
+ git_oid_from_string(&expected_id, file_hash, GIT_OID_SHA1);
cl_git_mkfile(file_name, file_contents);
cl_set_cleanup(&cleanup__remove_file, (void *)file_name);
diff --git a/tests/libgit2/status/submodules.c b/tests/libgit2/status/submodules.c
index 90d56d9cc8e..9c901144592 100644
--- a/tests/libgit2/status/submodules.c
+++ b/tests/libgit2/status/submodules.c
@@ -142,7 +142,7 @@ void test_status_submodules__moved_head(void)
/* move submodule HEAD to c47800c7266a2be04c571c04d5a6614691ea99bd */
cl_git_pass(
- git_oid__fromstr(&oid, "c47800c7266a2be04c571c04d5a6614691ea99bd", GIT_OID_SHA1));
+ git_oid_from_string(&oid, "c47800c7266a2be04c571c04d5a6614691ea99bd", GIT_OID_SHA1));
cl_git_pass(git_repository_set_head_detached(smrepo, &oid));
/* first do a normal status, which should now include the submodule */
diff --git a/tests/libgit2/status/worktree.c b/tests/libgit2/status/worktree.c
index efbf597a723..9e3623361bf 100644
--- a/tests/libgit2/status/worktree.c
+++ b/tests/libgit2/status/worktree.c
@@ -515,19 +515,19 @@ void test_status_worktree__conflict_with_diff3(void)
ancestor_entry.path = "modified_file";
ancestor_entry.mode = 0100644;
- git_oid__fromstr(&ancestor_entry.id,
+ git_oid_from_string(&ancestor_entry.id,
"452e4244b5d083ddf0460acf1ecc74db9dcfa11a",
GIT_OID_SHA1);
our_entry.path = "modified_file";
our_entry.mode = 0100644;
- git_oid__fromstr(&our_entry.id,
+ git_oid_from_string(&our_entry.id,
"452e4244b5d083ddf0460acf1ecc74db9dcfa11a",
GIT_OID_SHA1);
their_entry.path = "modified_file";
their_entry.mode = 0100644;
- git_oid__fromstr(&their_entry.id,
+ git_oid_from_string(&their_entry.id,
"452e4244b5d083ddf0460acf1ecc74db9dcfa11a",
GIT_OID_SHA1);
@@ -714,19 +714,19 @@ void test_status_worktree__conflicted_item(void)
ancestor_entry.mode = 0100644;
ancestor_entry.path = "modified_file";
- git_oid__fromstr(&ancestor_entry.id,
+ git_oid_from_string(&ancestor_entry.id,
"452e4244b5d083ddf0460acf1ecc74db9dcfa11a",
GIT_OID_SHA1);
our_entry.mode = 0100644;
our_entry.path = "modified_file";
- git_oid__fromstr(&our_entry.id,
+ git_oid_from_string(&our_entry.id,
"452e4244b5d083ddf0460acf1ecc74db9dcfa11a",
GIT_OID_SHA1);
their_entry.mode = 0100644;
their_entry.path = "modified_file";
- git_oid__fromstr(&their_entry.id,
+ git_oid_from_string(&their_entry.id,
"452e4244b5d083ddf0460acf1ecc74db9dcfa11a",
GIT_OID_SHA1);
@@ -754,7 +754,7 @@ void test_status_worktree__conflict_has_no_oid(void)
entry.mode = 0100644;
entry.path = "modified_file";
- git_oid__fromstr(&entry.id, "452e4244b5d083ddf0460acf1ecc74db9dcfa11a", GIT_OID_SHA1);
+ git_oid_from_string(&entry.id, "452e4244b5d083ddf0460acf1ecc74db9dcfa11a", GIT_OID_SHA1);
cl_git_pass(git_repository_index(&index, repo));
cl_git_pass(git_index_conflict_add(index, &entry, &entry, &entry));
@@ -1360,3 +1360,13 @@ void test_status_worktree__at_head_parent(void)
git_tree_free(parent_tree);
git_status_list_free(statuslist);
}
+
+void test_status_worktree__skip_hash(void)
+{
+ git_repository *repo = cl_git_sandbox_init("status_skiphash");
+ git_index *index;
+
+ cl_git_pass(git_repository_index(&index, repo));
+ cl_git_pass(git_index_read(index, true));
+ git_index_free(index);
+}
diff --git a/tests/libgit2/status/worktree_init.c b/tests/libgit2/status/worktree_init.c
index 40f1b2a3140..532b4bba084 100644
--- a/tests/libgit2/status/worktree_init.c
+++ b/tests/libgit2/status/worktree_init.c
@@ -7,6 +7,7 @@
#include "posix.h"
#include "util.h"
#include "path.h"
+#include "index.h"
static void cleanup_new_repo(void *path)
{
@@ -283,7 +284,7 @@ void test_status_worktree_init__disable_pathspec_match(void)
{
git_repository *repo;
git_status_options opts = GIT_STATUS_OPTIONS_INIT;
- char *file_with_bracket = "LICENSE[1].md",
+ char *file_with_bracket = "LICENSE[1].md",
*imaginary_file_with_bracket = "LICENSE[1-2].md";
cl_set_cleanup(&cleanup_new_repo, "pathspec");
@@ -291,18 +292,18 @@ void test_status_worktree_init__disable_pathspec_match(void)
cl_git_mkfile("pathspec/LICENSE[1].md", "screaming bracket\n");
cl_git_mkfile("pathspec/LICENSE1.md", "no bracket\n");
- opts.flags = GIT_STATUS_OPT_INCLUDE_UNTRACKED |
+ opts.flags = GIT_STATUS_OPT_INCLUDE_UNTRACKED |
GIT_STATUS_OPT_DISABLE_PATHSPEC_MATCH;
opts.pathspec.count = 1;
opts.pathspec.strings = &file_with_bracket;
cl_git_pass(
- git_status_foreach_ext(repo, &opts, cb_status__expected_path,
+ git_status_foreach_ext(repo, &opts, cb_status__expected_path,
file_with_bracket)
);
/* Test passing a pathspec matching files in the workdir. */
- /* Must not match because pathspecs are disabled. */
+ /* Must not match because pathspecs are disabled. */
opts.pathspec.strings = &imaginary_file_with_bracket;
cl_git_pass(
git_status_foreach_ext(repo, &opts, cb_status__expected_path, NULL)
diff --git a/tests/libgit2/stream/registration.c b/tests/libgit2/stream/registration.c
index bf3c20502a0..e1ce54a5dc2 100644
--- a/tests/libgit2/stream/registration.c
+++ b/tests/libgit2/stream/registration.c
@@ -81,10 +81,10 @@ void test_stream_registration__tls(void)
cl_git_pass(git_stream_register(GIT_STREAM_TLS, NULL));
error = git_tls_stream_new(&stream, "localhost", "443");
- /* We don't have TLS support enabled, or we're on Windows,
- * which has no arbitrary TLS stream support.
+ /* We don't have TLS support enabled, or we're on Windows
+ * with WinHTTP, which is not actually TLS stream support.
*/
-#if defined(GIT_WIN32) || !defined(GIT_HTTPS)
+#if defined(GIT_HTTPS_WINHTTP) || !defined(GIT_HTTPS)
cl_git_fail_with(-1, error);
#else
cl_git_pass(error);
diff --git a/tests/libgit2/submodule/add.c b/tests/libgit2/submodule/add.c
index a2a66e7f549..915ccf415dc 100644
--- a/tests/libgit2/submodule/add.c
+++ b/tests/libgit2/submodule/add.c
@@ -60,7 +60,7 @@ void test_submodule_add__url_absolute(void)
/* Verify gitdir path is relative */
cl_git_pass(git_futils_readbuffer(&dot_git_content, "submod2/" "sm_libgit2" "/.git"));
- cl_assert_equal_s("gitdir: ../.git/modules/sm_libgit2/", dot_git_content.ptr);
+ cl_assert_equal_s("gitdir: ../.git/modules/sm_libgit2/\n", dot_git_content.ptr);
git_repository_free(repo);
git_str_dispose(&dot_git_content);
@@ -139,7 +139,7 @@ static void test_add_entry(
{
git_index_entry entry = {{0}};
- cl_git_pass(git_oid__fromstr(&entry.id, idstr, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&entry.id, idstr, GIT_OID_SHA1));
entry.path = path;
entry.mode = mode;
diff --git a/tests/libgit2/submodule/lookup.c b/tests/libgit2/submodule/lookup.c
index acfdc838c26..2c5c6081f41 100644
--- a/tests/libgit2/submodule/lookup.c
+++ b/tests/libgit2/submodule/lookup.c
@@ -3,6 +3,7 @@
#include "git2/sys/repository.h"
#include "repository.h"
#include "futils.h"
+#include "index.h"
static git_repository *g_repo = NULL;
@@ -210,7 +211,7 @@ void test_submodule_lookup__lookup_even_with_missing_index(void)
git_index *idx;
/* give the repo an empty index */
- cl_git_pass(git_index_new(&idx));
+ cl_git_pass(git_index_new_ext(&idx, NULL));
git_repository_set_index(g_repo, idx);
git_index_free(idx);
@@ -400,6 +401,24 @@ void test_submodule_lookup__prefix_name(void)
git_submodule_free(sm);
}
+/* ".path" in name of submodule */
+void test_submodule_lookup__dotpath_in_name(void)
+{
+ sm_lookup_data data;
+
+ cl_git_rewritefile(
+ "submod2/.gitmodules", "[submodule \"kwb.pathdict\"]\n"
+ " path = kwb.pathdict\n"
+ " url = ../Test_App\n"
+ "[submodule \"fakin.path.app\"]\n"
+ " path = fakin.path.app\n"
+ " url = ../Test_App\n");
+
+ memset(&data, 0, sizeof(data));
+ cl_git_pass(git_submodule_foreach(g_repo, sm_lookup_cb, &data));
+ cl_assert_equal_i(9, data.count);
+}
+
void test_submodule_lookup__renamed(void)
{
const char *newpath = "sm_actually_changed";
diff --git a/tests/libgit2/submodule/repository_init.c b/tests/libgit2/submodule/repository_init.c
index 39b55c403df..f24ec1d2406 100644
--- a/tests/libgit2/submodule/repository_init.c
+++ b/tests/libgit2/submodule/repository_init.c
@@ -24,7 +24,7 @@ void test_submodule_repository_init__basic(void)
/* Verify gitlink */
cl_git_pass(git_futils_readbuffer(&dot_git_content, "submod2/" "sm_gitmodules_only" "/.git"));
- cl_assert_equal_s("gitdir: ../.git/modules/sm_gitmodules_only/", dot_git_content.ptr);
+ cl_assert_equal_s("gitdir: ../.git/modules/sm_gitmodules_only/\n", dot_git_content.ptr);
cl_assert(git_fs_path_isfile("submod2/" "sm_gitmodules_only" "/.git"));
diff --git a/tests/libgit2/submodule/update.c b/tests/libgit2/submodule/update.c
index 052a4a1fedd..674d1a4fe29 100644
--- a/tests/libgit2/submodule/update.c
+++ b/tests/libgit2/submodule/update.c
@@ -30,7 +30,7 @@ void test_submodule_update__uninitialized_submodule_no_init(void)
}
struct update_submodule_cb_payload {
- int update_tips_called;
+ int update_refs_called;
int checkout_progress_called;
int checkout_notify_called;
};
@@ -71,15 +71,16 @@ static int checkout_notify_cb(
return 0;
}
-static int update_tips(const char *refname, const git_oid *a, const git_oid *b, void *data)
+static int update_refs(const char *refname, const git_oid *a, const git_oid *b, git_refspec *spec, void *data)
{
struct update_submodule_cb_payload *update_payload = data;
GIT_UNUSED(refname);
GIT_UNUSED(a);
GIT_UNUSED(b);
+ GIT_UNUSED(spec);
- update_payload->update_tips_called = 1;
+ update_payload->update_refs_called = 1;
return 1;
}
@@ -96,7 +97,7 @@ void test_submodule_update__update_submodule(void)
update_options.checkout_opts.progress_cb = checkout_progress_cb;
update_options.checkout_opts.progress_payload = &update_payload;
- update_options.fetch_opts.callbacks.update_tips = update_tips;
+ update_options.fetch_opts.callbacks.update_refs = update_refs;
update_options.fetch_opts.callbacks.payload = &update_payload;
/* get the submodule */
@@ -126,7 +127,7 @@ void test_submodule_update__update_submodule(void)
/* verify that the expected callbacks have been called. */
cl_assert_equal_i(1, update_payload.checkout_progress_called);
- cl_assert_equal_i(1, update_payload.update_tips_called);
+ cl_assert_equal_i(1, update_payload.update_refs_called);
git_submodule_free(sm);
}
@@ -143,7 +144,7 @@ void test_submodule_update__update_submodule_with_path(void)
update_options.checkout_opts.progress_cb = checkout_progress_cb;
update_options.checkout_opts.progress_payload = &update_payload;
- update_options.fetch_opts.callbacks.update_tips = update_tips;
+ update_options.fetch_opts.callbacks.update_refs = update_refs;
update_options.fetch_opts.callbacks.payload = &update_payload;
/* get the submodule */
@@ -173,7 +174,7 @@ void test_submodule_update__update_submodule_with_path(void)
/* verify that the expected callbacks have been called. */
cl_assert_equal_i(1, update_payload.checkout_progress_called);
- cl_assert_equal_i(1, update_payload.update_tips_called);
+ cl_assert_equal_i(1, update_payload.update_refs_called);
git_submodule_free(sm);
}
diff --git a/tests/libgit2/trace/trace.c b/tests/libgit2/trace/trace.c
index 097208bffd6..9fea57668a2 100644
--- a/tests/libgit2/trace/trace.c
+++ b/tests/libgit2/trace/trace.c
@@ -32,16 +32,11 @@ void test_trace_trace__cleanup(void)
void test_trace_trace__sets(void)
{
-#ifdef GIT_TRACE
cl_assert(git_trace_level() == GIT_TRACE_INFO);
-#else
- cl_skip();
-#endif
}
void test_trace_trace__can_reset(void)
{
-#ifdef GIT_TRACE
cl_assert(git_trace_level() == GIT_TRACE_INFO);
cl_git_pass(git_trace_set(GIT_TRACE_ERROR, trace_callback));
@@ -51,14 +46,10 @@ void test_trace_trace__can_reset(void)
git_trace(GIT_TRACE_ERROR, "Hello %s!", "world");
cl_assert(written == 1);
-#else
- cl_skip();
-#endif
}
void test_trace_trace__can_unset(void)
{
-#ifdef GIT_TRACE
cl_assert(git_trace_level() == GIT_TRACE_INFO);
cl_git_pass(git_trace_set(GIT_TRACE_NONE, NULL));
@@ -67,40 +58,25 @@ void test_trace_trace__can_unset(void)
cl_assert(written == 0);
git_trace(GIT_TRACE_FATAL, "Hello %s!", "world");
cl_assert(written == 0);
-#else
- cl_skip();
-#endif
}
void test_trace_trace__skips_higher_level(void)
{
-#ifdef GIT_TRACE
cl_assert(written == 0);
git_trace(GIT_TRACE_DEBUG, "Hello %s!", "world");
cl_assert(written == 0);
-#else
- cl_skip();
-#endif
}
void test_trace_trace__writes(void)
{
-#ifdef GIT_TRACE
cl_assert(written == 0);
git_trace(GIT_TRACE_INFO, "Hello %s!", "world");
cl_assert(written == 1);
-#else
- cl_skip();
-#endif
}
void test_trace_trace__writes_lower_level(void)
{
-#ifdef GIT_TRACE
cl_assert(written == 0);
git_trace(GIT_TRACE_ERROR, "Hello %s!", "world");
cl_assert(written == 1);
-#else
- cl_skip();
-#endif
}
diff --git a/tests/libgit2/trace/windows/stacktrace.c b/tests/libgit2/trace/windows/stacktrace.c
index 0a77ef99d21..21dd13a48f4 100644
--- a/tests/libgit2/trace/windows/stacktrace.c
+++ b/tests/libgit2/trace/windows/stacktrace.c
@@ -1,7 +1,7 @@
#include "clar_libgit2.h"
#include "win32/w32_leakcheck.h"
-#if defined(GIT_WIN32_LEAKCHECK)
+#if defined(GIT_DEBUG_LEAKCHECK_WIN32)
static void a(void)
{
char buf[10000];
@@ -26,7 +26,7 @@ static void c(void)
void test_trace_windows_stacktrace__basic(void)
{
-#if defined(GIT_WIN32_LEAKCHECK)
+#if defined(GIT_DEBUG_LEAKCHECK_WIN32)
c();
#endif
}
@@ -34,7 +34,7 @@ void test_trace_windows_stacktrace__basic(void)
void test_trace_windows_stacktrace__leaks(void)
{
-#if defined(GIT_WIN32_LEAKCHECK)
+#if defined(GIT_DEBUG_LEAKCHECK_WIN32)
void * p1;
void * p2;
void * p3;
@@ -124,7 +124,7 @@ void test_trace_windows_stacktrace__leaks(void)
#endif
}
-#if defined(GIT_WIN32_LEAKCHECK)
+#if defined(GIT_DEBUG_LEAKCHECK_WIN32)
static void aux_cb_alloc__1(unsigned int *aux_id)
{
static unsigned int aux_counter = 0;
@@ -141,7 +141,7 @@ static void aux_cb_lookup__1(unsigned int aux_id, char *aux_msg, size_t aux_msg_
void test_trace_windows_stacktrace__aux1(void)
{
-#if defined(GIT_WIN32_LEAKCHECK)
+#if defined(GIT_DEBUG_LEAKCHECK_WIN32)
git_win32_leakcheck_stack_set_aux_cb(aux_cb_alloc__1, aux_cb_lookup__1);
c();
c();
diff --git a/tests/libgit2/transport/register.c b/tests/libgit2/transport/register.c
index 4d3c09726da..1554afc23c2 100644
--- a/tests/libgit2/transport/register.c
+++ b/tests/libgit2/transport/register.c
@@ -144,6 +144,7 @@ static int custom_subtransport__action(
git_remote_connect_options_dispose(&opts);
*out = git__calloc(1, sizeof(git_smart_subtransport_stream));
+ GIT_ERROR_CHECK_ALLOC(*out);
(*out)->subtransport = transport;
(*out)->read = custom_subtransport_stream__read;
(*out)->write = custom_subtransport_stream__write;
@@ -169,6 +170,7 @@ static void custom_subtransport__free(git_smart_subtransport *transport)
static int custom_transport_callback(git_smart_subtransport **out, git_transport *owner, void *param)
{
struct custom_subtransport *subtransport = git__calloc(1, sizeof(struct custom_subtransport));
+ GIT_ERROR_CHECK_ALLOC(subtransport);
subtransport->called = (int *)param;
subtransport->owner = owner;
subtransport->subtransport.action = custom_subtransport__action;
diff --git a/tests/libgit2/transport/ssh_exec.c b/tests/libgit2/transport/ssh_exec.c
new file mode 100644
index 00000000000..886c10ad7c3
--- /dev/null
+++ b/tests/libgit2/transport/ssh_exec.c
@@ -0,0 +1,79 @@
+#include "clar_libgit2.h"
+#include "git2/sys/remote.h"
+#include "git2/sys/transport.h"
+
+
+void test_transport_ssh_exec__reject_injection_username(void)
+{
+#ifndef GIT_SSH_EXEC
+ cl_skip();
+#else
+ git_remote *remote;
+ git_repository *repo;
+ git_transport *transport;
+ const char *url = "-oProxyCommand=git@somehost:somepath";
+ git_remote_connect_options opts = GIT_REMOTE_CONNECT_OPTIONS_INIT;
+
+
+ cl_git_pass(git_repository_init(&repo, "./transport-username", 0));
+ cl_git_pass(git_remote_create(&remote, repo, "test",
+ cl_fixture("testrepo.git")));
+ cl_git_pass(git_transport_new(&transport, remote, url));
+ cl_git_fail_with(-1, transport->connect(transport, url,
+ GIT_SERVICE_UPLOADPACK_LS, &opts));
+
+ transport->free(transport);
+ git_remote_free(remote);
+ git_repository_free(repo);
+#endif
+}
+
+void test_transport_ssh_exec__reject_injection_hostname(void)
+{
+#ifndef GIT_SSH_EXEC
+ cl_skip();
+#else
+ git_remote *remote;
+ git_repository *repo;
+ git_transport *transport;
+ const char *url = "-oProxyCommand=somehost:somepath-hostname";
+ git_remote_connect_options opts = GIT_REMOTE_CONNECT_OPTIONS_INIT;
+
+
+ cl_git_pass(git_repository_init(&repo, "./transport-hostname", 0));
+ cl_git_pass(git_remote_create(&remote, repo, "test",
+ cl_fixture("testrepo.git")));
+ cl_git_pass(git_transport_new(&transport, remote, url));
+ cl_git_fail_with(-1, transport->connect(transport, url,
+ GIT_SERVICE_UPLOADPACK_LS, &opts));
+
+ transport->free(transport);
+ git_remote_free(remote);
+ git_repository_free(repo);
+#endif
+}
+
+void test_transport_ssh_exec__reject_injection_path(void)
+{
+#ifndef GIT_SSH_EXEC
+ cl_skip();
+#else
+ git_remote *remote;
+ git_repository *repo;
+ git_transport *transport;
+ const char *url = "git@somehost:-somepath";
+ git_remote_connect_options opts = GIT_REMOTE_CONNECT_OPTIONS_INIT;
+
+
+ cl_git_pass(git_repository_init(&repo, "./transport-path", 0));
+ cl_git_pass(git_remote_create(&remote, repo, "test",
+ cl_fixture("testrepo.git")));
+ cl_git_pass(git_transport_new(&transport, remote, url));
+ cl_git_fail_with(-1, transport->connect(transport, url,
+ GIT_SERVICE_UPLOADPACK_LS, &opts));
+
+ transport->free(transport);
+ git_remote_free(remote);
+ git_repository_free(repo);
+#endif
+}
diff --git a/tests/libgit2/transports/smart/packet.c b/tests/libgit2/transports/smart/packet.c
index 2035e3b65d0..3fb0bf6b305 100644
--- a/tests/libgit2/transports/smart/packet.c
+++ b/tests/libgit2/transports/smart/packet.c
@@ -25,7 +25,7 @@ static void assert_data_pkt_parses(const char *line, const char *expected_data,
size_t linelen = strlen(line) + 1;
const char *endptr;
git_pkt_data *pkt;
- git_pkt_parse_data pkt_parse_data = { 0 };
+ git_pkt_parse_data pkt_parse_data = { 1, GIT_OID_SHA1 };
cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen, &pkt_parse_data));
cl_assert_equal_i(pkt->type, GIT_PKT_DATA);
@@ -71,9 +71,9 @@ static void assert_ack_parses(const char *line, const char *expected_oid, enum g
const char *endptr;
git_pkt_ack *pkt;
git_oid oid;
- git_pkt_parse_data pkt_parse_data = { 0 };
+ git_pkt_parse_data pkt_parse_data = { 1, GIT_OID_SHA1 };
- cl_git_pass(git_oid__fromstr(&oid, expected_oid, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, expected_oid, GIT_OID_SHA1));
cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen, &pkt_parse_data));
cl_assert_equal_i(pkt->type, GIT_PKT_ACK);
@@ -165,7 +165,7 @@ static void assert_ref_parses_(const char *line, size_t linelen, const char *exp
git_oid oid;
git_pkt_parse_data pkt_parse_data = { 0 };
- cl_git_pass(git_oid__fromstr(&oid, expected_oid, GIT_OID_SHA1));
+ cl_git_pass(git_oid_from_string(&oid, expected_oid, GIT_OID_SHA1));
cl_git_pass(git_pkt_parse_line((git_pkt **) &pkt, &endptr, line, linelen, &pkt_parse_data));
cl_assert_equal_i(pkt->type, GIT_PKT_REF);
diff --git a/tests/libgit2/win32/forbidden.c b/tests/libgit2/win32/forbidden.c
index c4e82e90deb..bcdcdc3a7c2 100644
--- a/tests/libgit2/win32/forbidden.c
+++ b/tests/libgit2/win32/forbidden.c
@@ -37,7 +37,7 @@ void test_win32_forbidden__can_add_forbidden_filename_with_entry(void)
entry.path = "aux";
entry.mode = GIT_FILEMODE_BLOB;
- git_oid__fromstr(&entry.id, "da623abd956bb2fd8052c708c7ed43f05d192d37", GIT_OID_SHA1);
+ git_oid_from_string(&entry.id, "da623abd956bb2fd8052c708c7ed43f05d192d37", GIT_OID_SHA1);
cl_git_pass(git_index_add(index, &entry));
@@ -53,7 +53,7 @@ void test_win32_forbidden__cannot_add_dot_git_even_with_entry(void)
entry.path = "foo/.git";
entry.mode = GIT_FILEMODE_BLOB;
- git_oid__fromstr(&entry.id, "da623abd956bb2fd8052c708c7ed43f05d192d37", GIT_OID_SHA1);
+ git_oid_from_string(&entry.id, "da623abd956bb2fd8052c708c7ed43f05d192d37", GIT_OID_SHA1);
cl_git_fail(git_index_add(index, &entry));
diff --git a/tests/libgit2/worktree/config.c b/tests/libgit2/worktree/config.c
index 81dcfe1fa51..1fd1f75b47b 100644
--- a/tests/libgit2/worktree/config.c
+++ b/tests/libgit2/worktree/config.c
@@ -6,15 +6,19 @@
static worktree_fixture fixture =
WORKTREE_FIXTURE_INIT(COMMON_REPO, WORKTREE_REPO);
+static worktree_fixture submodule =
+ WORKTREE_FIXTURE_INIT("submodules", "submodules-worktree-parent");
void test_worktree_config__initialize(void)
{
setup_fixture_worktree(&fixture);
+ setup_fixture_worktree(&submodule);
}
void test_worktree_config__cleanup(void)
{
cleanup_fixture_worktree(&fixture);
+ cleanup_fixture_worktree(&submodule);
}
void test_worktree_config__open(void)
@@ -27,7 +31,7 @@ void test_worktree_config__open(void)
git_config_free(cfg);
}
-void test_worktree_config__set(void)
+void test_worktree_config__set_level_local(void)
{
git_config *cfg;
int32_t val;
@@ -45,3 +49,78 @@ void test_worktree_config__set(void)
cl_assert_equal_i(val, 5);
git_config_free(cfg);
}
+
+void test_worktree_config__requires_extension(void)
+{
+ git_config *cfg;
+ git_config *wtcfg;
+ int extension = 0;
+
+ /*
+ * the "submodules" repo does not have extensions.worktreeconfig
+ * set, the worktree configuration should not be available.
+ */
+ cl_git_pass(git_repository_config(&cfg, submodule.repo));
+ cl_git_fail_with(GIT_ENOTFOUND, git_config_get_bool(&extension, cfg, "extensions.worktreeconfig"));
+ cl_assert_equal_i(0, extension);
+ cl_git_fail_with(GIT_ENOTFOUND, git_config_open_level(&wtcfg, cfg, GIT_CONFIG_LEVEL_WORKTREE));
+ git_config_free(cfg);
+
+ /* the "testrepo" repo does have the configuration set. */
+ cl_git_pass(git_repository_config(&cfg, fixture.repo));
+ cl_git_pass(git_config_get_bool(&extension, cfg, "extensions.worktreeconfig"));
+ cl_assert_equal_i(1, extension);
+ cl_git_pass(git_config_open_level(&wtcfg, cfg, GIT_CONFIG_LEVEL_WORKTREE));
+ git_config_free(wtcfg);
+ git_config_free(cfg);
+}
+
+void test_worktree_config__exists(void)
+{
+ git_config *cfg, *wtcfg, *snap;
+ const char *str;
+
+ cl_git_pass(git_repository_config(&cfg, fixture.repo));
+ cl_git_pass(git_repository_config(&wtcfg, fixture.worktree));
+
+ cl_git_pass(git_config_snapshot(&snap, cfg));
+ cl_git_pass(git_config_get_string(&str, snap, "worktreetest.config"));
+ cl_assert_equal_s("mainrepo", str);
+ git_config_free(snap);
+
+ cl_git_pass(git_config_snapshot(&snap, wtcfg));
+ cl_git_pass(git_config_get_string(&str, snap, "worktreetest.config"));
+ cl_assert_equal_s("worktreerepo", str);
+ git_config_free(snap);
+
+ git_config_free(cfg);
+ git_config_free(wtcfg);
+}
+
+void test_worktree_config__set_level_worktree(void)
+{
+ git_config *cfg;
+ git_config *wtcfg;
+ int32_t val;
+
+ cl_git_pass(git_repository_config(&cfg, fixture.repo));
+ cl_git_pass(git_config_open_level(&wtcfg, cfg, GIT_CONFIG_LEVEL_WORKTREE));
+ cl_git_pass(git_config_set_int32(wtcfg, "worktree.specific", 42));
+
+ cl_git_pass(git_config_get_int32(&val, cfg, "worktree.specific"));
+ cl_assert_equal_i(val, 42);
+
+ /* reopen to verify config has been set */
+ git_config_free(cfg);
+ cl_git_pass(git_repository_config(&cfg, fixture.repo));
+ cl_git_pass(git_config_get_int32(&val, cfg, "worktree.specific"));
+ cl_assert_equal_i(val, 42);
+
+ cl_git_fail_with(GIT_ENOTFOUND, git_config_delete_entry(cfg, "worktree.specific"));
+
+ cl_git_pass(git_config_delete_entry(wtcfg, "worktree.specific"));
+ cl_git_fail_with(GIT_ENOTFOUND, git_config_get_int32(&val, cfg, "worktree.specific"));
+
+ git_config_free(cfg);
+ git_config_free(wtcfg);
+}
diff --git a/tests/libgit2/worktree/refs.c b/tests/libgit2/worktree/refs.c
index 557726aafb6..51e7b2b9463 100644
--- a/tests/libgit2/worktree/refs.c
+++ b/tests/libgit2/worktree/refs.c
@@ -20,7 +20,7 @@ void test_worktree_refs__cleanup(void)
cleanup_fixture_worktree(&fixture);
}
-void test_worktree_refs__list(void)
+void test_worktree_refs__list_no_difference_in_worktree(void)
{
git_strarray refs, wtrefs;
unsigned i, j;
@@ -61,6 +61,66 @@ void test_worktree_refs__list(void)
cl_git_pass(error);
}
+void test_worktree_refs__list_worktree_specific(void)
+{
+ git_strarray refs, wtrefs;
+ git_reference *ref, *new_branch;
+ int error = 0;
+ git_oid oid;
+
+ cl_git_pass(git_reference_name_to_id(&oid, fixture.repo, "refs/heads/dir"));
+ cl_git_fail_with(GIT_ENOTFOUND, git_reference_lookup(&ref, fixture.repo, "refs/bisect/a-bisect-ref"));
+ cl_git_pass(git_reference_create(
+ &new_branch, fixture.worktree, "refs/bisect/a-bisect-ref", &oid,
+ 0, "test"));
+
+ cl_git_fail_with(GIT_ENOTFOUND, git_reference_lookup(&ref, fixture.repo, "refs/bisect/a-bisect-ref"));
+ cl_git_pass(git_reference_lookup(&ref, fixture.worktree, "refs/bisect/a-bisect-ref"));
+
+ cl_git_pass(git_reference_list(&refs, fixture.repo));
+ cl_git_pass(git_reference_list(&wtrefs, fixture.worktree));
+
+ cl_assert_equal_sz(wtrefs.count, refs.count + 1);
+
+ git_reference_free(ref);
+ git_reference_free(new_branch);
+ git_strarray_dispose(&refs);
+ git_strarray_dispose(&wtrefs);
+ cl_git_pass(error);
+}
+
+void test_worktree_refs__list_worktree_specific_hidden_in_main_repo(void)
+{
+ git_strarray refs, wtrefs;
+ git_reference *ref, *new_branch;
+ int error = 0;
+ git_oid oid;
+
+ cl_git_pass(
+ git_reference_name_to_id(&oid, fixture.repo, "refs/heads/dir"));
+ cl_git_fail_with(GIT_ENOTFOUND, git_reference_lookup(
+ &ref, fixture.worktree, "refs/bisect/a-bisect-ref"));
+ cl_git_pass(git_reference_create(
+ &new_branch, fixture.repo, "refs/bisect/a-bisect-ref", &oid,
+ 0, "test"));
+
+ cl_git_fail_with(GIT_ENOTFOUND, git_reference_lookup(
+ &ref, fixture.worktree, "refs/bisect/a-bisect-ref"));
+ cl_git_pass(git_reference_lookup(
+ &ref, fixture.repo, "refs/bisect/a-bisect-ref"));
+
+ cl_git_pass(git_reference_list(&refs, fixture.repo));
+ cl_git_pass(git_reference_list(&wtrefs, fixture.worktree));
+
+ cl_assert_equal_sz(refs.count, wtrefs.count + 1);
+
+ git_reference_free(ref);
+ git_reference_free(new_branch);
+ git_strarray_dispose(&refs);
+ git_strarray_dispose(&wtrefs);
+ cl_git_pass(error);
+}
+
void test_worktree_refs__read_head(void)
{
git_reference *head;
diff --git a/tests/libgit2/worktree/worktree.c b/tests/libgit2/worktree/worktree.c
index 9fd27f49c5f..00e3e3fe791 100644
--- a/tests/libgit2/worktree/worktree.c
+++ b/tests/libgit2/worktree/worktree.c
@@ -217,6 +217,50 @@ void test_worktree_worktree__init(void)
git_repository_free(repo);
}
+void test_worktree_worktree__add_remove_add(void)
+{
+ git_worktree_add_options add_opts = GIT_WORKTREE_ADD_OPTIONS_INIT;
+ git_worktree_prune_options opts = GIT_WORKTREE_PRUNE_OPTIONS_INIT;
+ git_str path = GIT_BUF_INIT;
+ git_reference *branch;
+ git_repository *repo;
+ git_worktree *wt;
+
+ /* Add the worktree */
+ cl_git_pass(git_str_joinpath(&path, fixture.repo->workdir, "../worktree-add-remove-add"));
+ cl_git_pass(git_worktree_add(&wt, fixture.repo, "worktree-add-remove-add", path.ptr, NULL));
+
+ /* Open and verify created repo */
+ cl_git_pass(git_repository_open(&repo, path.ptr));
+ cl_assert(git__suffixcmp(git_repository_workdir(repo), "worktree-add-remove-add/") == 0);
+ cl_git_pass(git_branch_lookup(&branch, repo, "worktree-add-remove-add", GIT_BRANCH_LOCAL));
+ git_reference_free(branch);
+ git_repository_free(repo);
+
+ /* Prune the worktree */
+ opts.flags = GIT_WORKTREE_PRUNE_VALID|GIT_WORKTREE_PRUNE_WORKING_TREE;
+ cl_git_pass(git_worktree_prune(wt, &opts));
+ cl_assert(!git_fs_path_exists(wt->gitdir_path));
+ cl_assert(!git_fs_path_exists(wt->gitlink_path));
+ git_worktree_free(wt);
+
+ /* Add the worktree back with default options should fail. */
+ cl_git_fail(git_worktree_add(&wt, fixture.repo, "worktree-add-remove-add", path.ptr, &add_opts));
+ /* If allowing checkout of existing branches, it should succeed. */
+ add_opts.checkout_existing = 1;
+ cl_git_pass(git_worktree_add(&wt, fixture.repo, "worktree-add-remove-add", path.ptr, &add_opts));
+
+ /* Open and verify created repo */
+ cl_git_pass(git_repository_open(&repo, path.ptr));
+ cl_assert(git__suffixcmp(git_repository_workdir(repo), "worktree-add-remove-add/") == 0);
+ cl_git_pass(git_branch_lookup(&branch, repo, "worktree-add-remove-add", GIT_BRANCH_LOCAL));
+ git_reference_free(branch);
+ git_repository_free(repo);
+
+ git_str_dispose(&path);
+ git_worktree_free(wt);
+}
+
void test_worktree_worktree__add_locked(void)
{
git_worktree *wt;
@@ -244,6 +288,7 @@ void test_worktree_worktree__add_locked(void)
void test_worktree_worktree__init_existing_branch(void)
{
+ git_worktree_add_options opts = GIT_WORKTREE_ADD_OPTIONS_INIT;
git_reference *head, *branch;
git_commit *commit;
git_worktree *wt;
@@ -251,12 +296,18 @@ void test_worktree_worktree__init_existing_branch(void)
cl_git_pass(git_repository_head(&head, fixture.repo));
cl_git_pass(git_commit_lookup(&commit, fixture.repo, &head->target.oid));
- cl_git_pass(git_branch_create(&branch, fixture.repo, "worktree-new", commit, false));
+ cl_git_pass(git_branch_create(&branch, fixture.repo, "worktree-new-exist", commit, false));
- cl_git_pass(git_str_joinpath(&path, fixture.repo->workdir, "../worktree-new"));
- cl_git_fail(git_worktree_add(&wt, fixture.repo, "worktree-new", path.ptr, NULL));
+ cl_git_pass(git_str_joinpath(&path, fixture.repo->workdir, "../worktree-new-exist"));
+
+ /* Add the worktree back with default options should fail. */
+ cl_git_fail(git_worktree_add(&wt, fixture.repo, "worktree-new-exist", path.ptr, NULL));
+ /* If allowing checkout of existing branches, it should succeed. */
+ opts.checkout_existing = 1;
+ cl_git_pass(git_worktree_add(&wt, fixture.repo, "worktree-new-exist", path.ptr, &opts));
git_str_dispose(&path);
+ git_worktree_free(wt);
git_commit_free(commit);
git_reference_free(head);
git_reference_free(branch);
@@ -645,3 +696,16 @@ void test_worktree_worktree__validate_invalid_worktreedir(void)
git_worktree_free(wt);
}
+
+void test_worktree_worktree__is_prunable_missing_repo(void)
+{
+ git_worktree *wt;
+
+ cl_git_pass(git_worktree_lookup(&wt, fixture.repo, "testrepo-worktree"));
+ p_rename("testrepo", "testrepo-tmp");
+ /* Should not be prunable since the repository moved */
+ cl_assert(!git_worktree_is_prunable(wt, NULL));
+ p_rename("testrepo-tmp", "testrepo");
+
+ git_worktree_free(wt);
+}
diff --git a/tests/resources/certs/README b/tests/resources/certs/README
new file mode 100644
index 00000000000..6a4fc4c68e0
--- /dev/null
+++ b/tests/resources/certs/README
@@ -0,0 +1,5 @@
+These are self-signed certificates for https://test.libgit2.org/.
+
+* one/ - contains certificates for https://test.libgit2.org:1443/
+* two.pem - contains a certificate for https://test.libgit2.org:2443/
+* three.pem - contains a certificate for https://test.libgit2.org:3443/
diff --git a/tests/resources/certs/one/61f2ddb6.0 b/tests/resources/certs/one/61f2ddb6.0
new file mode 100644
index 00000000000..7d9ef6fce2a
--- /dev/null
+++ b/tests/resources/certs/one/61f2ddb6.0
@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFWzCCA0MCFESY816VkhBPUOsdp7djKW5q4ZVzMA0GCSqGSIb3DQEBCwUAMGox
+CzAJBgNVBAYTAlVTMRYwFAYDVQQIDA1NYXNzYWNodXNldHRzMRIwEAYDVQQHDAlD
+YW1icmlkZ2UxFDASBgNVBAoMC2xpYmdpdDIub3JnMRkwFwYDVQQDDBB0ZXN0Lmxp
+YmdpdDIub3JnMB4XDTIxMDgyNTE4NTExMVoXDTMxMDgyMzE4NTExMVowajELMAkG
+A1UEBhMCVVMxFjAUBgNVBAgMDU1hc3NhY2h1c2V0dHMxEjAQBgNVBAcMCUNhbWJy
+aWRnZTEUMBIGA1UECgwLbGliZ2l0Mi5vcmcxGTAXBgNVBAMMEHRlc3QubGliZ2l0
+Mi5vcmcwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCgvaRUaM3IJh9N
+G6Yc7tHioUsIGU0MkzSvy/X6O/vONnuuioiJQyPIvfRSvZR2iQj8THTypDGhWn3r
+6h2wk5eOUGwJH2N9FrrlEBdpsMc7SKdiJXwTI30mkK3/qru8NzE71dgCkYp1xhKw
+edTkAFK+PkvyVLFL7K35cx8Bxfamyssdb+qGWa7g4P27CWUdvQgmurrzzPIMZiLD
+/cI1Kwer/N7nTY/6CSs9dcHTlanyZdf+mQ50+//vI4F6+OduGHJkxRF48jLUz1rz
+P3WGRMRbHjCmvWpX/9DLgqGk7XTy0hNgNUCit6kawwcv5y7SP/ii86MkynAHn5i8
+d+zhXjdrSSy8i0IbRJafnxmtrsmjGeIzraJSRqMlv7KKWEBz+alm6vlePnRUbWB7
+0po5uSsRPya6kJJCzMjIfKq1dgXq33m9jCG2wU+L4fEHVlEkFGXYTspMlIBNUjTc
+c45+e1EpamF8aHm32PP8gTF8fGZzQjOXmNW5g7t0joWMGZ+Ao2jYc1pG3SOARi36
+azrmB5/XJqbbfVZEzIue01fO/5R8RgabOP1qWUjH2KLb8zTDok+CW0ULNseU+MKf
+PHXG2OjxcR0vTqop2V6JlKTXXx3/TOD16/+mSrrPzNDejLrkvAH9oN38YpMBM8eg
+vfivHNRm0jjdGbv2OOPEBLEf1cNimQIDAQABMA0GCSqGSIb3DQEBCwUAA4ICAQBZ
+znFta24sWoqdgKXKAK5RHAh/HyOvTInwcXi9RU4XjYlbqNVs0ODR74VRZINoyAL2
+bo+x/iUuAp9+b8fjr79fpVof3nSMU7UtMcT1nvzVmaUYSkKQ0f/9vK4yg0kao1bV
+WwhIc0slKgOJjEicPVs3kd+duv5vakQeUajLPGM8SiS1F/nF67rIuZLdJn2Qp+im
+w5Q3Pjgqw5VrJxyk3AaUcntKHpWy1POLyNV79tXra6BxbtQVlRS0+h1MHELARDFx
+1ZtgyAe5YbWM7WrIiFKD4mmKZu4GMnJDXVpfUub5g0U/e7L/gg6Z1UyYZuln6axw
+RojuAHo1uAWFUsjhWLYV/7P/l/dC+7gFjvSsUqb1+U7jXObzfKjXo/FwYcy4VsVv
+xNbglbhdVjAo/YBTJuf3L0UZjSbxvQIYS+v8u1ECeWE6SH6cHRzryeo5wO4h8NJR
+n30xsvocHFbs4LWy5BVfMUo6wGUy0Y+1gSwSqVMv3JPuLwxUsv0HPdeC00Ab9cHq
+kYXPNZXg3a6orTDa4hJLdAm2V/fn/2KKJYlNj7iCL664QgoCHl7LFyLMiwFVCu5h
+4JjGL3Q+8MondaLZlq5YDmvtj979AyM/7qL4XAE2oofQ4J5dqnKKpMkWdAM/fI/9
+N5DK/4zMXJWgIED0yo2SSZHQmuqZplacOhmfjjZigQ==
+-----END CERTIFICATE-----
diff --git a/tests/resources/certs/one/db4f60b0.0 b/tests/resources/certs/one/db4f60b0.0
new file mode 100644
index 00000000000..7d9ef6fce2a
--- /dev/null
+++ b/tests/resources/certs/one/db4f60b0.0
@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFWzCCA0MCFESY816VkhBPUOsdp7djKW5q4ZVzMA0GCSqGSIb3DQEBCwUAMGox
+CzAJBgNVBAYTAlVTMRYwFAYDVQQIDA1NYXNzYWNodXNldHRzMRIwEAYDVQQHDAlD
+YW1icmlkZ2UxFDASBgNVBAoMC2xpYmdpdDIub3JnMRkwFwYDVQQDDBB0ZXN0Lmxp
+YmdpdDIub3JnMB4XDTIxMDgyNTE4NTExMVoXDTMxMDgyMzE4NTExMVowajELMAkG
+A1UEBhMCVVMxFjAUBgNVBAgMDU1hc3NhY2h1c2V0dHMxEjAQBgNVBAcMCUNhbWJy
+aWRnZTEUMBIGA1UECgwLbGliZ2l0Mi5vcmcxGTAXBgNVBAMMEHRlc3QubGliZ2l0
+Mi5vcmcwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCgvaRUaM3IJh9N
+G6Yc7tHioUsIGU0MkzSvy/X6O/vONnuuioiJQyPIvfRSvZR2iQj8THTypDGhWn3r
+6h2wk5eOUGwJH2N9FrrlEBdpsMc7SKdiJXwTI30mkK3/qru8NzE71dgCkYp1xhKw
+edTkAFK+PkvyVLFL7K35cx8Bxfamyssdb+qGWa7g4P27CWUdvQgmurrzzPIMZiLD
+/cI1Kwer/N7nTY/6CSs9dcHTlanyZdf+mQ50+//vI4F6+OduGHJkxRF48jLUz1rz
+P3WGRMRbHjCmvWpX/9DLgqGk7XTy0hNgNUCit6kawwcv5y7SP/ii86MkynAHn5i8
+d+zhXjdrSSy8i0IbRJafnxmtrsmjGeIzraJSRqMlv7KKWEBz+alm6vlePnRUbWB7
+0po5uSsRPya6kJJCzMjIfKq1dgXq33m9jCG2wU+L4fEHVlEkFGXYTspMlIBNUjTc
+c45+e1EpamF8aHm32PP8gTF8fGZzQjOXmNW5g7t0joWMGZ+Ao2jYc1pG3SOARi36
+azrmB5/XJqbbfVZEzIue01fO/5R8RgabOP1qWUjH2KLb8zTDok+CW0ULNseU+MKf
+PHXG2OjxcR0vTqop2V6JlKTXXx3/TOD16/+mSrrPzNDejLrkvAH9oN38YpMBM8eg
+vfivHNRm0jjdGbv2OOPEBLEf1cNimQIDAQABMA0GCSqGSIb3DQEBCwUAA4ICAQBZ
+znFta24sWoqdgKXKAK5RHAh/HyOvTInwcXi9RU4XjYlbqNVs0ODR74VRZINoyAL2
+bo+x/iUuAp9+b8fjr79fpVof3nSMU7UtMcT1nvzVmaUYSkKQ0f/9vK4yg0kao1bV
+WwhIc0slKgOJjEicPVs3kd+duv5vakQeUajLPGM8SiS1F/nF67rIuZLdJn2Qp+im
+w5Q3Pjgqw5VrJxyk3AaUcntKHpWy1POLyNV79tXra6BxbtQVlRS0+h1MHELARDFx
+1ZtgyAe5YbWM7WrIiFKD4mmKZu4GMnJDXVpfUub5g0U/e7L/gg6Z1UyYZuln6axw
+RojuAHo1uAWFUsjhWLYV/7P/l/dC+7gFjvSsUqb1+U7jXObzfKjXo/FwYcy4VsVv
+xNbglbhdVjAo/YBTJuf3L0UZjSbxvQIYS+v8u1ECeWE6SH6cHRzryeo5wO4h8NJR
+n30xsvocHFbs4LWy5BVfMUo6wGUy0Y+1gSwSqVMv3JPuLwxUsv0HPdeC00Ab9cHq
+kYXPNZXg3a6orTDa4hJLdAm2V/fn/2KKJYlNj7iCL664QgoCHl7LFyLMiwFVCu5h
+4JjGL3Q+8MondaLZlq5YDmvtj979AyM/7qL4XAE2oofQ4J5dqnKKpMkWdAM/fI/9
+N5DK/4zMXJWgIED0yo2SSZHQmuqZplacOhmfjjZigQ==
+-----END CERTIFICATE-----
diff --git a/tests/resources/certs/three.pem b/tests/resources/certs/three.pem
new file mode 100644
index 00000000000..b63f09301bc
--- /dev/null
+++ b/tests/resources/certs/three.pem
@@ -0,0 +1,33 @@
+-----BEGIN CERTIFICATE-----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+-----END CERTIFICATE-----
diff --git a/tests/resources/certs/three.pem.raw b/tests/resources/certs/three.pem.raw
new file mode 100644
index 00000000000..63e35f85d23
--- /dev/null
+++ b/tests/resources/certs/three.pem.raw
@@ -0,0 +1 @@
+MIIFtTCCA52gAwIBAgIUIGLmUoxDx3fh8dGDdrw81kDLWJgwDQYJKoZIhvcNAQELBQAwajELMAkGA1UEBhMCVVMxFjAUBgNVBAgMDU1hc3NhY2h1c2V0dHMxEjAQBgNVBAcMCUNhbWJyaWRnZTEUMBIGA1UECgwLbGliZ2l0Mi5vcmcxGTAXBgNVBAMMEHRlc3QubGliZ2l0Mi5vcmcwHhcNMjQxMDAxMDkwODEzWhcNMzQwOTI5MDkwODEzWjBqMQswCQYDVQQGEwJVUzEWMBQGA1UECAwNTWFzc2FjaHVzZXR0czESMBAGA1UEBwwJQ2FtYnJpZGdlMRQwEgYDVQQKDAtsaWJnaXQyLm9yZzEZMBcGA1UEAwwQdGVzdC5saWJnaXQyLm9yZzCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAL7tLetmORd4uklvSeFn9eJfHCrhmNkWHd1VVuMhjcKkjk+N7GNdq1UMsSZU0xnJMICjJcnqplZ9WnO6VkRibyIf/Xp5dh3sQh9jvuTNhvWAOYv9tjxX1sxA0WeHAZj/5qUMtvH3mr0gqNbtIrmEFAeWgcYSJbXhnWit7YEnGReHc17F50hbbLOgl5HLQAzIAEkj4nKXhR8KKgyQk3dNfoc9orSjUxDp8fq9Z2prcEOYFmkItvC8rtqLB9EBJ1moGjB1BWEd3Eg28TUXubRGwrTbpMWP5UWQWuS2Adnd/oQE7NVe5xhxzad8qlReEodF+ptSux5GNw+qy5l5GbMdNfgmXXp34vUldl8dH1BAtC0QH/fmAg5Ea7Ys0bnM9c0MRHJlX7QC3fk/pVCSw7ozuceTyJyqhHMRUAcKeGJETJoBz/nmWm2oG5VjZ54k6ktvjjKNGpuL44dR+xpZljESmHOm7c10AKBiuMjSG5i1o7wzWEDDfCPKo/5Uf5mMcTn78yrO83ztyhIIYfm1kDTbAMMDo1MYHnsqXROxc0ShyLM5fLf7hWh+p8p0MrLUWbAtdETOOx9YqOla6qOGwmKmZaDR82GBCNcLkkqiuWC9oWb2YCtw7UB6cT7BSR7z8mLzfKrzryuJ2IRawZ9JuuHmBMhvLmDWXoLy6zbxTc8eIaffAgMBAAGjUzBRMB0GA1UdDgQWBBTEX4I8cLBkgHHuPS6wu1Z2CFVwNjAfBgNVHSMEGDAWgBTEX4I8cLBkgHHuPS6wu1Z2CFVwNjAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3DQEBCwUAA4ICAQBzgWp1dk0YezID9uD4QRdKarPsRwH4EiXi4sk0udjrOljiPWrUTTvg4Zo/PszaJGmFUtoKGrSDRqaCHMeSOT3NGuxqvfdSvxT6I7b6mDTRiJGncQ/h6Efj/9M04lHvfPsv33055ZF/FZBNznG+FYJM0iOMsgsRq95sM28/Z0eG65YJ/4o4Y9eC+zKUqC+ksVvrEDiinFPPXPzrqJ5aW6TgUgQ583Q1u/Ijj3Z+LxlV3fe2OVgFKCL82XOsZPRCQq71vnNXA3KNRpmXw4fNgZYmYDzUuEaeP+0jL38sTIZaHOEOPlghjny9c+UgqAWUEiN9M1HC59Dc7ViTzRYlWUSbLOzh2vmT7nv7l9eRRNVp5gfWVhI6yu6lZ4tsH1BvMoJ3tgJ+c9pfWMZEIKuErZl0u58Zs09ozzXaXXnMjx6pnTrqwMqaHJe5SFHh3XvvycGjCXRy4vjhxs+BpmGqB44DRtYBbW6n4UDc481QVEoWd9DOQ7Y2OQJ1pHFTLLqkWSXw3KmO0cAX51H9Ab46WfmYhrtmGNrYWUB7fGSsJ1C/4fiuo8Hx5sq+NP11H80q8TOBcPGRyeTjK8L5y6T907tfZMlfloiBcbBFSbOf4+KCyVOYaM0O/LrroH+zZaNJiEP1By7Qsn/2Ekw0zxtlImc0SQ3NqnkfAsp6nfYMJPylZA==
\ No newline at end of file
diff --git a/tests/resources/certs/two.pem b/tests/resources/certs/two.pem
new file mode 100644
index 00000000000..e13417e483a
--- /dev/null
+++ b/tests/resources/certs/two.pem
@@ -0,0 +1,20 @@
+-----BEGIN CERTIFICATE-----
+MIIDUzCCAjsCFAb11im6DYQyGJ0GNQCIehXtegq6MA0GCSqGSIb3DQEBCwUAMGYx
+CzAJBgNVBAYTAlVTMRYwFAYDVQQIDA1NYXNzYWNodXNldHRzMRIwEAYDVQQHDAlD
+YW1icmlkZ2UxEDAOBgNVBAoMB2xpYmdpdDIxGTAXBgNVBAMMEHRlc3QubGliZ2l0
+Mi5vcmcwHhcNMjEwODMwMDAyMTQyWhcNMzEwODI4MDAyMTQyWjBmMQswCQYDVQQG
+EwJVUzEWMBQGA1UECAwNTWFzc2FjaHVzZXR0czESMBAGA1UEBwwJQ2FtYnJpZGdl
+MRAwDgYDVQQKDAdsaWJnaXQyMRkwFwYDVQQDDBB0ZXN0LmxpYmdpdDIub3JnMIIB
+IjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtqe6b1vnMni+z8Z+a2bGtykI
+ITvBged15rn+0qG6Fz+sn9bYG+ceFupztFfoN3cVpUgQDBTzr3CaAx036BlV0z8i
+CrG0Oh/XGL+9TITQLumEe4iGi8NoMSujBAyXPSNgmpzDmCTGrNFfmq3HzUtO8t3x
+i8OT7d9qCVjFimLvZbgnfHGQ38xvt1XyPgYIVqDQczmMEZ5BdYWB0A1VmnWuP2dH
+BgjwPEC3HwMmm1+PL0VoPTdvE5Su092Qdt8QsiA56466DQyll1d/omnOJfrK7z0N
+OnfDmnDpARSTy6vDofEAYUQoc3dyvBUk8IIzv2UDcR7fTVvYqseQReIOTEnXmQID
+AQABMA0GCSqGSIb3DQEBCwUAA4IBAQBmUEq+JhwWTbB5ODGOKrMG1fKJ+sf6ZH6M
+c4BgLEcdoi/nOTfPuw+ols72LuhH7NKaEcqxWev0jGF0WKqMcM8AGVbywZJ3mBWo
+sKdh6rAGFNkikW4TzhjtDfFbMR45Didl28Be7ieHQL4CQ0Lse3RMOxp250WpiEYV
+W2hIKMwIqOLKGShVD7lI+eHlv+QSH4yOYKHfRHve8s82Tac5OXinc8CJm9ySOtkO
+MfLgfkHtHdFBnV6OVbf4p/596MfMXdwT/bBxT6WPkDGc1AYhoDlmLFTpRgHIDCSK
+2wgV+qHppl7Kn+p3mFQ9sW/1IaRd+jNZOrgZ8Uu5tJ00OaqR/LVG
+-----END CERTIFICATE-----
diff --git a/tests/resources/git-sha256.index b/tests/resources/git-sha256.index
new file mode 100644
index 00000000000..84b5cabd998
Binary files /dev/null and b/tests/resources/git-sha256.index differ
diff --git a/tests/resources/grafted.git/HEAD b/tests/resources/grafted.git/HEAD
new file mode 100644
index 00000000000..cb089cd89a7
--- /dev/null
+++ b/tests/resources/grafted.git/HEAD
@@ -0,0 +1 @@
+ref: refs/heads/master
diff --git a/tests/resources/grafted.git/config b/tests/resources/grafted.git/config
new file mode 100644
index 00000000000..e6da231579b
--- /dev/null
+++ b/tests/resources/grafted.git/config
@@ -0,0 +1,6 @@
+[core]
+ repositoryformatversion = 0
+ filemode = true
+ bare = true
+ ignorecase = true
+ precomposeunicode = true
diff --git a/tests/resources/grafted.git/info/grafts b/tests/resources/grafted.git/info/grafts
new file mode 100644
index 00000000000..bb9df8c0a80
--- /dev/null
+++ b/tests/resources/grafted.git/info/grafts
@@ -0,0 +1,3 @@
+f503807ffa920e407a600cfaee96b7152259acc7 2f3053cbff8a4ca2f0666de364ddb734a28a31a9
+0512adebd3782157f0d5c9b22b043f87b4aaff9e 2f3053cbff8a4ca2f0666de364ddb734a28a31a9
+66cc22a015f6ca75b34c82d28f78ba663876bade e414f42f4e6bc6934563a2349a8600f0ab68618e 8a00e91619098618be97c0d2ceabb05a2c58edd9 1c18e80a276611bb9b146590616bbc5aebdf2945 2f3053cbff8a4ca2f0666de364ddb734a28a31a9
diff --git a/tests/resources/grafted.git/objects/05/12adebd3782157f0d5c9b22b043f87b4aaff9e b/tests/resources/grafted.git/objects/05/12adebd3782157f0d5c9b22b043f87b4aaff9e
new file mode 100644
index 00000000000..16880d596e5
Binary files /dev/null and b/tests/resources/grafted.git/objects/05/12adebd3782157f0d5c9b22b043f87b4aaff9e differ
diff --git a/tests/resources/grafted.git/objects/1c/18e80a276611bb9b146590616bbc5aebdf2945 b/tests/resources/grafted.git/objects/1c/18e80a276611bb9b146590616bbc5aebdf2945
new file mode 100644
index 00000000000..2c057b85d87
Binary files /dev/null and b/tests/resources/grafted.git/objects/1c/18e80a276611bb9b146590616bbc5aebdf2945 differ
diff --git a/tests/resources/grafted.git/objects/1c/3f11eca55d76bc1bf7353ca7e4226246d353ed b/tests/resources/grafted.git/objects/1c/3f11eca55d76bc1bf7353ca7e4226246d353ed
new file mode 100644
index 00000000000..b92a3047f18
Binary files /dev/null and b/tests/resources/grafted.git/objects/1c/3f11eca55d76bc1bf7353ca7e4226246d353ed differ
diff --git a/tests/resources/grafted.git/objects/2a/f02ebff1fc0142d2380c98758d81c67b365869 b/tests/resources/grafted.git/objects/2a/f02ebff1fc0142d2380c98758d81c67b365869
new file mode 100644
index 00000000000..ed3f874a7bd
Binary files /dev/null and b/tests/resources/grafted.git/objects/2a/f02ebff1fc0142d2380c98758d81c67b365869 differ
diff --git a/tests/resources/grafted.git/objects/2b/ecadd3f1ecad07a054392421edf9c0e1c375b2 b/tests/resources/grafted.git/objects/2b/ecadd3f1ecad07a054392421edf9c0e1c375b2
new file mode 100644
index 00000000000..724eedbb2ec
Binary files /dev/null and b/tests/resources/grafted.git/objects/2b/ecadd3f1ecad07a054392421edf9c0e1c375b2 differ
diff --git a/tests/resources/grafted.git/objects/2f/3053cbff8a4ca2f0666de364ddb734a28a31a9 b/tests/resources/grafted.git/objects/2f/3053cbff8a4ca2f0666de364ddb734a28a31a9
new file mode 100644
index 00000000000..3d124a67352
Binary files /dev/null and b/tests/resources/grafted.git/objects/2f/3053cbff8a4ca2f0666de364ddb734a28a31a9 differ
diff --git a/tests/resources/grafted.git/objects/45/342912745ba6f8893b1e126df4653a4355df1a b/tests/resources/grafted.git/objects/45/342912745ba6f8893b1e126df4653a4355df1a
new file mode 100644
index 00000000000..4a8c471bd5b
Binary files /dev/null and b/tests/resources/grafted.git/objects/45/342912745ba6f8893b1e126df4653a4355df1a differ
diff --git a/tests/resources/grafted.git/objects/48/b2b333732644eafb385771a992b923fa88f135 b/tests/resources/grafted.git/objects/48/b2b333732644eafb385771a992b923fa88f135
new file mode 100644
index 00000000000..ac640636beb
Binary files /dev/null and b/tests/resources/grafted.git/objects/48/b2b333732644eafb385771a992b923fa88f135 differ
diff --git a/tests/resources/grafted.git/objects/5d/31bf4b437e1191b6c709c665f1bd329d0ed0bf b/tests/resources/grafted.git/objects/5d/31bf4b437e1191b6c709c665f1bd329d0ed0bf
new file mode 100644
index 00000000000..47a05377ef3
Binary files /dev/null and b/tests/resources/grafted.git/objects/5d/31bf4b437e1191b6c709c665f1bd329d0ed0bf differ
diff --git a/tests/resources/grafted.git/objects/66/cc22a015f6ca75b34c82d28f78ba663876bade b/tests/resources/grafted.git/objects/66/cc22a015f6ca75b34c82d28f78ba663876bade
new file mode 100644
index 00000000000..c68b2cd4fb1
--- /dev/null
+++ b/tests/resources/grafted.git/objects/66/cc22a015f6ca75b34c82d28f78ba663876bade
@@ -0,0 +1,2 @@
+xœ¥ŽM
+Â0F]ç³Ê$™üDÜx=Á4N´Ð4ÒFϯÔ#¸úàñx|©–260dvmñap1° Ñaò}ö¹·N‹hL!E&}ã”BTO^dn ¤)“É$~øê–œ·l,õ =bF |ô:ŠâW{ÔÎm”y¸rYë ‡uÛN~øt/<N]ªåÚ¡EHkØ£ATi»Ú䯈ºH©o<N¢>Ñ«M,
\ No newline at end of file
diff --git a/tests/resources/grafted.git/objects/6c/f192eb71cd3243c9fbbe2551012c4449de3fcf b/tests/resources/grafted.git/objects/6c/f192eb71cd3243c9fbbe2551012c4449de3fcf
new file mode 100644
index 00000000000..a437f243204
Binary files /dev/null and b/tests/resources/grafted.git/objects/6c/f192eb71cd3243c9fbbe2551012c4449de3fcf differ
diff --git a/tests/resources/grafted.git/objects/7c/9da502b2744b70522bb694cd607fb00104a233 b/tests/resources/grafted.git/objects/7c/9da502b2744b70522bb694cd607fb00104a233
new file mode 100644
index 00000000000..b363584fd9a
Binary files /dev/null and b/tests/resources/grafted.git/objects/7c/9da502b2744b70522bb694cd607fb00104a233 differ
diff --git a/tests/resources/grafted.git/objects/8a/00e91619098618be97c0d2ceabb05a2c58edd9 b/tests/resources/grafted.git/objects/8a/00e91619098618be97c0d2ceabb05a2c58edd9
new file mode 100644
index 00000000000..887778a60a0
--- /dev/null
+++ b/tests/resources/grafted.git/objects/8a/00e91619098618be97c0d2ceabb05a2c58edd9
@@ -0,0 +1,2 @@
+xœ¥ŽA
+Â0E]ç³Êt’4Dtá <Á$™Ô@“Jï¯Ô#¸úðïý°”’ч¶Š@B§5ú@b$ Ñ'ÒØ[´iƒ÷ ±g&V/^¥6Hõ ]J<ŠAÇbH,2Þõ–ÈŽ ‚SünÏe…{ËR«ÀƒË¶T8oûvòÃשpž»°” |›Ódàˆ„¨Â~µÉ_u‹1× RžÅ¨ßšNC
\ No newline at end of file
diff --git a/tests/resources/grafted.git/objects/a0/4de168dd5c43aa2af594d794d62e922f8b3b34 b/tests/resources/grafted.git/objects/a0/4de168dd5c43aa2af594d794d62e922f8b3b34
new file mode 100644
index 00000000000..1ed3ed906ab
Binary files /dev/null and b/tests/resources/grafted.git/objects/a0/4de168dd5c43aa2af594d794d62e922f8b3b34 differ
diff --git a/tests/resources/grafted.git/objects/b2/b4f9e5fe5dacbb2f98bd71d1dc86c7b571ddd1 b/tests/resources/grafted.git/objects/b2/b4f9e5fe5dacbb2f98bd71d1dc86c7b571ddd1
new file mode 100644
index 00000000000..2adc857219e
Binary files /dev/null and b/tests/resources/grafted.git/objects/b2/b4f9e5fe5dacbb2f98bd71d1dc86c7b571ddd1 differ
diff --git a/tests/resources/grafted.git/objects/ba/54010f8d41532eb130eba420f50248881f7fc2 b/tests/resources/grafted.git/objects/ba/54010f8d41532eb130eba420f50248881f7fc2
new file mode 100644
index 00000000000..52a88727471
Binary files /dev/null and b/tests/resources/grafted.git/objects/ba/54010f8d41532eb130eba420f50248881f7fc2 differ
diff --git a/tests/resources/grafted.git/objects/d7/224d49d6d5aff6ade596ed74f4bcd4f77b29e2 b/tests/resources/grafted.git/objects/d7/224d49d6d5aff6ade596ed74f4bcd4f77b29e2
new file mode 100644
index 00000000000..5b41b6778f8
--- /dev/null
+++ b/tests/resources/grafted.git/objects/d7/224d49d6d5aff6ade596ed74f4bcd4f77b29e2
@@ -0,0 +1,2 @@
+xϴA
+Â0E]ç³ÊdÒDÜx=Á$™h¡I¤ž_Gpõà/ ÿ…šóÔ€,íÚ"ä%pŒ&é/Ñ1Úތԓ–˜Æ€¢ƒqÖ“zð"¥ZM ÅGãÒÖ%Œ6ŒžÈcoÒà|ÏœÒ(ŠŸí^8·IJ¸r^kú±“ß|ºežæ.Ô|mÑ u„öHˆ*lW›ü%QÉõ%¦Y „ZÚ§bUoaRj
\ No newline at end of file
diff --git a/tests/resources/grafted.git/objects/db/8e43f297a313c439530c977b733aaa8c10d54e b/tests/resources/grafted.git/objects/db/8e43f297a313c439530c977b733aaa8c10d54e
new file mode 100644
index 00000000000..b9cf5947b70
Binary files /dev/null and b/tests/resources/grafted.git/objects/db/8e43f297a313c439530c977b733aaa8c10d54e differ
diff --git a/tests/resources/grafted.git/objects/e4/14f42f4e6bc6934563a2349a8600f0ab68618e b/tests/resources/grafted.git/objects/e4/14f42f4e6bc6934563a2349a8600f0ab68618e
new file mode 100644
index 00000000000..1a14959c49b
Binary files /dev/null and b/tests/resources/grafted.git/objects/e4/14f42f4e6bc6934563a2349a8600f0ab68618e differ
diff --git a/tests/resources/grafted.git/objects/e6/7b587a57850c69f6f9351ee10c7c8a41dacc78 b/tests/resources/grafted.git/objects/e6/7b587a57850c69f6f9351ee10c7c8a41dacc78
new file mode 100644
index 00000000000..213f9ac22ef
Binary files /dev/null and b/tests/resources/grafted.git/objects/e6/7b587a57850c69f6f9351ee10c7c8a41dacc78 differ
diff --git a/tests/resources/grafted.git/objects/f0/7330bc2e4ed4bd0bf2301505f6c6bbad01aa2a b/tests/resources/grafted.git/objects/f0/7330bc2e4ed4bd0bf2301505f6c6bbad01aa2a
new file mode 100644
index 00000000000..f2d64889207
Binary files /dev/null and b/tests/resources/grafted.git/objects/f0/7330bc2e4ed4bd0bf2301505f6c6bbad01aa2a differ
diff --git a/tests/resources/grafted.git/objects/f5/03807ffa920e407a600cfaee96b7152259acc7 b/tests/resources/grafted.git/objects/f5/03807ffa920e407a600cfaee96b7152259acc7
new file mode 100644
index 00000000000..21436c177e9
--- /dev/null
+++ b/tests/resources/grafted.git/objects/f5/03807ffa920e407a600cfaee96b7152259acc7
@@ -0,0 +1,2 @@
+xϴA
+Â0E]ç³J&˜6)ºðž ™™Ô@“@ï¯Ô#¸ú·xŸZ)¹z{ê›D/É‹Mb9PŒ&yyBF&7Òí—™Q…wµ
=KÏPöVẠ;ÈOß–ò:P+3 ÕÆ ƒ³6Z+:®»üQwæ\Hy£>zAƒ
\ No newline at end of file
diff --git a/tests/resources/grafted.git/refs/heads/bottom b/tests/resources/grafted.git/refs/heads/bottom
new file mode 100644
index 00000000000..10513e69877
--- /dev/null
+++ b/tests/resources/grafted.git/refs/heads/bottom
@@ -0,0 +1 @@
+66cc22a015f6ca75b34c82d28f78ba663876bade
diff --git a/tests/resources/grafted.git/refs/heads/branch b/tests/resources/grafted.git/refs/heads/branch
new file mode 100644
index 00000000000..d0fe5c28390
--- /dev/null
+++ b/tests/resources/grafted.git/refs/heads/branch
@@ -0,0 +1 @@
+8a00e91619098618be97c0d2ceabb05a2c58edd9
diff --git a/tests/resources/grafted.git/refs/heads/master b/tests/resources/grafted.git/refs/heads/master
new file mode 100644
index 00000000000..de809b9421a
--- /dev/null
+++ b/tests/resources/grafted.git/refs/heads/master
@@ -0,0 +1 @@
+2f3053cbff8a4ca2f0666de364ddb734a28a31a9
diff --git a/tests/resources/grafted.git/refs/heads/top b/tests/resources/grafted.git/refs/heads/top
new file mode 100644
index 00000000000..ce226110b8e
--- /dev/null
+++ b/tests/resources/grafted.git/refs/heads/top
@@ -0,0 +1 @@
+1c18e80a276611bb9b146590616bbc5aebdf2945
diff --git a/tests/resources/merge-resolve/.gitted/objects/29 b/tests/resources/merge-resolve/.gitted/objects/29
new file mode 100644
index 00000000000..9661507079f
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/29 differ
diff --git a/tests/resources/merge-resolve/.gitted/objects/54/c9d15687fb4f56e08252662962d6d1dbc09d9d b/tests/resources/merge-resolve/.gitted/objects/54/c9d15687fb4f56e08252662962d6d1dbc09d9d
new file mode 100644
index 00000000000..7e0555b3ff6
--- /dev/null
+++ b/tests/resources/merge-resolve/.gitted/objects/54/c9d15687fb4f56e08252662962d6d1dbc09d9d
@@ -0,0 +1,3 @@
+x¥NI
+1ôœWô]žì/þÀ´Žãa&#~ß(þÀ:ÕFQ\—åÖAÛ¸éMtrš8K0Y›àK&Ž¥Xk¢w—É™"è$pPwj²vÕ\RðhÑgI=ŘK*SDaMÚ*zö¹68åµ ç¹.ºÂ^†ûaGù?µãº `
+q6YØâ€î8ÛåÏÅ3W^áBM½ùiQ†
\ No newline at end of file
diff --git a/tests/resources/merge-resolve/.gitted/objects/57/16ca5987cbf97d6bb54920bea6adde242d87e6 b/tests/resources/merge-resolve/.gitted/objects/57/16ca5987cbf97d6bb54920bea6adde242d87e6
new file mode 100644
index 00000000000..cfc3920fb3f
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/57/16ca5987cbf97d6bb54920bea6adde242d87e6 differ
diff --git a/tests/resources/merge-resolve/.gitted/objects/60/b12be2d2f57977ce83d8dfd32e2394ac1ba1a2 b/tests/resources/merge-resolve/.gitted/objects/60/b12be2d2f57977ce83d8dfd32e2394ac1ba1a2
new file mode 100644
index 00000000000..f53f75e0a13
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/60/b12be2d2f57977ce83d8dfd32e2394ac1ba1a2 differ
diff --git a/tests/resources/merge-resolve/.gitted/objects/a6/5140d5ec9f47064f614ecf8e43776baa5c0c11 b/tests/resources/merge-resolve/.gitted/objects/a6/5140d5ec9f47064f614ecf8e43776baa5c0c11
new file mode 100644
index 00000000000..dc6cf6493cb
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/a6/5140d5ec9f47064f614ecf8e43776baa5c0c11 differ
diff --git a/tests/resources/merge-resolve/.gitted/objects/ab/347abd8cda4a0e3b8bb42bb620c0c72c7df779 b/tests/resources/merge-resolve/.gitted/objects/ab/347abd8cda4a0e3b8bb42bb620c0c72c7df779
new file mode 100644
index 00000000000..d743a385c21
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/ab/347abd8cda4a0e3b8bb42bb620c0c72c7df779 differ
diff --git a/tests/resources/merge-resolve/.gitted/objects/bc/114411903fd2afaa4bb9b85ed13f27e37ac375 b/tests/resources/merge-resolve/.gitted/objects/bc/114411903fd2afaa4bb9b85ed13f27e37ac375
new file mode 100644
index 00000000000..08941ff9538
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/bc/114411903fd2afaa4bb9b85ed13f27e37ac375 differ
diff --git a/tests/resources/merge-resolve/.gitted/objects/cd/edf9760406dc79e0c6a8899ce9f180ec2a23a0 b/tests/resources/merge-resolve/.gitted/objects/cd/edf9760406dc79e0c6a8899ce9f180ec2a23a0
new file mode 100644
index 00000000000..011b5b3e58c
--- /dev/null
+++ b/tests/resources/merge-resolve/.gitted/objects/cd/edf9760406dc79e0c6a8899ce9f180ec2a23a0
@@ -0,0 +1,2 @@
+x¥A
+B1C]÷³¤µÓö "n¼¨Ó)ÀþBÕë[ŘUò ÕR¤Ã^ÛMo̽3¨“c:d Úcö™òÄhCð· i2FÅGŸkƒKzÅ–à:ײ֎<èÇù[üÒŽj9 zBë0XØê!5è8ïü猒EºÄ;4~Ê*uQo—$DÝ
\ No newline at end of file
diff --git a/tests/resources/merge-resolve/.gitted/objects/de/06afe070b65f94d7d791c39a6d389c58dda60d b/tests/resources/merge-resolve/.gitted/objects/de/06afe070b65f94d7d791c39a6d389c58dda60d
new file mode 100644
index 00000000000..28567b624d1
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/de/06afe070b65f94d7d791c39a6d389c58dda60d differ
diff --git a/tests/resources/merge-resolve/.gitted/objects/e5/0a49f9558d09d4d3bfc108363bb24c127ed263 b/tests/resources/merge-resolve/.gitted/objects/e5/0a49f9558d09d4d3bfc108363bb24c127ed263
new file mode 100644
index 00000000000..251c5dfb20c
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/e5/0a49f9558d09d4d3bfc108363bb24c127ed263 differ
diff --git a/tests/resources/merge-resolve/.gitted/objects/ea/789495e0a72efadcd0f86a48f4c9ed435bb8a3 b/tests/resources/merge-resolve/.gitted/objects/ea/789495e0a72efadcd0f86a48f4c9ed435bb8a3
new file mode 100644
index 00000000000..ed98d70564d
--- /dev/null
+++ b/tests/resources/merge-resolve/.gitted/objects/ea/789495e0a72efadcd0f86a48f4c9ed435bb8a3
@@ -0,0 +1,3 @@
+x¥OIj1ÌY¯è»!´¶‘Áøâ äV‹ÉA£ Ëøû–M~:ÕE÷Ö~&o>æÌZ;§uB[‹¡JärN9z)ÚVÄb¼ú¥!Ç.Rj
+:Ü
+‡$ÈŘKª:¢°!c ÝçÞ\˃Fï½·[?àK–ûbyê“{;ƒõÞ œpA-wòϵ–S[_iÀì{WOG‰Rï
\ No newline at end of file
diff --git a/tests/resources/merge-resolve/.gitted/refs/heads/emptyfile_renames b/tests/resources/merge-resolve/.gitted/refs/heads/emptyfile_renames
new file mode 100644
index 00000000000..89b4eea8ff5
--- /dev/null
+++ b/tests/resources/merge-resolve/.gitted/refs/heads/emptyfile_renames
@@ -0,0 +1 @@
+ea789495e0a72efadcd0f86a48f4c9ed435bb8a3
diff --git a/tests/resources/merge-resolve/.gitted/refs/heads/emptyfile_renames-branch b/tests/resources/merge-resolve/.gitted/refs/heads/emptyfile_renames-branch
new file mode 100644
index 00000000000..1c6a9f4db55
--- /dev/null
+++ b/tests/resources/merge-resolve/.gitted/refs/heads/emptyfile_renames-branch
@@ -0,0 +1 @@
+ab347abd8cda4a0e3b8bb42bb620c0c72c7df779
diff --git a/tests/resources/process/cat.bat b/tests/resources/process/cat.bat
new file mode 100644
index 00000000000..af9b573c793
--- /dev/null
+++ b/tests/resources/process/cat.bat
@@ -0,0 +1,2 @@
+@ECHO OFF
+FOR /F "tokens=*" %%a IN ('more') DO ECHO %%a
diff --git a/tests/resources/process/env.cmd b/tests/resources/process/env.cmd
new file mode 100644
index 00000000000..62675cf9edd
--- /dev/null
+++ b/tests/resources/process/env.cmd
@@ -0,0 +1,2 @@
+@ECHO OFF
+SET
diff --git a/tests/resources/process/helloworld.sh b/tests/resources/process/helloworld.sh
new file mode 100755
index 00000000000..0c4aefc384d
--- /dev/null
+++ b/tests/resources/process/helloworld.sh
@@ -0,0 +1,3 @@
+#!/bin/sh
+
+echo "Hello, world."
diff --git a/tests/resources/process/pwd.bat b/tests/resources/process/pwd.bat
new file mode 100644
index 00000000000..82e4fb60f17
--- /dev/null
+++ b/tests/resources/process/pwd.bat
@@ -0,0 +1,2 @@
+@ECHO OFF
+ECHO %CD%
diff --git a/tests/resources/push.sh b/tests/resources/push.sh
index 3e77fb5307f..648c2ad26f5 100644
--- a/tests/resources/push.sh
+++ b/tests/resources/push.sh
@@ -1,4 +1,4 @@
-#!/bin/sh
+#!/usr/bin/env bash
#creates push_src repo for libgit2 push tests.
set -eu
diff --git a/tests/resources/pushoptions.git/HEAD b/tests/resources/pushoptions.git/HEAD
new file mode 100644
index 00000000000..b870d82622c
--- /dev/null
+++ b/tests/resources/pushoptions.git/HEAD
@@ -0,0 +1 @@
+ref: refs/heads/main
diff --git a/tests/resources/pushoptions.git/branches/.gitignore b/tests/resources/pushoptions.git/branches/.gitignore
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/tests/resources/pushoptions.git/config b/tests/resources/pushoptions.git/config
new file mode 100644
index 00000000000..23d39788fa7
--- /dev/null
+++ b/tests/resources/pushoptions.git/config
@@ -0,0 +1,8 @@
+[core]
+ repositoryformatversion = 0
+ filemode = true
+ bare = true
+ ignorecase = true
+ precomposeunicode = true
+[receive]
+ advertisePushOptions = true
diff --git a/tests/resources/pushoptions.git/description b/tests/resources/pushoptions.git/description
new file mode 100644
index 00000000000..498b267a8c7
--- /dev/null
+++ b/tests/resources/pushoptions.git/description
@@ -0,0 +1 @@
+Unnamed repository; edit this file 'description' to name the repository.
diff --git a/tests/resources/pushoptions.git/hooks/pre-receive b/tests/resources/pushoptions.git/hooks/pre-receive
new file mode 100755
index 00000000000..24f48d34c54
--- /dev/null
+++ b/tests/resources/pushoptions.git/hooks/pre-receive
@@ -0,0 +1,3 @@
+#!/bin/sh
+printf "${GIT_PUSH_OPTION_1}${GIT_PUSH_OPTION_2}${GIT_PUSH_OPTION_3}" > "${GIT_PUSH_OPTION_0}"
+exit 0
diff --git a/tests/resources/pushoptions.git/info/exclude b/tests/resources/pushoptions.git/info/exclude
new file mode 100644
index 00000000000..a5196d1be8f
--- /dev/null
+++ b/tests/resources/pushoptions.git/info/exclude
@@ -0,0 +1,6 @@
+# git ls-files --others --exclude-from=.git/info/exclude
+# Lines that start with '#' are comments.
+# For a project mostly in C, the following would be a good set of
+# exclude patterns (uncomment them if you want to use them):
+# *.[oa]
+# *~
diff --git a/tests/resources/pushoptions.git/objects/info/.gitignore b/tests/resources/pushoptions.git/objects/info/.gitignore
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/tests/resources/pushoptions.git/objects/pack/.gitignore b/tests/resources/pushoptions.git/objects/pack/.gitignore
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/tests/resources/pushoptions.git/refs/heads/.gitignore b/tests/resources/pushoptions.git/refs/heads/.gitignore
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/tests/resources/pushoptions.git/refs/tags/.gitignore b/tests/resources/pushoptions.git/refs/tags/.gitignore
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/tests/resources/self-signed.pem.raw b/tests/resources/self-signed.pem.raw
new file mode 100644
index 00000000000..d16446ba04c
--- /dev/null
+++ b/tests/resources/self-signed.pem.raw
@@ -0,0 +1 @@
+MIIDUzCCAjsCFAb11im6DYQyGJ0GNQCIehXtegq6MA0GCSqGSIb3DQEBCwUAMGYxCzAJBgNVBAYTAlVTMRYwFAYDVQQIDA1NYXNzYWNodXNldHRzMRIwEAYDVQQHDAlDYW1icmlkZ2UxEDAOBgNVBAoMB2xpYmdpdDIxGTAXBgNVBAMMEHRlc3QubGliZ2l0Mi5vcmcwHhcNMjEwODMwMDAyMTQyWhcNMzEwODI4MDAyMTQyWjBmMQswCQYDVQQGEwJVUzEWMBQGA1UECAwNTWFzc2FjaHVzZXR0czESMBAGA1UEBwwJQ2FtYnJpZGdlMRAwDgYDVQQKDAdsaWJnaXQyMRkwFwYDVQQDDBB0ZXN0LmxpYmdpdDIub3JnMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtqe6b1vnMni+z8Z+a2bGtykIITvBged15rn+0qG6Fz+sn9bYG+ceFupztFfoN3cVpUgQDBTzr3CaAx036BlV0z8iCrG0Oh/XGL+9TITQLumEe4iGi8NoMSujBAyXPSNgmpzDmCTGrNFfmq3HzUtO8t3xi8OT7d9qCVjFimLvZbgnfHGQ38xvt1XyPgYIVqDQczmMEZ5BdYWB0A1VmnWuP2dHBgjwPEC3HwMmm1+PL0VoPTdvE5Su092Qdt8QsiA56466DQyll1d/omnOJfrK7z0NOnfDmnDpARSTy6vDofEAYUQoc3dyvBUk8IIzv2UDcR7fTVvYqseQReIOTEnXmQIDAQABMA0GCSqGSIb3DQEBCwUAA4IBAQBmUEq+JhwWTbB5ODGOKrMG1fKJ+sf6ZH6Mc4BgLEcdoi/nOTfPuw+ols72LuhH7NKaEcqxWev0jGF0WKqMcM8AGVbywZJ3mBWosKdh6rAGFNkikW4TzhjtDfFbMR45Didl28Be7ieHQL4CQ0Lse3RMOxp250WpiEYVW2hIKMwIqOLKGShVD7lI+eHlv+QSH4yOYKHfRHve8s82Tac5OXinc8CJm9ySOtkOMfLgfkHtHdFBnV6OVbf4p/596MfMXdwT/bBxT6WPkDGc1AYhoDlmLFTpRgHIDCSK2wgV+qHppl7Kn+p3mFQ9sW/1IaRd+jNZOrgZ8Uu5tJ00OaqR/LVG
\ No newline at end of file
diff --git a/tests/resources/status_skiphash/.gitted/COMMIT_EDITMSG b/tests/resources/status_skiphash/.gitted/COMMIT_EDITMSG
new file mode 100644
index 00000000000..ea450f959b9
--- /dev/null
+++ b/tests/resources/status_skiphash/.gitted/COMMIT_EDITMSG
@@ -0,0 +1 @@
+New file
diff --git a/tests/resources/status_skiphash/.gitted/HEAD b/tests/resources/status_skiphash/.gitted/HEAD
new file mode 100644
index 00000000000..b870d82622c
--- /dev/null
+++ b/tests/resources/status_skiphash/.gitted/HEAD
@@ -0,0 +1 @@
+ref: refs/heads/main
diff --git a/tests/resources/status_skiphash/.gitted/MERGE_RR b/tests/resources/status_skiphash/.gitted/MERGE_RR
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/tests/resources/status_skiphash/.gitted/config b/tests/resources/status_skiphash/.gitted/config
new file mode 100644
index 00000000000..16aebb686c2
--- /dev/null
+++ b/tests/resources/status_skiphash/.gitted/config
@@ -0,0 +1,9 @@
+[core]
+ repositoryformatversion = 0
+ filemode = false
+ bare = false
+ logallrefupdates = true
+ symlinks = false
+ ignorecase = true
+[index]
+ skipHash = true
diff --git a/tests/resources/status_skiphash/.gitted/description b/tests/resources/status_skiphash/.gitted/description
new file mode 100644
index 00000000000..498b267a8c7
--- /dev/null
+++ b/tests/resources/status_skiphash/.gitted/description
@@ -0,0 +1 @@
+Unnamed repository; edit this file 'description' to name the repository.
diff --git a/tests/resources/status_skiphash/.gitted/index b/tests/resources/status_skiphash/.gitted/index
new file mode 100644
index 00000000000..1963fe0d3d4
Binary files /dev/null and b/tests/resources/status_skiphash/.gitted/index differ
diff --git a/tests/resources/status_skiphash/.gitted/info/exclude b/tests/resources/status_skiphash/.gitted/info/exclude
new file mode 100644
index 00000000000..a5196d1be8f
--- /dev/null
+++ b/tests/resources/status_skiphash/.gitted/info/exclude
@@ -0,0 +1,6 @@
+# git ls-files --others --exclude-from=.git/info/exclude
+# Lines that start with '#' are comments.
+# For a project mostly in C, the following would be a good set of
+# exclude patterns (uncomment them if you want to use them):
+# *.[oa]
+# *~
diff --git a/tests/resources/status_skiphash/.gitted/logs/HEAD b/tests/resources/status_skiphash/.gitted/logs/HEAD
new file mode 100644
index 00000000000..35e1a747dbe
--- /dev/null
+++ b/tests/resources/status_skiphash/.gitted/logs/HEAD
@@ -0,0 +1 @@
+0000000000000000000000000000000000000000 34f4c90b237fcb4c677772a6093f3cba239c41a5 Parnic <github@parnic.com> 1708097798 -0600 commit (initial): New file
diff --git a/tests/resources/status_skiphash/.gitted/logs/refs/heads/main b/tests/resources/status_skiphash/.gitted/logs/refs/heads/main
new file mode 100644
index 00000000000..35e1a747dbe
--- /dev/null
+++ b/tests/resources/status_skiphash/.gitted/logs/refs/heads/main
@@ -0,0 +1 @@
+0000000000000000000000000000000000000000 34f4c90b237fcb4c677772a6093f3cba239c41a5 Parnic <github@parnic.com> 1708097798 -0600 commit (initial): New file
diff --git a/tests/resources/status_skiphash/.gitted/objects/34/f4c90b237fcb4c677772a6093f3cba239c41a5 b/tests/resources/status_skiphash/.gitted/objects/34/f4c90b237fcb4c677772a6093f3cba239c41a5
new file mode 100644
index 00000000000..0513158cb21
Binary files /dev/null and b/tests/resources/status_skiphash/.gitted/objects/34/f4c90b237fcb4c677772a6093f3cba239c41a5 differ
diff --git a/tests/resources/status_skiphash/.gitted/objects/71/a21e67674e9717aa7380e5782ec5e070a8d7e0 b/tests/resources/status_skiphash/.gitted/objects/71/a21e67674e9717aa7380e5782ec5e070a8d7e0
new file mode 100644
index 00000000000..7c48fa4f43b
Binary files /dev/null and b/tests/resources/status_skiphash/.gitted/objects/71/a21e67674e9717aa7380e5782ec5e070a8d7e0 differ
diff --git a/tests/resources/status_skiphash/.gitted/objects/d7/c1f165e51adbbfd7760162b7a5802d4117740c b/tests/resources/status_skiphash/.gitted/objects/d7/c1f165e51adbbfd7760162b7a5802d4117740c
new file mode 100644
index 00000000000..c685321ce69
Binary files /dev/null and b/tests/resources/status_skiphash/.gitted/objects/d7/c1f165e51adbbfd7760162b7a5802d4117740c differ
diff --git a/tests/resources/status_skiphash/.gitted/refs/heads/main b/tests/resources/status_skiphash/.gitted/refs/heads/main
new file mode 100644
index 00000000000..693a12b664c
--- /dev/null
+++ b/tests/resources/status_skiphash/.gitted/refs/heads/main
@@ -0,0 +1 @@
+34f4c90b237fcb4c677772a6093f3cba239c41a5
diff --git a/tests/resources/status_skiphash/new_file b/tests/resources/status_skiphash/new_file
new file mode 100644
index 00000000000..badcfca348a
--- /dev/null
+++ b/tests/resources/status_skiphash/new_file
@@ -0,0 +1 @@
+new_file
diff --git a/tests/resources/testrepo/.gitted/config b/tests/resources/testrepo/.gitted/config
index d0114012f98..04d750a93bc 100644
--- a/tests/resources/testrepo/.gitted/config
+++ b/tests/resources/testrepo/.gitted/config
@@ -3,6 +3,8 @@
filemode = true
bare = false
logallrefupdates = true
+[extensions]
+ worktreeconfig = true
[remote "test"]
url = git://github.com/libgit2/libgit2
fetch = +refs/heads/*:refs/remotes/test/*
diff --git a/tests/resources/testrepo/.gitted/config.worktree b/tests/resources/testrepo/.gitted/config.worktree
new file mode 100644
index 00000000000..df9f0caf650
--- /dev/null
+++ b/tests/resources/testrepo/.gitted/config.worktree
@@ -0,0 +1,2 @@
+[worktreetest]
+ config = mainrepo
diff --git a/tests/resources/testrepo/.gitted/worktrees/testrepo-worktree/config.worktree b/tests/resources/testrepo/.gitted/worktrees/testrepo-worktree/config.worktree
new file mode 100644
index 00000000000..7a130a7aed7
--- /dev/null
+++ b/tests/resources/testrepo/.gitted/worktrees/testrepo-worktree/config.worktree
@@ -0,0 +1,2 @@
+[worktreetest]
+ config = worktreerepo
diff --git a/tests/resources/testrepo2/.gitted/refs/heads/symbolic-one b/tests/resources/testrepo2/.gitted/refs/heads/symbolic-one
new file mode 100644
index 00000000000..cb089cd89a7
--- /dev/null
+++ b/tests/resources/testrepo2/.gitted/refs/heads/symbolic-one
@@ -0,0 +1 @@
+ref: refs/heads/master
diff --git a/tests/resources/testrepo2/.gitted/refs/heads/symbolic-two b/tests/resources/testrepo2/.gitted/refs/heads/symbolic-two
new file mode 100644
index 00000000000..cb089cd89a7
--- /dev/null
+++ b/tests/resources/testrepo2/.gitted/refs/heads/symbolic-two
@@ -0,0 +1 @@
+ref: refs/heads/master
diff --git a/tests/resources/testrepo_256/.gitted/HEAD b/tests/resources/testrepo_256/.gitted/HEAD
new file mode 100644
index 00000000000..cb089cd89a7
--- /dev/null
+++ b/tests/resources/testrepo_256/.gitted/HEAD
@@ -0,0 +1 @@
+ref: refs/heads/master
diff --git a/tests/resources/testrepo_256/.gitted/config b/tests/resources/testrepo_256/.gitted/config
new file mode 100644
index 00000000000..ba975e1be69
--- /dev/null
+++ b/tests/resources/testrepo_256/.gitted/config
@@ -0,0 +1,15 @@
+[core]
+ repositoryformatversion = 1
+ filemode = true
+ bare = false
+ logallrefupdates = true
+ ignorecase = true
+ precomposeunicode = true
+[remote "origin"]
+ url = /Users/ethomson/Personal/Projects/libgit2/libgit2/tests/resources/testrepo_256.git
+ fetch = +refs/heads/*:refs/remotes/origin/*
+[extensions]
+ objectformat = sha256
+[branch "master"]
+ remote = origin
+ merge = refs/heads/master
diff --git a/tests/resources/testrepo_256/.gitted/description b/tests/resources/testrepo_256/.gitted/description
new file mode 100644
index 00000000000..498b267a8c7
--- /dev/null
+++ b/tests/resources/testrepo_256/.gitted/description
@@ -0,0 +1 @@
+Unnamed repository; edit this file 'description' to name the repository.
diff --git a/tests/resources/testrepo_256/.gitted/index b/tests/resources/testrepo_256/.gitted/index
new file mode 100644
index 00000000000..6b18426ca7e
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/index differ
diff --git a/tests/resources/testrepo_256/.gitted/info/exclude b/tests/resources/testrepo_256/.gitted/info/exclude
new file mode 100644
index 00000000000..a5196d1be8f
--- /dev/null
+++ b/tests/resources/testrepo_256/.gitted/info/exclude
@@ -0,0 +1,6 @@
+# git ls-files --others --exclude-from=.git/info/exclude
+# Lines that start with '#' are comments.
+# For a project mostly in C, the following would be a good set of
+# exclude patterns (uncomment them if you want to use them):
+# *.[oa]
+# *~
diff --git a/tests/resources/testrepo_256/.gitted/logs/HEAD b/tests/resources/testrepo_256/.gitted/logs/HEAD
new file mode 100644
index 00000000000..35923030200
--- /dev/null
+++ b/tests/resources/testrepo_256/.gitted/logs/HEAD
@@ -0,0 +1 @@
+0000000000000000000000000000000000000000000000000000000000000000 decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f Edward Thomson <ethomson@vercel.com> 1680595792 +0100 clone: from /Users/ethomson/Personal/Projects/libgit2/libgit2/tests/resources/testrepo_256.git
diff --git a/tests/resources/testrepo_256/.gitted/logs/refs/heads/master b/tests/resources/testrepo_256/.gitted/logs/refs/heads/master
new file mode 100644
index 00000000000..35923030200
--- /dev/null
+++ b/tests/resources/testrepo_256/.gitted/logs/refs/heads/master
@@ -0,0 +1 @@
+0000000000000000000000000000000000000000000000000000000000000000 decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f Edward Thomson <ethomson@vercel.com> 1680595792 +0100 clone: from /Users/ethomson/Personal/Projects/libgit2/libgit2/tests/resources/testrepo_256.git
diff --git a/tests/resources/testrepo_256/.gitted/logs/refs/remotes/origin/HEAD b/tests/resources/testrepo_256/.gitted/logs/refs/remotes/origin/HEAD
new file mode 100644
index 00000000000..35923030200
--- /dev/null
+++ b/tests/resources/testrepo_256/.gitted/logs/refs/remotes/origin/HEAD
@@ -0,0 +1 @@
+0000000000000000000000000000000000000000000000000000000000000000 decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f Edward Thomson <ethomson@vercel.com> 1680595792 +0100 clone: from /Users/ethomson/Personal/Projects/libgit2/libgit2/tests/resources/testrepo_256.git
diff --git a/tests/resources/testrepo_256/.gitted/objects/00/404e6179d86039bbc01a925bdc34ccdab778bd1d824f5562aaa319c6c8f045 b/tests/resources/testrepo_256/.gitted/objects/00/404e6179d86039bbc01a925bdc34ccdab778bd1d824f5562aaa319c6c8f045
new file mode 100644
index 00000000000..8d8d1d8e828
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/00/404e6179d86039bbc01a925bdc34ccdab778bd1d824f5562aaa319c6c8f045 differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/01/18010feb81fe41b9df646d13866742a9070b56fd0ba9ab8dff828fc36c1f78 b/tests/resources/testrepo_256/.gitted/objects/01/18010feb81fe41b9df646d13866742a9070b56fd0ba9ab8dff828fc36c1f78
new file mode 100644
index 00000000000..c7fbd7e9ec8
--- /dev/null
+++ b/tests/resources/testrepo_256/.gitted/objects/01/18010feb81fe41b9df646d13866742a9070b56fd0ba9ab8dff828fc36c1f78
@@ -0,0 +1 @@
+x[NÅ0 ùî*üt•8§B°”Øq ¢iPš»º~GgŽ42zo œ±/kªÂ^rfK‚¡FO%BI"NªÉdwVe¡b8º”vb‘·ß<õ\°LçB6Ýk< ÅUtœÅ–¢%¦ÄÈÅYÿ#SµÔCè·ü\ßcÂù<Ž5~ô„7í:›<ªÎž¯¯žÛñÑßÁ:›n3&‚WƒÆl7½£–þSß>Kkt…Ú½ kÀõäҦʳéµý÷_‘
\ No newline at end of file
diff --git a/tests/resources/testrepo_256/.gitted/objects/02/df938cfb169b0b6ba0dd16acdd727ea9364f7d48c55afed2f7dd889804065b b/tests/resources/testrepo_256/.gitted/objects/02/df938cfb169b0b6ba0dd16acdd727ea9364f7d48c55afed2f7dd889804065b
new file mode 100644
index 00000000000..cdfafaca76c
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/02/df938cfb169b0b6ba0dd16acdd727ea9364f7d48c55afed2f7dd889804065b differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/05/f7b70a01b0ade8afa5a5fcd19f12cc38faf337d10ec03ef4363d1a86f63750 b/tests/resources/testrepo_256/.gitted/objects/05/f7b70a01b0ade8afa5a5fcd19f12cc38faf337d10ec03ef4363d1a86f63750
new file mode 100644
index 00000000000..b135eccdafa
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/05/f7b70a01b0ade8afa5a5fcd19f12cc38faf337d10ec03ef4363d1a86f63750 differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/14/bd335f9d7188c778d44eba8801fe9bda46b66593291f5b9f7cd5f8888af12f b/tests/resources/testrepo_256/.gitted/objects/14/bd335f9d7188c778d44eba8801fe9bda46b66593291f5b9f7cd5f8888af12f
new file mode 100644
index 00000000000..58b2d0932a9
--- /dev/null
+++ b/tests/resources/testrepo_256/.gitted/objects/14/bd335f9d7188c778d44eba8801fe9bda46b66593291f5b9f7cd5f8888af12f
@@ -0,0 +1 @@
+x
̱ƒ0 ÐÔžÂ#ÈB k „¾¹ä‘ j²}(^ûrÝ«Ùãô¶¬²„i3Ï Ãg ¾’õ _ÜœÝ8H§Ö¡N] “Š”ü}P·ó8žYò®o;¾o\Wùw×
\ No newline at end of file
diff --git a/tests/resources/testrepo_256/.gitted/objects/17/9496410f66032c03bd2b7e8ddfc9c8c47820fab5615cc04d904989ce800498 b/tests/resources/testrepo_256/.gitted/objects/17/9496410f66032c03bd2b7e8ddfc9c8c47820fab5615cc04d904989ce800498
new file mode 100644
index 00000000000..97157644b1b
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/17/9496410f66032c03bd2b7e8ddfc9c8c47820fab5615cc04d904989ce800498 differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/19/0a1349522cc11f8682e34acca4ce4e1ea8508dfd77c24cefd461b65cead09e b/tests/resources/testrepo_256/.gitted/objects/19/0a1349522cc11f8682e34acca4ce4e1ea8508dfd77c24cefd461b65cead09e
new file mode 100644
index 00000000000..554d191b3ac
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/19/0a1349522cc11f8682e34acca4ce4e1ea8508dfd77c24cefd461b65cead09e differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/1b/4b74772bd83ff28bf44cda9be93f4afc2279623bb5b36c9194a660b7623c24 b/tests/resources/testrepo_256/.gitted/objects/1b/4b74772bd83ff28bf44cda9be93f4afc2279623bb5b36c9194a660b7623c24
new file mode 100644
index 00000000000..d5c518ecc8c
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/1b/4b74772bd83ff28bf44cda9be93f4afc2279623bb5b36c9194a660b7623c24 differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/21/e1e1ebe45b2c1ef79ab050334e36a8015a546f0740bea4505e10d81a946f61 b/tests/resources/testrepo_256/.gitted/objects/21/e1e1ebe45b2c1ef79ab050334e36a8015a546f0740bea4505e10d81a946f61
new file mode 100644
index 00000000000..31aa9e5f53d
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/21/e1e1ebe45b2c1ef79ab050334e36a8015a546f0740bea4505e10d81a946f61 differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/23/8a501cf11a036f2f248008d88e14af624bb07fced6390997a0fa6abdad950a b/tests/resources/testrepo_256/.gitted/objects/23/8a501cf11a036f2f248008d88e14af624bb07fced6390997a0fa6abdad950a
new file mode 100644
index 00000000000..66dc15db486
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/23/8a501cf11a036f2f248008d88e14af624bb07fced6390997a0fa6abdad950a differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/26/149bf1ac4612f24b532ae50a12b15f26aace3718749624f008bde68670352a b/tests/resources/testrepo_256/.gitted/objects/26/149bf1ac4612f24b532ae50a12b15f26aace3718749624f008bde68670352a
new file mode 100644
index 00000000000..bee6a42d79b
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/26/149bf1ac4612f24b532ae50a12b15f26aace3718749624f008bde68670352a differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/2d/b6069c27ca4c08b784048644c307e17d0afe29b55f6488398cb59f13feb2f2 b/tests/resources/testrepo_256/.gitted/objects/2d/b6069c27ca4c08b784048644c307e17d0afe29b55f6488398cb59f13feb2f2
new file mode 100644
index 00000000000..3dfd5463ba9
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/2d/b6069c27ca4c08b784048644c307e17d0afe29b55f6488398cb59f13feb2f2 differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/33/e415b835a670bb5c3c760efa0433ac0cbd2d44679f68f2df3a9ae7014cf2a8 b/tests/resources/testrepo_256/.gitted/objects/33/e415b835a670bb5c3c760efa0433ac0cbd2d44679f68f2df3a9ae7014cf2a8
new file mode 100644
index 00000000000..cedb2a22e69
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/33/e415b835a670bb5c3c760efa0433ac0cbd2d44679f68f2df3a9ae7014cf2a8 differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/34/f79ad1c813b93d2ee11c830c2134815a31d9629e6aa9773338fedaab90976b b/tests/resources/testrepo_256/.gitted/objects/34/f79ad1c813b93d2ee11c830c2134815a31d9629e6aa9773338fedaab90976b
new file mode 100644
index 00000000000..3abc52f4164
--- /dev/null
+++ b/tests/resources/testrepo_256/.gitted/objects/34/f79ad1c813b93d2ee11c830c2134815a31d9629e6aa9773338fedaab90976b
@@ -0,0 +1 @@
+x ÌM‚0†a×=Å\@3ÃôcŒWнi;-`, ooq÷~‹ï)¾²æ°„WŠ$EŸ3£¡Î¶B™}#) ‹ö-Æ$È„dŒI”¥íˆ±± 9ÑY•ï;A\¦i,ªT{ð«<kì£O+ÜÒ ÷²ú-À9|þqíÇ2láT_ fëlƒ®…#:D¥ UYfØ Ám4
\ No newline at end of file
diff --git a/tests/resources/testrepo_256/.gitted/objects/36/eac24505d4c4405864ccf2f30d79af178374166daeceefbf11e2f058d30d60 b/tests/resources/testrepo_256/.gitted/objects/36/eac24505d4c4405864ccf2f30d79af178374166daeceefbf11e2f058d30d60
new file mode 100644
index 00000000000..df40d99afff
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/36/eac24505d4c4405864ccf2f30d79af178374166daeceefbf11e2f058d30d60 differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/39/bf1ac28cc3f8432ba7cfeeca6bfffd9a0fe641784db85de2eb0f57b7553869 b/tests/resources/testrepo_256/.gitted/objects/39/bf1ac28cc3f8432ba7cfeeca6bfffd9a0fe641784db85de2eb0f57b7553869
new file mode 100644
index 00000000000..c05cacfed5d
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/39/bf1ac28cc3f8432ba7cfeeca6bfffd9a0fe641784db85de2eb0f57b7553869 differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/3b/58565ee067f13349cd4f89aa396d10f71c69e168d5c48ea23de59734ec3ab1 b/tests/resources/testrepo_256/.gitted/objects/3b/58565ee067f13349cd4f89aa396d10f71c69e168d5c48ea23de59734ec3ab1
new file mode 100644
index 00000000000..1b299dc257b
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/3b/58565ee067f13349cd4f89aa396d10f71c69e168d5c48ea23de59734ec3ab1 differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/43/e084a4599ca42c476919917e3db8fde0045ee66305fd5e634b0c793c536a1b b/tests/resources/testrepo_256/.gitted/objects/43/e084a4599ca42c476919917e3db8fde0045ee66305fd5e634b0c793c536a1b
new file mode 100644
index 00000000000..2acf1b60726
--- /dev/null
+++ b/tests/resources/testrepo_256/.gitted/objects/43/e084a4599ca42c476919917e3db8fde0045ee66305fd5e634b0c793c536a1b
@@ -0,0 +1 @@
+xQj!Dóí)ú ÚÚ¶Â{„œ m53Y—‰¹ÿÊæù((ªx¥ã8ö Èô2ÏÖ€} Ýë’KØ¢¦ZQs’VP99GɧƑ} Å#yËÊ.&ê¥S‰æ.g»MЂ‹guÔë“ÆHZ#ºN‚˜´x_5—1'«0jÏRPÂêr·F~ç6NøÔ1'\7ÑqƒË>ÍÇ×!û÷›Žã r`t¼Z¶Ö¬t=ší?¬˜Û~Vø1ÅfTÂ
\ No newline at end of file
diff --git a/tests/resources/testrepo_256/.gitted/objects/47/3a0f4c3be8a93681a267e3b1e9a7dcda1185436fe141f7749120a303721813 b/tests/resources/testrepo_256/.gitted/objects/47/3a0f4c3be8a93681a267e3b1e9a7dcda1185436fe141f7749120a303721813
new file mode 100644
index 00000000000..71122389437
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/47/3a0f4c3be8a93681a267e3b1e9a7dcda1185436fe141f7749120a303721813 differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/4b/c142808884e472ee6cc331b132e66ef18f564d41efb055804ec1dd28efb3f5 b/tests/resources/testrepo_256/.gitted/objects/4b/c142808884e472ee6cc331b132e66ef18f564d41efb055804ec1dd28efb3f5
new file mode 100644
index 00000000000..d0d7e736e53
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/4b/c142808884e472ee6cc331b132e66ef18f564d41efb055804ec1dd28efb3f5 differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/4d/f8ed86acaac5dc82b5652170996ce459d39e3a441e9759b635b0bc4ecc43fd b/tests/resources/testrepo_256/.gitted/objects/4d/f8ed86acaac5dc82b5652170996ce459d39e3a441e9759b635b0bc4ecc43fd
new file mode 100644
index 00000000000..8dc1932822c
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/4d/f8ed86acaac5dc82b5652170996ce459d39e3a441e9759b635b0bc4ecc43fd differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/5a/2d5699fea33657b42ba98c22b7898baaa0eda205a21cafdcb7e0f94b07bb9b b/tests/resources/testrepo_256/.gitted/objects/5a/2d5699fea33657b42ba98c22b7898baaa0eda205a21cafdcb7e0f94b07bb9b
new file mode 100644
index 00000000000..dd993131694
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/5a/2d5699fea33657b42ba98c22b7898baaa0eda205a21cafdcb7e0f94b07bb9b differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/5c/a8959deb2b8327458e0344523eb1ddeeef4bce03e35864640b452f84d26848 b/tests/resources/testrepo_256/.gitted/objects/5c/a8959deb2b8327458e0344523eb1ddeeef4bce03e35864640b452f84d26848
new file mode 100644
index 00000000000..39e27c06a34
--- /dev/null
+++ b/tests/resources/testrepo_256/.gitted/objects/5c/a8959deb2b8327458e0344523eb1ddeeef4bce03e35864640b452f84d26848
@@ -0,0 +1 @@
+x1N1E©÷îRÆöØ KÑPÒqÏxœ”]£#®Spº¯'ý÷¥/}Û.ÃøäŸÆ¡j\å1‹KRP€8RDImªPšºÌ!´ˆD>“pÈÍú¦ìš[¾Ë¡û0µºàµ•¬›D ‚¸Œ‚hëSf !ƒ‹šÙÆ@©é µ-üyÀZ S>©¢å\çn¬ÖSŒ ]É€Cl¸äÂT[#GM|Û-å>Ö~˜úSŽj¾Ö¾Ýún^uÒGz?_ÆzçéÛ›±.y—,b0ÏS ˤó¡ÿí/ŸzœÕðQvYÍévçÇÉ·“¹ì£›~Ë/(jrS
\ No newline at end of file
diff --git a/tests/resources/testrepo_256/.gitted/objects/5d/bb1fff5c0094b31b25b4635ab9fbee66d65fe5dda47dd0ac5f01dd69a84c6f b/tests/resources/testrepo_256/.gitted/objects/5d/bb1fff5c0094b31b25b4635ab9fbee66d65fe5dda47dd0ac5f01dd69a84c6f
new file mode 100644
index 00000000000..17fae64f464
--- /dev/null
+++ b/tests/resources/testrepo_256/.gitted/objects/5d/bb1fff5c0094b31b25b4635ab9fbee66d65fe5dda47dd0ac5f01dd69a84c6f
@@ -0,0 +1,3 @@
+xuKj1D³žSô ¤–Üê† !'H. OgÀ3
+²Œ¯ 9É6»¢¨÷ rݶµ2>õ¦
+d=‹Š²³³-bŒ5ì‹“dòÅ•Ä„¦Pî(DÁeŽÉ{Òé+6Ý;Ì>±‹4KÆƦrLfˆ
Á,ö¿Ýo}©
>rí Þ–˜ë/×üNç-®—ç\·W°<[Çâá`‚1ÓhÇ£®
ÞË=¶ŸKÝ®Z‡ñ‘Nçµ/·ôÇ{"‚ï?¥÷¼À¯ê®Ó7bÆW
\ No newline at end of file
diff --git a/tests/resources/testrepo_256/.gitted/objects/61/489e9e831f1d9001084d39b79f964c293db8620d679ea3596673c8a326446e b/tests/resources/testrepo_256/.gitted/objects/61/489e9e831f1d9001084d39b79f964c293db8620d679ea3596673c8a326446e
new file mode 100644
index 00000000000..0bece845b96
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/61/489e9e831f1d9001084d39b79f964c293db8620d679ea3596673c8a326446e differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/6d/5fd291bb0f67444e99ab492f1bf1fcdf5dca09dab24cf331e05111b4cfc1a3 b/tests/resources/testrepo_256/.gitted/objects/6d/5fd291bb0f67444e99ab492f1bf1fcdf5dca09dab24cf331e05111b4cfc1a3
new file mode 100644
index 00000000000..112998d4257
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/6d/5fd291bb0f67444e99ab492f1bf1fcdf5dca09dab24cf331e05111b4cfc1a3 differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/70/30f925768d9beb65654ab8f436e3ca0a82b25eddefd237bf5a26a0441c2aa7 b/tests/resources/testrepo_256/.gitted/objects/70/30f925768d9beb65654ab8f436e3ca0a82b25eddefd237bf5a26a0441c2aa7
new file mode 100644
index 00000000000..860cad13cf8
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/70/30f925768d9beb65654ab8f436e3ca0a82b25eddefd237bf5a26a0441c2aa7 differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/73/8ff86401dbc5af692c83e660a4d510603c3f36e782a1a32ebd0388db6411ed b/tests/resources/testrepo_256/.gitted/objects/73/8ff86401dbc5af692c83e660a4d510603c3f36e782a1a32ebd0388db6411ed
new file mode 100644
index 00000000000..4c973ea83af
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/73/8ff86401dbc5af692c83e660a4d510603c3f36e782a1a32ebd0388db6411ed differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/73/b4f3c4f3182e6c8dd2c98aeb2c7811556538e7673e4b325307c71685fbf5b6 b/tests/resources/testrepo_256/.gitted/objects/73/b4f3c4f3182e6c8dd2c98aeb2c7811556538e7673e4b325307c71685fbf5b6
new file mode 100644
index 00000000000..67b84c462af
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/73/b4f3c4f3182e6c8dd2c98aeb2c7811556538e7673e4b325307c71685fbf5b6 differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/7e/4633ae1b0e83503dbea4417f9d5ccaf22b877c5a4522b6d1d2b16090ee2f6f b/tests/resources/testrepo_256/.gitted/objects/7e/4633ae1b0e83503dbea4417f9d5ccaf22b877c5a4522b6d1d2b16090ee2f6f
new file mode 100644
index 00000000000..993a62b1637
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/7e/4633ae1b0e83503dbea4417f9d5ccaf22b877c5a4522b6d1d2b16090ee2f6f differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/7e/9424c06052ca33bfc599bccadee60065d8664a9af7648a1455100c4f772e1c b/tests/resources/testrepo_256/.gitted/objects/7e/9424c06052ca33bfc599bccadee60065d8664a9af7648a1455100c4f772e1c
new file mode 100644
index 00000000000..70bf64e16bf
--- /dev/null
+++ b/tests/resources/testrepo_256/.gitted/objects/7e/9424c06052ca33bfc599bccadee60065d8664a9af7648a1455100c4f772e1c
@@ -0,0 +1,2 @@
+xÏAj1 …á®çÚ‚-i,B(]µ(tiÙ2 ’™ ƒ=~]zƒnÿÅ÷xe_×¥Æù© f]òb¨µ…$Öa9)yI
Ù'ñ‚2i«èæYÉÇTU[f™îù°ƒWVaÔ©5 sùu,QãÜ
+¢¤€¤:„P’OœCp*£ä)?ú×~Àùó 'x]6x˹\^àÜöýžóz¿Ù©ìë<!űÆÏÎ;7:nuû70½oK_ò
þ¤égƒV
\ No newline at end of file
diff --git a/tests/resources/testrepo_256/.gitted/objects/80/91b686de8bf697ef632dda9b3179f2419717275e3bfd2055b303489dbbfa47 b/tests/resources/testrepo_256/.gitted/objects/80/91b686de8bf697ef632dda9b3179f2419717275e3bfd2055b303489dbbfa47
new file mode 100644
index 00000000000..dec3810faf3
--- /dev/null
+++ b/tests/resources/testrepo_256/.gitted/objects/80/91b686de8bf697ef632dda9b3179f2419717275e3bfd2055b303489dbbfa47
@@ -0,0 +1 @@
+x+)JMU01c040031QrutñueX·hîaÖ+|fºŸbìï½
eú¶±i=ãö^Í*×ÉÆGêOæ
\ No newline at end of file
diff --git a/tests/resources/testrepo_256/.gitted/objects/81/55958bbda08eed88c8ac908dc44452ed38911cffa54ccc06076f30a1ffb1bf b/tests/resources/testrepo_256/.gitted/objects/81/55958bbda08eed88c8ac908dc44452ed38911cffa54ccc06076f30a1ffb1bf
new file mode 100644
index 00000000000..e610e3be8a1
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/81/55958bbda08eed88c8ac908dc44452ed38911cffa54ccc06076f30a1ffb1bf differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/90/1505c3355518bee35475c5d3f23bac1dded688b2bd314cc32b7f157e100724 b/tests/resources/testrepo_256/.gitted/objects/90/1505c3355518bee35475c5d3f23bac1dded688b2bd314cc32b7f157e100724
new file mode 100644
index 00000000000..09d0abfa7b4
--- /dev/null
+++ b/tests/resources/testrepo_256/.gitted/objects/90/1505c3355518bee35475c5d3f23bac1dded688b2bd314cc32b7f157e100724
@@ -0,0 +1 @@
+xQJ1 „}î)z¥M›¦ <‚'HÓÔýÁÝÊZïï¢7ðm˜ùf`tîû}y ú°N3?RÌÈ6§BŠY¹wÈJeH ‰R(…LÐM¬•Ì‰±€û”ÓŽåµA#8z½€‚Ú ÄPµ¥ÔµæÈÀ5¨d(:XH¾2 ÁÉ÷Úæéßt®å_7ÑyøÛ—þŠ—÷]î O:÷g r©röBp—{=ZöŸ®k§ ºù¿
?s?T¬U…
\ No newline at end of file
diff --git a/tests/resources/testrepo_256/.gitted/objects/93/1093620e5f050e2127fb0b96786ebaa9ee6535fb698ec01b5f7a800fa27cbe b/tests/resources/testrepo_256/.gitted/objects/93/1093620e5f050e2127fb0b96786ebaa9ee6535fb698ec01b5f7a800fa27cbe
new file mode 100644
index 00000000000..70431af8128
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/93/1093620e5f050e2127fb0b96786ebaa9ee6535fb698ec01b5f7a800fa27cbe differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/94/ed253efa9e86fc636805c294c441d08b89b455903c0c14e9b16587fec081f5 b/tests/resources/testrepo_256/.gitted/objects/94/ed253efa9e86fc636805c294c441d08b89b455903c0c14e9b16587fec081f5
new file mode 100644
index 00000000000..41bcd18afbb
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/94/ed253efa9e86fc636805c294c441d08b89b455903c0c14e9b16587fec081f5 differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/96/c18f0297e38d01f4b2dacddea4259aea6b2961eb0822bd2c0c3f6029030045 b/tests/resources/testrepo_256/.gitted/objects/96/c18f0297e38d01f4b2dacddea4259aea6b2961eb0822bd2c0c3f6029030045
new file mode 100644
index 00000000000..7ca4ceed504
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/96/c18f0297e38d01f4b2dacddea4259aea6b2961eb0822bd2c0c3f6029030045 differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/9c/cfa556cd7f73b426a7bedb7fc3a850e94f8c5ac1d71b9afa365a89005aff54 b/tests/resources/testrepo_256/.gitted/objects/9c/cfa556cd7f73b426a7bedb7fc3a850e94f8c5ac1d71b9afa365a89005aff54
new file mode 100644
index 00000000000..6e585cdb287
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/9c/cfa556cd7f73b426a7bedb7fc3a850e94f8c5ac1d71b9afa365a89005aff54 differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/9d/aab17c25f647d652c72c8cc3cf4602c270a369beebc7d0b67238897bbc426b b/tests/resources/testrepo_256/.gitted/objects/9d/aab17c25f647d652c72c8cc3cf4602c270a369beebc7d0b67238897bbc426b
new file mode 100644
index 00000000000..74b8385edc1
--- /dev/null
+++ b/tests/resources/testrepo_256/.gitted/objects/9d/aab17c25f647d652c72c8cc3cf4602c270a369beebc7d0b67238897bbc426b
@@ -0,0 +1 @@
+x+)JMU0´°d040031Qrutñue0~"ºÃtYÁî›2¾_,Ækxö꺤ÏÏøtßjÖsFŸO+L €@!1‰A¹+@æ£s¾¾JÇ>‘õIÞêÏ]³äœ¾àWÖÞµS¹ Æ&%æ%għeæ¤ê•T”0L;ØÏ4ýq/ã—M·ÎÞ[¢:ëU¶fâk¥½:<ö šÌ ®Pmy©å`å¹ñ—&îæOwñ›¹ÚS_úãŸû±§8omòùlø PpËùƒ‹¨TO
\ No newline at end of file
diff --git a/tests/resources/testrepo_256/.gitted/objects/a4/813ef6708e6011e8187224297e83e4a285f58bf5eabb1db270351388603c95 b/tests/resources/testrepo_256/.gitted/objects/a4/813ef6708e6011e8187224297e83e4a285f58bf5eabb1db270351388603c95
new file mode 100644
index 00000000000..2419974cbc2
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/a4/813ef6708e6011e8187224297e83e4a285f58bf5eabb1db270351388603c95 differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/ab/ee32b3339d1566d75613ea61f40c14bdfc5b101b60fde4f44b58dd06667640 b/tests/resources/testrepo_256/.gitted/objects/ab/ee32b3339d1566d75613ea61f40c14bdfc5b101b60fde4f44b58dd06667640
new file mode 100644
index 00000000000..b390250e308
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/ab/ee32b3339d1566d75613ea61f40c14bdfc5b101b60fde4f44b58dd06667640 differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/ae/a29dc305d40e362df25c3fdeed5502fd56b182af01b7740d297a24459333c5 b/tests/resources/testrepo_256/.gitted/objects/ae/a29dc305d40e362df25c3fdeed5502fd56b182af01b7740d297a24459333c5
new file mode 100644
index 00000000000..18a7f61c29e
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/ae/a29dc305d40e362df25c3fdeed5502fd56b182af01b7740d297a24459333c5 differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/b1/95873b48c824d995c974a3497ade7f62d2cd818bf388775cfa721de4068ebd b/tests/resources/testrepo_256/.gitted/objects/b1/95873b48c824d995c974a3497ade7f62d2cd818bf388775cfa721de4068ebd
new file mode 100644
index 00000000000..d1c032fce34
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/b1/95873b48c824d995c974a3497ade7f62d2cd818bf388775cfa721de4068ebd differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/b2/1c8c27a05a3f0bf9f0f44ebf05e11d9c591b04cfdaff7cc860310356d71827 b/tests/resources/testrepo_256/.gitted/objects/b2/1c8c27a05a3f0bf9f0f44ebf05e11d9c591b04cfdaff7cc860310356d71827
new file mode 100644
index 00000000000..c6da2ff7ace
--- /dev/null
+++ b/tests/resources/testrepo_256/.gitted/objects/b2/1c8c27a05a3f0bf9f0f44ebf05e11d9c591b04cfdaff7cc860310356d71827
@@ -0,0 +1 @@
+xuQj1 DûíSè)²WëÕB)д°e%^¨×Åqèõë´ýÍß0Ì{0RKÙ:8vO½©‚å³µleåà–e1rš EO³LŽ0aò8?Ú™¯Ðt BŠäBÒàÉG'Q**MYÉŸ'áhY… íL¸õ\¼Kí N9HÝáå*¿áx)aû|–Z^Áº…ØN¼ pA4£ º6xKß¡%øȵ\ï´ã= /[Ï·øÏ“÷¼zD7x¼‰-ì’áÏuWó¯W
\ No newline at end of file
diff --git a/tests/resources/testrepo_256/.gitted/objects/b6/1b940a8cd979a32e005682c5c09c22053675e2db24ea6b4b28cc75e9c10890 b/tests/resources/testrepo_256/.gitted/objects/b6/1b940a8cd979a32e005682c5c09c22053675e2db24ea6b4b28cc75e9c10890
new file mode 100644
index 00000000000..b1df3bdd5cf
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/b6/1b940a8cd979a32e005682c5c09c22053675e2db24ea6b4b28cc75e9c10890 differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/b8/3624f6ac0995273c0034a7ab8c68929bdc91b69ad54ef94979b93eba3f6022 b/tests/resources/testrepo_256/.gitted/objects/b8/3624f6ac0995273c0034a7ab8c68929bdc91b69ad54ef94979b93eba3f6022
new file mode 100644
index 00000000000..3e36331ea66
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/b8/3624f6ac0995273c0034a7ab8c68929bdc91b69ad54ef94979b93eba3f6022 differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/bd/f2066a28e11603a1af04157ee4aad97814279fe500340eb3465797cbd3be23 b/tests/resources/testrepo_256/.gitted/objects/bd/f2066a28e11603a1af04157ee4aad97814279fe500340eb3465797cbd3be23
new file mode 100644
index 00000000000..9bb5b623bdb
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/bd/f2066a28e11603a1af04157ee4aad97814279fe500340eb3465797cbd3be23 differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/bf/a3b3b9a161d354e2254a444b12c412210e9689c17e51bfc318ce4bb4360f19 b/tests/resources/testrepo_256/.gitted/objects/bf/a3b3b9a161d354e2254a444b12c412210e9689c17e51bfc318ce4bb4360f19
new file mode 100644
index 00000000000..3cbf7e6b714
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/bf/a3b3b9a161d354e2254a444b12c412210e9689c17e51bfc318ce4bb4360f19 differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/bf/cc4074ac517ed24d61b0aaa96359f304c3dc97e95f336269ed474ea846ada5 b/tests/resources/testrepo_256/.gitted/objects/bf/cc4074ac517ed24d61b0aaa96359f304c3dc97e95f336269ed474ea846ada5
new file mode 100644
index 00000000000..be8b99bba80
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/bf/cc4074ac517ed24d61b0aaa96359f304c3dc97e95f336269ed474ea846ada5 differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/c2/58f010a08328a29cde33411d955520e0375fcbbcc14b7636a70f7536c32ef6 b/tests/resources/testrepo_256/.gitted/objects/c2/58f010a08328a29cde33411d955520e0375fcbbcc14b7636a70f7536c32ef6
new file mode 100644
index 00000000000..9d2ceb1fff9
--- /dev/null
+++ b/tests/resources/testrepo_256/.gitted/objects/c2/58f010a08328a29cde33411d955520e0375fcbbcc14b7636a70f7536c32ef6
@@ -0,0 +1,2 @@
+x ŒÁ‚0D=÷+önbvK[JbŒ?àÍxßÖ¥¢Öƒ/™I^æð” P»1=%+X’5IœO6“´uà =V•“*pDòì]h±v˜„G/„÷HÜ,o £¿€r1Ë@eÖŠLpë²
+ž´ƒ£ò0¾¾çÒs÷>ä±?ÙH¾ŽÎ!ìÑ"s}t3,åͳIÿmø3‘
\ No newline at end of file
diff --git a/tests/resources/testrepo_256/.gitted/objects/ca/31f7336e882a233a2943787c5e94ba024ac9a4f763cb1d9bfd8e63aa7f7269 b/tests/resources/testrepo_256/.gitted/objects/ca/31f7336e882a233a2943787c5e94ba024ac9a4f763cb1d9bfd8e63aa7f7269
new file mode 100644
index 00000000000..cfcdac30697
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/ca/31f7336e882a233a2943787c5e94ba024ac9a4f763cb1d9bfd8e63aa7f7269 differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/cb/282e7c15fd8aeb2265cd621f5a228cb33dc84192980ca426cf9ab2a48cb9f0 b/tests/resources/testrepo_256/.gitted/objects/cb/282e7c15fd8aeb2265cd621f5a228cb33dc84192980ca426cf9ab2a48cb9f0
new file mode 100644
index 00000000000..77d9ec27d54
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/cb/282e7c15fd8aeb2265cd621f5a228cb33dc84192980ca426cf9ab2a48cb9f0 differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/cc/b5a03da85607c230d111abfa899655d1b00e6529101a40d42f6acb059dff9f b/tests/resources/testrepo_256/.gitted/objects/cc/b5a03da85607c230d111abfa899655d1b00e6529101a40d42f6acb059dff9f
new file mode 100644
index 00000000000..a67d6e647cc
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/cc/b5a03da85607c230d111abfa899655d1b00e6529101a40d42f6acb059dff9f differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/cf/84e5be57f8d5d51f136d3d137b654c602721c469c1b0a58e7e95647a9cf1c0 b/tests/resources/testrepo_256/.gitted/objects/cf/84e5be57f8d5d51f136d3d137b654c602721c469c1b0a58e7e95647a9cf1c0
new file mode 100644
index 00000000000..ec37060e379
--- /dev/null
+++ b/tests/resources/testrepo_256/.gitted/objects/cf/84e5be57f8d5d51f136d3d137b654c602721c469c1b0a58e7e95647a9cf1c0
@@ -0,0 +1,3 @@
+x•ŽA
+Â0E]ç³ëBÌ$©
ˆx¯ ™dª…ÆHŒ ·7xWÞãÃ%祑޴*<Æ}À“qVˆœ
ÖZFŠ‰P‹ ' q/yŽ§(–ÙšQÏèUxµ[©Ö%
+ ~8É;äÇ*»XòИ‰¼vä`«QkÕm¿Ð䯑:—&O)IþÀp]ÚåÞÝ%V M˜kÉ°.Ü©/××Eÿ
\ No newline at end of file
diff --git a/tests/resources/testrepo_256/.gitted/objects/d8/8b60d2641df3656381dc8e201abb820a414de03eb63c065b06a2ab37d3f5ca b/tests/resources/testrepo_256/.gitted/objects/d8/8b60d2641df3656381dc8e201abb820a414de03eb63c065b06a2ab37d3f5ca
new file mode 100644
index 00000000000..6845087e53a
--- /dev/null
+++ b/tests/resources/testrepo_256/.gitted/objects/d8/8b60d2641df3656381dc8e201abb820a414de03eb63c065b06a2ab37d3f5ca
@@ -0,0 +1 @@
+x5ÌÁjÃ0 €áýêyP”ÈŽ(£ÐëÖW²#‡´q4Rõ°·_/=þ|ðÏÐôǦ›d"ñMH=î"¦2åØ¡FOÄsšÚÉû.¥ëK;â%bãsi¹wö÷+VMÎ^gÞ656™ÆW¦ã[fÙa{®«é]68I•}ÉÇ"{åÇy®¼¬Ç¬õ "Š}ð‰-¢sߪwøá\.Zëb÷Ø=B
\ No newline at end of file
diff --git a/tests/resources/testrepo_256/.gitted/objects/de/caff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f b/tests/resources/testrepo_256/.gitted/objects/de/caff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f
new file mode 100644
index 00000000000..a53ab84cf2c
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/de/caff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/eb/ead5965196dfaeab52b1a5d92b78e54493fdaa78f72268d4cc69b61d5feee1 b/tests/resources/testrepo_256/.gitted/objects/eb/ead5965196dfaeab52b1a5d92b78e54493fdaa78f72268d4cc69b61d5feee1
new file mode 100644
index 00000000000..225c45734e0
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/eb/ead5965196dfaeab52b1a5d92b78e54493fdaa78f72268d4cc69b61d5feee1 differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/f2/a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736 b/tests/resources/testrepo_256/.gitted/objects/f2/a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736
new file mode 100644
index 00000000000..58d51e50232
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/f2/a108f86a3b4fd9ad75ed55e9cb3cb46e348fca3b9dba3db64f7c9f64b8a736 differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/f2/c8da1a7c2eb49ff25c47441f0b3f387faeddde1b37d0ad2f3f6a63f5327978 b/tests/resources/testrepo_256/.gitted/objects/f2/c8da1a7c2eb49ff25c47441f0b3f387faeddde1b37d0ad2f3f6a63f5327978
new file mode 100644
index 00000000000..04bf5eb0621
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/f2/c8da1a7c2eb49ff25c47441f0b3f387faeddde1b37d0ad2f3f6a63f5327978 differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/f3/1459efb9367c5a19c9dd24c75107423d5773066922ea5e55eaeb6490979562 b/tests/resources/testrepo_256/.gitted/objects/f3/1459efb9367c5a19c9dd24c75107423d5773066922ea5e55eaeb6490979562
new file mode 100644
index 00000000000..37a289ecc18
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/f3/1459efb9367c5a19c9dd24c75107423d5773066922ea5e55eaeb6490979562 differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/pack/pack-b87f1f214098b19ce092afb9ef6e7643653c03e7f91faa27b767e3eb8225f0f6.idx b/tests/resources/testrepo_256/.gitted/objects/pack/pack-b87f1f214098b19ce092afb9ef6e7643653c03e7f91faa27b767e3eb8225f0f6.idx
new file mode 100644
index 00000000000..897e8a478fc
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/pack/pack-b87f1f214098b19ce092afb9ef6e7643653c03e7f91faa27b767e3eb8225f0f6.idx differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/pack/pack-b87f1f214098b19ce092afb9ef6e7643653c03e7f91faa27b767e3eb8225f0f6.pack b/tests/resources/testrepo_256/.gitted/objects/pack/pack-b87f1f214098b19ce092afb9ef6e7643653c03e7f91faa27b767e3eb8225f0f6.pack
new file mode 100644
index 00000000000..9c8557886c8
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/pack/pack-b87f1f214098b19ce092afb9ef6e7643653c03e7f91faa27b767e3eb8225f0f6.pack differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/pack/pack-e2f07f30db7e480ea84a0e64ee791b9b270067124b2609019b74f33f256f33fa.idx b/tests/resources/testrepo_256/.gitted/objects/pack/pack-e2f07f30db7e480ea84a0e64ee791b9b270067124b2609019b74f33f256f33fa.idx
new file mode 100644
index 00000000000..9e2ec99c546
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/pack/pack-e2f07f30db7e480ea84a0e64ee791b9b270067124b2609019b74f33f256f33fa.idx differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/pack/pack-e2f07f30db7e480ea84a0e64ee791b9b270067124b2609019b74f33f256f33fa.pack b/tests/resources/testrepo_256/.gitted/objects/pack/pack-e2f07f30db7e480ea84a0e64ee791b9b270067124b2609019b74f33f256f33fa.pack
new file mode 100644
index 00000000000..66cd292a257
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/pack/pack-e2f07f30db7e480ea84a0e64ee791b9b270067124b2609019b74f33f256f33fa.pack differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/pack/pack-f72bbfa35af982c2a60735152c80b24ee981cf102db76764c383f9b87935d0d3.idx b/tests/resources/testrepo_256/.gitted/objects/pack/pack-f72bbfa35af982c2a60735152c80b24ee981cf102db76764c383f9b87935d0d3.idx
new file mode 100644
index 00000000000..1d197e87085
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/pack/pack-f72bbfa35af982c2a60735152c80b24ee981cf102db76764c383f9b87935d0d3.idx differ
diff --git a/tests/resources/testrepo_256/.gitted/objects/pack/pack-f72bbfa35af982c2a60735152c80b24ee981cf102db76764c383f9b87935d0d3.pack b/tests/resources/testrepo_256/.gitted/objects/pack/pack-f72bbfa35af982c2a60735152c80b24ee981cf102db76764c383f9b87935d0d3.pack
new file mode 100644
index 00000000000..5b615e15c27
Binary files /dev/null and b/tests/resources/testrepo_256/.gitted/objects/pack/pack-f72bbfa35af982c2a60735152c80b24ee981cf102db76764c383f9b87935d0d3.pack differ
diff --git a/tests/resources/testrepo_256/.gitted/packed-refs b/tests/resources/testrepo_256/.gitted/packed-refs
new file mode 100644
index 00000000000..75626adfed4
--- /dev/null
+++ b/tests/resources/testrepo_256/.gitted/packed-refs
@@ -0,0 +1,27 @@
+# pack-refs with: peeled fully-peeled sorted
+a4813ef6708e6011e8187224297e83e4a285f58bf5eabb1db270351388603c95 refs/remotes/origin/br2
+a4813ef6708e6011e8187224297e83e4a285f58bf5eabb1db270351388603c95 refs/remotes/origin/cannot-fetch
+4d46d9719e425ef2dfb5bfba098d0b62e21b2b92d0731892eef70db0870e3744 refs/remotes/origin/chomped
+7e9424c06052ca33bfc599bccadee60065d8664a9af7648a1455100c4f772e1c refs/remotes/origin/haacked
+decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f refs/remotes/origin/master
+decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f refs/remotes/origin/not-good
+66fe8385c6378bfa5ca5573bd0fdd773e4eadb0e86416b483f2c50c839859ecb refs/remotes/origin/packed
+43e084a4599ca42c476919917e3db8fde0045ee66305fd5e634b0c793c536a1b refs/remotes/origin/packed-test
+0118010feb81fe41b9df646d13866742a9070b56fd0ba9ab8dff828fc36c1f78 refs/remotes/origin/subtrees
+4d46d9719e425ef2dfb5bfba098d0b62e21b2b92d0731892eef70db0870e3744 refs/remotes/origin/test
+b83624f6ac0995273c0034a7ab8c68929bdc91b69ad54ef94979b93eba3f6022 refs/remotes/origin/track-local
+4d46d9719e425ef2dfb5bfba098d0b62e21b2b92d0731892eef70db0870e3744 refs/remotes/origin/trailing
+7e4633ae1b0e83503dbea4417f9d5ccaf22b877c5a4522b6d1d2b16090ee2f6f refs/remotes/origin/with-empty-log
+d88b60d2641df3656381dc8e201abb820a414de03eb63c065b06a2ab37d3f5ca refs/tags/annotated_tag_to_blob
+^33e415b835a670bb5c3c760efa0433ac0cbd2d44679f68f2df3a9ae7014cf2a8
+21e1e1ebe45b2c1ef79ab050334e36a8015a546f0740bea4505e10d81a946f61 refs/tags/e90810b
+^4d46d9719e425ef2dfb5bfba098d0b62e21b2b92d0731892eef70db0870e3744
+34f79ad1c813b93d2ee11c830c2134815a31d9629e6aa9773338fedaab90976b refs/tags/hard_tag
+^decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f
+33e415b835a670bb5c3c760efa0433ac0cbd2d44679f68f2df3a9ae7014cf2a8 refs/tags/point_to_blob
+14bd335f9d7188c778d44eba8801fe9bda46b66593291f5b9f7cd5f8888af12f refs/tags/taggerless
+^4d46d9719e425ef2dfb5bfba098d0b62e21b2b92d0731892eef70db0870e3744
+c258f010a08328a29cde33411d955520e0375fcbbcc14b7636a70f7536c32ef6 refs/tags/test
+^4d46d9719e425ef2dfb5bfba098d0b62e21b2b92d0731892eef70db0870e3744
+34f79ad1c813b93d2ee11c830c2134815a31d9629e6aa9773338fedaab90976b refs/tags/wrapped_tag
+^decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f
diff --git a/tests/resources/testrepo_256/.gitted/refs/heads/master b/tests/resources/testrepo_256/.gitted/refs/heads/master
new file mode 100644
index 00000000000..106231c4cfa
--- /dev/null
+++ b/tests/resources/testrepo_256/.gitted/refs/heads/master
@@ -0,0 +1 @@
+decaff3051968d1f3a2defd3d4a80ced03101555e1fd8913b3544026c0717d4f
diff --git a/tests/resources/testrepo_256/.gitted/refs/remotes/origin/HEAD b/tests/resources/testrepo_256/.gitted/refs/remotes/origin/HEAD
new file mode 100644
index 00000000000..6efe28fff83
--- /dev/null
+++ b/tests/resources/testrepo_256/.gitted/refs/remotes/origin/HEAD
@@ -0,0 +1 @@
+ref: refs/remotes/origin/master
diff --git a/tests/resources/testrepo_256/README b/tests/resources/testrepo_256/README
new file mode 100644
index 00000000000..a8233120f6a
--- /dev/null
+++ b/tests/resources/testrepo_256/README
@@ -0,0 +1 @@
+hey there
diff --git a/tests/resources/testrepo_256/branch_file.txt b/tests/resources/testrepo_256/branch_file.txt
new file mode 100644
index 00000000000..3697d64be94
--- /dev/null
+++ b/tests/resources/testrepo_256/branch_file.txt
@@ -0,0 +1,2 @@
+hi
+bye!
diff --git a/tests/resources/testrepo_256/new.txt b/tests/resources/testrepo_256/new.txt
new file mode 100644
index 00000000000..a71586c1dfe
--- /dev/null
+++ b/tests/resources/testrepo_256/new.txt
@@ -0,0 +1 @@
+my new file
diff --git a/tests/util/CMakeLists.txt b/tests/util/CMakeLists.txt
index 232590ffdfc..425c27dcdc5 100644
--- a/tests/util/CMakeLists.txt
+++ b/tests/util/CMakeLists.txt
@@ -1,5 +1,9 @@
# util: the unit tests for libgit2's utility library
+if(NOT "${CMAKE_VERSION}" VERSION_LESS 3.27)
+ cmake_policy(SET CMP0148 OLD)
+endif()
+
set(Python_ADDITIONAL_VERSIONS 3 2.7)
find_package(PythonInterp)
@@ -14,6 +18,7 @@ set(TEST_PATH "${CMAKE_CURRENT_SOURCE_DIR}")
add_definitions(-DCLAR_FIXTURE_PATH=\"${CLAR_FIXTURES}\")
add_definitions(-DCLAR_TMPDIR=\"libgit2_tests\")
add_definitions(-DCLAR_WIN32_LONGPATHS)
+add_definitions(-DCLAR_HAS_REALPATH)
add_definitions(-D_FILE_OFFSET_BITS=64)
# Ensure that we do not use deprecated functions internally
@@ -39,7 +44,6 @@ set_source_files_properties(
add_executable(util_tests ${SRC_CLAR} ${SRC_TEST} ${LIBGIT2_OBJECTS})
-set_target_properties(util_tests PROPERTIES C_STANDARD 90)
set_target_properties(util_tests PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${libgit2_BINARY_DIR})
target_include_directories(util_tests PRIVATE ${TEST_INCLUDES} ${LIBGIT2_INCLUDES} ${LIBGIT2_DEPENDENCY_INCLUDES})
diff --git a/tests/util/alloc.c b/tests/util/alloc.c
new file mode 100644
index 00000000000..492394a52c0
--- /dev/null
+++ b/tests/util/alloc.c
@@ -0,0 +1,68 @@
+#include "clar_libgit2.h"
+#include "clar_libgit2_alloc.h"
+#include "alloc.h"
+
+void test_alloc__cleanup(void)
+{
+ cl_alloc_reset();
+}
+
+void test_alloc__oom(void)
+{
+ void *ptr = NULL;
+
+ cl_alloc_limit(0);
+
+ cl_assert(git__malloc(1) == NULL);
+ cl_assert(git__calloc(1, 1) == NULL);
+ cl_assert(git__realloc(ptr, 1) == NULL);
+ cl_assert(git__strdup("test") == NULL);
+ cl_assert(git__strndup("test", 4) == NULL);
+}
+
+void test_alloc__single_byte_is_exhausted(void)
+{
+ void *ptr;
+
+ cl_alloc_limit(1);
+
+ cl_assert(ptr = git__malloc(1));
+ cl_assert(git__malloc(1) == NULL);
+ git__free(ptr);
+}
+
+void test_alloc__free_replenishes_byte(void)
+{
+ void *ptr;
+
+ cl_alloc_limit(1);
+
+ cl_assert(ptr = git__malloc(1));
+ cl_assert(git__malloc(1) == NULL);
+ git__free(ptr);
+ cl_assert(ptr = git__malloc(1));
+ git__free(ptr);
+}
+
+void test_alloc__realloc(void)
+{
+ char *ptr = NULL;
+
+ cl_alloc_limit(3);
+
+ cl_assert(ptr = git__realloc(ptr, 1));
+ *ptr = 'x';
+
+ cl_assert(ptr = git__realloc(ptr, 1));
+ cl_assert_equal_i(*ptr, 'x');
+
+ cl_assert(ptr = git__realloc(ptr, 2));
+ cl_assert_equal_i(*ptr, 'x');
+
+ cl_assert(git__realloc(ptr, 2) == NULL);
+
+ cl_assert(ptr = git__realloc(ptr, 1));
+ cl_assert_equal_i(*ptr, 'x');
+
+ git__free(ptr);
+}
diff --git a/tests/util/assert.c b/tests/util/assert.c
index 3babc475ae3..4644f3533e9 100644
--- a/tests/util/assert.c
+++ b/tests/util/assert.c
@@ -92,7 +92,8 @@ void test_assert__argument_with_void_return_type(void)
git_error_clear();
cl_assert_equal_p(foo, fn_returns_string(foo));
- cl_assert_equal_p(NULL, git_error_last());
+ cl_assert_equal_i(GIT_ERROR_NONE, git_error_last()->klass);
+ cl_assert_equal_s("no error", git_error_last()->message);
}
void test_assert__internal(void)
diff --git a/tests/util/errors.c b/tests/util/errors.c
index 78654a753ae..f9b85a65fde 100644
--- a/tests/util/errors.c
+++ b/tests/util/errors.c
@@ -5,7 +5,10 @@ void test_errors__public_api(void)
char *str_in_error;
git_error_clear();
- cl_assert(git_error_last() == NULL);
+
+ cl_assert(git_error_last() != NULL);
+ cl_assert(git_error_last()->klass == GIT_ERROR_NONE);
+ cl_assert(strcmp(git_error_last()->message, "no error") == 0);
git_error_set_oom();
@@ -23,7 +26,9 @@ void test_errors__public_api(void)
cl_assert(str_in_error != NULL);
git_error_clear();
- cl_assert(git_error_last() == NULL);
+ cl_assert(git_error_last() != NULL);
+ cl_assert(git_error_last()->klass == GIT_ERROR_NONE);
+ cl_assert(strcmp(git_error_last()->message, "no error") == 0);
}
#include "common.h"
@@ -35,7 +40,9 @@ void test_errors__new_school(void)
char *str_in_error;
git_error_clear();
- cl_assert(git_error_last() == NULL);
+ cl_assert(git_error_last() != NULL);
+ cl_assert(git_error_last()->klass == GIT_ERROR_NONE);
+ cl_assert(strcmp(git_error_last()->message, "no error") == 0);
git_error_set_oom(); /* internal fn */
@@ -53,7 +60,9 @@ void test_errors__new_school(void)
cl_assert(str_in_error != NULL);
git_error_clear();
- cl_assert(git_error_last() == NULL);
+ cl_assert(git_error_last() != NULL);
+ cl_assert(git_error_last()->klass == GIT_ERROR_NONE);
+ cl_assert(strcmp(git_error_last()->message, "no error") == 0);
do {
struct stat st;
@@ -88,52 +97,32 @@ void test_errors__new_school(void)
void test_errors__restore(void)
{
- git_error_state err_state = {0};
+ git_error *last_error;
git_error_clear();
- cl_assert(git_error_last() == NULL);
-
- cl_assert_equal_i(0, git_error_state_capture(&err_state, 0));
-
- memset(&err_state, 0x0, sizeof(git_error_state));
+ cl_assert(git_error_last() != NULL);
+ cl_assert(git_error_last()->klass == GIT_ERROR_NONE);
+ cl_assert(strcmp("no error", git_error_last()->message) == 0);
git_error_set(42, "Foo: %s", "bar");
- cl_assert_equal_i(-1, git_error_state_capture(&err_state, -1));
-
- cl_assert(git_error_last() == NULL);
-
- git_error_set(99, "Bar: %s", "foo");
-
- git_error_state_restore(&err_state);
-
- cl_assert_equal_i(42, git_error_last()->klass);
- cl_assert_equal_s("Foo: bar", git_error_last()->message);
-}
-
-void test_errors__free_state(void)
-{
- git_error_state err_state = {0};
+ cl_assert(git_error_save(&last_error) == 0);
git_error_clear();
-
- git_error_set(42, "Foo: %s", "bar");
- cl_assert_equal_i(-1, git_error_state_capture(&err_state, -1));
+ cl_assert(git_error_last() != NULL);
+ cl_assert(git_error_last()->klass == GIT_ERROR_NONE);
+ cl_assert(strcmp("no error", git_error_last()->message) == 0);
git_error_set(99, "Bar: %s", "foo");
- git_error_state_free(&err_state);
-
- cl_assert_equal_i(99, git_error_last()->klass);
- cl_assert_equal_s("Bar: foo", git_error_last()->message);
+ git_error_restore(last_error);
- git_error_state_restore(&err_state);
-
- cl_assert(git_error_last() == NULL);
+ cl_assert(git_error_last()->klass == 42);
+ cl_assert(strcmp("Foo: bar", git_error_last()->message) == 0);
}
void test_errors__restore_oom(void)
{
- git_error_state err_state = {0};
+ git_error *last_error;
const git_error *oom_error = NULL;
git_error_clear();
@@ -141,15 +130,18 @@ void test_errors__restore_oom(void)
git_error_set_oom(); /* internal fn */
oom_error = git_error_last();
cl_assert(oom_error);
+ cl_assert(oom_error->klass == GIT_ERROR_NOMEMORY);
- cl_assert_equal_i(-1, git_error_state_capture(&err_state, -1));
-
- cl_assert(git_error_last() == NULL);
- cl_assert_equal_i(GIT_ERROR_NOMEMORY, err_state.error_msg.klass);
- cl_assert_equal_s("Out of memory", err_state.error_msg.message);
+ cl_assert(git_error_save(&last_error) == 0);
+ cl_assert(last_error->klass == GIT_ERROR_NOMEMORY);
+ cl_assert(strcmp("Out of memory", last_error->message) == 0);
- git_error_state_restore(&err_state);
+ git_error_clear();
+ cl_assert(git_error_last() != NULL);
+ cl_assert(git_error_last()->klass == GIT_ERROR_NONE);
+ cl_assert(strcmp("no error", git_error_last()->message) == 0);
+ git_error_restore(last_error);
cl_assert(git_error_last()->klass == GIT_ERROR_NOMEMORY);
cl_assert_(git_error_last() == oom_error, "static oom error not restored");
@@ -204,11 +196,15 @@ void test_errors__integer_overflow_sets_oom(void)
git_error_clear();
cl_assert(!GIT_ADD_SIZET_OVERFLOW(&out, SIZE_MAX-1, 1));
- cl_assert_equal_p(NULL, git_error_last());
+ cl_assert(git_error_last() != NULL);
+ cl_assert(git_error_last()->klass == GIT_ERROR_NONE);
+ cl_assert(strcmp(git_error_last()->message, "no error") == 0);
git_error_clear();
cl_assert(!GIT_ADD_SIZET_OVERFLOW(&out, 42, 69));
- cl_assert_equal_p(NULL, git_error_last());
+ cl_assert(git_error_last() != NULL);
+ cl_assert(git_error_last()->klass == GIT_ERROR_NONE);
+ cl_assert(strcmp(git_error_last()->message, "no error") == 0);
git_error_clear();
cl_assert(GIT_ADD_SIZET_OVERFLOW(&out, SIZE_MAX, SIZE_MAX));
diff --git a/tests/util/hashmap.c b/tests/util/hashmap.c
new file mode 100644
index 00000000000..1bd072084b2
--- /dev/null
+++ b/tests/util/hashmap.c
@@ -0,0 +1,227 @@
+#include "clar_libgit2.h"
+#include "hashmap.h"
+#include "hashmap_str.h"
+
+GIT_HASHMAP_STR_SETUP(git_hashmap_test, char *);
+
+static git_hashmap_test g_table;
+
+void test_hashmap__initialize(void)
+{
+ memset(&g_table, 0x0, sizeof(git_hashmap_test));
+}
+
+void test_hashmap__cleanup(void)
+{
+ git_hashmap_test_dispose(&g_table);
+}
+
+void test_hashmap__0(void)
+{
+ cl_assert(git_hashmap_test_size(&g_table) == 0);
+}
+
+static void insert_strings(git_hashmap_test *table, size_t count)
+{
+ size_t i, j, over;
+ char *str;
+
+ for (i = 0; i < count; ++i) {
+ str = git__malloc(10);
+ for (j = 0; j < 10; ++j)
+ str[j] = 'a' + (i % 26);
+ str[9] = '\0';
+
+ /* if > 26, then encode larger value in first letters */
+ for (j = 0, over = i / 26; over > 0; j++, over = over / 26)
+ str[j] = 'A' + (over % 26);
+
+ cl_git_pass(git_hashmap_test_put(table, str, str));
+ }
+
+ cl_assert_equal_i(git_hashmap_test_size(table), count);
+}
+
+void test_hashmap__inserted_strings_can_be_retrieved(void)
+{
+ char *str;
+ git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
+ size_t idx = 0;
+
+ insert_strings(&g_table, 20);
+
+ cl_assert(git_hashmap_test_contains(&g_table, "aaaaaaaaa"));
+ cl_assert(git_hashmap_test_contains(&g_table, "ggggggggg"));
+ cl_assert(!git_hashmap_test_contains(&g_table, "aaaaaaaab"));
+ cl_assert(!git_hashmap_test_contains(&g_table, "abcdefghi"));
+
+ while (git_hashmap_test_iterate(&iter, NULL, &str, &g_table) == 0) {
+ idx++;
+ git__free(str);
+ }
+
+ cl_assert_equal_sz(20, idx);
+}
+
+void test_hashmap__deleted_entry_cannot_be_retrieved(void)
+{
+ const char *key;
+ char *str;
+ git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
+ size_t idx = 0;
+
+ insert_strings(&g_table, 20);
+
+ cl_assert(git_hashmap_test_contains(&g_table, "bbbbbbbbb"));
+ cl_git_pass(git_hashmap_test_get(&str, &g_table, "bbbbbbbbb"));
+ cl_assert_equal_s(str, "bbbbbbbbb");
+ cl_git_pass(git_hashmap_test_remove(&g_table, "bbbbbbbbb"));
+ git__free(str);
+
+ cl_assert(!git_hashmap_test_contains(&g_table, "bbbbbbbbb"));
+
+ while (git_hashmap_test_iterate(&iter, &key, &str, &g_table) == 0) {
+ idx++;
+ git__free(str);
+ }
+
+ cl_assert_equal_sz(idx, 19);
+}
+
+void test_hashmap__inserting_many_keys_succeeds(void)
+{
+ char *str;
+ git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
+ size_t idx = 0;
+
+ insert_strings(&g_table, 10000);
+
+ while (git_hashmap_test_iterate(&iter, NULL, &str, &g_table) == 0) {
+ idx++;
+ git__free(str);
+ }
+
+ cl_assert_equal_sz(idx, 10000);
+}
+
+void test_hashmap__get_succeeds_with_existing_entries(void)
+{
+ const char *keys[] = { "foo", "bar", "gobble" };
+ char *values[] = { "oof", "rab", "elbbog" };
+ char *str;
+ uint32_t i;
+
+ for (i = 0; i < ARRAY_SIZE(keys); i++)
+ cl_git_pass(git_hashmap_test_put(&g_table, keys[i], values[i]));
+
+ cl_git_pass(git_hashmap_test_get(&str, &g_table, "foo"));
+ cl_assert_equal_s(str, "oof");
+
+ cl_git_pass(git_hashmap_test_get(&str, &g_table, "bar"));
+ cl_assert_equal_s(str, "rab");
+
+ cl_git_pass(git_hashmap_test_get(&str, &g_table, "gobble"));
+ cl_assert_equal_s(str, "elbbog");
+}
+
+void test_hashmap__get_returns_notfound_on_nonexisting_key(void)
+{
+ const char *keys[] = { "foo", "bar", "gobble" };
+ char *values[] = { "oof", "rab", "elbbog" };
+ char *str;
+ uint32_t i;
+
+ for (i = 0; i < ARRAY_SIZE(keys); i++)
+ cl_git_pass(git_hashmap_test_put(&g_table, keys[i], values[i]));
+
+ cl_git_fail_with(GIT_ENOTFOUND, git_hashmap_test_get(&str, &g_table, "other"));
+}
+
+void test_hashmap__put_persists_key(void)
+{
+ char *str;
+
+ cl_git_pass(git_hashmap_test_put(&g_table, "foo", "oof"));
+
+ cl_git_pass(git_hashmap_test_get(&str, &g_table, "foo"));
+ cl_assert_equal_s(str, "oof");
+}
+
+void test_hashmap__put_persists_multpile_keys(void)
+{
+ char *str;
+
+ cl_git_pass(git_hashmap_test_put(&g_table, "foo", "oof"));
+ cl_git_pass(git_hashmap_test_put(&g_table, "bar", "rab"));
+
+ cl_git_pass(git_hashmap_test_get(&str, &g_table, "foo"));
+ cl_assert_equal_s(str, "oof");
+
+ cl_git_pass(git_hashmap_test_get(&str, &g_table, "bar"));
+ cl_assert_equal_s(str, "rab");
+}
+
+void test_hashmap__put_updates_existing_key(void)
+{
+ char *str;
+
+ cl_git_pass(git_hashmap_test_put(&g_table, "foo", "oof"));
+ cl_git_pass(git_hashmap_test_put(&g_table, "bar", "rab"));
+ cl_git_pass(git_hashmap_test_put(&g_table, "gobble", "elbbog"));
+ cl_assert_equal_i(3, git_hashmap_test_size(&g_table));
+
+ cl_git_pass(git_hashmap_test_put(&g_table, "foo", "other"));
+ cl_assert_equal_i(git_hashmap_test_size(&g_table), 3);
+
+ cl_git_pass(git_hashmap_test_get(&str, &g_table, "foo"));
+ cl_assert_equal_s(str, "other");
+}
+
+void test_hashmap__iteration(void)
+{
+ struct {
+ char *key;
+ char *value;
+ int seen;
+ } entries[] = {
+ { "foo", "oof" },
+ { "bar", "rab" },
+ { "gobble", "elbbog" },
+ };
+ const char *key;
+ char *value;
+ uint32_t i, n;
+ git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
+
+ for (i = 0; i < ARRAY_SIZE(entries); i++)
+ cl_git_pass(git_hashmap_test_put(&g_table, entries[i].key, entries[i].value));
+
+ i = 0, n = 0;
+ while (git_hashmap_test_iterate(&iter, &key, &value, &g_table) == 0) {
+ size_t j;
+
+ for (j = 0; j < ARRAY_SIZE(entries); j++) {
+ if (strcmp(entries[j].key, key))
+ continue;
+
+ cl_assert_equal_i(entries[j].seen, 0);
+ cl_assert_equal_s(entries[j].value, value);
+ entries[j].seen++;
+ break;
+ }
+
+ n++;
+ }
+
+ for (i = 0; i < ARRAY_SIZE(entries); i++)
+ cl_assert_equal_i(entries[i].seen, 1);
+
+ cl_assert_equal_i(n, ARRAY_SIZE(entries));
+}
+
+void test_hashmap__iterating_empty_map_stops_immediately(void)
+{
+ git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
+
+ cl_git_fail_with(GIT_ITEROVER, git_hashmap_test_iterate(&iter, NULL, NULL, &g_table));
+}
diff --git a/tests/util/hostname.c b/tests/util/hostname.c
new file mode 100644
index 00000000000..5d8bfe2ac99
--- /dev/null
+++ b/tests/util/hostname.c
@@ -0,0 +1,13 @@
+#include "clar_libgit2.h"
+#include "net.h"
+
+void test_hostname__matches_cert(void)
+{
+ cl_assert_equal_b(true, git_net_hostname_matches_cert("www.example.org", "*.example.org"));
+ cl_assert_equal_b(true, git_net_hostname_matches_cert("www.foo.example.org", "*.foo.example.org"));
+ cl_assert_equal_b(false, git_net_hostname_matches_cert("foo.example.org", "*.foo.example.org"));
+ cl_assert_equal_b(false, git_net_hostname_matches_cert("www.example.org", "*.foo.example.org"));
+ cl_assert_equal_b(false, git_net_hostname_matches_cert("example.org", "*.example.org"));
+ cl_assert_equal_b(false, git_net_hostname_matches_cert("www.foo.example.org", "*.example.org"));
+ cl_assert_equal_b(false, git_net_hostname_matches_cert("blah.www.www.example.org", "*.example.org"));
+}
diff --git a/tests/util/iconv.c b/tests/util/iconv.c
index e14aebb9908..4eb2aa5bb4a 100644
--- a/tests/util/iconv.c
+++ b/tests/util/iconv.c
@@ -1,7 +1,7 @@
#include "clar_libgit2.h"
#include "fs_path.h"
-#ifdef GIT_USE_ICONV
+#ifdef GIT_I18N_ICONV
static git_fs_path_iconv_t ic;
static char *nfc = "\xC3\x85\x73\x74\x72\xC3\xB6\x6D";
static char *nfd = "\x41\xCC\x8A\x73\x74\x72\x6F\xCC\x88\x6D";
@@ -9,21 +9,21 @@ static char *nfd = "\x41\xCC\x8A\x73\x74\x72\x6F\xCC\x88\x6D";
void test_iconv__initialize(void)
{
-#ifdef GIT_USE_ICONV
+#ifdef GIT_I18N_ICONV
cl_git_pass(git_fs_path_iconv_init_precompose(&ic));
#endif
}
void test_iconv__cleanup(void)
{
-#ifdef GIT_USE_ICONV
+#ifdef GIT_I18N_ICONV
git_fs_path_iconv_clear(&ic);
#endif
}
void test_iconv__unchanged(void)
{
-#ifdef GIT_USE_ICONV
+#ifdef GIT_I18N_ICONV
const char *data = "Ascii data", *original = data;
size_t datalen = strlen(data);
@@ -37,7 +37,7 @@ void test_iconv__unchanged(void)
void test_iconv__decomposed_to_precomposed(void)
{
-#ifdef GIT_USE_ICONV
+#ifdef GIT_I18N_ICONV
const char *data = nfd;
size_t datalen, nfdlen = strlen(nfd);
@@ -63,7 +63,7 @@ void test_iconv__decomposed_to_precomposed(void)
void test_iconv__precomposed_is_unmodified(void)
{
-#ifdef GIT_USE_ICONV
+#ifdef GIT_I18N_ICONV
const char *data = nfc;
size_t datalen = strlen(nfc);
diff --git a/tests/util/link.c b/tests/util/link.c
index 46cafada7e9..5909e26e391 100644
--- a/tests/util/link.c
+++ b/tests/util/link.c
@@ -98,7 +98,7 @@ static void do_junction(const char *old, const char *new)
git_str_putc(&unparsed_buf, '\\');
- subst_utf16_len = git__utf8_to_16(NULL, 0, git_str_cstr(&unparsed_buf));
+ subst_utf16_len = git_utf8_to_16(NULL, 0, git_str_cstr(&unparsed_buf));
subst_byte_len = subst_utf16_len * sizeof(WCHAR);
print_utf16_len = subst_utf16_len - 4;
@@ -124,11 +124,11 @@ static void do_junction(const char *old, const char *new)
subst_utf16 = reparse_buf->ReparseBuffer.MountPoint.PathBuffer;
print_utf16 = subst_utf16 + subst_utf16_len + 1;
- ret = git__utf8_to_16(subst_utf16, subst_utf16_len + 1,
+ ret = git_utf8_to_16(subst_utf16, subst_utf16_len + 1,
git_str_cstr(&unparsed_buf));
cl_assert_equal_i(subst_utf16_len, ret);
- ret = git__utf8_to_16(print_utf16,
+ ret = git_utf8_to_16(print_utf16,
print_utf16_len + 1, git_str_cstr(&unparsed_buf) + 4);
cl_assert_equal_i(print_utf16_len, ret);
diff --git a/tests/util/path.c b/tests/util/path.c
deleted file mode 100644
index 2c39e088700..00000000000
--- a/tests/util/path.c
+++ /dev/null
@@ -1,764 +0,0 @@
-#include "clar_libgit2.h"
-#include "futils.h"
-#include "fs_path.h"
-
-static char *path_save;
-
-void test_path__initialize(void)
-{
- path_save = cl_getenv("PATH");
-}
-
-void test_path__cleanup(void)
-{
- cl_setenv("PATH", path_save);
- git__free(path_save);
- path_save = NULL;
-}
-
-static void
-check_dirname(const char *A, const char *B)
-{
- git_str dir = GIT_STR_INIT;
- char *dir2;
-
- cl_assert(git_fs_path_dirname_r(&dir, A) >= 0);
- cl_assert_equal_s(B, dir.ptr);
- git_str_dispose(&dir);
-
- cl_assert((dir2 = git_fs_path_dirname(A)) != NULL);
- cl_assert_equal_s(B, dir2);
- git__free(dir2);
-}
-
-static void
-check_basename(const char *A, const char *B)
-{
- git_str base = GIT_STR_INIT;
- char *base2;
-
- cl_assert(git_fs_path_basename_r(&base, A) >= 0);
- cl_assert_equal_s(B, base.ptr);
- git_str_dispose(&base);
-
- cl_assert((base2 = git_fs_path_basename(A)) != NULL);
- cl_assert_equal_s(B, base2);
- git__free(base2);
-}
-
-static void
-check_joinpath(const char *path_a, const char *path_b, const char *expected_path)
-{
- git_str joined_path = GIT_STR_INIT;
-
- cl_git_pass(git_str_joinpath(&joined_path, path_a, path_b));
- cl_assert_equal_s(expected_path, joined_path.ptr);
-
- git_str_dispose(&joined_path);
-}
-
-static void
-check_joinpath_n(
- const char *path_a,
- const char *path_b,
- const char *path_c,
- const char *path_d,
- const char *expected_path)
-{
- git_str joined_path = GIT_STR_INIT;
-
- cl_git_pass(git_str_join_n(&joined_path, '/', 4,
- path_a, path_b, path_c, path_d));
- cl_assert_equal_s(expected_path, joined_path.ptr);
-
- git_str_dispose(&joined_path);
-}
-
-static void check_setenv(const char* name, const char* value)
-{
- char* check;
-
- cl_git_pass(cl_setenv(name, value));
- check = cl_getenv(name);
-
- if (value)
- cl_assert_equal_s(value, check);
- else
- cl_assert(check == NULL);
-
- git__free(check);
-}
-
-/* get the dirname of a path */
-void test_path__00_dirname(void)
-{
- check_dirname(NULL, ".");
- check_dirname("", ".");
- check_dirname("a", ".");
- check_dirname("/", "/");
- check_dirname("/usr", "/");
- check_dirname("/usr/", "/");
- check_dirname("/usr/lib", "/usr");
- check_dirname("/usr/lib/", "/usr");
- check_dirname("/usr/lib//", "/usr");
- check_dirname("usr/lib", "usr");
- check_dirname("usr/lib/", "usr");
- check_dirname("usr/lib//", "usr");
- check_dirname(".git/", ".");
-
- check_dirname(REP16("/abc"), REP15("/abc"));
-
-#ifdef GIT_WIN32
- check_dirname("C:/", "C:/");
- check_dirname("C:", "C:/");
- check_dirname("C:/path/", "C:/");
- check_dirname("C:/path", "C:/");
- check_dirname("//computername/", "//computername/");
- check_dirname("//computername", "//computername/");
- check_dirname("//computername/path/", "//computername/");
- check_dirname("//computername/path", "//computername/");
- check_dirname("//computername/sub/path/", "//computername/sub");
- check_dirname("//computername/sub/path", "//computername/sub");
-#endif
-}
-
-/* get the base name of a path */
-void test_path__01_basename(void)
-{
- check_basename(NULL, ".");
- check_basename("", ".");
- check_basename("a", "a");
- check_basename("/", "/");
- check_basename("/usr", "usr");
- check_basename("/usr/", "usr");
- check_basename("/usr/lib", "lib");
- check_basename("/usr/lib//", "lib");
- check_basename("usr/lib", "lib");
-
- check_basename(REP16("/abc"), "abc");
- check_basename(REP1024("/abc"), "abc");
-}
-
-/* properly join path components */
-void test_path__05_joins(void)
-{
- check_joinpath("", "", "");
- check_joinpath("", "a", "a");
- check_joinpath("", "/a", "/a");
- check_joinpath("a", "", "a/");
- check_joinpath("a", "/", "a/");
- check_joinpath("a", "b", "a/b");
- check_joinpath("/", "a", "/a");
- check_joinpath("/", "", "/");
- check_joinpath("/a", "/b", "/a/b");
- check_joinpath("/a", "/b/", "/a/b/");
- check_joinpath("/a/", "b/", "/a/b/");
- check_joinpath("/a/", "/b/", "/a/b/");
-
- check_joinpath("/abcd", "/defg", "/abcd/defg");
- check_joinpath("/abcd", "/defg/", "/abcd/defg/");
- check_joinpath("/abcd/", "defg/", "/abcd/defg/");
- check_joinpath("/abcd/", "/defg/", "/abcd/defg/");
-
- check_joinpath("/abcdefgh", "/12345678", "/abcdefgh/12345678");
- check_joinpath("/abcdefgh", "/12345678/", "/abcdefgh/12345678/");
- check_joinpath("/abcdefgh/", "12345678/", "/abcdefgh/12345678/");
-
- check_joinpath(REP1024("aaaa"), "", REP1024("aaaa") "/");
- check_joinpath(REP1024("aaaa/"), "", REP1024("aaaa/"));
- check_joinpath(REP1024("/aaaa"), "", REP1024("/aaaa") "/");
-
- check_joinpath(REP1024("aaaa"), REP1024("bbbb"),
- REP1024("aaaa") "/" REP1024("bbbb"));
- check_joinpath(REP1024("/aaaa"), REP1024("/bbbb"),
- REP1024("/aaaa") REP1024("/bbbb"));
-}
-
-/* properly join path components for more than one path */
-void test_path__06_long_joins(void)
-{
- check_joinpath_n("", "", "", "", "");
- check_joinpath_n("", "a", "", "", "a/");
- check_joinpath_n("a", "", "", "", "a/");
- check_joinpath_n("", "", "", "a", "a");
- check_joinpath_n("a", "b", "", "/c/d/", "a/b/c/d/");
- check_joinpath_n("a", "b", "", "/c/d", "a/b/c/d");
- check_joinpath_n("abcd", "efgh", "ijkl", "mnop", "abcd/efgh/ijkl/mnop");
- check_joinpath_n("abcd/", "efgh/", "ijkl/", "mnop/", "abcd/efgh/ijkl/mnop/");
- check_joinpath_n("/abcd/", "/efgh/", "/ijkl/", "/mnop/", "/abcd/efgh/ijkl/mnop/");
-
- check_joinpath_n(REP1024("a"), REP1024("b"), REP1024("c"), REP1024("d"),
- REP1024("a") "/" REP1024("b") "/"
- REP1024("c") "/" REP1024("d"));
- check_joinpath_n(REP1024("/a"), REP1024("/b"), REP1024("/c"), REP1024("/d"),
- REP1024("/a") REP1024("/b")
- REP1024("/c") REP1024("/d"));
-}
-
-
-static void
-check_path_to_dir(
- const char* path,
- const char* expected)
-{
- git_str tgt = GIT_STR_INIT;
-
- git_str_sets(&tgt, path);
- cl_git_pass(git_fs_path_to_dir(&tgt));
- cl_assert_equal_s(expected, tgt.ptr);
-
- git_str_dispose(&tgt);
-}
-
-static void
-check_string_to_dir(
- const char* path,
- size_t maxlen,
- const char* expected)
-{
- size_t len = strlen(path);
- char *buf = git__malloc(len + 2);
- cl_assert(buf);
-
- strncpy(buf, path, len + 2);
-
- git_fs_path_string_to_dir(buf, maxlen);
-
- cl_assert_equal_s(expected, buf);
-
- git__free(buf);
-}
-
-/* convert paths to dirs */
-void test_path__07_path_to_dir(void)
-{
- check_path_to_dir("", "");
- check_path_to_dir(".", "./");
- check_path_to_dir("./", "./");
- check_path_to_dir("a/", "a/");
- check_path_to_dir("ab", "ab/");
- /* make sure we try just under and just over an expansion that will
- * require a realloc
- */
- check_path_to_dir("abcdef", "abcdef/");
- check_path_to_dir("abcdefg", "abcdefg/");
- check_path_to_dir("abcdefgh", "abcdefgh/");
- check_path_to_dir("abcdefghi", "abcdefghi/");
- check_path_to_dir(REP1024("abcd") "/", REP1024("abcd") "/");
- check_path_to_dir(REP1024("abcd"), REP1024("abcd") "/");
-
- check_string_to_dir("", 1, "");
- check_string_to_dir(".", 1, ".");
- check_string_to_dir(".", 2, "./");
- check_string_to_dir(".", 3, "./");
- check_string_to_dir("abcd", 3, "abcd");
- check_string_to_dir("abcd", 4, "abcd");
- check_string_to_dir("abcd", 5, "abcd/");
- check_string_to_dir("abcd", 6, "abcd/");
-}
-
-/* join path to itself */
-void test_path__08_self_join(void)
-{
- git_str path = GIT_STR_INIT;
- size_t asize = 0;
-
- asize = path.asize;
- cl_git_pass(git_str_sets(&path, "/foo"));
- cl_assert_equal_s(path.ptr, "/foo");
- cl_assert(asize < path.asize);
-
- asize = path.asize;
- cl_git_pass(git_str_joinpath(&path, path.ptr, "this is a new string"));
- cl_assert_equal_s(path.ptr, "/foo/this is a new string");
- cl_assert(asize < path.asize);
-
- asize = path.asize;
- cl_git_pass(git_str_joinpath(&path, path.ptr, "/grow the buffer, grow the buffer, grow the buffer"));
- cl_assert_equal_s(path.ptr, "/foo/this is a new string/grow the buffer, grow the buffer, grow the buffer");
- cl_assert(asize < path.asize);
-
- git_str_dispose(&path);
- cl_git_pass(git_str_sets(&path, "/foo/bar"));
-
- cl_git_pass(git_str_joinpath(&path, path.ptr + 4, "baz"));
- cl_assert_equal_s(path.ptr, "/bar/baz");
-
- asize = path.asize;
- cl_git_pass(git_str_joinpath(&path, path.ptr + 4, "somethinglongenoughtorealloc"));
- cl_assert_equal_s(path.ptr, "/baz/somethinglongenoughtorealloc");
- cl_assert(asize < path.asize);
-
- git_str_dispose(&path);
-}
-
-static void check_percent_decoding(const char *expected_result, const char *input)
-{
- git_str buf = GIT_STR_INIT;
-
- cl_git_pass(git__percent_decode(&buf, input));
- cl_assert_equal_s(expected_result, git_str_cstr(&buf));
-
- git_str_dispose(&buf);
-}
-
-void test_path__09_percent_decode(void)
-{
- check_percent_decoding("abcd", "abcd");
- check_percent_decoding("a2%", "a2%");
- check_percent_decoding("a2%3", "a2%3");
- check_percent_decoding("a2%%3", "a2%%3");
- check_percent_decoding("a2%3z", "a2%3z");
- check_percent_decoding("a,", "a%2c");
- check_percent_decoding("a21", "a2%31");
- check_percent_decoding("a2%1", "a2%%31");
- check_percent_decoding("a bc ", "a%20bc%20");
- check_percent_decoding("Vicent Mart" "\355", "Vicent%20Mart%ED");
-}
-
-static void check_fromurl(const char *expected_result, const char *input, int should_fail)
-{
- git_str buf = GIT_STR_INIT;
-
- assert(should_fail || expected_result);
-
- if (!should_fail) {
- cl_git_pass(git_fs_path_fromurl(&buf, input));
- cl_assert_equal_s(expected_result, git_str_cstr(&buf));
- } else
- cl_git_fail(git_fs_path_fromurl(&buf, input));
-
- git_str_dispose(&buf);
-}
-
-#ifdef GIT_WIN32
-#define ABS_PATH_MARKER ""
-#else
-#define ABS_PATH_MARKER "/"
-#endif
-
-void test_path__10_fromurl(void)
-{
- /* Failing cases */
- check_fromurl(NULL, "a", 1);
- check_fromurl(NULL, "http:///c:/Temp%20folder/note.txt", 1);
- check_fromurl(NULL, "file://c:/Temp%20folder/note.txt", 1);
- check_fromurl(NULL, "file:////c:/Temp%20folder/note.txt", 1);
- check_fromurl(NULL, "file:///", 1);
- check_fromurl(NULL, "file:////", 1);
- check_fromurl(NULL, "file://servername/c:/Temp%20folder/note.txt", 1);
-
- /* Passing cases */
- check_fromurl(ABS_PATH_MARKER "c:/Temp folder/note.txt", "file:///c:/Temp%20folder/note.txt", 0);
- check_fromurl(ABS_PATH_MARKER "c:/Temp folder/note.txt", "file://localhost/c:/Temp%20folder/note.txt", 0);
- check_fromurl(ABS_PATH_MARKER "c:/Temp+folder/note.txt", "file:///c:/Temp+folder/note.txt", 0);
- check_fromurl(ABS_PATH_MARKER "a", "file:///a", 0);
-}
-
-typedef struct {
- int expect_idx;
- int cancel_after;
- char **expect;
-} check_walkup_info;
-
-#define CANCEL_VALUE 1234
-
-static int check_one_walkup_step(void *ref, const char *path)
-{
- check_walkup_info *info = (check_walkup_info *)ref;
-
- if (!info->cancel_after) {
- cl_assert_equal_s(info->expect[info->expect_idx], "[CANCEL]");
- return CANCEL_VALUE;
- }
- info->cancel_after--;
-
- cl_assert(info->expect[info->expect_idx] != NULL);
- cl_assert_equal_s(info->expect[info->expect_idx], path);
- info->expect_idx++;
-
- return 0;
-}
-
-void test_path__11_walkup(void)
-{
- git_str p = GIT_STR_INIT;
-
- char *expect[] = {
- /* 1 */ "/a/b/c/d/e/", "/a/b/c/d/", "/a/b/c/", "/a/b/", "/a/", "/", NULL,
- /* 2 */ "/a/b/c/d/e", "/a/b/c/d/", "/a/b/c/", "/a/b/", "/a/", "/", NULL,
- /* 3 */ "/a/b/c/d/e", "/a/b/c/d/", "/a/b/c/", "/a/b/", "/a/", "/", NULL,
- /* 4 */ "/a/b/c/d/e", "/a/b/c/d/", "/a/b/c/", "/a/b/", "/a/", "/", NULL,
- /* 5 */ "/a/b/c/d/e", "/a/b/c/d/", "/a/b/c/", "/a/b/", NULL,
- /* 6 */ "/a/b/c/d/e", "/a/b/c/d/", "/a/b/c/", "/a/b/", NULL,
- /* 7 */ "this_is_a_path", "", NULL,
- /* 8 */ "this_is_a_path/", "", NULL,
- /* 9 */ "///a///b///c///d///e///", "///a///b///c///d///", "///a///b///c///", "///a///b///", "///a///", "///", NULL,
- /* 10 */ "a/b/c/", "a/b/", "a/", "", NULL,
- /* 11 */ "a/b/c", "a/b/", "a/", "", NULL,
- /* 12 */ "a/b/c/", "a/b/", "a/", NULL,
- /* 13 */ "", NULL,
- /* 14 */ "/", NULL,
- /* 15 */ NULL
- };
-
- char *root[] = {
- /* 1 */ NULL,
- /* 2 */ NULL,
- /* 3 */ "/",
- /* 4 */ "",
- /* 5 */ "/a/b",
- /* 6 */ "/a/b/",
- /* 7 */ NULL,
- /* 8 */ NULL,
- /* 9 */ NULL,
- /* 10 */ NULL,
- /* 11 */ NULL,
- /* 12 */ "a/",
- /* 13 */ NULL,
- /* 14 */ NULL,
- };
-
- int i, j;
- check_walkup_info info;
-
- info.expect = expect;
- info.cancel_after = -1;
-
- for (i = 0, j = 0; expect[i] != NULL; i++, j++) {
-
- git_str_sets(&p, expect[i]);
-
- info.expect_idx = i;
- cl_git_pass(
- git_fs_path_walk_up(&p, root[j], check_one_walkup_step, &info)
- );
-
- cl_assert_equal_s(p.ptr, expect[i]);
- cl_assert(expect[info.expect_idx] == NULL);
- i = info.expect_idx;
- }
-
- git_str_dispose(&p);
-}
-
-void test_path__11a_walkup_cancel(void)
-{
- git_str p = GIT_STR_INIT;
- int cancel[] = { 3, 2, 1, 0 };
- char *expect[] = {
- "/a/b/c/d/e/", "/a/b/c/d/", "/a/b/c/", "[CANCEL]", NULL,
- "/a/b/c/d/e", "/a/b/c/d/", "[CANCEL]", NULL,
- "/a/b/c/d/e", "[CANCEL]", NULL,
- "[CANCEL]", NULL,
- NULL
- };
- char *root[] = { NULL, NULL, "/", "", NULL };
- int i, j;
- check_walkup_info info;
-
- info.expect = expect;
-
- for (i = 0, j = 0; expect[i] != NULL; i++, j++) {
-
- git_str_sets(&p, expect[i]);
-
- info.cancel_after = cancel[j];
- info.expect_idx = i;
-
- cl_assert_equal_i(
- CANCEL_VALUE,
- git_fs_path_walk_up(&p, root[j], check_one_walkup_step, &info)
- );
-
- /* skip to next run of expectations */
- while (expect[i] != NULL) i++;
- }
-
- git_str_dispose(&p);
-}
-
-void test_path__12_offset_to_path_root(void)
-{
- cl_assert(git_fs_path_root("non/rooted/path") == -1);
- cl_assert(git_fs_path_root("/rooted/path") == 0);
-
-#ifdef GIT_WIN32
- /* Windows specific tests */
- cl_assert(git_fs_path_root("C:non/rooted/path") == -1);
- cl_assert(git_fs_path_root("C:/rooted/path") == 2);
- cl_assert(git_fs_path_root("//computername/sharefolder/resource") == 14);
- cl_assert(git_fs_path_root("//computername/sharefolder") == 14);
- cl_assert(git_fs_path_root("//computername") == -1);
-#endif
-}
-
-#define NON_EXISTING_FILEPATH "i_hope_i_do_not_exist"
-
-void test_path__13_cannot_prettify_a_non_existing_file(void)
-{
- git_str p = GIT_STR_INIT;
-
- cl_assert_equal_b(git_fs_path_exists(NON_EXISTING_FILEPATH), false);
- cl_assert_equal_i(GIT_ENOTFOUND, git_fs_path_prettify(&p, NON_EXISTING_FILEPATH, NULL));
- cl_assert_equal_i(GIT_ENOTFOUND, git_fs_path_prettify(&p, NON_EXISTING_FILEPATH "/so-do-i", NULL));
-
- git_str_dispose(&p);
-}
-
-void test_path__14_apply_relative(void)
-{
- git_str p = GIT_STR_INIT;
-
- cl_git_pass(git_str_sets(&p, "/this/is/a/base"));
-
- cl_git_pass(git_fs_path_apply_relative(&p, "../test"));
- cl_assert_equal_s("/this/is/a/test", p.ptr);
-
- cl_git_pass(git_fs_path_apply_relative(&p, "../../the/./end"));
- cl_assert_equal_s("/this/is/the/end", p.ptr);
-
- cl_git_pass(git_fs_path_apply_relative(&p, "./of/this/../the/string"));
- cl_assert_equal_s("/this/is/the/end/of/the/string", p.ptr);
-
- cl_git_pass(git_fs_path_apply_relative(&p, "../../../../../.."));
- cl_assert_equal_s("/this/", p.ptr);
-
- cl_git_pass(git_fs_path_apply_relative(&p, "../"));
- cl_assert_equal_s("/", p.ptr);
-
- cl_git_fail(git_fs_path_apply_relative(&p, "../../.."));
-
-
- cl_git_pass(git_str_sets(&p, "d:/another/test"));
-
- cl_git_pass(git_fs_path_apply_relative(&p, "../.."));
- cl_assert_equal_s("d:/", p.ptr);
-
- cl_git_pass(git_fs_path_apply_relative(&p, "from/here/to/../and/./back/."));
- cl_assert_equal_s("d:/from/here/and/back/", p.ptr);
-
-
- cl_git_pass(git_str_sets(&p, "https://my.url.com/test.git"));
-
- cl_git_pass(git_fs_path_apply_relative(&p, "../another.git"));
- cl_assert_equal_s("https://my.url.com/another.git", p.ptr);
-
- cl_git_pass(git_fs_path_apply_relative(&p, "../full/path/url.patch"));
- cl_assert_equal_s("https://my.url.com/full/path/url.patch", p.ptr);
-
- cl_git_pass(git_fs_path_apply_relative(&p, ".."));
- cl_assert_equal_s("https://my.url.com/full/path/", p.ptr);
-
- cl_git_pass(git_fs_path_apply_relative(&p, "../../../"));
- cl_assert_equal_s("https://", p.ptr);
-
-
- cl_git_pass(git_str_sets(&p, "../../this/is/relative"));
-
- cl_git_pass(git_fs_path_apply_relative(&p, "../../preserves/the/prefix"));
- cl_assert_equal_s("../../this/preserves/the/prefix", p.ptr);
-
- cl_git_pass(git_fs_path_apply_relative(&p, "../../../../that"));
- cl_assert_equal_s("../../that", p.ptr);
-
- cl_git_pass(git_fs_path_apply_relative(&p, "../there"));
- cl_assert_equal_s("../../there", p.ptr);
- git_str_dispose(&p);
-}
-
-static void assert_resolve_relative(
- git_str *buf, const char *expected, const char *path)
-{
- cl_git_pass(git_str_sets(buf, path));
- cl_git_pass(git_fs_path_resolve_relative(buf, 0));
- cl_assert_equal_s(expected, buf->ptr);
-}
-
-void test_path__15_resolve_relative(void)
-{
- git_str buf = GIT_STR_INIT;
-
- assert_resolve_relative(&buf, "", "");
- assert_resolve_relative(&buf, "", ".");
- assert_resolve_relative(&buf, "", "./");
- assert_resolve_relative(&buf, "..", "..");
- assert_resolve_relative(&buf, "../", "../");
- assert_resolve_relative(&buf, "..", "./..");
- assert_resolve_relative(&buf, "../", "./../");
- assert_resolve_relative(&buf, "../", "../.");
- assert_resolve_relative(&buf, "../", ".././");
- assert_resolve_relative(&buf, "../..", "../..");
- assert_resolve_relative(&buf, "../../", "../../");
-
- assert_resolve_relative(&buf, "/", "/");
- assert_resolve_relative(&buf, "/", "/.");
-
- assert_resolve_relative(&buf, "", "a/..");
- assert_resolve_relative(&buf, "", "a/../");
- assert_resolve_relative(&buf, "", "a/../.");
-
- assert_resolve_relative(&buf, "/a", "/a");
- assert_resolve_relative(&buf, "/a/", "/a/.");
- assert_resolve_relative(&buf, "/", "/a/../");
- assert_resolve_relative(&buf, "/", "/a/../.");
- assert_resolve_relative(&buf, "/", "/a/.././");
-
- assert_resolve_relative(&buf, "a", "a");
- assert_resolve_relative(&buf, "a/", "a/");
- assert_resolve_relative(&buf, "a/", "a/.");
- assert_resolve_relative(&buf, "a/", "a/./");
-
- assert_resolve_relative(&buf, "a/b", "a//b");
- assert_resolve_relative(&buf, "a/b/c", "a/b/c");
- assert_resolve_relative(&buf, "b/c", "./b/c");
- assert_resolve_relative(&buf, "a/c", "a/./c");
- assert_resolve_relative(&buf, "a/b/", "a/b/.");
-
- assert_resolve_relative(&buf, "/a/b/c", "///a/b/c");
- assert_resolve_relative(&buf, "/", "////");
- assert_resolve_relative(&buf, "/a", "///a");
- assert_resolve_relative(&buf, "/", "///.");
- assert_resolve_relative(&buf, "/", "///a/..");
-
- assert_resolve_relative(&buf, "../../path", "../../test//../././path");
- assert_resolve_relative(&buf, "../d", "a/b/../../../c/../d");
-
- cl_git_pass(git_str_sets(&buf, "/.."));
- cl_git_fail(git_fs_path_resolve_relative(&buf, 0));
-
- cl_git_pass(git_str_sets(&buf, "/./.."));
- cl_git_fail(git_fs_path_resolve_relative(&buf, 0));
-
- cl_git_pass(git_str_sets(&buf, "/.//.."));
- cl_git_fail(git_fs_path_resolve_relative(&buf, 0));
-
- cl_git_pass(git_str_sets(&buf, "/../."));
- cl_git_fail(git_fs_path_resolve_relative(&buf, 0));
-
- cl_git_pass(git_str_sets(&buf, "/../.././../a"));
- cl_git_fail(git_fs_path_resolve_relative(&buf, 0));
-
- cl_git_pass(git_str_sets(&buf, "////.."));
- cl_git_fail(git_fs_path_resolve_relative(&buf, 0));
-
- /* things that start with Windows network paths */
-#ifdef GIT_WIN32
- assert_resolve_relative(&buf, "//a/b/c", "//a/b/c");
- assert_resolve_relative(&buf, "//a/", "//a/b/..");
- assert_resolve_relative(&buf, "//a/b/c", "//a/Q/../b/x/y/../../c");
-
- cl_git_pass(git_str_sets(&buf, "//a/b/../.."));
- cl_git_fail(git_fs_path_resolve_relative(&buf, 0));
-#else
- assert_resolve_relative(&buf, "/a/b/c", "//a/b/c");
- assert_resolve_relative(&buf, "/a/", "//a/b/..");
- assert_resolve_relative(&buf, "/a/b/c", "//a/Q/../b/x/y/../../c");
- assert_resolve_relative(&buf, "/", "//a/b/../..");
-#endif
-
- git_str_dispose(&buf);
-}
-
-#define assert_common_dirlen(i, p, q) \
- cl_assert_equal_i((i), git_fs_path_common_dirlen((p), (q)));
-
-void test_path__16_resolve_relative(void)
-{
- assert_common_dirlen(0, "", "");
- assert_common_dirlen(0, "", "bar.txt");
- assert_common_dirlen(0, "foo.txt", "bar.txt");
- assert_common_dirlen(0, "foo.txt", "");
- assert_common_dirlen(0, "foo/bar.txt", "bar/foo.txt");
- assert_common_dirlen(0, "foo/bar.txt", "../foo.txt");
-
- assert_common_dirlen(1, "/one.txt", "/two.txt");
- assert_common_dirlen(4, "foo/one.txt", "foo/two.txt");
- assert_common_dirlen(5, "/foo/one.txt", "/foo/two.txt");
-
- assert_common_dirlen(6, "a/b/c/foo.txt", "a/b/c/d/e/bar.txt");
- assert_common_dirlen(7, "/a/b/c/foo.txt", "/a/b/c/d/e/bar.txt");
-}
-
-static void fix_path(git_str *s)
-{
-#ifndef GIT_WIN32
- GIT_UNUSED(s);
-#else
- char* c;
-
- for (c = s->ptr; *c; c++) {
- if (*c == '/')
- *c = '\\';
- }
-#endif
-}
-
-void test_path__find_exe_in_path(void)
-{
- char *orig_path;
- git_str sandbox_path = GIT_STR_INIT;
- git_str new_path = GIT_STR_INIT, full_path = GIT_STR_INIT,
- dummy_path = GIT_STR_INIT;
-
-#ifdef GIT_WIN32
- static const char *bogus_path_1 = "c:\\does\\not\\exist\\";
- static const char *bogus_path_2 = "e:\\non\\existent";
-#else
- static const char *bogus_path_1 = "/this/path/does/not/exist/";
- static const char *bogus_path_2 = "/non/existent";
-#endif
-
- orig_path = cl_getenv("PATH");
-
- git_str_puts(&sandbox_path, clar_sandbox_path());
- git_str_joinpath(&dummy_path, sandbox_path.ptr, "dummmmmmmy_libgit2_file");
- cl_git_rewritefile(dummy_path.ptr, "this is a dummy file");
-
- fix_path(&sandbox_path);
- fix_path(&dummy_path);
-
- cl_git_pass(git_str_printf(&new_path, "%s%c%s%c%s%c%s",
- bogus_path_1, GIT_PATH_LIST_SEPARATOR,
- orig_path, GIT_PATH_LIST_SEPARATOR,
- sandbox_path.ptr, GIT_PATH_LIST_SEPARATOR,
- bogus_path_2));
-
- check_setenv("PATH", new_path.ptr);
-
- cl_git_fail_with(GIT_ENOTFOUND, git_fs_path_find_executable(&full_path, "this_file_does_not_exist"));
- cl_git_pass(git_fs_path_find_executable(&full_path, "dummmmmmmy_libgit2_file"));
-
- cl_assert_equal_s(full_path.ptr, dummy_path.ptr);
-
- git_str_dispose(&full_path);
- git_str_dispose(&new_path);
- git_str_dispose(&dummy_path);
- git_str_dispose(&sandbox_path);
- git__free(orig_path);
-}
-
-void test_path__validate_current_user_ownership(void)
-{
- bool is_cur;
-
- cl_must_pass(p_mkdir("testdir", 0777));
- cl_git_pass(git_fs_path_owner_is_current_user(&is_cur, "testdir"));
- cl_assert_equal_i(is_cur, 1);
-
- cl_git_rewritefile("testfile", "This is a test file.");
- cl_git_pass(git_fs_path_owner_is_current_user(&is_cur, "testfile"));
- cl_assert_equal_i(is_cur, 1);
-
-#ifdef GIT_WIN32
- cl_git_pass(git_fs_path_owner_is_current_user(&is_cur, "C:\\"));
- cl_assert_equal_i(is_cur, 0);
-
- cl_git_fail(git_fs_path_owner_is_current_user(&is_cur, "c:\\path\\does\\not\\exist"));
-#else
- cl_git_pass(git_fs_path_owner_is_current_user(&is_cur, "/"));
- cl_assert_equal_i(is_cur, 0);
-
- cl_git_fail(git_fs_path_owner_is_current_user(&is_cur, "/path/does/not/exist"));
-#endif
-}
diff --git a/tests/util/path/core.c b/tests/util/path/core.c
index f30f6c01b0d..d1935a816a9 100644
--- a/tests/util/path/core.c
+++ b/tests/util/path/core.c
@@ -1,6 +1,784 @@
#include "clar_libgit2.h"
+#include "futils.h"
#include "fs_path.h"
+#ifndef GIT_WIN32
+# include <unistd.h>
+#endif
+
+static char *path_save;
+
+void test_path_core__initialize(void)
+{
+ path_save = cl_getenv("PATH");
+}
+
+void test_path_core__cleanup(void)
+{
+ cl_setenv("PATH", path_save);
+ git__free(path_save);
+ path_save = NULL;
+}
+
+static void
+check_dirname(const char *A, const char *B)
+{
+ git_str dir = GIT_STR_INIT;
+ char *dir2;
+
+ cl_assert(git_fs_path_dirname_r(&dir, A) >= 0);
+ cl_assert_equal_s(B, dir.ptr);
+ git_str_dispose(&dir);
+
+ cl_assert((dir2 = git_fs_path_dirname(A)) != NULL);
+ cl_assert_equal_s(B, dir2);
+ git__free(dir2);
+}
+
+static void
+check_basename(const char *A, const char *B)
+{
+ git_str base = GIT_STR_INIT;
+ char *base2;
+
+ cl_assert(git_fs_path_basename_r(&base, A) >= 0);
+ cl_assert_equal_s(B, base.ptr);
+ git_str_dispose(&base);
+
+ cl_assert((base2 = git_fs_path_basename(A)) != NULL);
+ cl_assert_equal_s(B, base2);
+ git__free(base2);
+}
+
+static void
+check_joinpath(const char *path_a, const char *path_b, const char *expected_path)
+{
+ git_str joined_path = GIT_STR_INIT;
+
+ cl_git_pass(git_str_joinpath(&joined_path, path_a, path_b));
+ cl_assert_equal_s(expected_path, joined_path.ptr);
+
+ git_str_dispose(&joined_path);
+}
+
+static void
+check_joinpath_n(
+ const char *path_a,
+ const char *path_b,
+ const char *path_c,
+ const char *path_d,
+ const char *expected_path)
+{
+ git_str joined_path = GIT_STR_INIT;
+
+ cl_git_pass(git_str_join_n(&joined_path, '/', 4,
+ path_a, path_b, path_c, path_d));
+ cl_assert_equal_s(expected_path, joined_path.ptr);
+
+ git_str_dispose(&joined_path);
+}
+
+static void check_setenv(const char* name, const char* value)
+{
+ char* check;
+
+ cl_git_pass(cl_setenv(name, value));
+ check = cl_getenv(name);
+
+ if (value)
+ cl_assert_equal_s(value, check);
+ else
+ cl_assert(check == NULL);
+
+ git__free(check);
+}
+
+/* get the dirname of a path */
+void test_path_core__00_dirname(void)
+{
+ check_dirname(NULL, ".");
+ check_dirname("", ".");
+ check_dirname("a", ".");
+ check_dirname("/", "/");
+ check_dirname("/usr", "/");
+ check_dirname("/usr/", "/");
+ check_dirname("/usr/lib", "/usr");
+ check_dirname("/usr/lib/", "/usr");
+ check_dirname("/usr/lib//", "/usr");
+ check_dirname("usr/lib", "usr");
+ check_dirname("usr/lib/", "usr");
+ check_dirname("usr/lib//", "usr");
+ check_dirname(".git/", ".");
+
+ check_dirname(REP16("/abc"), REP15("/abc"));
+
+#ifdef GIT_WIN32
+ check_dirname("C:/", "C:/");
+ check_dirname("C:", "C:/");
+ check_dirname("C:/path/", "C:/");
+ check_dirname("C:/path", "C:/");
+ check_dirname("//computername/", "//computername/");
+ check_dirname("//computername", "//computername/");
+ check_dirname("//computername/path/", "//computername/");
+ check_dirname("//computername/path", "//computername/");
+ check_dirname("//computername/sub/path/", "//computername/sub");
+ check_dirname("//computername/sub/path", "//computername/sub");
+#endif
+}
+
+/* get the base name of a path */
+void test_path_core__01_basename(void)
+{
+ check_basename(NULL, ".");
+ check_basename("", ".");
+ check_basename("a", "a");
+ check_basename("/", "/");
+ check_basename("/usr", "usr");
+ check_basename("/usr/", "usr");
+ check_basename("/usr/lib", "lib");
+ check_basename("/usr/lib//", "lib");
+ check_basename("usr/lib", "lib");
+
+ check_basename(REP16("/abc"), "abc");
+ check_basename(REP1024("/abc"), "abc");
+}
+
+/* properly join path components */
+void test_path_core__05_joins(void)
+{
+ check_joinpath("", "", "");
+ check_joinpath("", "a", "a");
+ check_joinpath("", "/a", "/a");
+ check_joinpath("a", "", "a/");
+ check_joinpath("a", "/", "a/");
+ check_joinpath("a", "b", "a/b");
+ check_joinpath("/", "a", "/a");
+ check_joinpath("/", "", "/");
+ check_joinpath("/a", "/b", "/a/b");
+ check_joinpath("/a", "/b/", "/a/b/");
+ check_joinpath("/a/", "b/", "/a/b/");
+ check_joinpath("/a/", "/b/", "/a/b/");
+
+ check_joinpath("/abcd", "/defg", "/abcd/defg");
+ check_joinpath("/abcd", "/defg/", "/abcd/defg/");
+ check_joinpath("/abcd/", "defg/", "/abcd/defg/");
+ check_joinpath("/abcd/", "/defg/", "/abcd/defg/");
+
+ check_joinpath("/abcdefgh", "/12345678", "/abcdefgh/12345678");
+ check_joinpath("/abcdefgh", "/12345678/", "/abcdefgh/12345678/");
+ check_joinpath("/abcdefgh/", "12345678/", "/abcdefgh/12345678/");
+
+ check_joinpath(REP1024("aaaa"), "", REP1024("aaaa") "/");
+ check_joinpath(REP1024("aaaa/"), "", REP1024("aaaa/"));
+ check_joinpath(REP1024("/aaaa"), "", REP1024("/aaaa") "/");
+
+ check_joinpath(REP1024("aaaa"), REP1024("bbbb"),
+ REP1024("aaaa") "/" REP1024("bbbb"));
+ check_joinpath(REP1024("/aaaa"), REP1024("/bbbb"),
+ REP1024("/aaaa") REP1024("/bbbb"));
+}
+
+/* properly join path components for more than one path */
+void test_path_core__06_long_joins(void)
+{
+ check_joinpath_n("", "", "", "", "");
+ check_joinpath_n("", "a", "", "", "a/");
+ check_joinpath_n("a", "", "", "", "a/");
+ check_joinpath_n("", "", "", "a", "a");
+ check_joinpath_n("a", "b", "", "/c/d/", "a/b/c/d/");
+ check_joinpath_n("a", "b", "", "/c/d", "a/b/c/d");
+ check_joinpath_n("abcd", "efgh", "ijkl", "mnop", "abcd/efgh/ijkl/mnop");
+ check_joinpath_n("abcd/", "efgh/", "ijkl/", "mnop/", "abcd/efgh/ijkl/mnop/");
+ check_joinpath_n("/abcd/", "/efgh/", "/ijkl/", "/mnop/", "/abcd/efgh/ijkl/mnop/");
+
+ check_joinpath_n(REP1024("a"), REP1024("b"), REP1024("c"), REP1024("d"),
+ REP1024("a") "/" REP1024("b") "/"
+ REP1024("c") "/" REP1024("d"));
+ check_joinpath_n(REP1024("/a"), REP1024("/b"), REP1024("/c"), REP1024("/d"),
+ REP1024("/a") REP1024("/b")
+ REP1024("/c") REP1024("/d"));
+}
+
+
+static void
+check_path_to_dir(
+ const char* path,
+ const char* expected)
+{
+ git_str tgt = GIT_STR_INIT;
+
+ git_str_sets(&tgt, path);
+ cl_git_pass(git_fs_path_to_dir(&tgt));
+ cl_assert_equal_s(expected, tgt.ptr);
+
+ git_str_dispose(&tgt);
+}
+
+static void
+check_string_to_dir(
+ const char* path,
+ size_t maxlen,
+ const char* expected)
+{
+ size_t len = strlen(path);
+ char *buf = git__malloc(len + 2);
+ cl_assert(buf);
+
+ strncpy(buf, path, len + 2);
+
+ git_fs_path_string_to_dir(buf, maxlen);
+
+ cl_assert_equal_s(expected, buf);
+
+ git__free(buf);
+}
+
+/* convert paths to dirs */
+void test_path_core__07_path_to_dir(void)
+{
+ check_path_to_dir("", "");
+ check_path_to_dir(".", "./");
+ check_path_to_dir("./", "./");
+ check_path_to_dir("a/", "a/");
+ check_path_to_dir("ab", "ab/");
+ /* make sure we try just under and just over an expansion that will
+ * require a realloc
+ */
+ check_path_to_dir("abcdef", "abcdef/");
+ check_path_to_dir("abcdefg", "abcdefg/");
+ check_path_to_dir("abcdefgh", "abcdefgh/");
+ check_path_to_dir("abcdefghi", "abcdefghi/");
+ check_path_to_dir(REP1024("abcd") "/", REP1024("abcd") "/");
+ check_path_to_dir(REP1024("abcd"), REP1024("abcd") "/");
+
+ check_string_to_dir("", 1, "");
+ check_string_to_dir(".", 1, ".");
+ check_string_to_dir(".", 2, "./");
+ check_string_to_dir(".", 3, "./");
+ check_string_to_dir("abcd", 3, "abcd");
+ check_string_to_dir("abcd", 4, "abcd");
+ check_string_to_dir("abcd", 5, "abcd/");
+ check_string_to_dir("abcd", 6, "abcd/");
+}
+
+/* join path to itself */
+void test_path_core__08_self_join(void)
+{
+ git_str path = GIT_STR_INIT;
+ size_t asize = 0;
+
+ asize = path.asize;
+ cl_git_pass(git_str_sets(&path, "/foo"));
+ cl_assert_equal_s(path.ptr, "/foo");
+ cl_assert(asize < path.asize);
+
+ asize = path.asize;
+ cl_git_pass(git_str_joinpath(&path, path.ptr, "this is a new string"));
+ cl_assert_equal_s(path.ptr, "/foo/this is a new string");
+ cl_assert(asize < path.asize);
+
+ asize = path.asize;
+ cl_git_pass(git_str_joinpath(&path, path.ptr, "/grow the buffer, grow the buffer, grow the buffer"));
+ cl_assert_equal_s(path.ptr, "/foo/this is a new string/grow the buffer, grow the buffer, grow the buffer");
+ cl_assert(asize < path.asize);
+
+ git_str_dispose(&path);
+ cl_git_pass(git_str_sets(&path, "/foo/bar"));
+
+ cl_git_pass(git_str_joinpath(&path, path.ptr + 4, "baz"));
+ cl_assert_equal_s(path.ptr, "/bar/baz");
+
+ asize = path.asize;
+ cl_git_pass(git_str_joinpath(&path, path.ptr + 4, "somethinglongenoughtorealloc"));
+ cl_assert_equal_s(path.ptr, "/baz/somethinglongenoughtorealloc");
+ cl_assert(asize < path.asize);
+
+ git_str_dispose(&path);
+}
+
+static void check_percent_decoding(const char *expected_result, const char *input)
+{
+ git_str buf = GIT_STR_INIT;
+
+ cl_git_pass(git__percent_decode(&buf, input));
+ cl_assert_equal_s(expected_result, git_str_cstr(&buf));
+
+ git_str_dispose(&buf);
+}
+
+void test_path_core__09_percent_decode(void)
+{
+ check_percent_decoding("abcd", "abcd");
+ check_percent_decoding("a2%", "a2%");
+ check_percent_decoding("a2%3", "a2%3");
+ check_percent_decoding("a2%%3", "a2%%3");
+ check_percent_decoding("a2%3z", "a2%3z");
+ check_percent_decoding("a,", "a%2c");
+ check_percent_decoding("a21", "a2%31");
+ check_percent_decoding("a2%1", "a2%%31");
+ check_percent_decoding("a bc ", "a%20bc%20");
+ check_percent_decoding("Vicent Mart" "\355", "Vicent%20Mart%ED");
+}
+
+static void check_fromurl(const char *expected_result, const char *input, int should_fail)
+{
+ git_str buf = GIT_STR_INIT;
+
+ assert(should_fail || expected_result);
+
+ if (!should_fail) {
+ cl_git_pass(git_fs_path_fromurl(&buf, input));
+ cl_assert_equal_s(expected_result, git_str_cstr(&buf));
+ } else
+ cl_git_fail(git_fs_path_fromurl(&buf, input));
+
+ git_str_dispose(&buf);
+}
+
+#ifdef GIT_WIN32
+#define ABS_PATH_MARKER ""
+#else
+#define ABS_PATH_MARKER "/"
+#endif
+
+void test_path_core__10_fromurl(void)
+{
+ /* Failing cases */
+ check_fromurl(NULL, "a", 1);
+ check_fromurl(NULL, "http:///c:/Temp%20folder/note.txt", 1);
+ check_fromurl(NULL, "file://c:/Temp%20folder/note.txt", 1);
+ check_fromurl(NULL, "file:////c:/Temp%20folder/note.txt", 1);
+ check_fromurl(NULL, "file:///", 1);
+ check_fromurl(NULL, "file:////", 1);
+ check_fromurl(NULL, "file://servername/c:/Temp%20folder/note.txt", 1);
+
+ /* Passing cases */
+ check_fromurl(ABS_PATH_MARKER "c:/Temp folder/note.txt", "file:///c:/Temp%20folder/note.txt", 0);
+ check_fromurl(ABS_PATH_MARKER "c:/Temp folder/note.txt", "file://localhost/c:/Temp%20folder/note.txt", 0);
+ check_fromurl(ABS_PATH_MARKER "c:/Temp+folder/note.txt", "file:///c:/Temp+folder/note.txt", 0);
+ check_fromurl(ABS_PATH_MARKER "a", "file:///a", 0);
+}
+
+typedef struct {
+ int expect_idx;
+ int cancel_after;
+ char **expect;
+} check_walkup_info;
+
+#define CANCEL_VALUE 1234
+
+static int check_one_walkup_step(void *ref, const char *path)
+{
+ check_walkup_info *info = (check_walkup_info *)ref;
+
+ if (!info->cancel_after) {
+ cl_assert_equal_s(info->expect[info->expect_idx], "[CANCEL]");
+ return CANCEL_VALUE;
+ }
+ info->cancel_after--;
+
+ cl_assert(info->expect[info->expect_idx] != NULL);
+ cl_assert_equal_s(info->expect[info->expect_idx], path);
+ info->expect_idx++;
+
+ return 0;
+}
+
+void test_path_core__11_walkup(void)
+{
+ git_str p = GIT_STR_INIT;
+
+ char *expect[] = {
+ /* 1 */ "/a/b/c/d/e/", "/a/b/c/d/", "/a/b/c/", "/a/b/", "/a/", "/", NULL,
+ /* 2 */ "/a/b/c/d/e", "/a/b/c/d/", "/a/b/c/", "/a/b/", "/a/", "/", NULL,
+ /* 3 */ "/a/b/c/d/e", "/a/b/c/d/", "/a/b/c/", "/a/b/", "/a/", "/", NULL,
+ /* 4 */ "/a/b/c/d/e", "/a/b/c/d/", "/a/b/c/", "/a/b/", "/a/", "/", NULL,
+ /* 5 */ "/a/b/c/d/e", "/a/b/c/d/", "/a/b/c/", "/a/b/", NULL,
+ /* 6 */ "/a/b/c/d/e", "/a/b/c/d/", "/a/b/c/", "/a/b/", NULL,
+ /* 7 */ "this_is_a_path", "", NULL,
+ /* 8 */ "this_is_a_path/", "", NULL,
+ /* 9 */ "///a///b///c///d///e///", "///a///b///c///d///", "///a///b///c///", "///a///b///", "///a///", "///", NULL,
+ /* 10 */ "a/b/c/", "a/b/", "a/", "", NULL,
+ /* 11 */ "a/b/c", "a/b/", "a/", "", NULL,
+ /* 12 */ "a/b/c/", "a/b/", "a/", NULL,
+ /* 13 */ "", NULL,
+ /* 14 */ "/", NULL,
+ /* 15 */ NULL
+ };
+
+ char *root[] = {
+ /* 1 */ NULL,
+ /* 2 */ NULL,
+ /* 3 */ "/",
+ /* 4 */ "",
+ /* 5 */ "/a/b",
+ /* 6 */ "/a/b/",
+ /* 7 */ NULL,
+ /* 8 */ NULL,
+ /* 9 */ NULL,
+ /* 10 */ NULL,
+ /* 11 */ NULL,
+ /* 12 */ "a/",
+ /* 13 */ NULL,
+ /* 14 */ NULL,
+ };
+
+ int i, j;
+ check_walkup_info info;
+
+ info.expect = expect;
+ info.cancel_after = -1;
+
+ for (i = 0, j = 0; expect[i] != NULL; i++, j++) {
+
+ git_str_sets(&p, expect[i]);
+
+ info.expect_idx = i;
+ cl_git_pass(
+ git_fs_path_walk_up(&p, root[j], check_one_walkup_step, &info)
+ );
+
+ cl_assert_equal_s(p.ptr, expect[i]);
+ cl_assert(expect[info.expect_idx] == NULL);
+ i = info.expect_idx;
+ }
+
+ git_str_dispose(&p);
+}
+
+void test_path_core__11a_walkup_cancel(void)
+{
+ git_str p = GIT_STR_INIT;
+ int cancel[] = { 3, 2, 1, 0 };
+ char *expect[] = {
+ "/a/b/c/d/e/", "/a/b/c/d/", "/a/b/c/", "[CANCEL]", NULL,
+ "/a/b/c/d/e", "/a/b/c/d/", "[CANCEL]", NULL,
+ "/a/b/c/d/e", "[CANCEL]", NULL,
+ "[CANCEL]", NULL,
+ NULL
+ };
+ char *root[] = { NULL, NULL, "/", "", NULL };
+ int i, j;
+ check_walkup_info info;
+
+ info.expect = expect;
+
+ for (i = 0, j = 0; expect[i] != NULL; i++, j++) {
+
+ git_str_sets(&p, expect[i]);
+
+ info.cancel_after = cancel[j];
+ info.expect_idx = i;
+
+ cl_assert_equal_i(
+ CANCEL_VALUE,
+ git_fs_path_walk_up(&p, root[j], check_one_walkup_step, &info)
+ );
+
+ /* skip to next run of expectations */
+ while (expect[i] != NULL) i++;
+ }
+
+ git_str_dispose(&p);
+}
+
+void test_path_core__12_offset_to_path_root(void)
+{
+ cl_assert(git_fs_path_root("non/rooted/path") == -1);
+ cl_assert(git_fs_path_root("/rooted/path") == 0);
+
+#ifdef GIT_WIN32
+ /* Windows specific tests */
+ cl_assert(git_fs_path_root("C:non/rooted/path") == -1);
+ cl_assert(git_fs_path_root("C:/rooted/path") == 2);
+ cl_assert(git_fs_path_root("//computername/sharefolder/resource") == 14);
+ cl_assert(git_fs_path_root("//computername/sharefolder") == 14);
+ cl_assert(git_fs_path_root("//computername") == -1);
+#endif
+}
+
+#define NON_EXISTING_FILEPATH "i_hope_i_do_not_exist"
+
+void test_path_core__13_cannot_prettify_a_non_existing_file(void)
+{
+ git_str p = GIT_STR_INIT;
+
+ cl_assert_equal_b(git_fs_path_exists(NON_EXISTING_FILEPATH), false);
+ cl_assert_equal_i(GIT_ENOTFOUND, git_fs_path_prettify(&p, NON_EXISTING_FILEPATH, NULL));
+ cl_assert_equal_i(GIT_ENOTFOUND, git_fs_path_prettify(&p, NON_EXISTING_FILEPATH "/so-do-i", NULL));
+
+ git_str_dispose(&p);
+}
+
+void test_path_core__14_apply_relative(void)
+{
+ git_str p = GIT_STR_INIT;
+
+ cl_git_pass(git_str_sets(&p, "/this/is/a/base"));
+
+ cl_git_pass(git_fs_path_apply_relative(&p, "../test"));
+ cl_assert_equal_s("/this/is/a/test", p.ptr);
+
+ cl_git_pass(git_fs_path_apply_relative(&p, "../../the/./end"));
+ cl_assert_equal_s("/this/is/the/end", p.ptr);
+
+ cl_git_pass(git_fs_path_apply_relative(&p, "./of/this/../the/string"));
+ cl_assert_equal_s("/this/is/the/end/of/the/string", p.ptr);
+
+ cl_git_pass(git_fs_path_apply_relative(&p, "../../../../../.."));
+ cl_assert_equal_s("/this/", p.ptr);
+
+ cl_git_pass(git_fs_path_apply_relative(&p, "../"));
+ cl_assert_equal_s("/", p.ptr);
+
+ cl_git_fail(git_fs_path_apply_relative(&p, "../../.."));
+
+
+ cl_git_pass(git_str_sets(&p, "d:/another/test"));
+
+ cl_git_pass(git_fs_path_apply_relative(&p, "../.."));
+ cl_assert_equal_s("d:/", p.ptr);
+
+ cl_git_pass(git_fs_path_apply_relative(&p, "from/here/to/../and/./back/."));
+ cl_assert_equal_s("d:/from/here/and/back/", p.ptr);
+
+
+ cl_git_pass(git_str_sets(&p, "https://my.url.com/test.git"));
+
+ cl_git_pass(git_fs_path_apply_relative(&p, "../another.git"));
+ cl_assert_equal_s("https://my.url.com/another.git", p.ptr);
+
+ cl_git_pass(git_fs_path_apply_relative(&p, "../full/path/url.patch"));
+ cl_assert_equal_s("https://my.url.com/full/path/url.patch", p.ptr);
+
+ cl_git_pass(git_fs_path_apply_relative(&p, ".."));
+ cl_assert_equal_s("https://my.url.com/full/path/", p.ptr);
+
+ cl_git_pass(git_fs_path_apply_relative(&p, "../../../"));
+ cl_assert_equal_s("https://", p.ptr);
+
+
+ cl_git_pass(git_str_sets(&p, "../../this/is/relative"));
+
+ cl_git_pass(git_fs_path_apply_relative(&p, "../../preserves/the/prefix"));
+ cl_assert_equal_s("../../this/preserves/the/prefix", p.ptr);
+
+ cl_git_pass(git_fs_path_apply_relative(&p, "../../../../that"));
+ cl_assert_equal_s("../../that", p.ptr);
+
+ cl_git_pass(git_fs_path_apply_relative(&p, "../there"));
+ cl_assert_equal_s("../../there", p.ptr);
+ git_str_dispose(&p);
+}
+
+static void assert_resolve_relative(
+ git_str *buf, const char *expected, const char *path)
+{
+ cl_git_pass(git_str_sets(buf, path));
+ cl_git_pass(git_fs_path_resolve_relative(buf, 0));
+ cl_assert_equal_s(expected, buf->ptr);
+}
+
+void test_path_core__15_resolve_relative(void)
+{
+ git_str buf = GIT_STR_INIT;
+
+ assert_resolve_relative(&buf, "", "");
+ assert_resolve_relative(&buf, "", ".");
+ assert_resolve_relative(&buf, "", "./");
+ assert_resolve_relative(&buf, "..", "..");
+ assert_resolve_relative(&buf, "../", "../");
+ assert_resolve_relative(&buf, "..", "./..");
+ assert_resolve_relative(&buf, "../", "./../");
+ assert_resolve_relative(&buf, "../", "../.");
+ assert_resolve_relative(&buf, "../", ".././");
+ assert_resolve_relative(&buf, "../..", "../..");
+ assert_resolve_relative(&buf, "../../", "../../");
+
+ assert_resolve_relative(&buf, "/", "/");
+ assert_resolve_relative(&buf, "/", "/.");
+
+ assert_resolve_relative(&buf, "", "a/..");
+ assert_resolve_relative(&buf, "", "a/../");
+ assert_resolve_relative(&buf, "", "a/../.");
+
+ assert_resolve_relative(&buf, "/a", "/a");
+ assert_resolve_relative(&buf, "/a/", "/a/.");
+ assert_resolve_relative(&buf, "/", "/a/../");
+ assert_resolve_relative(&buf, "/", "/a/../.");
+ assert_resolve_relative(&buf, "/", "/a/.././");
+
+ assert_resolve_relative(&buf, "a", "a");
+ assert_resolve_relative(&buf, "a/", "a/");
+ assert_resolve_relative(&buf, "a/", "a/.");
+ assert_resolve_relative(&buf, "a/", "a/./");
+
+ assert_resolve_relative(&buf, "a/b", "a//b");
+ assert_resolve_relative(&buf, "a/b/c", "a/b/c");
+ assert_resolve_relative(&buf, "b/c", "./b/c");
+ assert_resolve_relative(&buf, "a/c", "a/./c");
+ assert_resolve_relative(&buf, "a/b/", "a/b/.");
+
+ assert_resolve_relative(&buf, "/a/b/c", "///a/b/c");
+ assert_resolve_relative(&buf, "/", "////");
+ assert_resolve_relative(&buf, "/a", "///a");
+ assert_resolve_relative(&buf, "/", "///.");
+ assert_resolve_relative(&buf, "/", "///a/..");
+
+ assert_resolve_relative(&buf, "../../path", "../../test//../././path");
+ assert_resolve_relative(&buf, "../d", "a/b/../../../c/../d");
+
+ cl_git_pass(git_str_sets(&buf, "/.."));
+ cl_git_fail(git_fs_path_resolve_relative(&buf, 0));
+
+ cl_git_pass(git_str_sets(&buf, "/./.."));
+ cl_git_fail(git_fs_path_resolve_relative(&buf, 0));
+
+ cl_git_pass(git_str_sets(&buf, "/.//.."));
+ cl_git_fail(git_fs_path_resolve_relative(&buf, 0));
+
+ cl_git_pass(git_str_sets(&buf, "/../."));
+ cl_git_fail(git_fs_path_resolve_relative(&buf, 0));
+
+ cl_git_pass(git_str_sets(&buf, "/../.././../a"));
+ cl_git_fail(git_fs_path_resolve_relative(&buf, 0));
+
+ cl_git_pass(git_str_sets(&buf, "////.."));
+ cl_git_fail(git_fs_path_resolve_relative(&buf, 0));
+
+ /* things that start with Windows network paths */
+#ifdef GIT_WIN32
+ assert_resolve_relative(&buf, "//a/b/c", "//a/b/c");
+ assert_resolve_relative(&buf, "//a/", "//a/b/..");
+ assert_resolve_relative(&buf, "//a/b/c", "//a/Q/../b/x/y/../../c");
+
+ cl_git_pass(git_str_sets(&buf, "//a/b/../.."));
+ cl_git_fail(git_fs_path_resolve_relative(&buf, 0));
+#else
+ assert_resolve_relative(&buf, "/a/b/c", "//a/b/c");
+ assert_resolve_relative(&buf, "/a/", "//a/b/..");
+ assert_resolve_relative(&buf, "/a/b/c", "//a/Q/../b/x/y/../../c");
+ assert_resolve_relative(&buf, "/", "//a/b/../..");
+#endif
+
+ git_str_dispose(&buf);
+}
+
+#define assert_common_dirlen(i, p, q) \
+ cl_assert_equal_i((i), git_fs_path_common_dirlen((p), (q)));
+
+void test_path_core__16_resolve_relative(void)
+{
+ assert_common_dirlen(0, "", "");
+ assert_common_dirlen(0, "", "bar.txt");
+ assert_common_dirlen(0, "foo.txt", "bar.txt");
+ assert_common_dirlen(0, "foo.txt", "");
+ assert_common_dirlen(0, "foo/bar.txt", "bar/foo.txt");
+ assert_common_dirlen(0, "foo/bar.txt", "../foo.txt");
+
+ assert_common_dirlen(1, "/one.txt", "/two.txt");
+ assert_common_dirlen(4, "foo/one.txt", "foo/two.txt");
+ assert_common_dirlen(5, "/foo/one.txt", "/foo/two.txt");
+
+ assert_common_dirlen(6, "a/b/c/foo.txt", "a/b/c/d/e/bar.txt");
+ assert_common_dirlen(7, "/a/b/c/foo.txt", "/a/b/c/d/e/bar.txt");
+}
+
+static void fix_path(git_str *s)
+{
+#ifndef GIT_WIN32
+ GIT_UNUSED(s);
+#else
+ char* c;
+
+ for (c = s->ptr; *c; c++) {
+ if (*c == '/')
+ *c = '\\';
+ }
+#endif
+}
+
+void test_path_core__find_exe_in_path(void)
+{
+ char *orig_path;
+ git_str sandbox_path = GIT_STR_INIT;
+ git_str new_path = GIT_STR_INIT, full_path = GIT_STR_INIT,
+ dummy_path = GIT_STR_INIT;
+
+#ifdef GIT_WIN32
+ static const char *bogus_path_1 = "c:\\does\\not\\exist\\";
+ static const char *bogus_path_2 = "e:\\non\\existent";
+#else
+ static const char *bogus_path_1 = "/this/path/does/not/exist/";
+ static const char *bogus_path_2 = "/non/existent";
+#endif
+
+ orig_path = cl_getenv("PATH");
+
+ git_str_puts(&sandbox_path, clar_sandbox_path());
+ git_str_joinpath(&dummy_path, sandbox_path.ptr, "dummmmmmmy_libgit2_file");
+ cl_git_rewritefile(dummy_path.ptr, "this is a dummy file");
+
+ fix_path(&sandbox_path);
+ fix_path(&dummy_path);
+
+ cl_git_pass(git_str_printf(&new_path, "%s%c%s%c%s%c%s",
+ bogus_path_1, GIT_PATH_LIST_SEPARATOR,
+ orig_path, GIT_PATH_LIST_SEPARATOR,
+ sandbox_path.ptr, GIT_PATH_LIST_SEPARATOR,
+ bogus_path_2));
+
+ check_setenv("PATH", new_path.ptr);
+
+ cl_git_fail_with(GIT_ENOTFOUND, git_fs_path_find_executable(&full_path, "this_file_does_not_exist"));
+ cl_git_pass(git_fs_path_find_executable(&full_path, "dummmmmmmy_libgit2_file"));
+
+ cl_assert_equal_s(full_path.ptr, dummy_path.ptr);
+
+ git_str_dispose(&full_path);
+ git_str_dispose(&new_path);
+ git_str_dispose(&dummy_path);
+ git_str_dispose(&sandbox_path);
+ git__free(orig_path);
+}
+
+void test_path_core__validate_current_user_ownership(void)
+{
+ bool is_cur;
+
+ cl_must_pass(p_mkdir("testdir", 0777));
+ cl_git_pass(git_fs_path_owner_is_current_user(&is_cur, "testdir"));
+ cl_assert_equal_i(is_cur, 1);
+
+ cl_git_rewritefile("testfile", "This is a test file.");
+ cl_git_pass(git_fs_path_owner_is_current_user(&is_cur, "testfile"));
+ cl_assert_equal_i(is_cur, 1);
+
+#ifdef GIT_WIN32
+ cl_git_pass(git_fs_path_owner_is_current_user(&is_cur, "C:\\"));
+ cl_assert_equal_i(is_cur, 0);
+
+ cl_git_fail(git_fs_path_owner_is_current_user(&is_cur, "c:\\path\\does\\not\\exist"));
+#else
+ cl_git_pass(git_fs_path_owner_is_current_user(&is_cur, "/"));
+ cl_assert_equal_i(is_cur, (geteuid() == 0));
+
+ cl_git_fail(git_fs_path_owner_is_current_user(&is_cur, "/path/does/not/exist"));
+#endif
+}
+
+void test_path_core__dirlen(void)
+{
+ cl_assert_equal_sz(13, git_fs_path_dirlen("/foo/bar/asdf"));
+ cl_assert_equal_sz(13, git_fs_path_dirlen("/foo/bar/asdf/"));
+ cl_assert_equal_sz(13, git_fs_path_dirlen("/foo/bar/asdf//"));
+ cl_assert_equal_sz(3, git_fs_path_dirlen("foo////"));
+ cl_assert_equal_sz(3, git_fs_path_dirlen("foo"));
+ cl_assert_equal_sz(1, git_fs_path_dirlen("/"));
+ cl_assert_equal_sz(1, git_fs_path_dirlen("////"));
+ cl_assert_equal_sz(0, git_fs_path_dirlen(""));
+}
+
static void test_make_relative(
const char *expected_path,
const char *path,
@@ -341,3 +1119,29 @@ void test_path_core__join_unrooted_respects_funny_windows_roots(void)
test_join_unrooted("💩:/foo/bar/foobar", 13, "💩:/foo/bar/foobar", "💩:/foo/bar");
test_join_unrooted("💩:/foo/bar/foobar", 9, "💩:/foo/bar/foobar", "💩:/foo/");
}
+
+void test_path_core__is_root(void)
+{
+ cl_assert_equal_b(true, git_fs_path_is_root("/"));
+ cl_assert_equal_b(false, git_fs_path_is_root("//"));
+ cl_assert_equal_b(false, git_fs_path_is_root("foo/"));
+ cl_assert_equal_b(false, git_fs_path_is_root("/foo/"));
+ cl_assert_equal_b(false, git_fs_path_is_root("/foo"));
+ cl_assert_equal_b(false, git_fs_path_is_root("\\"));
+
+#ifdef GIT_WIN32
+ cl_assert_equal_b(true, git_fs_path_is_root("A:\\"));
+ cl_assert_equal_b(false, git_fs_path_is_root("B:\\foo"));
+ cl_assert_equal_b(false, git_fs_path_is_root("B:\\foo\\"));
+ cl_assert_equal_b(true, git_fs_path_is_root("C:\\"));
+ cl_assert_equal_b(true, git_fs_path_is_root("c:\\"));
+ cl_assert_equal_b(true, git_fs_path_is_root("z:\\"));
+ cl_assert_equal_b(false, git_fs_path_is_root("z:\\\\"));
+ cl_assert_equal_b(false, git_fs_path_is_root("\\\\localhost"));
+ cl_assert_equal_b(false, git_fs_path_is_root("\\\\localhost\\"));
+ cl_assert_equal_b(false, git_fs_path_is_root("\\\\localhost\\c$\\"));
+ cl_assert_equal_b(false, git_fs_path_is_root("\\\\localhost\\c$\\Foo"));
+ cl_assert_equal_b(false, git_fs_path_is_root("\\\\localhost\\c$\\Foo\\"));
+ cl_assert_equal_b(false, git_fs_path_is_root("\\\\Volume\\12345\\Foo\\Bar.txt"));
+#endif
+}
diff --git a/tests/util/path/win32.c b/tests/util/path/win32.c
index 1aaf6867a26..6f90b447dda 100644
--- a/tests/util/path/win32.c
+++ b/tests/util/path/win32.c
@@ -278,5 +278,38 @@ void test_path_win32__8dot3_name(void)
cl_must_pass(p_mkdir(".bar", 0777));
cl_assert_equal_s("BAR~2", (shortname = git_win32_path_8dot3_name(".bar")));
git__free(shortname);
+
+ p_rmdir(".foo");
+ p_rmdir(".bar");
+ p_unlink("bar~1");
+#endif
+}
+
+void test_path_win32__realpath(void)
+{
+#ifdef GIT_WIN32
+ git_str expected = GIT_STR_INIT;
+ char result[GIT_PATH_MAX];
+
+ /* Ensure relative paths become absolute */
+ cl_must_pass(git_str_joinpath(&expected, clar_sandbox_path(), "abcdef"));
+ cl_must_pass(p_mkdir("abcdef", 0777));
+ cl_assert(p_realpath("./abcdef", result) != NULL);
+ cl_assert_equal_s(expected.ptr, result);
+
+ /* Ensure case is canonicalized */
+ git_str_clear(&expected);
+ cl_must_pass(git_str_joinpath(&expected, clar_sandbox_path(), "FOO"));
+ cl_must_pass(p_mkdir("FOO", 0777));
+ cl_assert(p_realpath("foo", result) != NULL);
+ cl_assert_equal_s(expected.ptr, result);
+
+ cl_assert(p_realpath("nonexistent", result) == NULL);
+ cl_assert_equal_i(ENOENT, errno);
+
+ git_str_dispose(&expected);
+
+ p_rmdir("abcdef");
+ p_rmdir("FOO");
#endif
}
diff --git a/tests/util/process/env.c b/tests/util/process/env.c
new file mode 100644
index 00000000000..a6dc62e7e42
--- /dev/null
+++ b/tests/util/process/env.c
@@ -0,0 +1,111 @@
+#include "clar_libgit2.h"
+#include "process.h"
+#include "vector.h"
+
+static git_str env_cmd = GIT_STR_INIT;
+static git_str accumulator = GIT_STR_INIT;
+static git_vector env_result = GIT_VECTOR_INIT;
+
+void test_process_env__initialize(void)
+{
+#ifdef GIT_WIN32
+ git_str_printf(&env_cmd, "%s/env.cmd", cl_fixture("process"));
+#else
+ git_str_puts(&env_cmd, "/usr/bin/env");
+#endif
+
+ cl_git_pass(git_vector_init(&env_result, 32, git__strcmp_cb));
+}
+
+void test_process_env__cleanup(void)
+{
+ git_vector_dispose(&env_result);
+ git_str_dispose(&accumulator);
+ git_str_dispose(&env_cmd);
+}
+
+static void run_env(const char **env_array, size_t env_len, bool exclude_env)
+{
+ const char *args_array[] = { env_cmd.ptr };
+
+ git_process *process;
+ git_process_options opts = GIT_PROCESS_OPTIONS_INIT;
+ git_process_result result = GIT_PROCESS_RESULT_INIT;
+
+ char buf[1024], *tok;
+ ssize_t ret;
+
+ opts.capture_out = 1;
+ opts.exclude_env = exclude_env;
+
+ cl_git_pass(git_process_new(&process, args_array, ARRAY_SIZE(args_array), env_array, env_len, &opts));
+ cl_git_pass(git_process_start(process));
+
+ while ((ret = git_process_read(process, buf, 1024)) > 0)
+ cl_git_pass(git_str_put(&accumulator, buf, (size_t)ret));
+
+ cl_assert_equal_i(0, ret);
+
+ cl_git_pass(git_process_wait(&result, process));
+
+ cl_assert_equal_i(GIT_PROCESS_STATUS_NORMAL, result.status);
+ cl_assert_equal_i(0, result.exitcode);
+ cl_assert_equal_i(0, result.signal);
+
+ for (tok = strtok(accumulator.ptr, "\n"); tok; tok = strtok(NULL, "\n")) {
+#ifdef GIT_WIN32
+ if (strlen(tok) && tok[strlen(tok) - 1] == '\r')
+ tok[strlen(tok) - 1] = '\0';
+#endif
+
+ cl_git_pass(git_vector_insert(&env_result, tok));
+ }
+
+ git_process_close(process);
+ git_process_free(process);
+}
+
+void test_process_env__can_add_env(void)
+{
+ const char *env_array[] = { "TEST_NEW_ENV=added", "TEST_OTHER_ENV=also_added" };
+ run_env(env_array, 2, false);
+
+ cl_git_pass(git_vector_search(NULL, &env_result, "TEST_NEW_ENV=added"));
+ cl_git_pass(git_vector_search(NULL, &env_result, "TEST_OTHER_ENV=also_added"));
+}
+
+void test_process_env__can_propagate_env(void)
+{
+ cl_setenv("TEST_NEW_ENV", "propagated");
+ run_env(NULL, 0, false);
+
+ cl_git_pass(git_vector_search(NULL, &env_result, "TEST_NEW_ENV=propagated"));
+}
+
+void test_process_env__can_remove_env(void)
+{
+ const char *env_array[] = { "TEST_NEW_ENV=" };
+ char *str;
+ size_t i;
+
+ cl_setenv("TEST_NEW_ENV", "propagated");
+ run_env(env_array, 1, false);
+
+ git_vector_foreach(&env_result, i, str)
+ cl_assert(git__prefixcmp(str, "TEST_NEW_ENV=") != 0);
+}
+
+void test_process_env__can_clear_env(void)
+{
+ const char *env_array[] = { "TEST_NEW_ENV=added", "TEST_OTHER_ENV=also_added" };
+
+ cl_setenv("SOME_EXISTING_ENV", "propagated");
+ run_env(env_array, 2, true);
+
+ /*
+ * We can't simply test that the environment is precisely what we
+ * provided. Some systems (eg win32) will add environment variables
+ * to all processes.
+ */
+ cl_assert_equal_i(GIT_ENOTFOUND, git_vector_search(NULL, &env_result, "SOME_EXISTING_ENV=propagated"));
+}
diff --git a/tests/util/process/start.c b/tests/util/process/start.c
new file mode 100644
index 00000000000..19ae5e312a4
--- /dev/null
+++ b/tests/util/process/start.c
@@ -0,0 +1,247 @@
+#include "clar_libgit2.h"
+#include "process.h"
+#include "vector.h"
+
+#ifndef GIT_WIN32
+# include <signal.h>
+#endif
+
+#ifndef SIGTERM
+# define SIGTERM 42
+#endif
+
+#ifndef SIGPIPE
+# define SIGPIPE 42
+#endif
+
+static git_str helloworld_cmd = GIT_STR_INIT;
+static git_str cat_cmd = GIT_STR_INIT;
+static git_str pwd_cmd = GIT_STR_INIT;
+
+void test_process_start__initialize(void)
+{
+#ifdef GIT_WIN32
+ git_str_printf(&helloworld_cmd, "%s/helloworld.bat", cl_fixture("process"));
+ git_str_printf(&cat_cmd, "%s/cat.bat", cl_fixture("process"));
+ git_str_printf(&pwd_cmd, "%s/pwd.bat", cl_fixture("process"));
+#else
+ git_str_printf(&helloworld_cmd, "%s/helloworld.sh", cl_fixture("process"));
+#endif
+}
+
+void test_process_start__cleanup(void)
+{
+ git_str_dispose(&pwd_cmd);
+ git_str_dispose(&cat_cmd);
+ git_str_dispose(&helloworld_cmd);
+}
+
+void test_process_start__returncode(void)
+{
+#if defined(GIT_WIN32)
+ const char *args_array[] = { "C:\\Windows\\System32\\cmd.exe", "/c", "exit", "1" };
+#elif defined(__APPLE__) || defined(__NetBSD__) || defined(__FreeBSD__) || \
+ defined(__MidnightBSD__) || defined(__DragonFly__)
+ const char *args_array[] = { "/usr/bin/false" };
+#else
+ const char *args_array[] = { "/bin/false" };
+#endif
+
+ git_process *process;
+ git_process_options opts = GIT_PROCESS_OPTIONS_INIT;
+ git_process_result result = GIT_PROCESS_RESULT_INIT;
+
+ cl_git_pass(git_process_new(&process, args_array, ARRAY_SIZE(args_array), NULL, 0, &opts));
+ cl_git_pass(git_process_start(process));
+ cl_git_pass(git_process_wait(&result, process));
+
+ cl_assert_equal_i(GIT_PROCESS_STATUS_NORMAL, result.status);
+ cl_assert_equal_i(1, result.exitcode);
+ cl_assert_equal_i(0, result.signal);
+
+ git_process_free(process);
+}
+
+void test_process_start__not_found(void)
+{
+#ifdef GIT_WIN32
+ const char *args_array[] = { "C:\\a\\b\\z\\y\\not_found" };
+#else
+ const char *args_array[] = { "/a/b/z/y/not_found" };
+#endif
+
+ git_process *process;
+ git_process_options opts = GIT_PROCESS_OPTIONS_INIT;
+
+ cl_git_pass(git_process_new(&process, args_array, ARRAY_SIZE(args_array), NULL, 0, &opts));
+ cl_git_fail(git_process_start(process));
+ git_process_free(process);
+}
+
+static void write_all(git_process *process, char *buf)
+{
+ size_t buf_len = strlen(buf);
+ ssize_t ret;
+
+ while (buf_len) {
+ ret = git_process_write(process, buf, buf_len);
+ cl_git_pass(ret < 0 ? (int)ret : 0);
+
+ buf += ret;
+ buf_len -= ret;
+ }
+}
+
+static void read_all(git_str *out, git_process *process)
+{
+ char buf[32];
+ size_t buf_len = 32;
+ ssize_t ret;
+
+ while ((ret = git_process_read(process, buf, buf_len)) > 0)
+ cl_git_pass(git_str_put(out, buf, ret));
+
+ cl_git_pass(ret < 0 ? (int)ret : 0);
+}
+
+void test_process_start__redirect_stdio(void)
+{
+#ifdef GIT_WIN32
+ const char *args_array[] = { "C:\\Windows\\System32\\cmd.exe", "/c", cat_cmd.ptr };
+#else
+ const char *args_array[] = { "/bin/cat" };
+#endif
+
+ git_process *process;
+ git_process_options opts = GIT_PROCESS_OPTIONS_INIT;
+ git_process_result result = GIT_PROCESS_RESULT_INIT;
+ git_str buf = GIT_STR_INIT;
+
+ opts.capture_in = 1;
+ opts.capture_out = 1;
+
+ cl_git_pass(git_process_new(&process, args_array, ARRAY_SIZE(args_array), NULL, 0, &opts));
+ cl_git_pass(git_process_start(process));
+
+ write_all(process, "Hello, world.\r\nHello!\r\n");
+ cl_git_pass(git_process_close_in(process));
+
+ read_all(&buf, process);
+ cl_assert_equal_s("Hello, world.\r\nHello!\r\n", buf.ptr);
+
+ cl_git_pass(git_process_wait(&result, process));
+
+ cl_assert_equal_i(GIT_PROCESS_STATUS_NORMAL, result.status);
+ cl_assert_equal_i(0, result.exitcode);
+ cl_assert_equal_i(0, result.signal);
+
+ git_str_dispose(&buf);
+ git_process_free(process);
+}
+
+/*
+void test_process_start__catch_sigterm(void)
+{
+ const char *args_array[] = { "/bin/cat" };
+
+ git_process *process;
+ git_process_options opts = GIT_PROCESS_OPTIONS_INIT;
+ git_process_result result = GIT_PROCESS_RESULT_INIT;
+ p_pid_t pid;
+
+ opts.capture_out = 1;
+
+ cl_git_pass(git_process_new(&process, args_array, ARRAY_SIZE(args_array), NULL, 0, &opts));
+ cl_git_pass(git_process_start(process));
+ cl_git_pass(git_process_id(&pid, process));
+
+ cl_must_pass(kill(pid, SIGTERM));
+
+ cl_git_pass(git_process_wait(&result, process));
+
+ cl_assert_equal_i(GIT_PROCESS_STATUS_ERROR, result.status);
+ cl_assert_equal_i(0, result.exitcode);
+ cl_assert_equal_i(SIGTERM, result.signal);
+
+ git_process_free(process);
+}
+
+void test_process_start__catch_sigpipe(void)
+{
+ const char *args_array[] = { helloworld_cmd.ptr };
+
+ git_process *process;
+ git_process_options opts = GIT_PROCESS_OPTIONS_INIT;
+ git_process_result result = GIT_PROCESS_RESULT_INIT;
+
+ opts.capture_out = 1;
+
+ cl_git_pass(git_process_new(&process, args_array, ARRAY_SIZE(args_array), NULL, 0, &opts));
+ cl_git_pass(git_process_start(process));
+ cl_git_pass(git_process_close(process));
+ cl_git_pass(git_process_wait(&result, process));
+
+ cl_assert_equal_i(GIT_PROCESS_STATUS_ERROR, result.status);
+ cl_assert_equal_i(0, result.exitcode);
+ cl_assert_equal_i(SIGPIPE, result.signal);
+
+ git_process_free(process);
+}
+*/
+
+void test_process_start__can_chdir(void)
+{
+#ifdef GIT_WIN32
+ const char *args_array[] = { "C:\\Windows\\System32\\cmd.exe", "/c", pwd_cmd.ptr };
+ char *startwd = "C:\\";
+#else
+ const char *args_array[] = { "/bin/pwd" };
+ char *startwd = "/";
+#endif
+
+ git_process *process;
+ git_process_options opts = GIT_PROCESS_OPTIONS_INIT;
+ git_process_result result = GIT_PROCESS_RESULT_INIT;
+ git_str buf = GIT_STR_INIT;
+
+ opts.cwd = startwd;
+ opts.capture_out = 1;
+
+ cl_git_pass(git_process_new(&process, args_array, ARRAY_SIZE(args_array), NULL, 0, &opts));
+ cl_git_pass(git_process_start(process));
+
+ read_all(&buf, process);
+ git_str_rtrim(&buf);
+
+ cl_assert_equal_s(startwd, buf.ptr);
+
+ cl_git_pass(git_process_wait(&result, process));
+
+ cl_assert_equal_i(GIT_PROCESS_STATUS_NORMAL, result.status);
+ cl_assert_equal_i(0, result.exitcode);
+ cl_assert_equal_i(0, result.signal);
+
+ git_str_dispose(&buf);
+ git_process_free(process);
+}
+
+void test_process_start__cannot_chdir_to_nonexistent_dir(void)
+{
+#ifdef GIT_WIN32
+ const char *args_array[] = { "C:\\Windows\\System32\\cmd.exe", "/c", pwd_cmd.ptr };
+ char *startwd = "C:\\a\\b\\z\\y\\not_found";
+#else
+ const char *args_array[] = { "/bin/pwd" };
+ char *startwd = "/a/b/z/y/not_found";
+#endif
+
+ git_process *process;
+ git_process_options opts = GIT_PROCESS_OPTIONS_INIT;
+
+ opts.cwd = startwd;
+ opts.capture_out = 1;
+
+ cl_git_pass(git_process_new(&process, args_array, ARRAY_SIZE(args_array), NULL, 0, &opts));
+ cl_git_fail(git_process_start(process));
+ git_process_free(process);
+}
diff --git a/tests/util/process/win32.c b/tests/util/process/win32.c
new file mode 100644
index 00000000000..c04a56ec54b
--- /dev/null
+++ b/tests/util/process/win32.c
@@ -0,0 +1,63 @@
+#include "clar_libgit2.h"
+#include "process.h"
+#include "vector.h"
+
+#ifdef GIT_WIN32
+static git_str result;
+
+# define assert_cmdline(expected, given) do { \
+ cl_git_pass(git_process__cmdline(&result, given, ARRAY_SIZE(given))); \
+ cl_assert_equal_s(expected, result.ptr); \
+ git_str_dispose(&result); \
+ } while(0)
+
+#endif
+
+
+void test_process_win32__cmdline_is_whitespace_delimited(void)
+{
+#ifdef GIT_WIN32
+ const char *one[] = { "one" };
+ const char *two[] = { "one", "two" };
+ const char *three[] = { "one", "two", "three" };
+ const char *four[] = { "one", "two", "three", "four" };
+
+ assert_cmdline("one", one);
+ assert_cmdline("one two", two);
+ assert_cmdline("one two three", three);
+ assert_cmdline("one two three four", four);
+#endif
+}
+
+void test_process_win32__cmdline_escapes_whitespace(void)
+{
+#ifdef GIT_WIN32
+ const char *spaces[] = { "one with spaces" };
+ const char *tabs[] = { "one\twith\ttabs" };
+ const char *multiple[] = { "one with many spaces" };
+
+ assert_cmdline("one\" \"with\" \"spaces", spaces);
+ assert_cmdline("one\"\t\"with\"\t\"tabs", tabs);
+ assert_cmdline("one\" \"with\" \"many\" \"spaces", multiple);
+#endif
+}
+
+void test_process_win32__cmdline_escapes_quotes(void)
+{
+#ifdef GIT_WIN32
+ const char *one[] = { "echo", "\"hello world\"" };
+
+ assert_cmdline("echo \\\"hello\" \"world\\\"", one);
+#endif
+}
+
+void test_process_win32__cmdline_escapes_backslash(void)
+{
+#ifdef GIT_WIN32
+ const char *one[] = { "foo\\bar", "foo\\baz" };
+ const char *two[] = { "c:\\program files\\foo bar\\foo bar.exe", "c:\\path\\to\\other\\", "/a", "/b" };
+
+ assert_cmdline("foo\\\\bar foo\\\\baz", one);
+ assert_cmdline("c:\\\\program\" \"files\\\\foo\" \"bar\\\\foo\" \"bar.exe c:\\\\path\\\\to\\\\other\\\\ /a /b", two);
+#endif
+}
diff --git a/tests/util/sha1.c b/tests/util/sha1.c
index fe4032c13ec..c144def714f 100644
--- a/tests/util/sha1.c
+++ b/tests/util/sha1.c
@@ -70,7 +70,7 @@ void test_sha1__detect_collision_attack(void)
0x9a, 0xe6, 0xa4, 0xc8, 0x0c, 0xad, 0xcc, 0xbb, 0x7f, 0x0a
};
-#ifdef GIT_SHA1_COLLISIONDETECT
+#ifdef GIT_SHA1_BUILTIN
GIT_UNUSED(&expected);
cl_git_fail(sha1_file(actual, FIXTURE_DIR "/shattered-1.pdf"));
cl_assert_equal_s("SHA1 collision attack detected", git_error_last()->message);
diff --git a/tests/util/str/oom.c b/tests/util/str/oom.c
index dd3796674f6..810c1f25a7a 100644
--- a/tests/util/str/oom.c
+++ b/tests/util/str/oom.c
@@ -1,4 +1,5 @@
#include "clar_libgit2.h"
+#include "clar_libgit2_alloc.h"
/* Override default allocators with ones that will fail predictably. */
@@ -56,3 +57,15 @@ void test_str_oom__grow_by(void)
cl_assert(git_str_grow_by(&buf, 101) == -1);
cl_assert(git_str_oom(&buf));
}
+
+void test_str_oom__allocation_failure(void)
+{
+ git_str buf = GIT_STR_INIT;
+
+ cl_alloc_limit(10);
+
+ cl_git_pass(git_str_puts(&buf, "foobar"));
+ cl_git_fail(git_str_puts(&buf, "foobar"));
+
+ cl_alloc_reset();
+}
diff --git a/tests/util/string.c b/tests/util/string.c
index de04dea6983..051f8c3298c 100644
--- a/tests/util/string.c
+++ b/tests/util/string.c
@@ -111,12 +111,6 @@ void test_string__strcasecmp(void)
cl_assert(git__strcasecmp("foo", "FOO") == 0);
cl_assert(git__strcasecmp("foo", "fOO") == 0);
- cl_assert(strcasecmp("rt\303\202of", "rt dev\302\266h") > 0);
- cl_assert(strcasecmp("e\342\202\254ghi=", "et") > 0);
- cl_assert(strcasecmp("rt dev\302\266h", "rt\303\202of") < 0);
- cl_assert(strcasecmp("et", "e\342\202\254ghi=") < 0);
- cl_assert(strcasecmp("\303\215", "\303\255") < 0);
-
cl_assert(git__strcasecmp("rt\303\202of", "rt dev\302\266h") > 0);
cl_assert(git__strcasecmp("e\342\202\254ghi=", "et") > 0);
cl_assert(git__strcasecmp("rt dev\302\266h", "rt\303\202of") < 0);
diff --git a/tests/util/strmap.c b/tests/util/strmap.c
deleted file mode 100644
index c4f5c864704..00000000000
--- a/tests/util/strmap.c
+++ /dev/null
@@ -1,190 +0,0 @@
-#include "clar_libgit2.h"
-#include "strmap.h"
-
-static git_strmap *g_table;
-
-void test_strmap__initialize(void)
-{
- cl_git_pass(git_strmap_new(&g_table));
- cl_assert(g_table != NULL);
-}
-
-void test_strmap__cleanup(void)
-{
- git_strmap_free(g_table);
-}
-
-void test_strmap__0(void)
-{
- cl_assert(git_strmap_size(g_table) == 0);
-}
-
-static void insert_strings(git_strmap *table, size_t count)
-{
- size_t i, j, over;
- char *str;
-
- for (i = 0; i < count; ++i) {
- str = malloc(10);
- for (j = 0; j < 10; ++j)
- str[j] = 'a' + (i % 26);
- str[9] = '\0';
-
- /* if > 26, then encode larger value in first letters */
- for (j = 0, over = i / 26; over > 0; j++, over = over / 26)
- str[j] = 'A' + (over % 26);
-
- cl_git_pass(git_strmap_set(table, str, str));
- }
-
- cl_assert_equal_i(git_strmap_size(table), count);
-}
-
-void test_strmap__inserted_strings_can_be_retrieved(void)
-{
- char *str;
- int i;
-
- insert_strings(g_table, 20);
-
- cl_assert(git_strmap_exists(g_table, "aaaaaaaaa"));
- cl_assert(git_strmap_exists(g_table, "ggggggggg"));
- cl_assert(!git_strmap_exists(g_table, "aaaaaaaab"));
- cl_assert(!git_strmap_exists(g_table, "abcdefghi"));
-
- i = 0;
- git_strmap_foreach_value(g_table, str, { i++; free(str); });
- cl_assert(i == 20);
-}
-
-void test_strmap__deleted_entry_cannot_be_retrieved(void)
-{
- char *str;
- int i;
-
- insert_strings(g_table, 20);
-
- cl_assert(git_strmap_exists(g_table, "bbbbbbbbb"));
- str = git_strmap_get(g_table, "bbbbbbbbb");
- cl_assert_equal_s(str, "bbbbbbbbb");
- cl_git_pass(git_strmap_delete(g_table, "bbbbbbbbb"));
- free(str);
-
- cl_assert(!git_strmap_exists(g_table, "bbbbbbbbb"));
-
- i = 0;
- git_strmap_foreach_value(g_table, str, { i++; free(str); });
- cl_assert_equal_i(i, 19);
-}
-
-void test_strmap__inserting_many_keys_succeeds(void)
-{
- char *str;
- int i;
-
- insert_strings(g_table, 10000);
-
- i = 0;
- git_strmap_foreach_value(g_table, str, { i++; free(str); });
- cl_assert_equal_i(i, 10000);
-}
-
-void test_strmap__get_succeeds_with_existing_entries(void)
-{
- const char *keys[] = { "foo", "bar", "gobble" };
- char *values[] = { "oof", "rab", "elbbog" };
- size_t i;
-
- for (i = 0; i < ARRAY_SIZE(keys); i++)
- cl_git_pass(git_strmap_set(g_table, keys[i], values[i]));
-
- cl_assert_equal_s(git_strmap_get(g_table, "foo"), "oof");
- cl_assert_equal_s(git_strmap_get(g_table, "bar"), "rab");
- cl_assert_equal_s(git_strmap_get(g_table, "gobble"), "elbbog");
-}
-
-void test_strmap__get_returns_null_on_nonexisting_key(void)
-{
- const char *keys[] = { "foo", "bar", "gobble" };
- char *values[] = { "oof", "rab", "elbbog" };
- size_t i;
-
- for (i = 0; i < ARRAY_SIZE(keys); i++)
- cl_git_pass(git_strmap_set(g_table, keys[i], values[i]));
-
- cl_assert_equal_p(git_strmap_get(g_table, "other"), NULL);
-}
-
-void test_strmap__set_persists_key(void)
-{
- cl_git_pass(git_strmap_set(g_table, "foo", "oof"));
- cl_assert_equal_s(git_strmap_get(g_table, "foo"), "oof");
-}
-
-void test_strmap__set_persists_multpile_keys(void)
-{
- cl_git_pass(git_strmap_set(g_table, "foo", "oof"));
- cl_git_pass(git_strmap_set(g_table, "bar", "rab"));
- cl_assert_equal_s(git_strmap_get(g_table, "foo"), "oof");
- cl_assert_equal_s(git_strmap_get(g_table, "bar"), "rab");
-}
-
-void test_strmap__set_updates_existing_key(void)
-{
- cl_git_pass(git_strmap_set(g_table, "foo", "oof"));
- cl_git_pass(git_strmap_set(g_table, "bar", "rab"));
- cl_git_pass(git_strmap_set(g_table, "gobble", "elbbog"));
- cl_assert_equal_i(git_strmap_size(g_table), 3);
-
- cl_git_pass(git_strmap_set(g_table, "foo", "other"));
- cl_assert_equal_i(git_strmap_size(g_table), 3);
-
- cl_assert_equal_s(git_strmap_get(g_table, "foo"), "other");
-}
-
-void test_strmap__iteration(void)
-{
- struct {
- char *key;
- char *value;
- int seen;
- } entries[] = {
- { "foo", "oof" },
- { "bar", "rab" },
- { "gobble", "elbbog" },
- };
- const char *key, *value;
- size_t i, n;
-
- for (i = 0; i < ARRAY_SIZE(entries); i++)
- cl_git_pass(git_strmap_set(g_table, entries[i].key, entries[i].value));
-
- i = 0, n = 0;
- while (git_strmap_iterate((void **) &value, g_table, &i, &key) == 0) {
- size_t j;
-
- for (j = 0; j < ARRAY_SIZE(entries); j++) {
- if (strcmp(entries[j].key, key))
- continue;
-
- cl_assert_equal_i(entries[j].seen, 0);
- cl_assert_equal_s(entries[j].value, value);
- entries[j].seen++;
- break;
- }
-
- n++;
- }
-
- for (i = 0; i < ARRAY_SIZE(entries); i++)
- cl_assert_equal_i(entries[i].seen, 1);
-
- cl_assert_equal_i(n, ARRAY_SIZE(entries));
-}
-
-void test_strmap__iterating_empty_map_stops_immediately(void)
-{
- size_t i = 0;
-
- cl_git_fail_with(git_strmap_iterate(NULL, g_table, &i, NULL), GIT_ITEROVER);
-}
diff --git a/tests/util/url/http.c b/tests/util/url/http.c
new file mode 100644
index 00000000000..88238896257
--- /dev/null
+++ b/tests/util/url/http.c
@@ -0,0 +1,752 @@
+#include "clar_libgit2.h"
+#include "net.h"
+
+static git_net_url conndata;
+
+void test_url_http__initialize(void)
+{
+ memset(&conndata, 0, sizeof(conndata));
+}
+
+void test_url_http__cleanup(void)
+{
+ git_net_url_dispose(&conndata);
+}
+
+/* Hostname */
+
+void test_url_http__has_scheme(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata, "http://example.com/resource"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "example.com");
+ cl_assert_equal_s(conndata.port, "80");
+ cl_assert_equal_s(conndata.path, "/resource");
+ cl_assert_equal_p(conndata.username, NULL);
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_p(conndata.query, NULL);
+ cl_assert_equal_p(conndata.fragment, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+}
+
+void test_url_http__no_scheme(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata, "example.com/resource"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "example.com");
+ cl_assert_equal_s(conndata.port, "80");
+ cl_assert_equal_s(conndata.path, "/resource");
+ cl_assert_equal_p(conndata.username, NULL);
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_p(conndata.query, NULL);
+ cl_assert_equal_p(conndata.fragment, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+}
+
+void test_url_http__hostname_root(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata, "example.com/"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "example.com");
+ cl_assert_equal_s(conndata.port, "80");
+ cl_assert_equal_s(conndata.path, "/");
+ cl_assert_equal_p(conndata.username, NULL);
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_p(conndata.query, NULL);
+ cl_assert_equal_p(conndata.fragment, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+}
+
+void test_url_http__hostname_implied_root(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata, "example.com"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "example.com");
+ cl_assert_equal_s(conndata.port, "80");
+ cl_assert_equal_s(conndata.path, "/");
+ cl_assert_equal_p(conndata.username, NULL);
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_p(conndata.query, NULL);
+ cl_assert_equal_p(conndata.fragment, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+}
+
+void test_url_http__hostname_numeric(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata, "8888888/"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "8888888");
+ cl_assert_equal_s(conndata.port, "80");
+ cl_assert_equal_s(conndata.path, "/");
+ cl_assert_equal_p(conndata.username, NULL);
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_p(conndata.query, NULL);
+ cl_assert_equal_p(conndata.fragment, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+}
+
+void test_url_http__hostname_implied_root_custom_port(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata, "example.com:42"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "example.com");
+ cl_assert_equal_s(conndata.port, "42");
+ cl_assert_equal_s(conndata.path, "/");
+ cl_assert_equal_p(conndata.username, NULL);
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_p(conndata.query, NULL);
+ cl_assert_equal_p(conndata.fragment, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+}
+
+void test_url_http__hostname_implied_root_empty_port(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata, "example.com:"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "example.com");
+ cl_assert_equal_s(conndata.port, "80");
+ cl_assert_equal_s(conndata.path, "/");
+ cl_assert_equal_p(conndata.username, NULL);
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_p(conndata.query, NULL);
+ cl_assert_equal_p(conndata.fragment, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+}
+
+void test_url_http__hostname_encoded_password(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata,
+ "user:pass%2fis%40bad@hostname.com:1234/"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "hostname.com");
+ cl_assert_equal_s(conndata.port, "1234");
+ cl_assert_equal_s(conndata.path, "/");
+ cl_assert_equal_s(conndata.username, "user");
+ cl_assert_equal_s(conndata.password, "pass/is@bad");
+ cl_assert_equal_p(conndata.query, NULL);
+ cl_assert_equal_p(conndata.fragment, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+}
+
+void test_url_http__hostname_user(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata,
+ "user@example.com/resource"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "example.com");
+ cl_assert_equal_s(conndata.port, "80");
+ cl_assert_equal_s(conndata.path, "/resource");
+ cl_assert_equal_s(conndata.username, "user");
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_p(conndata.query, NULL);
+ cl_assert_equal_p(conndata.fragment, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+}
+
+void test_url_http__hostname_user_pass(void)
+{
+ /* user:pass@hostname.tld/resource */
+ cl_git_pass(git_net_url_parse_http(&conndata,
+ "user:pass@example.com/resource"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "example.com");
+ cl_assert_equal_s(conndata.port, "80");
+ cl_assert_equal_s(conndata.path, "/resource");
+ cl_assert_equal_s(conndata.username, "user");
+ cl_assert_equal_s(conndata.password, "pass");
+ cl_assert_equal_p(conndata.query, NULL);
+ cl_assert_equal_p(conndata.fragment, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+}
+
+void test_url_http__hostname_port(void)
+{
+ /* hostname.tld:port/resource */
+ cl_git_pass(git_net_url_parse_http(&conndata,
+ "example.com:9191/resource"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "example.com");
+ cl_assert_equal_s(conndata.port, "9191");
+ cl_assert_equal_s(conndata.path, "/resource");
+ cl_assert_equal_p(conndata.username, NULL);
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_p(conndata.query, NULL);
+ cl_assert_equal_p(conndata.fragment, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+}
+
+void test_url_http__hostname_empty_port(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata, "example.com:/resource"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "example.com");
+ cl_assert_equal_s(conndata.port, "80");
+ cl_assert_equal_s(conndata.path, "/resource");
+ cl_assert_equal_p(conndata.username, NULL);
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_p(conndata.query, NULL);
+ cl_assert_equal_p(conndata.fragment, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+}
+
+void test_url_http__hostname_user_port(void)
+{
+ /* user@hostname.tld:port/resource */
+ cl_git_pass(git_net_url_parse_http(&conndata,
+ "user@example.com:9191/resource"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "example.com");
+ cl_assert_equal_s(conndata.port, "9191");
+ cl_assert_equal_s(conndata.path, "/resource");
+ cl_assert_equal_s(conndata.username, "user");
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_p(conndata.query, NULL);
+ cl_assert_equal_p(conndata.fragment, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+}
+
+void test_url_http__hostname_user_pass_port(void)
+{
+ /* user:pass@hostname.tld:port/resource */
+ cl_git_pass(git_net_url_parse_http(&conndata,
+ "user:pass@example.com:9191/resource"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "example.com");
+ cl_assert_equal_s(conndata.port, "9191");
+ cl_assert_equal_s(conndata.path, "/resource");
+ cl_assert_equal_s(conndata.username, "user");
+ cl_assert_equal_s(conndata.password, "pass");
+ cl_assert_equal_p(conndata.query, NULL);
+ cl_assert_equal_p(conndata.fragment, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+}
+
+void test_url_http__hostname_user_pass_port_query(void)
+{
+ /* user:pass@hostname.tld:port/resource */
+ cl_git_pass(git_net_url_parse_http(&conndata,
+ "user:pass@example.com:9191/resource?query=q&foo=bar&z=asdf"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "example.com");
+ cl_assert_equal_s(conndata.port, "9191");
+ cl_assert_equal_s(conndata.path, "/resource");
+ cl_assert_equal_s(conndata.username, "user");
+ cl_assert_equal_s(conndata.password, "pass");
+ cl_assert_equal_s(conndata.query, "query=q&foo=bar&z=asdf");
+ cl_assert_equal_p(conndata.fragment, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+}
+
+void test_url_http__hostname_user_pass_port_fragment(void)
+{
+ /* user:pass@hostname.tld:port/resource */
+ cl_git_pass(git_net_url_parse_http(&conndata,
+ "user:pass@example.com:9191/resource#fragment"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "example.com");
+ cl_assert_equal_s(conndata.port, "9191");
+ cl_assert_equal_s(conndata.path, "/resource");
+ cl_assert_equal_s(conndata.username, "user");
+ cl_assert_equal_s(conndata.password, "pass");
+ cl_assert_equal_p(conndata.query, NULL);
+ cl_assert_equal_s(conndata.fragment, "fragment");
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+}
+
+void test_url_http__hostname_user_pass_port_query_fragment(void)
+{
+ /* user:pass@hostname.tld:port/resource */
+ cl_git_pass(git_net_url_parse_http(&conndata,
+ "user:pass@example.com:9191/resource?query=q&foo=bar&z=asdf#fragment"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "example.com");
+ cl_assert_equal_s(conndata.port, "9191");
+ cl_assert_equal_s(conndata.path, "/resource");
+ cl_assert_equal_s(conndata.username, "user");
+ cl_assert_equal_s(conndata.password, "pass");
+ cl_assert_equal_s(conndata.query, "query=q&foo=bar&z=asdf");
+ cl_assert_equal_s(conndata.fragment, "fragment");
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+}
+
+void test_url_http__fragment_with_question_mark(void)
+{
+ /* user:pass@hostname.tld:port/resource */
+ cl_git_pass(git_net_url_parse_http(&conndata,
+ "user:pass@example.com:9191/resource#fragment_with?question_mark"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "example.com");
+ cl_assert_equal_s(conndata.port, "9191");
+ cl_assert_equal_s(conndata.path, "/resource");
+ cl_assert_equal_s(conndata.username, "user");
+ cl_assert_equal_s(conndata.password, "pass");
+ cl_assert_equal_p(conndata.query, NULL);
+ cl_assert_equal_s(conndata.fragment, "fragment_with?question_mark");
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+}
+
+/* IPv4 addresses */
+
+void test_url_http__ipv4_trivial(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata, "192.168.1.1/resource"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "192.168.1.1");
+ cl_assert_equal_s(conndata.port, "80");
+ cl_assert_equal_s(conndata.path, "/resource");
+ cl_assert_equal_p(conndata.username, NULL);
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+}
+
+void test_url_http__ipv4_root(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata, "192.168.1.1/"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "192.168.1.1");
+ cl_assert_equal_s(conndata.port, "80");
+ cl_assert_equal_s(conndata.path, "/");
+ cl_assert_equal_p(conndata.username, NULL);
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+}
+
+void test_url_http__ipv4_implied_root(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata, "192.168.1.1"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "192.168.1.1");
+ cl_assert_equal_s(conndata.port, "80");
+ cl_assert_equal_s(conndata.path, "/");
+ cl_assert_equal_p(conndata.username, NULL);
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+}
+
+void test_url_http__ipv4_implied_root_custom_port(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata, "192.168.1.1:42"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "192.168.1.1");
+ cl_assert_equal_s(conndata.port, "42");
+ cl_assert_equal_s(conndata.path, "/");
+ cl_assert_equal_p(conndata.username, NULL);
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+}
+
+void test_url_http__ipv4_implied_root_empty_port(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata, "192.168.1.1:"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "192.168.1.1");
+ cl_assert_equal_s(conndata.port, "80");
+ cl_assert_equal_s(conndata.path, "/");
+ cl_assert_equal_p(conndata.username, NULL);
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+}
+
+void test_url_http__ipv4_encoded_password(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata,
+ "user:pass%2fis%40bad@192.168.1.1:1234/"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "192.168.1.1");
+ cl_assert_equal_s(conndata.port, "1234");
+ cl_assert_equal_s(conndata.path, "/");
+ cl_assert_equal_s(conndata.username, "user");
+ cl_assert_equal_s(conndata.password, "pass/is@bad");
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+}
+
+void test_url_http__ipv4_user(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata,
+ "user@192.168.1.1/resource"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "192.168.1.1");
+ cl_assert_equal_s(conndata.port, "80");
+ cl_assert_equal_s(conndata.path, "/resource");
+ cl_assert_equal_s(conndata.username, "user");
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+}
+
+void test_url_http__ipv4_user_pass(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata,
+ "user:pass@192.168.1.1/resource"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "192.168.1.1");
+ cl_assert_equal_s(conndata.port, "80");
+ cl_assert_equal_s(conndata.path, "/resource");
+ cl_assert_equal_s(conndata.username, "user");
+ cl_assert_equal_s(conndata.password, "pass");
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+}
+
+void test_url_http__ipv4_port(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata,
+ "192.168.1.1:9191/resource"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "192.168.1.1");
+ cl_assert_equal_s(conndata.port, "9191");
+ cl_assert_equal_s(conndata.path, "/resource");
+ cl_assert_equal_p(conndata.username, NULL);
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+}
+
+void test_url_http__ipv4_empty_port(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata, "192.168.1.1:/resource"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "192.168.1.1");
+ cl_assert_equal_s(conndata.port, "80");
+ cl_assert_equal_s(conndata.path, "/resource");
+ cl_assert_equal_p(conndata.username, NULL);
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+}
+
+void test_url_http__ipv4_user_port(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata,
+ "user@192.168.1.1:9191/resource"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "192.168.1.1");
+ cl_assert_equal_s(conndata.port, "9191");
+ cl_assert_equal_s(conndata.path, "/resource");
+ cl_assert_equal_s(conndata.username, "user");
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+}
+
+void test_url_http__ipv4_user_pass_port(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata,
+ "user:pass@192.168.1.1:9191/resource"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "192.168.1.1");
+ cl_assert_equal_s(conndata.port, "9191");
+ cl_assert_equal_s(conndata.path, "/resource");
+ cl_assert_equal_s(conndata.username, "user");
+ cl_assert_equal_s(conndata.password, "pass");
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+}
+
+/* IPv6 addresses */
+
+void test_url_http__ipv6_trivial(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata, "[fe80::dcad:beff:fe00:0001]/resource"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001");
+ cl_assert_equal_s(conndata.port, "80");
+ cl_assert_equal_s(conndata.path, "/resource");
+ cl_assert_equal_p(conndata.username, NULL);
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+}
+
+void test_url_http__ipv6_root(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata, "[fe80::dcad:beff:fe00:0001]/"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001");
+ cl_assert_equal_s(conndata.port, "80");
+ cl_assert_equal_s(conndata.path, "/");
+ cl_assert_equal_p(conndata.username, NULL);
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+}
+
+void test_url_http__ipv6_implied_root(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata, "[fe80::dcad:beff:fe00:0001]"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001");
+ cl_assert_equal_s(conndata.port, "80");
+ cl_assert_equal_s(conndata.path, "/");
+ cl_assert_equal_p(conndata.username, NULL);
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+}
+
+void test_url_http__ipv6_implied_root_custom_port(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata, "[fe80::dcad:beff:fe00:0001]:42"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001");
+ cl_assert_equal_s(conndata.port, "42");
+ cl_assert_equal_s(conndata.path, "/");
+ cl_assert_equal_p(conndata.username, NULL);
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+}
+
+void test_url_http__ipv6_implied_root_empty_port(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata, "[fe80::dcad:beff:fe00:0001]:"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001");
+ cl_assert_equal_s(conndata.port, "80");
+ cl_assert_equal_s(conndata.path, "/");
+ cl_assert_equal_p(conndata.username, NULL);
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+}
+
+void test_url_http__ipv6_encoded_password(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata,
+ "user:pass%2fis%40bad@[fe80::dcad:beff:fe00:0001]:1234/"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001");
+ cl_assert_equal_s(conndata.port, "1234");
+ cl_assert_equal_s(conndata.path, "/");
+ cl_assert_equal_s(conndata.username, "user");
+ cl_assert_equal_s(conndata.password, "pass/is@bad");
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+}
+
+void test_url_http__ipv6_user(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata,
+ "user@[fe80::dcad:beff:fe00:0001]/resource"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001");
+ cl_assert_equal_s(conndata.port, "80");
+ cl_assert_equal_s(conndata.path, "/resource");
+ cl_assert_equal_s(conndata.username, "user");
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+}
+
+void test_url_http__ipv6_user_pass(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata,
+ "user:pass@[fe80::dcad:beff:fe00:0001]/resource"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001");
+ cl_assert_equal_s(conndata.port, "80");
+ cl_assert_equal_s(conndata.path, "/resource");
+ cl_assert_equal_s(conndata.username, "user");
+ cl_assert_equal_s(conndata.password, "pass");
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+}
+
+void test_url_http__ipv6_port(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata,
+ "[fe80::dcad:beff:fe00:0001]:9191/resource"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001");
+ cl_assert_equal_s(conndata.port, "9191");
+ cl_assert_equal_s(conndata.path, "/resource");
+ cl_assert_equal_p(conndata.username, NULL);
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+}
+
+void test_url_http__ipv6_empty_port(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata, "[fe80::dcad:beff:fe00:0001]:/resource"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001");
+ cl_assert_equal_s(conndata.port, "80");
+ cl_assert_equal_s(conndata.path, "/resource");
+ cl_assert_equal_p(conndata.username, NULL);
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+}
+
+void test_url_http__ipv6_user_port(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata,
+ "user@[fe80::dcad:beff:fe00:0001]:9191/resource"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001");
+ cl_assert_equal_s(conndata.port, "9191");
+ cl_assert_equal_s(conndata.path, "/resource");
+ cl_assert_equal_s(conndata.username, "user");
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+}
+
+void test_url_http__ipv6_user_pass_port(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata,
+ "user:pass@[fe80::dcad:beff:fe00:0001]:9191/resource"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "fe80::dcad:beff:fe00:0001");
+ cl_assert_equal_s(conndata.port, "9191");
+ cl_assert_equal_s(conndata.path, "/resource");
+ cl_assert_equal_s(conndata.username, "user");
+ cl_assert_equal_s(conndata.password, "pass");
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+}
+
+void test_url_http__ipv6_invalid_addresses(void)
+{
+ /* Opening bracket missing */
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "fe80::dcad:beff:fe00:0001]/resource"));
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "fe80::dcad:beff:fe00:0001]/"));
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "fe80::dcad:beff:fe00:0001]"));
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "fe80::dcad:beff:fe00:0001]:42"));
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "fe80::dcad:beff:fe00:0001]:"));
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "user:pass%2fis%40bad@fe80::dcad:beff:fe00:0001]:1234/"));
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "user@fe80::dcad:beff:fe00:0001]/resource"));
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "user:pass@fe80::dcad:beff:fe00:0001]/resource"));
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "fe80::dcad:beff:fe00:0001]:9191/resource"));
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "fe80::dcad:beff:fe00:0001]:/resource"));
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "user@fe80::dcad:beff:fe00:0001]:9191/resource"));
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "user:pass@fe80::dcad:beff:fe00:0001]:9191/resource"));
+
+ /* Closing bracket missing */
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "[fe80::dcad:beff:fe00:0001/resource"));
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "[fe80::dcad:beff:fe00:0001/"));
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "[fe80::dcad:beff:fe00:0001"));
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "[fe80::dcad:beff:fe00:0001:42"));
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "[fe80::dcad:beff:fe00:0001:"));
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "user:pass%2fis%40bad@[fe80::dcad:beff:fe00:0001:1234/"));
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "user@[fe80::dcad:beff:fe00:0001/resource"));
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "user:pass@[fe80::dcad:beff:fe00:0001/resource"));
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "[fe80::dcad:beff:fe00:0001:9191/resource"));
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "[fe80::dcad:beff:fe00:0001:/resource"));
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "user@[fe80::dcad:beff:fe00:0001:9191/resource"));
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "user:pass@[fe80::dcad:beff:fe00:0001:9191/resource"));
+
+ /* Both brackets missing */
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "fe80::dcad:beff:fe00:0001/resource"));
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "fe80::dcad:beff:fe00:0001/"));
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "fe80::dcad:beff:fe00:0001"));
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "fe80::dcad:beff:fe00:0001:42"));
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "fe80::dcad:beff:fe00:0001:"));
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "user:pass%2fis%40bad@fe80::dcad:beff:fe00:0001:1234/"));
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "user@fe80::dcad:beff:fe00:0001/resource"));
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "user:pass@fe80::dcad:beff:fe00:0001/resource"));
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "fe80::dcad:beff:fe00:0001:9191/resource"));
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "fe80::dcad:beff:fe00:0001:/resource"));
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "user@fe80::dcad:beff:fe00:0001:9191/resource"));
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "user:pass@fe80::dcad:beff:fe00:0001:9191/resource"));
+
+ /* Invalid character inside address */
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata, "[fe8o::dcad:beff:fe00:0001]/resource"));
+
+ /* Characters before/after braces */
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "fe80::[dcad:beff:fe00:0001]/resource"));
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "cafe[fe80::dcad:beff:fe00:0001]/resource"));
+ cl_git_fail_with(GIT_EINVALIDSPEC, git_net_url_parse_http(&conndata,
+ "[fe80::dcad:beff:fe00:0001]cafe/resource"));
+}
+
+/* Oddities */
+
+void test_url_http__invalid_scheme_is_relative(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata, "foo!bar://host:42/path/to/project?query_string=yes"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "foo!bar");
+ cl_assert_equal_s(conndata.port, "80");
+ cl_assert_equal_s(conndata.path, "//host:42/path/to/project");
+ cl_assert_equal_p(conndata.username, NULL);
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_s(conndata.query, "query_string=yes");
+ cl_assert_equal_p(conndata.fragment, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+}
+
+void test_url_http__scheme_case_is_normalized(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata, "GIT+SSH://host:42/path/to/project"));
+ cl_assert_equal_s(conndata.scheme, "git+ssh");
+}
+
+void test_url_http__no_scheme_relative_path(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata, "path"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "path");
+ cl_assert_equal_s(conndata.port, "80");
+ cl_assert_equal_s(conndata.path, "/");
+ cl_assert_equal_p(conndata.username, NULL);
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+}
+
+void test_url_http__no_scheme_absolute_path(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata, "/path"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_p(conndata.host, NULL);
+ cl_assert_equal_s(conndata.port, "80");
+ cl_assert_equal_s(conndata.path, "/path");
+ cl_assert_equal_p(conndata.username, NULL);
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+}
+
+void test_url_http__empty_path_with_empty_authority(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata, ""));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_p(conndata.host, NULL);
+ cl_assert_equal_s(conndata.port, "80");
+ cl_assert_equal_s(conndata.path, "/");
+ cl_assert_equal_p(conndata.username, NULL);
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+}
+
+void test_url_http__spaces_in_the_name(void)
+{
+ cl_git_pass(git_net_url_parse_http(&conndata, "libgit2@dev.azure.com/libgit2/test/_git/spaces%20in%20the%20name"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "dev.azure.com");
+ cl_assert_equal_s(conndata.port, "80");
+ cl_assert_equal_s(conndata.path, "/libgit2/test/_git/spaces%20in%20the%20name");
+ cl_assert_equal_s(conndata.username, "libgit2");
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+}
diff --git a/tests/util/url/joinpath.c b/tests/util/url/joinpath.c
index 9fc02cde4a9..6027093e492 100644
--- a/tests/util/url/joinpath.c
+++ b/tests/util/url/joinpath.c
@@ -1,6 +1,5 @@
#include "clar_libgit2.h"
#include "net.h"
-#include "netops.h"
static git_net_url source, target;
diff --git a/tests/util/url/parse.c b/tests/util/url/parse.c
index 631d9b456d9..ece379780ac 100644
--- a/tests/util/url/parse.c
+++ b/tests/util/url/parse.c
@@ -27,6 +27,7 @@ void test_url_parse__hostname_trivial(void)
cl_assert_equal_p(conndata.query, NULL);
cl_assert_equal_p(conndata.fragment, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_parse__hostname_root(void)
@@ -41,6 +42,7 @@ void test_url_parse__hostname_root(void)
cl_assert_equal_p(conndata.query, NULL);
cl_assert_equal_p(conndata.fragment, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_parse__hostname_implied_root(void)
@@ -55,6 +57,7 @@ void test_url_parse__hostname_implied_root(void)
cl_assert_equal_p(conndata.query, NULL);
cl_assert_equal_p(conndata.fragment, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_parse__hostname_numeric(void)
@@ -69,6 +72,7 @@ void test_url_parse__hostname_numeric(void)
cl_assert_equal_p(conndata.query, NULL);
cl_assert_equal_p(conndata.fragment, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_parse__hostname_implied_root_custom_port(void)
@@ -83,6 +87,22 @@ void test_url_parse__hostname_implied_root_custom_port(void)
cl_assert_equal_p(conndata.query, NULL);
cl_assert_equal_p(conndata.fragment, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+ cl_assert_equal_i(conndata.port_specified, 1);
+}
+
+void test_url_parse__specified_default_port(void)
+{
+ cl_git_pass(git_net_url_parse(&conndata, "http://example.com:80/"));
+ cl_assert_equal_s(conndata.scheme, "http");
+ cl_assert_equal_s(conndata.host, "example.com");
+ cl_assert_equal_s(conndata.port, "80");
+ cl_assert_equal_s(conndata.path, "/");
+ cl_assert_equal_p(conndata.username, NULL);
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_p(conndata.query, NULL);
+ cl_assert_equal_p(conndata.fragment, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 1);
}
void test_url_parse__hostname_implied_root_empty_port(void)
@@ -97,6 +117,7 @@ void test_url_parse__hostname_implied_root_empty_port(void)
cl_assert_equal_p(conndata.query, NULL);
cl_assert_equal_p(conndata.fragment, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_parse__hostname_encoded_password(void)
@@ -112,6 +133,7 @@ void test_url_parse__hostname_encoded_password(void)
cl_assert_equal_p(conndata.query, NULL);
cl_assert_equal_p(conndata.fragment, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+ cl_assert_equal_i(conndata.port_specified, 1);
}
void test_url_parse__hostname_user(void)
@@ -127,6 +149,7 @@ void test_url_parse__hostname_user(void)
cl_assert_equal_p(conndata.query, NULL);
cl_assert_equal_p(conndata.fragment, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_parse__hostname_user_pass(void)
@@ -143,6 +166,7 @@ void test_url_parse__hostname_user_pass(void)
cl_assert_equal_p(conndata.query, NULL);
cl_assert_equal_p(conndata.fragment, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_parse__hostname_port(void)
@@ -159,6 +183,7 @@ void test_url_parse__hostname_port(void)
cl_assert_equal_p(conndata.query, NULL);
cl_assert_equal_p(conndata.fragment, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+ cl_assert_equal_i(conndata.port_specified, 1);
}
void test_url_parse__hostname_empty_port(void)
@@ -173,6 +198,7 @@ void test_url_parse__hostname_empty_port(void)
cl_assert_equal_p(conndata.query, NULL);
cl_assert_equal_p(conndata.fragment, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_parse__hostname_user_port(void)
@@ -189,6 +215,7 @@ void test_url_parse__hostname_user_port(void)
cl_assert_equal_p(conndata.query, NULL);
cl_assert_equal_p(conndata.fragment, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+ cl_assert_equal_i(conndata.port_specified, 1);
}
void test_url_parse__hostname_user_pass_port(void)
@@ -205,6 +232,7 @@ void test_url_parse__hostname_user_pass_port(void)
cl_assert_equal_p(conndata.query, NULL);
cl_assert_equal_p(conndata.fragment, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+ cl_assert_equal_i(conndata.port_specified, 1);
}
void test_url_parse__hostname_user_pass_port_query(void)
@@ -221,6 +249,7 @@ void test_url_parse__hostname_user_pass_port_query(void)
cl_assert_equal_s(conndata.query, "query=q&foo=bar&z=asdf");
cl_assert_equal_p(conndata.fragment, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+ cl_assert_equal_i(conndata.port_specified, 1);
}
void test_url_parse__hostname_user_pass_port_fragment(void)
@@ -237,6 +266,7 @@ void test_url_parse__hostname_user_pass_port_fragment(void)
cl_assert_equal_p(conndata.query, NULL);
cl_assert_equal_s(conndata.fragment, "fragment");
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+ cl_assert_equal_i(conndata.port_specified, 1);
}
void test_url_parse__hostname_user_pass_port_query_fragment(void)
@@ -253,6 +283,7 @@ void test_url_parse__hostname_user_pass_port_query_fragment(void)
cl_assert_equal_s(conndata.query, "query=q&foo=bar&z=asdf");
cl_assert_equal_s(conndata.fragment, "fragment");
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+ cl_assert_equal_i(conndata.port_specified, 1);
}
void test_url_parse__fragment_with_question_mark(void)
@@ -269,6 +300,7 @@ void test_url_parse__fragment_with_question_mark(void)
cl_assert_equal_p(conndata.query, NULL);
cl_assert_equal_s(conndata.fragment, "fragment_with?question_mark");
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+ cl_assert_equal_i(conndata.port_specified, 1);
}
/* IPv4 addresses */
@@ -283,6 +315,7 @@ void test_url_parse__ipv4_trivial(void)
cl_assert_equal_p(conndata.username, NULL);
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_parse__ipv4_root(void)
@@ -295,6 +328,7 @@ void test_url_parse__ipv4_root(void)
cl_assert_equal_p(conndata.username, NULL);
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_parse__ipv4_implied_root(void)
@@ -307,6 +341,7 @@ void test_url_parse__ipv4_implied_root(void)
cl_assert_equal_p(conndata.username, NULL);
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_parse__ipv4_implied_root_custom_port(void)
@@ -319,6 +354,7 @@ void test_url_parse__ipv4_implied_root_custom_port(void)
cl_assert_equal_p(conndata.username, NULL);
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+ cl_assert_equal_i(conndata.port_specified, 1);
}
void test_url_parse__ipv4_implied_root_empty_port(void)
@@ -331,6 +367,7 @@ void test_url_parse__ipv4_implied_root_empty_port(void)
cl_assert_equal_p(conndata.username, NULL);
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_parse__ipv4_encoded_password(void)
@@ -344,6 +381,7 @@ void test_url_parse__ipv4_encoded_password(void)
cl_assert_equal_s(conndata.username, "user");
cl_assert_equal_s(conndata.password, "pass/is@bad");
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+ cl_assert_equal_i(conndata.port_specified, 1);
}
void test_url_parse__ipv4_user(void)
@@ -357,6 +395,7 @@ void test_url_parse__ipv4_user(void)
cl_assert_equal_s(conndata.username, "user");
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_parse__ipv4_user_pass(void)
@@ -370,6 +409,7 @@ void test_url_parse__ipv4_user_pass(void)
cl_assert_equal_s(conndata.username, "user");
cl_assert_equal_s(conndata.password, "pass");
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_parse__ipv4_port(void)
@@ -383,6 +423,7 @@ void test_url_parse__ipv4_port(void)
cl_assert_equal_p(conndata.username, NULL);
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+ cl_assert_equal_i(conndata.port_specified, 1);
}
void test_url_parse__ipv4_empty_port(void)
@@ -395,6 +436,7 @@ void test_url_parse__ipv4_empty_port(void)
cl_assert_equal_p(conndata.username, NULL);
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_parse__ipv4_user_port(void)
@@ -408,6 +450,7 @@ void test_url_parse__ipv4_user_port(void)
cl_assert_equal_s(conndata.username, "user");
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+ cl_assert_equal_i(conndata.port_specified, 1);
}
void test_url_parse__ipv4_user_pass_port(void)
@@ -421,6 +464,7 @@ void test_url_parse__ipv4_user_pass_port(void)
cl_assert_equal_s(conndata.username, "user");
cl_assert_equal_s(conndata.password, "pass");
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+ cl_assert_equal_i(conndata.port_specified, 1);
}
/* IPv6 addresses */
@@ -435,6 +479,7 @@ void test_url_parse__ipv6_trivial(void)
cl_assert_equal_p(conndata.username, NULL);
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_parse__ipv6_root(void)
@@ -447,6 +492,7 @@ void test_url_parse__ipv6_root(void)
cl_assert_equal_p(conndata.username, NULL);
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_parse__ipv6_implied_root(void)
@@ -459,6 +505,7 @@ void test_url_parse__ipv6_implied_root(void)
cl_assert_equal_p(conndata.username, NULL);
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_parse__ipv6_implied_root_custom_port(void)
@@ -471,6 +518,7 @@ void test_url_parse__ipv6_implied_root_custom_port(void)
cl_assert_equal_p(conndata.username, NULL);
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+ cl_assert_equal_i(conndata.port_specified, 1);
}
void test_url_parse__ipv6_implied_root_empty_port(void)
@@ -483,6 +531,7 @@ void test_url_parse__ipv6_implied_root_empty_port(void)
cl_assert_equal_p(conndata.username, NULL);
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_parse__ipv6_encoded_password(void)
@@ -496,6 +545,7 @@ void test_url_parse__ipv6_encoded_password(void)
cl_assert_equal_s(conndata.username, "user");
cl_assert_equal_s(conndata.password, "pass/is@bad");
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+ cl_assert_equal_i(conndata.port_specified, 1);
}
void test_url_parse__ipv6_user(void)
@@ -509,6 +559,7 @@ void test_url_parse__ipv6_user(void)
cl_assert_equal_s(conndata.username, "user");
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_parse__ipv6_user_pass(void)
@@ -522,6 +573,7 @@ void test_url_parse__ipv6_user_pass(void)
cl_assert_equal_s(conndata.username, "user");
cl_assert_equal_s(conndata.password, "pass");
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_parse__ipv6_port(void)
@@ -535,6 +587,7 @@ void test_url_parse__ipv6_port(void)
cl_assert_equal_p(conndata.username, NULL);
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+ cl_assert_equal_i(conndata.port_specified, 1);
}
void test_url_parse__ipv6_empty_port(void)
@@ -547,6 +600,7 @@ void test_url_parse__ipv6_empty_port(void)
cl_assert_equal_p(conndata.username, NULL);
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_parse__ipv6_user_port(void)
@@ -560,6 +614,7 @@ void test_url_parse__ipv6_user_port(void)
cl_assert_equal_s(conndata.username, "user");
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+ cl_assert_equal_i(conndata.port_specified, 1);
}
void test_url_parse__ipv6_user_pass_port(void)
@@ -573,6 +628,7 @@ void test_url_parse__ipv6_user_pass_port(void)
cl_assert_equal_s(conndata.username, "user");
cl_assert_equal_s(conndata.password, "pass");
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+ cl_assert_equal_i(conndata.port_specified, 1);
}
void test_url_parse__ipv6_invalid_addresses(void)
@@ -669,6 +725,21 @@ void test_url_parse__ipv6_invalid_addresses(void)
/* Oddities */
+void test_url_parse__empty_scheme(void)
+{
+ cl_git_pass(git_net_url_parse(&conndata, "://example.com/resource"));
+ cl_assert_equal_s(conndata.scheme, NULL);
+ cl_assert_equal_s(conndata.host, NULL);
+ cl_assert_equal_s(conndata.port, NULL);
+ cl_assert_equal_s(conndata.path, "//example.com/resource");
+ cl_assert_equal_p(conndata.username, NULL);
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_p(conndata.query, NULL);
+ cl_assert_equal_p(conndata.fragment, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+ cl_assert_equal_i(conndata.port_specified, 0);
+}
+
void test_url_parse__invalid_scheme_is_relative(void)
{
cl_git_pass(git_net_url_parse(&conndata, "foo!bar://host:42/path/to/project?query_string=yes"));
@@ -681,12 +752,14 @@ void test_url_parse__invalid_scheme_is_relative(void)
cl_assert_equal_s(conndata.query, "query_string=yes");
cl_assert_equal_p(conndata.fragment, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_parse__scheme_case_is_normalized(void)
{
cl_git_pass(git_net_url_parse(&conndata, "GIT+SSH://host:42/path/to/project"));
cl_assert_equal_s(conndata.scheme, "git+ssh");
+ cl_assert_equal_i(conndata.port_specified, 1);
}
void test_url_parse__nonhierarchical_scheme(void)
@@ -699,6 +772,7 @@ void test_url_parse__nonhierarchical_scheme(void)
cl_assert_equal_p(conndata.username, NULL);
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_parse__no_scheme_relative_path(void)
@@ -711,6 +785,7 @@ void test_url_parse__no_scheme_relative_path(void)
cl_assert_equal_p(conndata.username, NULL);
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_parse__no_scheme_absolute_path(void)
@@ -723,6 +798,7 @@ void test_url_parse__no_scheme_absolute_path(void)
cl_assert_equal_p(conndata.username, NULL);
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_parse__empty_path(void)
@@ -735,6 +811,7 @@ void test_url_parse__empty_path(void)
cl_assert_equal_p(conndata.username, NULL);
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_parse__empty_path_with_empty_authority(void)
@@ -747,6 +824,7 @@ void test_url_parse__empty_path_with_empty_authority(void)
cl_assert_equal_p(conndata.username, NULL);
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_parse__http_follows_the_rfc(void)
@@ -764,6 +842,7 @@ void test_url_parse__ssh_from_terrible_google_rfc_violating_products(void)
cl_assert_equal_s(conndata.username, "my.email.address@gmail.com");
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+ cl_assert_equal_i(conndata.port_specified, 1);
}
void test_url_parse__ssh_with_password_from_terrible_google_rfc_violating_products(void)
@@ -776,6 +855,7 @@ void test_url_parse__ssh_with_password_from_terrible_google_rfc_violating_produc
cl_assert_equal_s(conndata.username, "my.email.address@gmail.com");
cl_assert_equal_s(conndata.password, "seekret");
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+ cl_assert_equal_i(conndata.port_specified, 1);
}
void test_url_parse__spaces_in_the_name(void)
@@ -788,4 +868,5 @@ void test_url_parse__spaces_in_the_name(void)
cl_assert_equal_s(conndata.username, "libgit2");
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
diff --git a/tests/util/url/redirect.c b/tests/util/url/redirect.c
index 5401778618f..a6f99dcdf09 100644
--- a/tests/util/url/redirect.c
+++ b/tests/util/url/redirect.c
@@ -1,6 +1,5 @@
#include "clar_libgit2.h"
#include "net.h"
-#include "netops.h"
static git_net_url conndata;
diff --git a/tests/util/url/scp.c b/tests/util/url/scp.c
index 0e0dce17eab..1fd7c313e0a 100644
--- a/tests/util/url/scp.c
+++ b/tests/util/url/scp.c
@@ -25,6 +25,7 @@ void test_url_scp__hostname_trivial(void)
cl_assert_equal_p(conndata.username, NULL);
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_scp__hostname_bracketed(void)
@@ -37,6 +38,7 @@ void test_url_scp__hostname_bracketed(void)
cl_assert_equal_p(conndata.username, NULL);
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_scp__hostname_root(void)
@@ -49,6 +51,7 @@ void test_url_scp__hostname_root(void)
cl_assert_equal_p(conndata.username, NULL);
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_scp__hostname_user(void)
@@ -61,6 +64,7 @@ void test_url_scp__hostname_user(void)
cl_assert_equal_s(conndata.username, "git");
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_scp__hostname_user_bracketed(void)
@@ -73,6 +77,7 @@ void test_url_scp__hostname_user_bracketed(void)
cl_assert_equal_s(conndata.username, "git");
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_scp__hostname_port(void)
@@ -85,6 +90,20 @@ void test_url_scp__hostname_port(void)
cl_assert_equal_p(conndata.username, NULL);
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+ cl_assert_equal_i(conndata.port_specified, 1);
+}
+
+void test_url_scp__hostname_specified_default_port(void)
+{
+ cl_git_pass(git_net_url_parse_scp(&conndata, "[example.com:22]:/resource"));
+ cl_assert_equal_s(conndata.scheme, "ssh");
+ cl_assert_equal_s(conndata.host, "example.com");
+ cl_assert_equal_s(conndata.port, "22");
+ cl_assert_equal_s(conndata.path, "/resource");
+ cl_assert_equal_p(conndata.username, NULL);
+ cl_assert_equal_p(conndata.password, NULL);
+ cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 1);
}
void test_url_scp__hostname_user_port(void)
@@ -97,6 +116,7 @@ void test_url_scp__hostname_user_port(void)
cl_assert_equal_s(conndata.username, "git");
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+ cl_assert_equal_i(conndata.port_specified, 1);
}
void test_url_scp__ipv4_trivial(void)
@@ -109,6 +129,7 @@ void test_url_scp__ipv4_trivial(void)
cl_assert_equal_p(conndata.username, NULL);
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_scp__ipv4_bracketed(void)
@@ -121,6 +142,7 @@ void test_url_scp__ipv4_bracketed(void)
cl_assert_equal_p(conndata.username, NULL);
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_scp__ipv4_user(void)
@@ -133,6 +155,7 @@ void test_url_scp__ipv4_user(void)
cl_assert_equal_s(conndata.username, "git");
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_scp__ipv4_port(void)
@@ -145,6 +168,7 @@ void test_url_scp__ipv4_port(void)
cl_assert_equal_p(conndata.username, NULL);
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+ cl_assert_equal_i(conndata.port_specified, 1);
}
void test_url_scp__ipv4_user_port(void)
@@ -157,6 +181,7 @@ void test_url_scp__ipv4_user_port(void)
cl_assert_equal_s(conndata.username, "git");
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+ cl_assert_equal_i(conndata.port_specified, 1);
}
void test_url_scp__ipv6_trivial(void)
@@ -169,6 +194,7 @@ void test_url_scp__ipv6_trivial(void)
cl_assert_equal_p(conndata.username, NULL);
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_scp__ipv6_user(void)
@@ -181,6 +207,7 @@ void test_url_scp__ipv6_user(void)
cl_assert_equal_s(conndata.username, "git");
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_scp__ipv6_port(void)
@@ -193,6 +220,7 @@ void test_url_scp__ipv6_port(void)
cl_assert_equal_p(conndata.username, NULL);
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+ cl_assert_equal_i(conndata.port_specified, 1);
}
void test_url_scp__ipv6_user_port(void)
@@ -205,6 +233,7 @@ void test_url_scp__ipv6_user_port(void)
cl_assert_equal_s(conndata.username, "git");
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 0);
+ cl_assert_equal_i(conndata.port_specified, 1);
}
void test_url_scp__hexhost_and_port(void)
@@ -217,6 +246,7 @@ void test_url_scp__hexhost_and_port(void)
cl_assert_equal_p(conndata.username, NULL);
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 1);
}
void test_url_scp__malformed_ipv6_one(void)
@@ -229,6 +259,7 @@ void test_url_scp__malformed_ipv6_one(void)
cl_assert_equal_p(conndata.username, NULL);
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_scp__malformed_ipv6_two(void)
@@ -241,6 +272,7 @@ void test_url_scp__malformed_ipv6_two(void)
cl_assert_equal_p(conndata.username, NULL);
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_scp__malformed_ipv6_with_user(void)
@@ -253,6 +285,7 @@ void test_url_scp__malformed_ipv6_with_user(void)
cl_assert_equal_s(conndata.username, "git");
cl_assert_equal_p(conndata.password, NULL);
cl_assert_equal_i(git_net_url_is_default_port(&conndata), 1);
+ cl_assert_equal_i(conndata.port_specified, 0);
}
void test_url_scp__invalid_addresses(void)
diff --git a/tests/util/vector.c b/tests/util/vector.c
index 04afaa49658..66f6b383406 100644
--- a/tests/util/vector.c
+++ b/tests/util/vector.c
@@ -12,7 +12,7 @@ void test_vector__0(void)
for (i = 0; i < 10; ++i) {
git_vector_insert(&x, (void*) 0xabc);
}
- git_vector_free(&x);
+ git_vector_dispose(&x);
}
@@ -27,7 +27,7 @@ void test_vector__1(void)
git_vector_insert(&x, (void*) 0x123);
git_vector_remove(&x, 0); /* used to read past array bounds. */
- git_vector_free(&x);
+ git_vector_dispose(&x);
}
@@ -59,7 +59,7 @@ void test_vector__2(void)
git_vector_uniq(&x, NULL);
cl_assert(x.length == 2);
- git_vector_free(&x);
+ git_vector_dispose(&x);
git__free(ptrs[0]);
git__free(ptrs[1]);
@@ -91,7 +91,7 @@ void test_vector__3(void)
cl_assert(git_vector_get(&x, i) == (void*)(i + 1));
}
- git_vector_free(&x);
+ git_vector_dispose(&x);
}
/* insert_sorted with duplicates */
@@ -122,7 +122,7 @@ void test_vector__4(void)
cl_assert(git_vector_get(&x, i) == (void*)(i / 2 + 1));
}
- git_vector_free(&x);
+ git_vector_dispose(&x);
}
typedef struct {
@@ -189,7 +189,7 @@ void test_vector__5(void)
_struct_count--;
}
- git_vector_free(&x);
+ git_vector_dispose(&x);
}
static int remove_ones(const git_vector *v, size_t idx, void *p)
@@ -274,7 +274,7 @@ void test_vector__remove_matching(void)
git_vector_remove_matching(&x, remove_ones, NULL);
cl_assert(x.length == 4);
- git_vector_free(&x);
+ git_vector_dispose(&x);
}
static void assert_vector(git_vector *x, void *expected[], size_t len)
@@ -376,7 +376,7 @@ void test_vector__grow_and_shrink(void)
git_vector_remove_range(&x, 0, 1);
assert_vector(&x, NULL, 0);
- git_vector_free(&x);
+ git_vector_dispose(&x);
}
void test_vector__reverse(void)
@@ -407,7 +407,7 @@ void test_vector__reverse(void)
for (i = 0; i < 5; i++)
cl_assert_equal_p(out2[i], git_vector_get(&v, i));
- git_vector_free(&v);
+ git_vector_dispose(&v);
}
void test_vector__dup_empty_vector(void)
@@ -426,5 +426,5 @@ void test_vector__dup_empty_vector(void)
cl_assert_equal_i(8, dup._alloc_size);
cl_assert_equal_i(1, dup.length);
- git_vector_free(&dup);
+ git_vector_dispose(&dup);
}