e850b07 Merge branch 'pkg-lock-config' — HardenedBSD-pkg

modified libpkg/pkg.h.in

@@ -995,9 +995,8 @@ int pkgdb_open_all(struct pkgdb **db, pkgdb_t type, const char *reponame);

 /**
  * Locking functions
  */
 int pkgdb_obtain_lock(struct pkgdb *db, pkgdb_lock_t type, double delay, unsigned int retries);
 int pkgdb_upgrade_lock(struct pkgdb *db, pkgdb_lock_t old_type, pkgdb_lock_t new_type,
 		double delay, unsigned int retries);
 int pkgdb_obtain_lock(struct pkgdb *db, pkgdb_lock_t type);
 int pkgdb_upgrade_lock(struct pkgdb *db, pkgdb_lock_t old_type, pkgdb_lock_t new_type);
 int pkgdb_release_lock(struct pkgdb *db, pkgdb_lock_t type);
 /**

modified libpkg/pkg_config.c

@@ -294,6 +294,18 @@ static struct config_entry c[] = {

 		"NO",
 		"Match package names case sensitively",
 	},
 	{
 		PKG_INT,
 		"LOCK_WAIT",
 		"1",
 		"Wait time to regain a lock if it is not available"
 	},
 	{
 		PKG_INT,
 		"LOCK_RETRIES",
 		"5",
 		"Retries performed to obtain a lock"
 	}
 };
 static bool parsed = false;

modified libpkg/pkg_jobs.c

@@ -2021,7 +2021,7 @@ pkg_jobs_execute(struct pkg_jobs *j)

 	/* XXX: get rid of hardcoded values */
 	retcode = pkgdb_upgrade_lock(j->db, PKGDB_LOCK_ADVISORY,
 			PKGDB_LOCK_EXCLUSIVE, 0.5, 20);
 			PKGDB_LOCK_EXCLUSIVE);
 	if (retcode != EPKG_OK)
 		return (retcode);

modified libpkg/pkgdb.c

@@ -4175,13 +4175,15 @@ pkgdb_check_lock_pid(struct pkgdb *db)

 		if (pid != lpid) {
 			if (kill((pid_t)pid, 0) == -1) {
 				pkg_debug(1, "found stale pid %lld in lock database, my pid is: %lld",
 						pid, lpid);
 						(long long)pid, (long long)lpid);
 				if (pkgdb_remove_lock_pid(db, pid) != EPKG_OK){
 					sqlite3_finalize(stmt);
 					return (EPKG_FATAL);
 				}
 			}
 			else {
 				pkg_emit_notice("process with pid %lld still holds the lock",
 						(long long int)pid);
 				found ++;
 			}
 		}

@@ -4209,15 +4211,24 @@ pkgdb_reset_lock(struct pkgdb *db)

 }
 static int
 pkgdb_try_lock(struct pkgdb *db, const char *lock_sql,
 		double delay, unsigned int retries, pkgdb_lock_t type,
 pkgdb_try_lock(struct pkgdb *db, const char *lock_sql, pkgdb_lock_t type,
 		bool upgrade)
 {
 	unsigned int tries = 0;
 	struct timespec ts;
 	int ret = EPKG_END;
 	const pkg_object *timeout, *max_tries;
 	int64_t num_timeout = 1, num_maxtries = 1;
 	while (tries <= retries) {
 	timeout = pkg_config_get("LOCK_WAIT");
 	max_tries = pkg_config_get("LOCK_RETRIES");
 	if (timeout)
 		num_timeout = pkg_object_int(timeout);
 	if (max_tries)
 		num_maxtries = pkg_object_int(max_tries);
 	while (tries <= num_maxtries) {
 		ret = sqlite3_exec(db->sqlite, lock_sql, NULL, NULL, NULL);
 		if (ret != SQLITE_OK) {
 			if (ret == SQLITE_READONLY && type == PKGDB_LOCK_READONLY) {

@@ -4240,15 +4251,15 @@ pkgdb_try_lock(struct pkgdb *db, const char *lock_sql,

 					 * hence switch upgrade to retain
 					 */
 					pkgdb_remove_lock_pid(db, (int64_t)getpid());
 					return pkgdb_obtain_lock(db, type, delay, retries - tries);
 					return pkgdb_obtain_lock(db, type);
 				}
 				continue;
 			}
 			else if (delay > 0) {
 				ts.tv_sec = (int)delay;
 				ts.tv_nsec = (delay - (int)delay) * 1000000000.;
 			else if (num_timeout > 0) {
 				ts.tv_sec = (int)num_timeout;
 				ts.tv_nsec = (num_timeout - (int)num_timeout) * 1000000000.;
 				pkg_debug(1, "waiting for database lock for %d times, "
 						"next try in %.2f seconds", tries, delay);
 						"next try in %.2f seconds", tries, num_timeout);
 				(void)nanosleep(&ts, NULL);
 			}
 			else {

@@ -4270,8 +4281,7 @@ pkgdb_try_lock(struct pkgdb *db, const char *lock_sql,

 }
 int
 pkgdb_obtain_lock(struct pkgdb *db, pkgdb_lock_t type,
 		double delay, unsigned int retries)
 pkgdb_obtain_lock(struct pkgdb *db, pkgdb_lock_t type)
 {
 	int ret;
 	const char table_sql[] = ""

@@ -4323,14 +4333,13 @@ pkgdb_obtain_lock(struct pkgdb *db, pkgdb_lock_t type,

 		break;
 	}
 	ret = pkgdb_try_lock(db, lock_sql, delay, retries, type, false);
 	ret = pkgdb_try_lock(db, lock_sql, type, false);
 	return (ret);
 }
 int
 pkgdb_upgrade_lock(struct pkgdb *db, pkgdb_lock_t old_type, pkgdb_lock_t new_type,
 		double delay, unsigned int retries)
 pkgdb_upgrade_lock(struct pkgdb *db, pkgdb_lock_t old_type, pkgdb_lock_t new_type)
 {
 	const char advisory_exclusive_lock_sql[] = ""
 		"UPDATE pkg_lock SET exclusive=1,advisory=1 WHERE exclusive=0 AND advisory=1 AND read=0;";

@@ -4340,7 +4349,7 @@ pkgdb_upgrade_lock(struct pkgdb *db, pkgdb_lock_t old_type, pkgdb_lock_t new_typ

 	if (old_type == PKGDB_LOCK_ADVISORY && new_type == PKGDB_LOCK_EXCLUSIVE) {
 		pkg_debug(1, "want to upgrade advisory to exclusive lock");
 		ret = pkgdb_try_lock(db, advisory_exclusive_lock_sql, delay, retries,
 		ret = pkgdb_try_lock(db, advisory_exclusive_lock_sql,
 				new_type, true);
 	}

modified src/add.c

@@ -132,7 +132,7 @@ exec_add(int argc, char **argv)

 	if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK)
 		return (EX_IOERR);
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_EXCLUSIVE, 0, 0) != EPKG_OK) {
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_EXCLUSIVE) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get an exclusive lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);

modified src/annotate.c

@@ -298,7 +298,7 @@ exec_annotate(int argc, char **argv)

 		return (EX_IOERR);
 	}
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_EXCLUSIVE, 0, 0) != EPKG_OK) {
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_EXCLUSIVE) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get an exclusive lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);

modified src/audit.c

@@ -176,7 +176,7 @@ exec_audit(int argc, char **argv)

 		if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK)
 			return (EX_IOERR);
 		if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY, 0, 0) != EPKG_OK) {
 		if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY) != EPKG_OK) {
 			pkgdb_close(db);
 			warnx("Cannot get a read lock on a database, it is locked by another process");
 			return (EX_TEMPFAIL);

modified src/autoremove.c

@@ -101,7 +101,7 @@ exec_autoremove(__unused int argc, __unused char **argv)

 		return (EX_IOERR);
 	}
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_ADVISORY, 0, 0) != EPKG_OK) {
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_ADVISORY) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get an advisory lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);

modified src/check.c

@@ -149,7 +149,7 @@ fix_deps(struct pkgdb *db, struct deps_head *dh, int nbpkgs, bool yes)

 		return (EPKG_ENODB);
 	}
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_ADVISORY, 0, 0) != EPKG_OK) {
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_ADVISORY) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get an advisory lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);

@@ -354,7 +354,7 @@ exec_check(int argc, char **argv)

 	if (ret != EPKG_OK)
 		return (EX_IOERR);
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_ADVISORY, 0, 0) != EPKG_OK) {
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_ADVISORY) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get an advisory lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);

@@ -386,7 +386,7 @@ exec_check(int argc, char **argv)

 			}
 			if (recompute) {
 				if (pkgdb_upgrade_lock(db, PKGDB_LOCK_ADVISORY,
 						PKGDB_LOCK_EXCLUSIVE, 0.5, 20) == EPKG_OK) {
 						PKGDB_LOCK_EXCLUSIVE) == EPKG_OK) {
 					if (verbose)
 						pkg_printf("Recomputing size and checksums: %n\n", pkg);
 					if (pkg_recompute(db, pkg) != EPKG_OK) {

@@ -400,7 +400,7 @@ exec_check(int argc, char **argv)

 			}
 			if (reanalyse_shlibs) {
 				if (pkgdb_upgrade_lock(db, PKGDB_LOCK_ADVISORY,
 						PKGDB_LOCK_EXCLUSIVE, 0.5, 20) == EPKG_OK) {
 						PKGDB_LOCK_EXCLUSIVE) == EPKG_OK) {
 					if (verbose)
 						pkg_printf("Reanalyzing files for shlibs: %n\n", pkg);
 					if (pkgdb_reanalyse_shlibs(db, pkg) != EPKG_OK) {

@@ -419,7 +419,7 @@ exec_check(int argc, char **argv)

 			printf("\n>>> Missing package dependencies were detected.\n");
 			printf(">>> Found %d issue(s) in the package database.\n\n", nbpkgs);
 			if (pkgdb_upgrade_lock(db, PKGDB_LOCK_ADVISORY,
 					PKGDB_LOCK_EXCLUSIVE, 0.5, 20) == EPKG_OK) {
 					PKGDB_LOCK_EXCLUSIVE) == EPKG_OK) {
 				ret = fix_deps(db, &dh, nbpkgs, yes);
 				if (ret == EPKG_OK)
 					check_summary(db, &dh);

modified src/clean.c

@@ -222,7 +222,7 @@ exec_clean(int argc, char **argv)

 	if (pkgdb_open(&db, PKGDB_REMOTE) != EPKG_OK)
 		return (EX_IOERR);
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY, 0, 0) != EPKG_OK) {
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get a read lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);

modified src/convert.c

@@ -72,7 +72,7 @@ convert_to_old(const char *pkg_add_dbdir, bool dry_run)

 	if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK)
 		return (EX_IOERR);
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_EXCLUSIVE, 0, 0) != EPKG_OK) {
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_EXCLUSIVE) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get an exclusive lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);

modified src/create.c

@@ -91,7 +91,7 @@ pkg_create_matches(int argc, char **argv, match_t match, pkg_formats fmt,

 		return (EX_IOERR);
 	}
 	/* XXX: get rid of hardcoded timeouts */
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY, 0, 0) != EPKG_OK) {
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get a read lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);

modified src/delete.c

@@ -139,7 +139,7 @@ exec_delete(int argc, char **argv)

 	if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK)
 		return (EX_IOERR);
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_ADVISORY, 0, 0) != EPKG_OK) {
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_ADVISORY) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get an advisory lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);

modified src/fetch.c

@@ -160,7 +160,7 @@ exec_fetch(int argc, char **argv)

 	if (pkgdb_open_all(&db, PKGDB_REMOTE, reponame) != EPKG_OK)
 		return (EX_IOERR);
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY, 0, 0) != EPKG_OK) {
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get a read lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);

modified src/info.c

@@ -273,7 +273,7 @@ exec_info(int argc, char **argv)

 	if (ret != EPKG_OK)
 		return (EX_IOERR);
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY, 0, 0) != EPKG_OK) {
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get a read lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);

modified src/install.c

@@ -190,7 +190,7 @@ exec_install(int argc, char **argv)

 	    reponame) != EPKG_OK)
 		return (EX_IOERR);
 	if (pkgdb_obtain_lock(db, lock_type, 0, 0) != EPKG_OK) {
 	if (pkgdb_obtain_lock(db, lock_type) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get an advisory lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);

modified src/lock.c

@@ -117,7 +117,7 @@ list_locked()

 	if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK)
 		return (EX_IOERR);
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY, 0, 0) != EPKG_OK) {
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get a read lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);

@@ -227,7 +227,7 @@ exec_lock_unlock(int argc, char **argv, enum action action)

 	if (retcode != EPKG_OK)
 		return (EX_IOERR);
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_EXCLUSIVE, 0, 0) != EPKG_OK) {
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_EXCLUSIVE) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get an exclusive lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);

modified src/query.c

@@ -941,7 +941,7 @@ exec_query(int argc, char **argv)

 	if (ret != EPKG_OK)
 		return (EX_IOERR);
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY, 0, 0) != EPKG_OK) {
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get an read lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);

modified src/register.c

@@ -298,7 +298,7 @@ exec_register(int argc, char **argv)

 		if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK)
 			return (EX_IOERR);
 		if (pkgdb_obtain_lock(db, PKGDB_LOCK_EXCLUSIVE, 0, 0) != EPKG_OK) {
 		if (pkgdb_obtain_lock(db, PKGDB_LOCK_EXCLUSIVE) != EPKG_OK) {
 			pkgdb_close(db);
 			warnx("Cannot get an exclusive lock on a database, it is locked by another process");
 			return (EX_TEMPFAIL);

modified src/set.c

@@ -157,7 +157,7 @@ exec_set(int argc, char **argv)

 	if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK)
 		return (EX_IOERR);
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_EXCLUSIVE, 0, 0) != EPKG_OK) {
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_EXCLUSIVE) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get an exclusive lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);

modified src/shlib.c

@@ -177,7 +177,7 @@ exec_shlib(int argc, char **argv)

 	if (retcode != EPKG_OK)
 		return (EX_IOERR);
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY, 0, 0) != EPKG_OK) {
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get a read lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);

modified src/stats.c

@@ -82,7 +82,7 @@ exec_stats(__unused int argc, __unused char **argv)

 		return (EX_IOERR);
 	}
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY, 0, 0) != EPKG_OK) {
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get a read lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);

modified src/updating.c

@@ -107,7 +107,7 @@ exec_updating(int argc, char **argv)

 	if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK)
 		return (EX_IOERR);
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY, 0, 0) != EPKG_OK) {
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get a read lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);

modified src/upgrade.c

@@ -143,7 +143,7 @@ exec_upgrade(int argc, char **argv)

 	if (pkgdb_open_all(&db, PKGDB_REMOTE, reponame) != EPKG_OK)
 		return (EX_IOERR);
 	if (pkgdb_obtain_lock(db, lock_type, 0, 0) != EPKG_OK) {
 	if (pkgdb_obtain_lock(db, lock_type) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get an advisory lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);

modified src/version.c

@@ -385,7 +385,7 @@ do_source_index(unsigned int opt, char limchar, char *pattern, match_t match,

 	indexhead = hash_indexfile(indexfile);
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY, 0, 0) != EPKG_OK) {
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY) != EPKG_OK) {
 		pkgdb_close(db);
 		free_index(indexhead);
 		warnx("Cannot get a read lock on the database. "

@@ -454,7 +454,7 @@ do_source_remote(unsigned int opt, char limchar, char *pattern, match_t match,

 	if (pkgdb_open_all(&db, PKGDB_REMOTE, reponame) != EPKG_OK)
 		return (EX_IOERR);
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY, 0, 0) != EPKG_OK) {
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get a read lock on a database. "
 		      "It is locked by another process");

@@ -619,7 +619,7 @@ do_source_ports(unsigned int opt, char limchar, char *pattern, match_t match,

 	if (pkgdb_open(&db, PKGDB_DEFAULT) != EPKG_OK)
 		return (EX_IOERR);
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY, 0, 0) != EPKG_OK) {
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get a read lock on a database. "
 		      "It is locked by another process");

modified src/which.c

@@ -96,7 +96,7 @@ exec_which(int argc, char **argv)

 		return (EX_IOERR);
 	}
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY, 0, 0) != EPKG_OK) {
 	if (pkgdb_obtain_lock(db, PKGDB_LOCK_READONLY) != EPKG_OK) {
 		pkgdb_close(db);
 		warnx("Cannot get a read lock on a database, it is locked by another process");
 		return (EX_TEMPFAIL);