X-Git-Url: https://arthur.barton.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=etc%2Fcnid_dbd%2Fmain.c;h=55bbcddbb100c3b34fb34f5355d965c00bc6b3f0;hb=7be2a68aa70fa5641e944ad0aed6f699736d3de9;hp=5cafb2ef12f9a0de4e70098892fd61ee073fddf6;hpb=1677082f6a0fd3cf062d8e40885dc86b1d73dcc9;p=netatalk.git diff --git a/etc/cnid_dbd/main.c b/etc/cnid_dbd/main.c index 5cafb2ef..55bbcddb 100644 --- a/etc/cnid_dbd/main.c +++ b/etc/cnid_dbd/main.c @@ -1,6 +1,4 @@ /* - * $Id: main.c,v 1.16 2009-11-25 14:59:15 franklahm Exp $ - * * Copyright (C) Joerg Lenneis 2003 * Copyright (c) Frank Lahm 2009 * All Rights Reserved. See COPYING. @@ -10,44 +8,38 @@ #include "config.h" #endif /* HAVE_CONFIG_H */ -#ifdef HAVE_UNISTD_H #include -#endif /* HAVE_UNISTD_H */ -#ifdef HAVE_FCNTL_H #include -#endif /* HAVE_FCNTL_H */ #include #include #include #include #include -#ifdef HAVE_SYS_TYPES_H #include -#endif /* HAVE_SYS_TYPES_H */ #include -#ifdef HAVE_SYS_STAT_H #include -#endif /* HAVE_SYS_STAT_H */ #include #include +#include -#include #include #include +#include #include "db_param.h" #include "dbif.h" #include "dbd.h" #include "comm.h" -#define LOCKFILENAME "lock" - /* Note: DB_INIT_LOCK is here so we can run the db_* utilities while netatalk is running. It's a likey performance hit, but it might we worth it. */ #define DBOPTIONS (DB_CREATE | DB_INIT_LOG | DB_INIT_MPOOL | DB_INIT_LOCK | DB_INIT_TXN) +/* Global, needed by pack.c:idxname() */ +struct volinfo volinfo; + static DBD *dbd; static int exit_sig = 0; static int db_locked; @@ -72,57 +64,6 @@ static void block_sigs_onoff(int block) return; } -/*! - * Get lock on db lock file - * - * @args cmd (r) !=0: lock, 0: unlock - * @returns 1 if lock was acquired, 0 if file is already locked, -1 on error - */ -static int get_lock(int cmd) -{ - static int lockfd = -1; - struct flock lock; - - if (cmd == 0) { - if (lockfd == -1) - return -1; - - lock.l_start = 0; - lock.l_whence = SEEK_SET; - lock.l_len = 0; - lock.l_type = F_UNLCK; - fcntl(lockfd, F_SETLK, &lock); - close(lockfd); - lockfd = -1; - return 0; - } - - if (lockfd == -1) { - if ((lockfd = open(LOCKFILENAME, O_RDWR | O_CREAT, 0644)) < 0) { - LOG(log_error, logtype_cnid, "get_lock: error opening lockfile: %s", strerror(errno)); - return -1; - } - } - - lock.l_start = 0; - lock.l_whence = SEEK_SET; - lock.l_len = 0; - lock.l_type = F_WRLCK; - - if (fcntl(lockfd, F_SETLK, &lock) < 0) { - if (errno == EACCES || errno == EAGAIN) { - LOG(log_debug, logtype_cnid, "get_lock: couldn't lock"); - return 0; - } else { - LOG(log_error, logtype_cnid, "get_lock: fcntl F_WRLCK lockfile: %s", strerror(errno)); - return -1; - } - } - - LOG(log_debug, logtype_cnid, "get_lock: got lock"); - return 1; -} - /* The dbd_XXX and comm_XXX functions all obey the same protocol for return values: @@ -169,20 +110,6 @@ static int loop(struct db_param *dbp) dbp->flush_interval, timebuf); while (1) { - /* - * If we haven't got the lock yet, get it now. - * Prevents a race with dbd: - * 1. no cnid_dbd running - * 2. dbd -r starts, gets the lock - * 3. cnid_dbd starts, doesn't get lock, doesn't run recovery, all is fine - * 4. dbd from (2) finishes, drops lock - * 5. anothet dbd but this time with -re is started which - * - succeeds getting the lock - * - runs recovery => this kills (3) - */ - if (!db_locked) - if ((db_locked = get_lock(1)) == -1) - return -1; timeout = min(time_next_flush, time_last_rqst +dbp->idle_timeout); if (timeout > now) timeout -= now; @@ -241,12 +168,15 @@ static int loop(struct db_param *dbp) case CNID_DBD_OP_REBUILD_ADD: ret = dbd_rebuild_add(dbd, &rqst, &rply); break; + case CNID_DBD_OP_SEARCH: + ret = dbd_search(dbd, &rqst, &rply); + break; default: LOG(log_error, logtype_cnid, "loop: unknown op %d", rqst.op); ret = -1; break; } - + if ((cret = comm_snd(&rply)) < 0 || ret < 0) { dbif_txn_abort(dbd); return -1; @@ -344,50 +274,95 @@ static void set_signal(void) int main(int argc, char *argv[]) { struct db_param *dbp; - int err = 0; + int err = 0, ret, delete_bdb = 0; int ctrlfd, clntfd; - char *dir, *logconfig; + char *logconfig; set_processname("cnid_dbd"); - /* FIXME: implement -d from cnid_metad */ - if (argc != 5) { + while (( ret = getopt( argc, argv, "vVd")) != -1 ) { + switch (ret) { + case 'v': + case 'V': + printf("cnid_dbd (Netatalk %s)\n", VERSION); + return -1; + case 'd': + delete_bdb = 1; + break; + } + } + + if (argc - optind != 4) { LOG(log_error, logtype_cnid, "main: not enough arguments"); - exit(1); + exit(EXIT_FAILURE); + } + + /* Load .volinfo file */ + if (loadvolinfo(argv[optind], &volinfo) == -1) { + LOG(log_error, logtype_cnid, "Cant load volinfo for \"%s\"", argv[1]); + exit(EXIT_FAILURE); + } + /* Put "/.AppleDB" at end of volpath, get path from volinfo file */ + char dbpath[MAXPATHLEN+1]; + if ((strlen(volinfo.v_dbpath) + strlen("/.AppleDB")) > MAXPATHLEN ) { + LOG(log_error, logtype_cnid, "CNID db pathname too long: \"%s\"", volinfo.v_dbpath); + exit(EXIT_FAILURE); } + strncpy(dbpath, volinfo.v_dbpath, MAXPATHLEN - strlen("/.AppleDB")); + strcat(dbpath, "/.AppleDB"); - dir = argv[1]; - ctrlfd = atoi(argv[2]); - clntfd = atoi(argv[3]); - logconfig = strdup(argv[4]); + ctrlfd = atoi(argv[optind + 1]); + clntfd = atoi(argv[optind + 2]); + logconfig = strdup(argv[optind + 3]); setuplog(logconfig); - switch_to_user(dir); + if (vol_load_charsets(&volinfo) == -1) { + LOG(log_error, logtype_cnid, "Error loading charsets!"); + exit(EXIT_FAILURE); + } + LOG(log_debug, logtype_cnid, "db dir: \"%s\"", dbpath); - /* Before we do anything else, check if there is an instance of cnid_dbd - running already and silently exit if yes. */ - if ((db_locked = get_lock(1)) == -1) { + switch_to_user(dbpath); + + /* Get db lock */ + if ((db_locked = get_lock(LOCK_EXCL, dbpath)) == -1) { + LOG(log_error, logtype_cnid, "main: fatal db lock error"); exit(1); } + if (db_locked != LOCK_EXCL) { + /* Couldn't get exclusive lock, try shared lock */ + if ((db_locked = get_lock(LOCK_SHRD, NULL)) != LOCK_SHRD) { + LOG(log_error, logtype_cnid, "main: fatal db lock error"); + exit(1); + } + } - LOG(log_info, logtype_cnid, "Startup, DB dir %s", dir); + if (delete_bdb && (db_locked == LOCK_EXCL)) { + LOG(log_warning, logtype_cnid, "main: too many CNID db opening attempts, wiping the slate clean"); + chdir(dbpath); + system("rm -f cnid2.db lock log.* __db.*"); + if ((db_locked = get_lock(LOCK_EXCL, dbpath)) != LOCK_EXCL) { + LOG(log_error, logtype_cnid, "main: fatal db lock error"); + exit(EXIT_FAILURE); + } + } set_signal(); /* SIGINT and SIGTERM are always off, unless we are in pselect */ block_sigs_onoff(1); - if ((dbp = db_param_read(dir, CNID_DBD)) == NULL) + if ((dbp = db_param_read(dbpath)) == NULL) exit(1); LOG(log_maxdebug, logtype_cnid, "Finished parsing db_param config file"); - if (NULL == (dbd = dbif_init(".", "cnid2.db"))) + if (NULL == (dbd = dbif_init(dbpath, "cnid2.db"))) exit(2); /* Only recover if we got the lock */ if (dbif_env_open(dbd, dbp, - db_locked ? DBOPTIONS | DB_RECOVER : DBOPTIONS) < 0) + (db_locked == LOCK_EXCL) ? DBOPTIONS | DB_RECOVER : DBOPTIONS) < 0) exit(2); /* FIXME: same exit code as failure for dbif_open() */ LOG(log_debug, logtype_cnid, "Finished initializing BerkeleyDB environment"); @@ -397,11 +372,18 @@ int main(int argc, char *argv[]) } LOG(log_debug, logtype_cnid, "Finished opening BerkeleyDB databases"); - if (dbd_stamp(dbd) < 0) { - dbif_close(dbd); - exit(5); + /* Downgrade db lock */ + if (db_locked == LOCK_EXCL) { + if (get_lock(LOCK_UNLOCK, NULL) != 0) { + dbif_close(dbd); + exit(2); + } + if (get_lock(LOCK_SHRD, NULL) != LOCK_SHRD) { + dbif_close(dbd); + exit(2); + } } - LOG(log_maxdebug, logtype_cnid, "Finished checking database stamp"); + if (comm_init(dbp, ctrlfd, clntfd) < 0) { dbif_close(dbd); @@ -414,11 +396,9 @@ int main(int argc, char *argv[]) if (dbif_close(dbd) < 0) err++; - if (dbif_prep_upgrade(dir) < 0) + if (dbif_env_remove(dbpath) < 0) err++; - (void)get_lock(0); - if (err) exit(4); else if (exit_sig)