Lines Matching defs:be
29 * be able to statvfs(2) possibly large systems. This define gives us
71 #define IS_VOLATILE(be) ((be)->be_ppath != NULL)
342 * is repeated in backend_check_upgrade(), and must be kept in-sync.
374 * must be kept in sync with the indexing specification here.
493 sqlite_backend_t *be = arg;
496 (void) fprintf(stderr, "%d: %s\n", be->be_type, sql);
602 backend_error(sqlite_backend_t *be, int error, char *errmsg)
619 backend_panic("%s: db error: %s", be->be_path, errmsg);
642 * dirname will either be pathname, or ".".
794 backend_backup_base(sqlite_backend_t *be, const char *name,
804 (void) strlcpy(out, IS_VOLATILE(be) ? be->be_ppath : be->be_path,
846 backend_checkpoint_repository(sqlite_backend_t *be)
850 assert(be->be_readonly); /* Only need a checkpoint if / is ro */
851 assert(be->be_type == BACKEND_TYPE_NORMAL);
852 assert(be->be_checkpoint == NULL); /* Only 1 checkpoint */
854 r = backend_copy_repository(be->be_path, REPOSITORY_CHECKPOINT, 0);
856 be->be_checkpoint = REPOSITORY_CHECKPOINT;
997 backend_create_backup_locked(sqlite_backend_t *be, const char *name)
1032 if (be->be_readonly) {
1038 result = backend_backup_base(be, name, finalpath, PATH_MAX);
1048 if (be->be_checkpoint && name &&
1052 src = be->be_checkpoint;
1056 src = be->be_path;
1174 (void) unlink(be->be_checkpoint);
1175 be->be_checkpoint = NULL;
1200 backend_check_upgrade(sqlite_backend_t *be, boolean_t do_upgrade)
1211 r = sqlite_exec(be->be_db, "SELECT value_order FROM value_tbl LIMIT 1;",
1216 r = sqlite_exec(be->be_db,
1242 be->be_path, errp);
1253 backend_check_readonly(sqlite_backend_t *be, int writing, hrtime_t t)
1260 assert(be->be_readonly);
1261 assert(be == bes[BACKEND_TYPE_NORMAL]);
1264 * If we don't *need* to be writable, only check every once in a
1268 if ((uint64_t)(t - be->be_lastcheck) <
1271 be->be_lastcheck = t;
1275 * It could be that the repository has been moved to non-persistent
1278 * non-persistent path will always be writable.
1280 check_path = IS_VOLATILE(be) ? be->be_ppath : be->be_path;
1299 if (writing && (IS_VOLATILE(be) == 0))
1309 be->be_readonly = 0;
1311 if (IS_VOLATILE(be)) {
1327 sqlite_close(be->be_db);
1328 be->be_db = new;
1331 if (be->be_type == BACKEND_TYPE_NORMAL)
1332 backend_check_upgrade(be, B_TRUE);
1334 if (backend_create_backup_locked(be, REPOSITORY_BOOT_BACKUP) !=
1338 REPOSITORY_BOOT_BACKUP, be->be_path);
1354 sqlite_backend_t *be = NULL;
1362 be = bes[t];
1364 assert(be != NULL); /* should always be there */
1366 if (be == NULL)
1374 (void) pthread_mutex_lock(&be->be_lock);
1375 UPDATE_TOTALS_WR(be, writing, bt_lock, ts, vts);
1378 (void) pthread_mutex_unlock(&be->be_lock);
1381 be->be_thread = pthread_self();
1383 if (be->be_readonly) {
1387 r = backend_check_readonly(be, writing, ts);
1389 be->be_thread = 0;
1390 (void) pthread_mutex_unlock(&be->be_lock);
1396 (void) sqlite_trace(be->be_db, backend_trace_sql, be);
1398 (void) sqlite_trace(be->be_db, NULL, NULL);
1400 be->be_writing = writing;
1401 *bep = be;
1406 backend_unlock(sqlite_backend_t *be)
1408 be->be_writing = 0;
1409 be->be_thread = 0;
1410 (void) pthread_mutex_unlock(&be->be_lock);
1414 backend_destroy(sqlite_backend_t *be)
1416 if (be->be_db != NULL) {
1417 sqlite_close(be->be_db);
1418 be->be_db = NULL;
1420 be->be_thread = 0;
1421 (void) pthread_mutex_unlock(&be->be_lock);
1422 (void) pthread_mutex_destroy(&be->be_lock);
1426 backend_create_finish(backend_type_t backend_id, sqlite_backend_t *be)
1428 assert(MUTEX_HELD(&be->be_lock));
1429 assert(be == &be_info[backend_id]);
1431 bes[backend_id] = be;
1432 (void) pthread_mutex_unlock(&be->be_lock);
1464 sqlite_backend_t *be;
1467 result = backend_lock(BACKEND_TYPE_NORMAL, 0, &be);
1470 result = backend_create_backup_locked(be, name);
1471 backend_unlock(be);
1628 sqlite_backend_t *be;
1640 &be);
1657 if (strcmp(be->be_path, dst) == 0) {
1664 result = backend_copy_repository(be->be_path, dst, dir);
1678 free((char *)be->be_path);
1679 be->be_path = strdup(dst);
1680 if (be->be_path == NULL) {
1687 sqlite_close(be->be_db);
1688 be->be_db = new;
1691 be->be_ppath = NULL;
1698 be->be_ppath = REPOSITORY_DB;
1720 backend_unlock(be);
1835 sqlite_backend_t *be;
1843 be = &be_info[backend_id];
1845 assert(be->be_db == NULL);
1847 (void) pthread_mutex_init(&be->be_lock, NULL);
1848 (void) pthread_mutex_lock(&be->be_lock);
1850 be->be_type = backend_id;
1851 be->be_path = strdup(db_file);
1852 if (be->be_path == NULL) {
1857 be->be_db = sqlite_open(be->be_path, 0600, &errp);
1859 if (be->be_db == NULL) {
1880 r = sqlite_exec(be->be_db, "SELECT schema_version FROM schema_version;",
1886 * Could be an empty repository, could be pre-schema_version
1889 r = sqlite_exec(be->be_db, "SELECT count() FROM id_tbl;",
1894 *bep = be;
1904 backend_destroy(be);
1933 r = sqlite_exec(be->be_db, "PRAGMA integrity_check;",
1939 backend_destroy(be);
1985 " failed. The database might be damaged or a media error might have\n"
1989 " The system will not be able to boot until you have restored a working\n"
1995 " can be run to restore a backup version of your repository. See\n"
2009 * not be writable at this point. Actual upgrade is carried out
2013 * can be used when retrieving property values early in boot.
2016 backend_check_upgrade(be, B_FALSE);
2020 r = backend_is_readonly(be->be_db, be->be_path);
2025 backend_destroy(be);
2030 be->be_readonly = 1;
2031 *bep = be;
2035 *bep = be;
2040 backend_destroy(be);
2075 sqlite_backend_t *be;
2081 if ((ret = backend_lock(t, 0, &be)) != REP_PROTOCOL_SUCCESS)
2086 ret = sqlite_exec(be->be_db, q->bq_buf, cb, data, &errmsg);
2087 UPDATE_TOTALS(be, bt_exec, ts, vts);
2088 ret = backend_error(be, ret, errmsg);
2089 backend_unlock(be);
2111 sqlite_backend_t *be;
2120 if ((r = backend_lock(t, writable, &be)) != REP_PROTOCOL_SUCCESS) {
2125 ret->bt_be = be;
2143 sqlite_backend_t *be;
2145 be = tx->bt_be;
2151 * sqlite tends to be sticky with SQLITE_FULL, so we try
2155 new = sqlite_open(be->be_path, 0600, NULL);
2157 sqlite_close(be->be_db);
2158 be->be_db = new;
2161 backend_unlock(be);
2218 sqlite_backend_t *be;
2222 be = tx->bt_be;
2226 r = sqlite_exec(be->be_db, "ROLLBACK TRANSACTION", NULL, NULL,
2228 UPDATE_TOTALS(be, bt_exec, ts, vts);
2231 (void) backend_error(be, r, errmsg);
2245 sqlite_backend_t *be;
2249 be = tx->bt_be;
2252 r = sqlite_exec(be->be_db, "COMMIT TRANSACTION", NULL, NULL,
2254 UPDATE_TOTALS(be, bt_exec, ts, vts);
2258 r = backend_error(be, r, errmsg);
2262 r2 = sqlite_exec(be->be_db, "ROLLBACK TRANSACTION", NULL, NULL,
2264 r2 = backend_error(be, r2, errmsg);
2312 sqlite_backend_t *be;
2316 be = tx->bt_be;
2323 ret = sqlite_exec_printf(be->be_db,
2327 UPDATE_TOTALS(be, bt_exec, ts, vts);
2331 ret = backend_error(be, ret, errmsg);
2352 sqlite_backend_t *be;
2356 be = tx->bt_be;
2363 ret = sqlite_exec(be->be_db, q->bq_buf, cb, data, &errmsg);
2364 UPDATE_TOTALS(be, bt_exec, ts, vts);
2367 ret = backend_error(be, ret, errmsg);
2406 sqlite_backend_t *be;
2410 be = tx->bt_be;
2415 ret = sqlite_exec_vprintf(be->be_db, format, NULL, NULL, &errmsg, a);
2416 UPDATE_TOTALS(be, bt_exec, ts, vts);
2420 ret = backend_error(be, ret, errmsg);
2435 sqlite_backend_t *be;
2439 be = tx->bt_be;
2444 ret = sqlite_exec_vprintf(be->be_db, format, NULL, NULL, &errmsg, a);
2445 UPDATE_TOTALS(be, bt_exec, ts, vts);
2450 ret = backend_error(be, ret, errmsg);
2455 #define BACKEND_ADD_SCHEMA(be, file, tbls, idxs) \
2456 (backend_add_schema((be), (file), \
2461 backend_add_schema(sqlite_backend_t *be, const char *file,
2477 ret = sqlite_exec_printf(be->be_db,
2499 ret = sqlite_exec_printf(be->be_db,
2516 backend_init_schema(sqlite_backend_t *be, const char *db_file, backend_type_t t)
2525 ret = BACKEND_ADD_SCHEMA(be, db_file, tbls_normal, idxs_normal);
2527 ret = BACKEND_ADD_SCHEMA(be, db_file, tbls_np, idxs_np);
2536 ret = BACKEND_ADD_SCHEMA(be, db_file, tbls_common, idxs_common);
2544 ret = sqlite_exec_printf(be->be_db,
2559 ret = sqlite_exec_printf(be->be_db,
2574 ret = sqlite_exec_printf(be->be_db,
2591 sqlite_backend_t *be;
2602 configd_critical("Mismatched link! (%s should be %s)\n",
2614 * If the svc.configd crashed, there might be a leftover transient
2619 * manifest import. The other reason is that the repository may be
2638 r = backend_create(BACKEND_TYPE_NORMAL, db_file, &be);
2650 if (backend_init_schema(be, db_file, BACKEND_TYPE_NORMAL)) {
2651 backend_destroy(be);
2659 backend_create_finish(BACKEND_TYPE_NORMAL, be);
2663 * If there was a transient repository that could not be copied
2687 sqlite_close(be->be_db);
2688 be->be_db = fast_db;
2689 be->be_ppath = be->be_path;
2690 be->be_path = db_name_copy;
2699 r = backend_create(BACKEND_TYPE_NONPERSIST, npdb_file, &be);
2711 if (backend_init_schema(be, db_file,
2713 backend_destroy(be);
2721 backend_create_finish(BACKEND_TYPE_NONPERSIST, be);
2738 backend_lock(BACKEND_TYPE_NORMAL, 0, &be) ==
2740 if (backend_create_backup_locked(be,
2745 be->be_path);
2747 backend_unlock(be);
2757 * can be used to create the boot time backup of the
2763 backend_lock(BACKEND_TYPE_NORMAL, 0, &be) ==
2765 r = backend_checkpoint_repository(be);
2768 "of \"%s\"\n", be->be_path);
2770 backend_unlock(be);
2780 backend_lock(BACKEND_TYPE_NORMAL, 0, &be) ==
2786 be->be_checkpoint = REPOSITORY_CHECKPOINT;
2796 if (be->be_checkpoint && writable_persist) {
2797 if (backend_create_backup_locked(be,
2803 be->be_path);
2806 backend_unlock(be);
2820 r = backend_lock(BACKEND_TYPE_NORMAL, 1, &be);
2822 backend_check_upgrade(be, B_TRUE);
2823 backend_unlock(be);