/*
* __wt_conn_btree_get --
* Get an open btree file handle, otherwise open a new one.
*/
int
__wt_conn_btree_get(WT_SESSION_IMPL *session,
const char *name, const char *ckpt, const char *cfg[], uint32_t flags)
{
WT_DATA_HANDLE *dhandle;
WT_DECL_RET;
if (LF_ISSET(WT_DHANDLE_HAVE_REF))
WT_RET(
__conn_dhandle_open_lock(session, session->dhandle, flags));
else {
WT_WITH_DHANDLE_LOCK(session,
ret = __conn_dhandle_get(session, name, ckpt, flags));
WT_RET(ret);
}
dhandle = session->dhandle;
if (!LF_ISSET(WT_DHANDLE_LOCK_ONLY) &&
(!F_ISSET(dhandle, WT_DHANDLE_OPEN) ||
LF_ISSET(WT_BTREE_SPECIAL_FLAGS)))
if ((ret = __conn_btree_open(session, cfg, flags)) != 0) {
F_CLR(dhandle, WT_DHANDLE_EXCLUSIVE);
WT_TRET(__wt_writeunlock(session, dhandle->rwlock));
}
WT_ASSERT(session, ret != 0 ||
LF_ISSET(WT_DHANDLE_EXCLUSIVE) ==
F_ISSET(dhandle, WT_DHANDLE_EXCLUSIVE));
return (ret);
}
/*
* __txn_log_file_sync --
* Write a log record for a file sync.
*/
static int
__txn_log_file_sync(WT_SESSION_IMPL *session, uint32_t flags, WT_LSN *lsnp)
{
WT_BTREE *btree;
WT_DECL_ITEM(logrec);
WT_DECL_RET;
size_t header_size;
uint32_t rectype = WT_LOGREC_FILE_SYNC;
int start;
bool need_sync;
const char *fmt = WT_UNCHECKED_STRING(III);
btree = S2BT(session);
start = LF_ISSET(WT_TXN_LOG_CKPT_START);
need_sync = LF_ISSET(WT_TXN_LOG_CKPT_SYNC);
WT_RET(__wt_struct_size(
session, &header_size, fmt, rectype, btree->id, start));
WT_RET(__wt_logrec_alloc(session, header_size, &logrec));
WT_ERR(__wt_struct_pack(session,
(uint8_t *)logrec->data + logrec->size, header_size,
fmt, rectype, btree->id, start));
logrec->size += (uint32_t)header_size;
WT_ERR(__wt_log_write(
session, logrec, lsnp, need_sync ? WT_LOG_FSYNC : 0));
err: __wt_logrec_free(session, &logrec);
return (ret);
}
/*
* o_set --
* Set an option's value.
*
* PUBLIC: int o_set __P((SCR *, int, u_int, const char *, u_long));
*/
int
o_set(SCR *sp, int opt, u_int flags, const char *str, u_long val)
{
OPTION *op;
/* Set a pointer to the options area. */
op = F_ISSET(&sp->opts[opt], OPT_GLOBAL) ?
&sp->gp->opts[sp->opts[opt].o_cur.val] : &sp->opts[opt];
/* Copy the string, if requested. */
if (LF_ISSET(OS_STRDUP) && (str = strdup(str)) == NULL) {
msgq(sp, M_SYSERR, NULL);
return (1);
}
/* Free the previous string, if requested, and set the value. */
if LF_ISSET(OS_DEF)
if (LF_ISSET(OS_STR | OS_STRDUP)) {
if (!LF_ISSET(OS_NOFREE) && op->o_def.str != NULL)
free(__UNCONST(op->o_def.str));
op->o_def.str = str;
} else
op->o_def.val = val;
else
if (LF_ISSET(OS_STR | OS_STRDUP)) {
/*
* ex_ldisplay --
* Display a line without any preceding number.
*
* PUBLIC: int ex_ldisplay(SCR *, const CHAR_T *, size_t, size_t, u_int);
*/
int
ex_ldisplay(SCR *sp, const CHAR_T *p, size_t len, size_t col, u_int flags)
{
if (len > 0 && ex_prchars(sp, p, &col, len, LF_ISSET(E_C_LIST), 0))
return (1);
if (!INTERRUPTED(sp) && LF_ISSET(E_C_LIST)) {
p = L("$");
if (ex_prchars(sp, p, &col, 1, LF_ISSET(E_C_LIST), 0))
return (1);
}
if (!INTERRUPTED(sp))
(void)ex_puts(sp, "\n");
return (0);
}
/*
* ex_print --
* Print the selected lines.
*
* PUBLIC: int ex_print(SCR *, EXCMD *, MARK *, MARK *, u_int32_t);
*/
int
ex_print(SCR *sp, EXCMD *cmdp, MARK *fp, MARK *tp, u_int32_t flags)
{
GS *gp;
recno_t from, to;
size_t col, len;
CHAR_T *p;
CHAR_T buf[10];
NEEDFILE(sp, cmdp);
gp = sp->gp;
for (from = fp->lno, to = tp->lno; from <= to; ++from) {
col = 0;
/*
* Display the line number. The %6 format is specified
* by POSIX 1003.2, and is almost certainly large enough.
* Check, though, just in case.
*/
if (LF_ISSET(E_C_HASH)) {
if (from <= 999999) {
SPRINTF(buf, SIZE(buf), L("%6u "), from);
p = buf;
} else
p = L("TOOBIG ");
if (ex_prchars(sp, p, &col, 8, 0, 0))
return (1);
}
/*
* Display the line. The format for E_C_PRINT isn't very good,
* especially in handling end-of-line tabs, but they're almost
* backward compatible.
*/
if (db_get(sp, from, DBG_FATAL, &p, &len))
return (1);
if (len == 0 && !LF_ISSET(E_C_LIST))
(void)ex_puts(sp, "\n");
else if (ex_ldisplay(sp, p, len, col, flags))
return (1);
if (INTERRUPTED(sp))
break;
}
return (0);
}
/*
* __posix_fs_remove --
* Remove a file.
*/
static int
__posix_fs_remove(WT_FILE_SYSTEM *file_system,
WT_SESSION *wt_session, const char *name, uint32_t flags)
{
WT_DECL_RET;
WT_SESSION_IMPL *session;
WT_UNUSED(file_system);
session = (WT_SESSION_IMPL *)wt_session;
/*
* ISO C doesn't require remove return -1 on failure or set errno (note
* POSIX 1003.1 extends C with those requirements). Regardless, use the
* unlink system call, instead of remove, to simplify error handling;
* where we're not doing any special checking for standards compliance,
* using unlink may be marginally safer.
*/
WT_SYSCALL(unlink(name), ret);
if (ret != 0)
WT_RET_MSG(session, ret, "%s: file-remove: unlink", name);
if (!LF_ISSET(WT_FS_DURABLE))
return (0);
#ifdef __linux__
/* Flush the backing directory to guarantee the remove. */
WT_RET (__posix_directory_sync(session, name));
#endif
return (0);
}
/*
* __wt_btree_stat_init --
* Initialize the Btree statistics.
*/
int
__wt_btree_stat_init(WT_SESSION_IMPL *session, uint32_t flags)
{
WT_BM *bm;
WT_BTREE *btree;
WT_DECL_RET;
WT_DSRC_STATS *stats;
WT_PAGE *page;
btree = S2BT(session);
bm = btree->bm;
stats = &btree->dhandle->stats;
WT_RET(bm->stat(bm, session, stats));
WT_STAT_SET(stats, btree_fixed_len, btree->bitcnt);
WT_STAT_SET(stats, btree_maximum_depth, btree->maximum_depth);
WT_STAT_SET(stats, btree_maxintlitem, btree->maxintlitem);
WT_STAT_SET(stats, btree_maxintlpage, btree->maxintlpage);
WT_STAT_SET(stats, btree_maxleafitem, btree->maxleafitem);
WT_STAT_SET(stats, btree_maxleafpage, btree->maxleafpage);
page = NULL;
if (LF_ISSET(WT_STATISTICS_FAST))
return (0);
while ((ret = __wt_tree_walk(session, &page, 0)) == 0 && page != NULL)
WT_RET(__stat_page(session, page, stats));
return (ret == WT_NOTFOUND ? 0 : ret);
}
/*
* __wt_conn_dhandle_find --
* Find a previously opened data handle.
*/
int
__wt_conn_dhandle_find(WT_SESSION_IMPL *session,
const char *name, const char *ckpt, uint32_t flags)
{
WT_CONNECTION_IMPL *conn;
WT_DATA_HANDLE *dhandle;
uint64_t bucket;
WT_UNUSED(flags); /* Only used in diagnostic builds */
conn = S2C(session);
/* We must be holding the handle list lock at a higher level. */
WT_ASSERT(session, F_ISSET(session, WT_SESSION_HANDLE_LIST_LOCKED) &&
!LF_ISSET(WT_DHANDLE_HAVE_REF));
/* Increment the reference count if we already have the btree open. */
bucket = __wt_hash_city64(name, strlen(name)) % WT_HASH_ARRAY_SIZE;
SLIST_FOREACH(dhandle, &conn->dhhash[bucket], hashl)
if (strcmp(name, dhandle->name) == 0 &&
((ckpt == NULL && dhandle->checkpoint == NULL) ||
(ckpt != NULL && dhandle->checkpoint != NULL &&
strcmp(ckpt, dhandle->checkpoint) == 0))) {
session->dhandle = dhandle;
return (0);
}
return (WT_NOTFOUND);
}
/*
* __evict_force_check --
* Check if a page matches the criteria for forced eviction.
*/
static int
__evict_force_check(WT_SESSION_IMPL *session, WT_PAGE *page, uint32_t flags)
{
WT_BTREE *btree;
btree = S2BT(session);
/* Pages are usually small enough, check that first. */
if (page->memory_footprint < btree->maxmempage)
return (0);
/* Leaf pages only. */
if (WT_PAGE_IS_INTERNAL(page))
return (0);
/* Eviction may be turned off. */
if (LF_ISSET(WT_READ_NO_EVICT) || F_ISSET(btree, WT_BTREE_NO_EVICTION))
return (0);
/*
* It's hard to imagine a page with a huge memory footprint that has
* never been modified, but check to be sure.
*/
if (page->modify == NULL)
return (0);
/* Trigger eviction on the next page release. */
__wt_page_evict_soon(page);
/* If eviction cannot succeed, don't try. */
return (__wt_page_can_evict(session, page, 1));
}
/*
* file_m1 --
* First modification check routine. The :next, :prev, :rewind, :tag,
* :tagpush, :tagpop, ^^ modifications check.
*
* PUBLIC: int file_m1 __P((SCR *, int, int));
*/
int
file_m1(SCR *sp, int force, int flags)
{
EXF *ep;
ep = sp->ep;
/* If no file loaded, return no modifications. */
if (ep == NULL)
return (0);
/*
* If the file has been modified, we'll want to write it back or
* fail. If autowrite is set, we'll write it back automatically,
* unless force is also set. Otherwise, we fail unless forced or
* there's another open screen on this file.
*/
if (F_ISSET(ep, F_MODIFIED)) {
if (O_ISSET(sp, O_AUTOWRITE)) {
if (!force && file_aw(sp, flags))
return (1);
} else if (ep->refcnt <= 1 && !force) {
msgq(sp, M_ERR, LF_ISSET(FS_POSSIBLE) ?
"262|File modified since last complete write; write or use ! to override" :
"263|File modified since last complete write; write or use :edit! to override");
return (1);
}
}
return (file_m3(sp, force));
}
/*
* txt_prompt --
* Display the ex prompt, line number, ai characters. Characters had
* better be printable by the terminal driver, but that's its problem,
* not ours.
*/
static void
txt_prompt(SCR *sp, TEXT *tp, ARG_CHAR_T prompt, u_int32_t flags)
{
/* Display the prompt. */
if (LF_ISSET(TXT_PROMPT))
(void)ex_printf(sp, "%c", prompt);
/* Display the line number. */
if (LF_ISSET(TXT_NUMBER) && O_ISSET(sp, O_NUMBER))
(void)ex_printf(sp, "%6lu ", (u_long)tp->lno);
/* Print out autoindent string. */
if (LF_ISSET(TXT_AUTOINDENT))
(void)ex_printf(sp, WVS, (int)tp->ai, tp->lb);
(void)ex_fflush(sp);
}
/*
* __wt_page_out --
* Discard an in-memory page, freeing all memory associated with it.
*/
void
__wt_page_out(WT_SESSION_IMPL *session, WT_PAGE *page, uint32_t flags)
{
/*
* When a page is discarded, it's been disconnected from its parent and
* parent's WT_REF structure may now point to a different page. Make
* sure we don't use any of that information by accident.
*/
page->parent = NULL;
page->ref = NULL;
WT_ASSERT(session, !F_ISSET(page, WT_PAGE_EVICT_LRU));
/* If not a split merged into its parent, the page must be clean. */
WT_ASSERT(session,
!__wt_page_is_modified(page) ||
F_ISSET(page, WT_PAGE_REC_SPLIT_MERGE));
#ifdef HAVE_DIAGNOSTIC
__wt_hazard_validate(session, page);
#endif
/*
* If this page has a memory footprint associated with it, update
* the cache information.
*/
if (page->memory_footprint != 0)
__wt_cache_page_evict(session, page);
switch (page->type) {
case WT_PAGE_COL_FIX:
__free_page_col_fix(session, page);
break;
case WT_PAGE_COL_INT:
__free_page_col_int(session, page);
break;
case WT_PAGE_COL_VAR:
__free_page_col_var(session, page);
break;
case WT_PAGE_ROW_INT:
__free_page_row_int(session, page);
break;
case WT_PAGE_ROW_LEAF:
__free_page_row_leaf(session, page);
break;
}
if (!LF_ISSET(WT_PAGE_FREE_IGNORE_DISK)) /* Disk image */
__wt_free(session, page->dsk);
if (page->modify != NULL) { /* WT_PAGE_MODIFY */
__wt_free(session, page->modify->track);
__wt_free(session, page->modify);
}
#ifdef HAVE_DIAGNOSTIC
memset(page, WT_DEBUG_BYTE, sizeof(WT_PAGE));
#endif
__wt_free(session, page);
}
/*
* __log_direct_write --
* Write a log record without using the consolidation arrays.
*/
static int
__log_direct_write(WT_SESSION_IMPL *session, WT_ITEM *record, WT_LSN *lsnp,
uint32_t flags)
{
WT_DECL_RET;
WT_LOG *log;
WT_LOGSLOT tmp;
WT_MYSLOT myslot;
int locked;
WT_DECL_SPINLOCK_ID(id); /* Must appear last */
log = S2C(session)->log;
myslot.slot = &tmp;
myslot.offset = 0;
WT_CLEAR(tmp);
/* Fast path the contended case. */
if (__wt_spin_trylock(session, &log->log_slot_lock, &id) != 0)
return (EAGAIN);
locked = 1;
if (LF_ISSET(WT_LOG_FSYNC))
F_SET(&tmp, SLOT_SYNC);
WT_ERR(__log_acquire(session, record->size, &tmp));
__wt_spin_unlock(session, &log->log_slot_lock);
locked = 0;
WT_ERR(__log_fill(session, &myslot, 1, record, lsnp));
WT_ERR(__log_release(session, &tmp));
err: if (locked)
__wt_spin_unlock(session, &log->log_slot_lock);
return (ret);
}
/*
* __posix_fs_rename --
* Rename a file.
*/
static int
__posix_fs_rename(WT_FILE_SYSTEM *file_system,
WT_SESSION *wt_session, const char *from, const char *to, uint32_t flags)
{
WT_DECL_RET;
WT_SESSION_IMPL *session;
WT_UNUSED(file_system);
session = (WT_SESSION_IMPL *)wt_session;
/*
* ISO C doesn't require rename return -1 on failure or set errno (note
* POSIX 1003.1 extends C with those requirements). Be cautious, force
* any non-zero return to -1 so we'll check errno. We can still end up
* with the wrong errno (if errno is garbage), or the generic WT_ERROR
* return (if errno is 0), but we've done the best we can.
*/
WT_SYSCALL(rename(from, to) != 0 ? -1 : 0, ret);
if (ret != 0)
WT_RET_MSG(
session, ret, "%s to %s: file-rename: rename", from, to);
if (!LF_ISSET(WT_FS_DURABLE))
return (0);
#ifdef __linux__
/*
* Flush the backing directory to guarantee the rename. My reading of
* POSIX 1003.1 is there's no guarantee flushing only one of the from
* or to directories, or flushing a common parent, is sufficient, and
* even if POSIX were to make that guarantee, existing filesystems are
* known to not provide the guarantee or only provide the guarantee
* with specific mount options. Flush both of the from/to directories
* until it's a performance problem.
*/
WT_RET(__posix_directory_sync(session, from));
/*
* In almost all cases, we're going to be renaming files in the same
* directory, we can at least fast-path that.
*/
{
bool same_directory;
const char *fp, *tp;
fp = strrchr(from, '/');
tp = strrchr(to, '/');
same_directory = (fp == NULL && tp == NULL) ||
(fp != NULL && tp != NULL &&
fp - from == tp - to && memcmp(from, to, (size_t)(fp - from)) == 0);
if (!same_directory)
WT_RET(__posix_directory_sync(session, to));
}
#endif
return (0);
}
/*
* ex_prchars --
* Local routine to dump characters to the screen.
*/
static int
ex_prchars(SCR *sp, const CHAR_T *p, size_t *colp, size_t len,
u_int flags, int repeatc)
{
CHAR_T ch;
char *kp;
GS *gp;
size_t col, tlen, ts;
if (O_ISSET(sp, O_LIST))
LF_SET(E_C_LIST);
gp = sp->gp;
ts = O_VAL(sp, O_TABSTOP);
for (col = *colp; len--;)
if ((ch = *p++) == L('\t') && !LF_ISSET(E_C_LIST))
for (tlen = ts - col % ts;
col < sp->cols && tlen--; ++col) {
(void)ex_printf(sp,
"%c", repeatc ? repeatc : ' ');
if (INTERRUPTED(sp))
goto intr;
}
else {
kp = KEY_NAME(sp, ch);
tlen = KEY_COL(sp, ch);
/*
* Start a new line if the last character does not fit
* into the current line. The implicit new lines are
* not interruptible.
*/
if (col + tlen > sp->cols) {
col = 0;
(void)ex_puts(sp, "\n");
}
col += tlen;
if (!repeatc) {
(void)ex_puts(sp, kp);
if (INTERRUPTED(sp))
goto intr;
} else while (tlen--) {
(void)ex_printf(sp, "%c", repeatc);
if (INTERRUPTED(sp))
goto intr;
}
if (col == sp->cols) {
col = 0;
(void)ex_puts(sp, "\n");
}
}
intr: *colp = col;
return (0);
}
/*
* __wt_fopen --
* Open a stream handle.
*/
int
__wt_fopen(WT_SESSION_IMPL *session,
const char *name, uint32_t open_flags, uint32_t flags, WT_FSTREAM **fstrp)
{
WT_DECL_RET;
WT_FH *fh;
WT_FSTREAM *fstr;
*fstrp = NULL;
fstr = NULL;
WT_RET(__wt_open(
session, name, WT_OPEN_FILE_TYPE_REGULAR, open_flags, &fh));
WT_ERR(__wt_calloc_one(session, &fstr));
fstr->fh = fh;
fstr->name = fh->name;
fstr->flags = flags;
fstr->close = __fstream_close;
WT_ERR(__wt_filesize(session, fh, &fstr->size));
if (LF_ISSET(WT_STREAM_APPEND))
fstr->off = fstr->size;
if (LF_ISSET(WT_STREAM_APPEND | WT_STREAM_WRITE)) {
fstr->fstr_flush = __fstream_flush;
fstr->fstr_getline = __fstream_getline_notsup;
fstr->fstr_printf = __fstream_printf;
} else {
WT_ASSERT(session, LF_ISSET(WT_STREAM_READ));
fstr->fstr_flush = __fstream_flush_notsup;
fstr->fstr_getline = __fstream_getline;
fstr->fstr_printf = __fstream_printf_notsup;
}
*fstrp = fstr;
return (0);
err: WT_TRET(__wt_close(session, &fh));
__wt_free(session, fstr);
return (ret);
}
extern "C" ct_entry *
__dbsrv_sharedb(ct_entry *db_ctp, const char *name, const char *subdb, DBTYPE type, u_int32_t flags)
{
ct_entry *ctp;
/*
* Check if we can share a db handle. Criteria for sharing are:
* If any of the non-sharable flags are set, we cannot share.
* Must be a db ctp, obviously.
* Must share the same env parent.
* Must be the same type, or current one DB_UNKNOWN.
* Must be same byteorder, or current one must not care.
* All flags must match.
* Must be same name, but don't share in-memory databases.
* Must be same subdb name.
*/
if (flags & DB_SERVER_DBNOSHARE)
return (NULL);
for (ctp = LIST_FIRST(&__dbsrv_head); ctp != NULL;
ctp = LIST_NEXT(ctp, entries)) {
/*
* Skip ourselves.
*/
if (ctp == db_ctp)
continue;
if (ctp->ct_type != CT_DB)
continue;
if (ctp->ct_envparent != db_ctp->ct_envparent)
continue;
if (type != DB_UNKNOWN && ctp->ct_dbdp.type != type)
continue;
if (ctp->ct_dbdp.dbflags != LF_ISSET(DB_SERVER_DBFLAGS))
continue;
if (db_ctp->ct_dbdp.setflags != 0 &&
ctp->ct_dbdp.setflags != db_ctp->ct_dbdp.setflags)
continue;
if (name == NULL || ctp->ct_dbdp.db == NULL ||
strcmp(name, ctp->ct_dbdp.db) != 0)
continue;
if (subdb != ctp->ct_dbdp.subdb &&
(subdb == NULL || ctp->ct_dbdp.subdb == NULL ||
strcmp(subdb, ctp->ct_dbdp.subdb) != 0))
continue;
/*
* If we get here, then we match.
*/
ctp->ct_refcount++;
return (ctp);
}
return (NULL);
}
/*
* ex_prchars --
* Local routine to dump characters to the screen.
*/
static int
ex_prchars(SCR *sp, const CHAR_T *p, size_t *colp, size_t len,
u_int flags, int repeatc)
{
CHAR_T ch;
const char *kp;
size_t col, tlen, ts;
if (O_ISSET(sp, O_LIST))
LF_SET(E_C_LIST);
ts = O_VAL(sp, O_TABSTOP);
for (col = *colp; len--;)
if ((ch = *p++) == L('\t') && !LF_ISSET(E_C_LIST))
for (tlen = ts - col % ts;
col < sp->cols && tlen--; ++col) {
(void)ex_printf(sp,
"%c", repeatc ? repeatc : ' ');
if (INTERRUPTED(sp))
goto intr;
}
else {
/* XXXX */
if (INTISWIDE(ch)) {
CHAR_T str[2] = {0, 0};
str[0] = ch;
INT2CHAR(sp, str, 2, kp, tlen);
} else {
kp = (char *)KEY_NAME(sp, ch);
tlen = KEY_LEN(sp, ch);
}
if (!repeatc && col + tlen < sp->cols) {
(void)ex_puts(sp, kp);
col += tlen;
} else
for (; tlen--; ++kp, ++col) {
if (col == sp->cols) {
col = 0;
(void)ex_puts(sp, "\n");
}
(void)ex_printf(sp,
"%c", repeatc ? repeatc : *kp);
if (INTERRUPTED(sp))
goto intr;
}
}
intr: *colp = col;
return (0);
}
/*
* __wt_fopen --
* Open a FILE handle.
*/
int
__wt_fopen(WT_SESSION_IMPL *session,
const char *name, WT_FHANDLE_MODE mode_flag, u_int flags, FILE **fpp)
{
WT_DECL_RET;
const char *mode, *path;
char *pathbuf;
WT_RET(__wt_verbose(session, WT_VERB_FILEOPS, "%s: fopen", name));
pathbuf = NULL;
if (LF_ISSET(WT_FOPEN_FIXED))
path = name;
else {
WT_RET(__wt_filename(session, name, &pathbuf));
path = pathbuf;
}
mode = NULL;
switch (mode_flag) {
case WT_FHANDLE_APPEND:
mode = WT_FOPEN_APPEND;
break;
case WT_FHANDLE_READ:
mode = WT_FOPEN_READ;
break;
case WT_FHANDLE_WRITE:
mode = WT_FOPEN_WRITE;
break;
}
*fpp = fopen(path, mode);
if (*fpp == NULL)
ret = __wt_errno();
if (pathbuf != NULL)
__wt_free(session, pathbuf);
if (ret == 0)
return (0);
WT_RET_MSG(session, ret, "%s: fopen", name);
}
/*
* __wt_verify_dsk_image --
* Verify a single block as read from disk.
*/
int
__wt_verify_dsk_image(WT_SESSION_IMPL *session,
const char *tag, const WT_PAGE_HEADER *dsk, size_t size, int empty_page_ok)
{
const uint8_t *p, *end;
u_int i;
uint8_t flags;
/* Check the page type. */
switch (dsk->type) {
case WT_PAGE_BLOCK_MANAGER:
case WT_PAGE_COL_FIX:
case WT_PAGE_COL_INT:
case WT_PAGE_COL_VAR:
case WT_PAGE_OVFL:
case WT_PAGE_ROW_INT:
case WT_PAGE_ROW_LEAF:
break;
case WT_PAGE_INVALID:
default:
WT_RET_VRFY(session,
"page at %s has an invalid type of %" PRIu32,
tag, dsk->type);
}
/* Check the page record number. */
switch (dsk->type) {
case WT_PAGE_COL_FIX:
case WT_PAGE_COL_INT:
case WT_PAGE_COL_VAR:
if (dsk->recno != 0)
break;
WT_RET_VRFY(session,
"%s page at %s has a record number of zero",
__wt_page_type_string(dsk->type), tag);
case WT_PAGE_BLOCK_MANAGER:
case WT_PAGE_OVFL:
case WT_PAGE_ROW_INT:
case WT_PAGE_ROW_LEAF:
if (dsk->recno == 0)
break;
WT_RET_VRFY(session,
"%s page at %s has a non-zero record number",
__wt_page_type_string(dsk->type), tag);
}
/* Check the page flags. */
flags = dsk->flags;
if (LF_ISSET(WT_PAGE_COMPRESSED))
LF_CLR(WT_PAGE_COMPRESSED);
if (LF_ISSET(WT_PAGE_ENCRYPTED))
LF_CLR(WT_PAGE_ENCRYPTED);
if (dsk->type == WT_PAGE_ROW_LEAF) {
if (LF_ISSET(WT_PAGE_EMPTY_V_ALL) &&
LF_ISSET(WT_PAGE_EMPTY_V_NONE))
WT_RET_VRFY(session,
"page at %s has invalid flags combination: 0x%"
PRIx8,
tag, dsk->flags);
if (LF_ISSET(WT_PAGE_EMPTY_V_ALL))
LF_CLR(WT_PAGE_EMPTY_V_ALL);
if (LF_ISSET(WT_PAGE_EMPTY_V_NONE))
LF_CLR(WT_PAGE_EMPTY_V_NONE);
}
if (flags != 0)
WT_RET_VRFY(session,
"page at %s has invalid flags set: 0x%" PRIx8,
tag, flags);
/* Unused bytes */
for (p = dsk->unused, i = sizeof(dsk->unused); i > 0; --i)
if (*p != '\0')
WT_RET_VRFY(session,
"page at %s has non-zero unused page header bytes",
tag);
/*
* Any bytes after the data chunk should be nul bytes; ignore if the
* size is 0, that allows easy checking of disk images where we don't
* have the size.
*/
if (size != 0) {
p = (uint8_t *)dsk + dsk->mem_size;
end = (uint8_t *)dsk + size;
for (; p < end; ++p)
if (*p != '\0')
WT_RET_VRFY(session,
"%s page at %s has non-zero trailing bytes",
__wt_page_type_string(dsk->type), tag);
}
/* Check for empty pages, then verify the items on the page. */
switch (dsk->type) {
case WT_PAGE_COL_INT:
case WT_PAGE_COL_FIX:
case WT_PAGE_COL_VAR:
case WT_PAGE_ROW_INT:
case WT_PAGE_ROW_LEAF:
if (!empty_page_ok && dsk->u.entries == 0)
WT_RET_VRFY(session, "%s page at %s has no entries",
__wt_page_type_string(dsk->type), tag);
break;
case WT_PAGE_BLOCK_MANAGER:
case WT_PAGE_OVFL:
if (dsk->u.datalen == 0)
WT_RET_VRFY(session, "%s page at %s has no data",
__wt_page_type_string(dsk->type), tag);
break;
}
switch (dsk->type) {
case WT_PAGE_COL_INT:
return (__verify_dsk_col_int(session, tag, dsk));
case WT_PAGE_COL_FIX:
return (__verify_dsk_col_fix(session, tag, dsk));
case WT_PAGE_COL_VAR:
return (__verify_dsk_col_var(session, tag, dsk));
case WT_PAGE_ROW_INT:
case WT_PAGE_ROW_LEAF:
return (__verify_dsk_row(session, tag, dsk));
case WT_PAGE_BLOCK_MANAGER:
case WT_PAGE_OVFL:
return (__verify_dsk_chunk(session, tag, dsk, dsk->u.datalen));
WT_ILLEGAL_VALUE(session);
}
/* NOTREACHED */
}
/*
* ex_txt --
* Get lines from the terminal for ex.
*
* PUBLIC: int ex_txt(SCR *, TEXTH *, ARG_CHAR_T, u_int32_t);
*/
int
ex_txt(SCR *sp, TEXTH *tiqh, ARG_CHAR_T prompt, u_int32_t flags)
{
EVENT ev;
GS *gp;
TEXT ait, *ntp, *tp;
carat_t carat_st;
size_t cnt;
int rval;
int nochange;
rval = 0;
/*
* Get a TEXT structure with some initial buffer space, reusing the
* last one if it's big enough. (All TEXT bookkeeping fields default
* to 0 -- text_init() handles this.)
*/
if (!TAILQ_EMPTY(tiqh)) {
tp = TAILQ_FIRST(tiqh);
if (TAILQ_NEXT(tp, q) != NULL || tp->lb_len < 32) {
text_lfree(tiqh);
goto newtp;
}
tp->len = 0;
} else {
newtp: if ((tp = text_init(sp, NULL, 0, 32)) == NULL)
goto err;
TAILQ_INSERT_HEAD(tiqh, tp, q);
}
/* Set the starting line number. */
tp->lno = sp->lno + 1;
/*
* If it's a terminal, set up autoindent, put out the prompt, and
* set it up so we know we were suspended. Otherwise, turn off
* the autoindent flag, as that requires less special casing below.
*
* XXX
* Historic practice is that ^Z suspended command mode (but, because
* it ran in cooked mode, it was unaffected by the autowrite option.)
* On restart, any "current" input was discarded, whether in insert
* mode or not, and ex was in command mode. This code matches historic
* practice, but not 'cause it's easier.
*/
gp = sp->gp;
if (F_ISSET(gp, G_SCRIPTED))
LF_CLR(TXT_AUTOINDENT);
else {
if (LF_ISSET(TXT_AUTOINDENT)) {
LF_SET(TXT_EOFCHAR);
if (v_txt_auto(sp, sp->lno, NULL, 0, tp))
goto err;
}
txt_prompt(sp, tp, prompt, flags);
}
for (carat_st = C_NOTSET, nochange = 0;;) {
if (v_event_get(sp, &ev, 0, 0))
goto err;
/* Deal with all non-character events. */
switch (ev.e_event) {
case E_CHARACTER:
break;
case E_ERR:
goto err;
case E_REPAINT:
case E_WRESIZE:
continue;
case E_EOF:
rval = 1;
/* FALLTHROUGH */
case E_INTERRUPT:
/*
* Handle EOF/SIGINT events by discarding partially
* entered text and returning. EOF returns failure,
* E_INTERRUPT returns success.
*/
goto notlast;
default:
v_event_err(sp, &ev);
goto notlast;
}
/*
* Deal with character events.
*
* Check to see if the character fits into the input buffer.
* (Use tp->len, ignore overwrite and non-printable chars.)
*/
BINC_GOTOW(sp, tp->lb, tp->lb_len, tp->len + 1);
switch (ev.e_value) {
case K_CR:
/*
* !!!
* Historically, <carriage-return>'s in the command
* weren't special, so the ex parser would return an
* unknown command error message. However, if they
* terminated the command if they were in a map. I'm
* pretty sure this still isn't right, but it handles
* what I've seen so far.
*/
if (!F_ISSET(&ev.e_ch, CH_MAPPED))
goto ins_ch;
/* FALLTHROUGH */
case K_NL:
/*
* '\' can escape <carriage-return>/<newline>. We
* don't discard the backslash because we need it
* to get the <newline> through the ex parser.
*/
if (LF_ISSET(TXT_BACKSLASH) &&
tp->len != 0 && tp->lb[tp->len - 1] == '\\')
goto ins_ch;
/*
* CR returns from the ex command line.
*
* XXX
* Terminate with a nul, needed by filter.
*/
if (LF_ISSET(TXT_CR)) {
tp->lb[tp->len] = '\0';
goto done;
}
/*
* '.' may terminate text input mode; free the current
* TEXT.
*/
if (LF_ISSET(TXT_DOTTERM) && tp->len == tp->ai + 1 &&
tp->lb[tp->len - 1] == '.') {
notlast: TAILQ_REMOVE(tiqh, tp, q);
text_free(tp);
goto done;
}
/* Set up bookkeeping for the new line. */
if ((ntp = text_init(sp, NULL, 0, 32)) == NULL)
goto err;
ntp->lno = tp->lno + 1;
/*
* Reset the autoindent line value. 0^D keeps the ai
* line from changing, ^D changes the level, even if
* there were no characters in the old line. Note, if
* using the current tp structure, use the cursor as
* the length, the autoindent characters may have been
* erased.
*/
if (LF_ISSET(TXT_AUTOINDENT)) {
if (nochange) {
nochange = 0;
if (v_txt_auto(sp,
OOBLNO, &ait, ait.ai, ntp))
goto err;
free(ait.lb);
} else
if (v_txt_auto(sp,
OOBLNO, tp, tp->len, ntp))
goto err;
carat_st = C_NOTSET;
}
txt_prompt(sp, ntp, prompt, flags);
/*
* Swap old and new TEXT's, and insert the new TEXT
* into the queue.
*/
tp = ntp;
TAILQ_INSERT_TAIL(tiqh, tp, q);
break;
case K_CARAT: /* Delete autoindent chars. */
if (tp->len <= tp->ai && LF_ISSET(TXT_AUTOINDENT))
carat_st = C_CARATSET;
goto ins_ch;
case K_ZERO: /* Delete autoindent chars. */
if (tp->len <= tp->ai && LF_ISSET(TXT_AUTOINDENT))
carat_st = C_ZEROSET;
goto ins_ch;
case K_CNTRLD: /* Delete autoindent char. */
/*
* !!!
* Historically, the ^D command took (but then ignored)
* a count. For simplicity, we don't return it unless
* it's the first character entered. The check for len
* equal to 0 is okay, TXT_AUTOINDENT won't be set.
*/
if (LF_ISSET(TXT_CNTRLD)) {
for (cnt = 0; cnt < tp->len; ++cnt)
if (!isblank(tp->lb[cnt]))
break;
if (cnt == tp->len) {
tp->len = 1;
tp->lb[0] = ev.e_c;
tp->lb[1] = '\0';
/*
* Put out a line separator, in case
* the command fails.
*/
(void)putchar('\n');
goto done;
}
}
/*
* POSIX 1003.1b-1993, paragraph 7.1.1.9, states that
* the EOF characters are discarded if there are other
* characters to process in the line, i.e. if the EOF
* is not the first character in the line. For this
* reason, historic ex discarded the EOF characters,
* even if occurring in the middle of the input line.
* We match that historic practice.
*
* !!!
* The test for discarding in the middle of the line is
* done in the switch, because the CARAT forms are N+1,
* not N.
*
* !!!
* There's considerable magic to make the terminal code
* return the EOF character at all. See that code for
* details.
*/
if (!LF_ISSET(TXT_AUTOINDENT) || tp->len == 0)
continue;
switch (carat_st) {
case C_CARATSET: /* ^^D */
if (tp->len > tp->ai + 1)
continue;
/* Save the ai string for later. */
ait.lb = NULL;
ait.lb_len = 0;
BINC_GOTOW(sp, ait.lb, ait.lb_len, tp->ai);
MEMCPY(ait.lb, tp->lb, tp->ai);
ait.ai = ait.len = tp->ai;
carat_st = C_NOTSET;
nochange = 1;
goto leftmargin;
case C_ZEROSET: /* 0^D */
if (tp->len > tp->ai + 1)
continue;
carat_st = C_NOTSET;
leftmargin: (void)gp->scr_ex_adjust(sp, EX_TERM_CE);
tp->ai = tp->len = 0;
break;
case C_NOTSET: /* ^D */
if (tp->len > tp->ai)
continue;
if (txt_dent(sp, tp))
goto err;
break;
default:
abort();
}
/* Clear and redisplay the line. */
(void)gp->scr_ex_adjust(sp, EX_TERM_CE);
txt_prompt(sp, tp, prompt, flags);
break;
default:
/*
* See the TXT_BEAUTIFY comment in vi/v_txt_ev.c.
*
* Silently eliminate any iscntrl() character that was
* not already handled specially, except for <tab> and
* <ff>.
*/
ins_ch: if (LF_ISSET(TXT_BEAUTIFY) && ISCNTRL(ev.e_c) &&
ev.e_value != K_FORMFEED && ev.e_value != K_TAB)
break;
tp->lb[tp->len++] = ev.e_c;
break;
}
}
/* NOTREACHED */
done: return (rval);
err:
alloc_err:
return (1);
}
/*
* editor --
* Main editor routine.
*
* PUBLIC: int editor(GS *, int, char *[]);
*/
int
editor(GS *gp, int argc, char *argv[])
{
extern int optind;
extern char *optarg;
const char *p;
EVENT ev;
FREF *frp;
SCR *sp;
size_t len;
u_int flags;
int ch, flagchk, lflag, secure, startup, readonly, rval, silent;
char *tag_f, *wsizearg, path[256];
CHAR_T *w;
size_t wlen;
/* Initialize the busy routine, if not defined by the screen. */
if (gp->scr_busy == NULL)
gp->scr_busy = vs_busy;
/* Initialize the message routine, if not defined by the screen. */
if (gp->scr_msg == NULL)
gp->scr_msg = vs_msg;
gp->catd = (nl_catd)-1;
/* Common global structure initialization. */
TAILQ_INIT(gp->dq);
TAILQ_INIT(gp->hq);
SLIST_INIT(gp->ecq);
SLIST_INSERT_HEAD(gp->ecq, &gp->excmd, q);
gp->noprint = DEFAULT_NOPRINT;
/* Structures shared by screens so stored in the GS structure. */
TAILQ_INIT(gp->frefq);
TAILQ_INIT(gp->dcb_store.textq);
SLIST_INIT(gp->cutq);
SLIST_INIT(gp->seqq);
/* Set initial screen type and mode based on the program name. */
readonly = 0;
if (!strcmp(getprogname(), "ex") || !strcmp(getprogname(), "nex"))
LF_INIT(SC_EX);
else {
/* Nview, view are readonly. */
if (!strcmp(getprogname(), "nview") ||
!strcmp(getprogname(), "view"))
readonly = 1;
/* Vi is the default. */
LF_INIT(SC_VI);
}
/* Convert old-style arguments into new-style ones. */
if (v_obsolete(argv))
return (1);
/* Parse the arguments. */
flagchk = '\0';
tag_f = wsizearg = NULL;
lflag = secure = silent = 0;
startup = 1;
/* Set the file snapshot flag. */
F_SET(gp, G_SNAPSHOT);
#ifdef DEBUG
while ((ch = getopt(argc, argv, "c:D:eFlRrSsT:t:vw:")) != EOF)
#else
while ((ch = getopt(argc, argv, "c:eFlRrSst:vw:")) != EOF)
#endif
switch (ch) {
case 'c': /* Run the command. */
/*
* XXX
* We should support multiple -c options.
*/
if (gp->c_option != NULL) {
warnx("only one -c command may be specified.");
return (1);
}
gp->c_option = optarg;
break;
#ifdef DEBUG
case 'D':
switch (optarg[0]) {
case 's':
startup = 0;
break;
case 'w':
attach(gp);
break;
default:
warnx("usage: -D requires s or w argument.");
return (1);
}
break;
#endif
case 'e': /* Ex mode. */
LF_CLR(SC_VI);
LF_SET(SC_EX);
break;
case 'F': /* No snapshot. */
F_CLR(gp, G_SNAPSHOT);
break;
case 'l': /* Set lisp, showmatch options. */
lflag = 1;
break;
case 'R': /* Readonly. */
readonly = 1;
break;
case 'r': /* Recover. */
if (flagchk == 't') {
warnx("only one of -r and -t may be specified.");
return (1);
}
flagchk = 'r';
break;
case 'S':
secure = 1;
break;
case 's':
silent = 1;
break;
#ifdef DEBUG
case 'T': /* Trace. */
if ((gp->tracefp = fopen(optarg, "w")) == NULL) {
warn("%s", optarg);
goto err;
}
(void)fprintf(gp->tracefp,
"\n===\ntrace: open %s\n", optarg);
break;
#endif
case 't': /* Tag. */
if (flagchk == 'r') {
warnx("only one of -r and -t may be specified.");
return (1);
}
if (flagchk == 't') {
warnx("only one tag file may be specified.");
return (1);
}
flagchk = 't';
tag_f = optarg;
break;
case 'v': /* Vi mode. */
LF_CLR(SC_EX);
LF_SET(SC_VI);
break;
case 'w':
wsizearg = optarg;
break;
case '?':
default:
(void)gp->scr_usage();
return (1);
}
argc -= optind;
argv += optind;
/*
* -s option is only meaningful to ex.
*
* If not reading from a terminal, it's like -s was specified.
*/
if (silent && !LF_ISSET(SC_EX)) {
warnx("-s option is only applicable to ex.");
goto err;
}
if (LF_ISSET(SC_EX) && F_ISSET(gp, G_SCRIPTED))
silent = 1;
/*
* Build and initialize the first/current screen. This is a bit
* tricky. If an error is returned, we may or may not have a
* screen structure. If we have a screen structure, put it on a
* display queue so that the error messages get displayed.
*
* !!!
* Everything we do until we go interactive is done in ex mode.
*/
if (screen_init(gp, NULL, &sp)) {
if (sp != NULL)
TAILQ_INSERT_HEAD(gp->dq, sp, q);
goto err;
}
F_SET(sp, SC_EX);
TAILQ_INSERT_HEAD(gp->dq, sp, q);
if (v_key_init(sp)) /* Special key initialization. */
goto err;
{ int oargs[5], *oargp = oargs;
if (lflag) { /* Command-line options. */
*oargp++ = O_LISP;
*oargp++ = O_SHOWMATCH;
}
if (readonly)
*oargp++ = O_READONLY;
if (secure)
*oargp++ = O_SECURE;
*oargp = -1; /* Options initialization. */
if (opts_init(sp, oargs))
goto err;
}
if (wsizearg != NULL) {
ARGS *av[2], a, b;
(void)snprintf(path, sizeof(path), "window=%s", wsizearg);
a.bp = (CHAR_T *)path;
a.len = strlen(path);
b.bp = NULL;
b.len = 0;
av[0] = &a;
av[1] = &b;
(void)opts_set(sp, av, NULL);
}
if (silent) { /* Ex batch mode option values. */
O_CLR(sp, O_AUTOPRINT);
O_CLR(sp, O_PROMPT);
O_CLR(sp, O_VERBOSE);
O_CLR(sp, O_WARN);
F_SET(sp, SC_EX_SILENT);
}
sp->rows = O_VAL(sp, O_LINES); /* Make ex formatting work. */
sp->cols = O_VAL(sp, O_COLUMNS);
if (!silent && startup) { /* Read EXINIT, exrc files. */
if (ex_exrc(sp))
goto err;
if (F_ISSET(sp, SC_EXIT | SC_EXIT_FORCE)) {
if (screen_end(sp))
goto err;
goto done;
}
}
/*
* List recovery files if -r specified without file arguments.
* Note, options must be initialized and startup information
* read before doing this.
*/
if (flagchk == 'r' && argv[0] == NULL) {
if (rcv_list(sp))
goto err;
if (screen_end(sp))
goto err;
goto done;
}
/*
* !!!
* Initialize the default ^D, ^U scrolling value here, after the
* user has had every opportunity to set the window option.
*
* It's historic practice that changing the value of the window
* option did not alter the default scrolling value, only giving
* a count to ^D/^U did that.
*/
sp->defscroll = (O_VAL(sp, O_WINDOW) + 1) / 2;
/*
* If we don't have a command-line option, switch into the right
* editor now, so that we position default files correctly, and
* so that any tags file file-already-locked messages are in the
* vi screen, not the ex screen.
*
* XXX
* If we have a command-line option, the error message can end
* up in the wrong place, but I think that the combination is
* unlikely.
*/
if (gp->c_option == NULL) {
F_CLR(sp, SC_EX | SC_VI);
F_SET(sp, LF_ISSET(SC_EX | SC_VI));
}
/* Open a tag file if specified. */
if (tag_f != NULL) {
CHAR2INT(sp, tag_f, strlen(tag_f) + 1, w, wlen);
if (ex_tag_first(sp, w))
goto err;
}
/*
* Append any remaining arguments as file names. Files are recovery
* files if -r specified. If the tag option or ex startup commands
* loaded a file, then any file arguments are going to come after it.
*/
if (*argv != NULL) {
if (sp->frp != NULL) {
/* Cheat -- we know we have an extra argv slot. */
*--argv = strdup(sp->frp->name);
if (*argv == NULL) {
warn(NULL);
goto err;
}
}
sp->argv = sp->cargv = argv;
F_SET(sp, SC_ARGNOFREE);
if (flagchk == 'r')
F_SET(sp, SC_ARGRECOVER);
}
/*
* If the ex startup commands and or/the tag option haven't already
* created a file, create one. If no command-line files were given,
* use a temporary file.
*/
if (sp->frp == NULL) {
if (sp->argv == NULL) {
if ((frp = file_add(sp, NULL)) == NULL)
goto err;
} else {
if ((frp = file_add(sp, sp->argv[0])) == NULL)
goto err;
if (F_ISSET(sp, SC_ARGRECOVER))
F_SET(frp, FR_RECOVER);
}
if (file_init(sp, frp, NULL, 0))
goto err;
if (EXCMD_RUNNING(gp)) {
(void)ex_cmd(sp);
if (F_ISSET(sp, SC_EXIT | SC_EXIT_FORCE)) {
if (screen_end(sp))
goto err;
goto done;
}
}
}
/*
* Check to see if we need to wait for ex. If SC_SCR_EX is set, ex
* was forced to initialize the screen during startup. We'd like to
* wait for a single character from the user, but we can't because
* we're not in raw mode. We can't switch to raw mode because the
* vi initialization will switch to xterm's alternate screen, causing
* us to lose the messages we're pausing to make sure the user read.
* So, wait for a complete line.
*/
if (F_ISSET(sp, SC_SCR_EX)) {
p = msg_cmsg(sp, CMSG_CONT_R, &len);
(void)write(STDOUT_FILENO, p, len);
for (;;) {
if (v_event_get(sp, &ev, 0, 0))
goto err;
if (ev.e_event == E_INTERRUPT ||
(ev.e_event == E_CHARACTER &&
(ev.e_value == K_CR || ev.e_value == K_NL)))
break;
(void)gp->scr_bell(sp);
}
}
/* Switch into the right editor, regardless. */
F_CLR(sp, SC_EX | SC_VI);
F_SET(sp, LF_ISSET(SC_EX | SC_VI) | SC_STATUS_CNT);
/*
* Main edit loop. Vi handles split screens itself, we only return
* here when switching editor modes or restarting the screen.
*/
while (sp != NULL)
if (F_ISSET(sp, SC_EX) ? ex(&sp) : vi(&sp))
goto err;
done: rval = 0;
if (0)
err: rval = 1;
/* Clean out the global structure. */
v_end(gp);
return (rval);
}
/*
* msgq_status --
* Report on the file's status.
*
* PUBLIC: void msgq_status(SCR *, recno_t, u_int);
*/
void
msgq_status(
SCR *sp,
recno_t lno,
u_int flags)
{
recno_t last;
size_t blen, len;
int cnt, needsep;
const char *t;
char **ap, *bp, *np, *p, *s, *ep;
CHAR_T *wp;
size_t wlen;
/* Get sufficient memory. */
len = strlen(sp->frp->name);
GET_SPACE_GOTOC(sp, bp, blen, len * MAX_CHARACTER_COLUMNS + 128);
p = bp;
ep = bp + blen;
/* Convert the filename. */
CHAR2INT(sp, sp->frp->name, len + 1, wp, wlen);
/* Copy in the filename. */
for (; *wp != '\0'; ++wp) {
len = KEY_LEN(sp, *wp);
memcpy(p, KEY_NAME(sp, *wp), len);
p += len;
}
np = p;
*p++ = ':';
*p++ = ' ';
/* Copy in the argument count. */
if (F_ISSET(sp, SC_STATUS_CNT) && sp->argv != NULL) {
for (cnt = 0, ap = sp->argv; *ap != NULL; ++ap, ++cnt);
if (cnt > 1) {
(void)snprintf(p, ep - p,
msg_cat(sp, "317|%d files to edit", NULL), cnt);
p += strlen(p);
*p++ = ':';
*p++ = ' ';
}
F_CLR(sp, SC_STATUS_CNT);
}
/*
* See nvi/exf.c:file_init() for a description of how and when the
* read-only bit is set.
*
* !!!
* The historic display for "name changed" was "[Not edited]".
*/
needsep = 0;
if (F_ISSET(sp->frp, FR_NEWFILE)) {
F_CLR(sp->frp, FR_NEWFILE);
t = msg_cat(sp, "021|new file", &len);
memcpy(p, t, len);
p += len;
needsep = 1;
} else {
if (F_ISSET(sp->frp, FR_NAMECHANGE)) {
t = msg_cat(sp, "022|name changed", &len);
memcpy(p, t, len);
p += len;
needsep = 1;
}
if (needsep) {
*p++ = ',';
*p++ = ' ';
}
if (F_ISSET(sp->ep, F_MODIFIED))
t = msg_cat(sp, "023|modified", &len);
else
t = msg_cat(sp, "024|unmodified", &len);
memcpy(p, t, len);
p += len;
needsep = 1;
}
if (F_ISSET(sp->frp, FR_UNLOCKED)) {
if (needsep) {
*p++ = ',';
*p++ = ' ';
}
t = msg_cat(sp, "025|UNLOCKED", &len);
memcpy(p, t, len);
p += len;
needsep = 1;
}
if (O_ISSET(sp, O_READONLY)) {
if (needsep) {
*p++ = ',';
*p++ = ' ';
}
t = msg_cat(sp, "026|readonly", &len);
memcpy(p, t, len);
p += len;
needsep = 1;
}
if (needsep) {
*p++ = ':';
*p++ = ' ';
}
if (LF_ISSET(MSTAT_SHOWLAST)) {
if (db_last(sp, &last))
return;
if (last == 0) {
t = msg_cat(sp, "028|empty file", &len);
memcpy(p, t, len);
p += len;
} else {
t = msg_cat(sp, "027|line %lu of %lu [%ld%%]", &len);
(void)snprintf(p, ep - p, t, (u_long)lno, (u_long)last,
((u_long)lno * 100) / last);
p += strlen(p);
}
} else {
t = msg_cat(sp, "029|line %lu", &len);
(void)snprintf(p, ep - p, t, (u_long)lno);
p += strlen(p);
}
#ifdef DEBUG
(void)snprintf(p, ep - p, " (pid %lu)", (u_long)getpid());
p += strlen(p);
#endif
*p++ = '\n';
len = p - bp;
/*
* There's a nasty problem with long path names. Cscope and tags files
* can result in long paths and vi will request a continuation key from
* the user as soon as it starts the screen. Unfortunately, the user
* has already typed ahead, and chaos results. If we assume that the
* characters in the filenames and informational messages only take a
* single screen column each, we can trim the filename.
*
* XXX
* Status lines get put up at fairly awkward times. For example, when
* you do a filter read (e.g., :read ! echo foo) in the top screen of a
* split screen, we have to repaint the status lines for all the screens
* below the top screen. We don't want users having to enter continue
* characters for those screens. Make it really hard to screw this up.
*/
s = bp;
if (LF_ISSET(MSTAT_TRUNCATE) && len > sp->cols) {
for (; s < np && (*s != '/' || (p - s) > sp->cols - 3); ++s);
if (s == np) {
s = p - (sp->cols - 5);
*--s = ' ';
}
*--s = '.';
*--s = '.';
*--s = '.';
len = p - s;
}
/* Flush any waiting ex messages. */
(void)ex_fflush(sp);
sp->gp->scr_msg(sp, M_INFO, s, len);
FREE_SPACE(sp, bp, blen);
alloc_err:
return;
}
/*
* __tree_walk_internal --
* Move to the next/previous page in the tree.
*/
static inline int
__tree_walk_internal(WT_SESSION_IMPL *session,
WT_REF **refp, uint64_t *walkcntp,
int (*skip_func)(WT_SESSION_IMPL *, WT_REF *, void *, bool *),
void *func_cookie, uint32_t flags)
{
WT_BTREE *btree;
WT_DECL_RET;
WT_PAGE_INDEX *pindex;
WT_REF *couple, *couple_orig, *ref;
uint32_t slot;
bool empty_internal, initial_descent, prev, skip;
btree = S2BT(session);
pindex = NULL;
empty_internal = initial_descent = false;
/*
* Tree walks are special: they look inside page structures that splits
* may want to free. Publish that the tree is active during this
* window.
*/
WT_ENTER_PAGE_INDEX(session);
/* Walk should never instantiate deleted pages. */
LF_SET(WT_READ_NO_EMPTY);
/*
* !!!
* Fast-truncate currently only works on row-store trees.
*/
if (btree->type != BTREE_ROW)
LF_CLR(WT_READ_TRUNCATE);
prev = LF_ISSET(WT_READ_PREV) ? 1 : 0;
/*
* There are multiple reasons and approaches to walking the in-memory
* tree:
*
* (1) finding pages to evict (the eviction server);
* (2) writing just dirty leaves or internal nodes (checkpoint);
* (3) discarding pages (close);
* (4) truncating pages in a range (fast truncate);
* (5) skipping pages based on outside information (compaction);
* (6) cursor scans (applications).
*
* Except for cursor scans and compaction, the walk is limited to the
* cache, no pages are read. In all cases, hazard pointers protect the
* walked pages from eviction.
*
* Walks use hazard-pointer coupling through the tree and that's OK
* (hazard pointers can't deadlock, so there's none of the usual
* problems found when logically locking up a btree). If the eviction
* thread tries to evict the active page, it fails because of our
* hazard pointer. If eviction tries to evict our parent, that fails
* because the parent has a child page that can't be discarded. We do
* play one game: don't couple up to our parent and then back down to a
* new leaf, couple to the next page to which we're descending, it
* saves a hazard-pointer swap for each cursor page movement.
*
* !!!
* NOTE: we depend on the fact it's OK to release a page we don't hold,
* that is, it's OK to release couple when couple is set to NULL.
*
* Take a copy of any held page and clear the return value. Remember
* the hazard pointer we're currently holding.
*
* Clear the returned value, it makes future error handling easier.
*/
couple = couple_orig = ref = *refp;
*refp = NULL;
/* If no page is active, begin a walk from the start/end of the tree. */
if (ref == NULL) {
restart: /*
* We can be here with a NULL or root WT_REF; the page release
* function handles them internally, don't complicate this code
* by calling them out.
*/
WT_ERR(__wt_page_release(session, couple, flags));
/*
* We're not supposed to walk trees without root pages. As this
* has not always been the case, assert to debug that change.
*/
WT_ASSERT(session, btree->root.page != NULL);
couple = couple_orig = ref = &btree->root;
initial_descent = true;
goto descend;
}
/*
* If the active page was the root, we've reached the walk's end; we
* only get here if we've returned the root to our caller, so we're
* holding no hazard pointers.
*/
if (__wt_ref_is_root(ref))
goto done;
/* Figure out the current slot in the WT_REF array. */
__ref_index_slot(session, ref, &pindex, &slot);
for (;;) {
/*
* If we're at the last/first slot on the internal page, return
* it in post-order traversal. Otherwise move to the next/prev
* slot and left/right-most element in that subtree.
*/
while ((prev && slot == 0) ||
(!prev && slot == pindex->entries - 1)) {
/* Ascend to the parent. */
__ref_ascend(session, &ref, &pindex, &slot);
/*
* If at the root and returning internal pages, return
* the root page, otherwise we're done. Regardless, no
* hazard pointer is required, release the one we hold.
*/
if (__wt_ref_is_root(ref)) {
WT_ERR(__wt_page_release(
session, couple, flags));
if (!LF_ISSET(WT_READ_SKIP_INTL))
*refp = ref;
goto done;
}
/*
* If we got all the way through an internal page and
* all of the child pages were deleted, mark it for
* eviction.
*/
if (empty_internal && pindex->entries > 1) {
__wt_page_evict_soon(session, ref);
empty_internal = false;
}
/*
* Optionally return internal pages. Swap our previous
* hazard pointer for the page we'll return. We don't
* handle restart or not-found returns, it would require
* additional complexity and is not a possible return:
* we're moving to the parent of the current child page,
* the parent can't have been evicted.
*/
if (!LF_ISSET(WT_READ_SKIP_INTL)) {
WT_ERR(__wt_page_swap(
session, couple, ref, flags));
*refp = ref;
goto done;
}
}
if (prev)
--slot;
else
++slot;
if (walkcntp != NULL)
++*walkcntp;
for (;;) {
/*
* Move to the next slot, and set the reference hint if
* it's wrong (used when we continue the walk). We don't
* always update the hints when splitting, it's expected
* for them to be incorrect in some workloads.
*/
ref = pindex->index[slot];
if (ref->pindex_hint != slot)
ref->pindex_hint = slot;
/*
* If we see any child states other than deleted, the
* page isn't empty.
*/
if (ref->state != WT_REF_DELETED &&
!LF_ISSET(WT_READ_TRUNCATE))
empty_internal = false;
if (LF_ISSET(WT_READ_CACHE)) {
/*
* Only look at unlocked pages in memory:
* fast-path some common cases.
*/
if (LF_ISSET(WT_READ_NO_WAIT) &&
ref->state != WT_REF_MEM)
break;
/* Skip lookaside pages if not requested. */
if (ref->state == WT_REF_LOOKASIDE &&
!LF_ISSET(WT_READ_LOOKASIDE))
break;
} else if (LF_ISSET(WT_READ_TRUNCATE)) {
/*
* Avoid pulling a deleted page back in to try
* to delete it again.
*/
if (ref->state == WT_REF_DELETED &&
__wt_delete_page_skip(session, ref, false))
break;
/*
* If deleting a range, try to delete the page
* without instantiating it.
*/
WT_ERR(__wt_delete_page(session, ref, &skip));
if (skip)
break;
empty_internal = false;
} else if (skip_func != NULL) {
WT_ERR(skip_func(session,
ref, func_cookie, &skip));
if (skip)
break;
} else {
/*
* Try to skip deleted pages visible to us.
*/
if (ref->state == WT_REF_DELETED &&
__wt_delete_page_skip(session, ref, false))
break;
}
ret = __wt_page_swap(session, couple, ref,
WT_READ_NOTFOUND_OK | WT_READ_RESTART_OK | flags);
/*
* Not-found is an expected return when only walking
* in-cache pages, or if we see a deleted page.
*/
if (ret == WT_NOTFOUND) {
ret = 0;
break;
}
/*
* The page we're moving to might have split, in which
* case move to the last position we held.
*/
if (ret == WT_RESTART) {
ret = 0;
/*
* If a cursor is setting up at the end of the
* tree, we can't use our parent page's index,
* because it may have already split; restart
* the walk.
*/
if (prev && initial_descent)
goto restart;
/*
* If a new walk that never coupled from the
* root to a new saved position in the tree,
* restart the walk.
*/
if (couple == &btree->root)
goto restart;
/*
* If restarting from some original position,
* repeat the increment or decrement we made at
* that time. Otherwise, couple is an internal
* page we've acquired after moving from that
* starting position and we can treat it as a
* new page. This works because we never acquire
* a hazard pointer on a leaf page we're not
* going to return to our caller, this will quit
* working if that ever changes.
*/
WT_ASSERT(session,
couple == couple_orig ||
WT_PAGE_IS_INTERNAL(couple->page));
ref = couple;
__ref_index_slot(session, ref, &pindex, &slot);
if (couple == couple_orig)
break;
}
WT_ERR(ret);
couple = ref;
/*
* A new page: configure for traversal of any internal
* page's children, else return the leaf page.
*/
if (WT_PAGE_IS_INTERNAL(ref->page)) {
descend: empty_internal = true;
/*
* There's a split race when a cursor is setting
* up at the end of the tree or moving backwards
* through the tree and descending a level. When
* splitting an internal page into its parent,
* we move the WT_REF structures and update the
* parent's page index before updating the split
* page's page index, and it's not an atomic
* update. A thread can read the parent page's
* replacement page index, then read the split
* page's original index, or the parent page's
* original and the split page's replacement.
*
* This isn't a problem for a cursor setting up
* at the start of the tree or moving forwards
* through the tree because we do right-hand
* splits on internal pages and the initial part
* of the split page's namespace won't change as
* part of a split. A thread reading the parent
* page's and split page's indexes will move to
* the same slot no matter what order of indexes
* are read.
*
* Handle a cursor setting up at the end of the
* tree or moving backwards through the tree.
*/
if (!prev) {
WT_INTL_INDEX_GET(
session, ref->page, pindex);
slot = 0;
} else if (initial_descent) {
if (!__ref_initial_descent_prev(
session, ref, &pindex))
goto restart;
slot = pindex->entries - 1;
} else {
__ref_descend_prev(
session, ref, &pindex);
slot = pindex->entries - 1;
}
continue;
}
/*
* The tree-walk restart code knows we return any leaf
* page we acquire (never hazard-pointer coupling on
* after acquiring a leaf page), and asserts no restart
* happens while holding a leaf page. This page must be
* returned to our caller.
*/
*refp = ref;
goto done;
}
}
done:
err: WT_LEAVE_PAGE_INDEX(session);
return (ret);
}
/*
* __wt_tree_walk --
* Move to the next/previous page in the tree.
*/
int
__wt_tree_walk(WT_SESSION_IMPL *session,
WT_REF **refp, uint64_t *walkcntp, uint32_t flags)
{
WT_BTREE *btree;
WT_DECL_RET;
WT_PAGE *page;
WT_PAGE_INDEX *pindex;
WT_REF *couple, *couple_orig, *ref;
int prev, skip;
uint32_t slot;
btree = S2BT(session);
/*
* Tree walks are special: they look inside page structures that splits
* may want to free. Publish that the tree is active during this
* window.
*/
WT_ENTER_PAGE_INDEX(session);
/*
* !!!
* Fast-truncate currently only works on row-store trees.
*/
if (btree->type != BTREE_ROW)
LF_CLR(WT_READ_TRUNCATE);
prev = LF_ISSET(WT_READ_PREV) ? 1 : 0;
/*
* There are multiple reasons and approaches to walking the in-memory
* tree:
*
* (1) finding pages to evict (the eviction server);
* (2) writing just dirty leaves or internal nodes (checkpoint);
* (3) discarding pages (close);
* (4) truncating pages in a range (fast truncate);
* (5) skipping pages based on outside information (compaction);
* (6) cursor scans (applications).
*
* Except for cursor scans and compaction, the walk is limited to the
* cache, no pages are read. In all cases, hazard pointers protect the
* walked pages from eviction.
*
* Walks use hazard-pointer coupling through the tree and that's OK
* (hazard pointers can't deadlock, so there's none of the usual
* problems found when logically locking up a btree). If the eviction
* thread tries to evict the active page, it fails because of our
* hazard pointer. If eviction tries to evict our parent, that fails
* because the parent has a child page that can't be discarded. We do
* play one game: don't couple up to our parent and then back down to a
* new leaf, couple to the next page to which we're descending, it
* saves a hazard-pointer swap for each cursor page movement.
*
* !!!
* NOTE: we depend on the fact it's OK to release a page we don't hold,
* that is, it's OK to release couple when couple is set to NULL.
*
* Take a copy of any held page and clear the return value. Remember
* the hazard pointer we're currently holding.
*
* We may be passed a pointer to btree->evict_page that we are clearing
* here. We check when discarding pages that we're not discarding that
* page, so this clear must be done before the page is released.
*/
couple = couple_orig = ref = *refp;
*refp = NULL;
/* If no page is active, begin a walk from the start of the tree. */
if (ref == NULL) {
ref = &btree->root;
if (ref->page == NULL)
goto done;
goto descend;
}
ascend: /*
* If the active page was the root, we've reached the walk's end.
* Release any hazard-pointer we're holding.
*/
if (__wt_ref_is_root(ref)) {
WT_ERR(__wt_page_release(session, couple, flags));
goto done;
}
/* Figure out the current slot in the WT_REF array. */
__wt_page_refp(session, ref, &pindex, &slot);
for (;;) {
/*
* If we're at the last/first slot on the page, return this page
* in post-order traversal. Otherwise we move to the next/prev
* slot and left/right-most element in its subtree.
*/
if ((prev && slot == 0) ||
(!prev && slot == pindex->entries - 1)) {
ref = ref->home->pg_intl_parent_ref;
/* Optionally skip internal pages. */
if (LF_ISSET(WT_READ_SKIP_INTL))
goto ascend;
/*
* We've ascended the tree and are returning an internal
* page. If it's the root, discard our hazard pointer,
* otherwise, swap our hazard pointer for the page we'll
* return.
*/
if (__wt_ref_is_root(ref))
WT_ERR(__wt_page_release(
session, couple, flags));
else {
/*
* Locate the reference to our parent page then
* swap our child hazard pointer for the parent.
* We don't handle restart or not-found returns.
* It would require additional complexity and is
* not a possible return: we're moving to the
* parent of the current child page, our parent
* reference can't have split or been evicted.
*/
__wt_page_refp(session, ref, &pindex, &slot);
if ((ret = __wt_page_swap(
session, couple, ref, flags)) != 0) {
WT_TRET(__wt_page_release(
session, couple, flags));
WT_ERR(ret);
}
}
*refp = ref;
goto done;
}
if (prev)
--slot;
else
++slot;
if (walkcntp != NULL)
++*walkcntp;
for (;;) {
ref = pindex->index[slot];
if (LF_ISSET(WT_READ_CACHE)) {
/*
* Only look at unlocked pages in memory:
* fast-path some common cases.
*/
if (LF_ISSET(WT_READ_NO_WAIT) &&
ref->state != WT_REF_MEM)
break;
} else if (LF_ISSET(WT_READ_TRUNCATE)) {
/*
* Avoid pulling a deleted page back in to try
* to delete it again.
*/
if (ref->state == WT_REF_DELETED &&
__wt_delete_page_skip(session, ref))
break;
/*
* If deleting a range, try to delete the page
* without instantiating it.
*/
WT_ERR(__wt_delete_page(session, ref, &skip));
if (skip)
break;
} else if (LF_ISSET(WT_READ_COMPACT)) {
/*
* Skip deleted pages, rewriting them doesn't
* seem useful.
*/
if (ref->state == WT_REF_DELETED)
break;
/*
* If the page is in-memory, we want to look at
* it (it may have been modified and written,
* and the current location is the interesting
* one in terms of compaction, not the original
* location). If the page isn't in-memory, test
* if the page will help with compaction, don't
* read it if we don't have to.
*/
if (ref->state == WT_REF_DISK) {
WT_ERR(__wt_compact_page_skip(
session, ref, &skip));
if (skip)
break;
}
} else {
/*
* Try to skip deleted pages visible to us.
*/
if (ref->state == WT_REF_DELETED &&
__wt_delete_page_skip(session, ref))
break;
}
ret = __wt_page_swap(session, couple, ref, flags);
/*
* Not-found is an expected return when only walking
* in-cache pages.
*/
if (ret == WT_NOTFOUND) {
ret = 0;
break;
}
/*
* The page we're moving to might have split, in which
* case move to the last position we held.
*/
if (ret == WT_RESTART) {
ret = 0;
/*
* If a new walk that never coupled from the
* root to a new saved position in the tree,
* restart the walk.
*/
if (couple == &btree->root) {
ref = &btree->root;
if (ref->page == NULL)
goto done;
goto descend;
}
/*
* If restarting from some original position,
* repeat the increment or decrement we made at
* that time. Otherwise, couple is an internal
* page we've acquired after moving from that
* starting position and we can treat it as a
* new page. This works because we never acquire
* a hazard pointer on a leaf page we're not
* going to return to our caller, this will quit
* working if that ever changes.
*/
WT_ASSERT(session,
couple == couple_orig ||
WT_PAGE_IS_INTERNAL(couple->page));
ref = couple;
__wt_page_refp(session, ref, &pindex, &slot);
if (couple == couple_orig)
break;
}
WT_ERR(ret);
/*
* A new page: configure for traversal of any internal
* page's children, else return the leaf page.
*/
descend: couple = ref;
page = ref->page;
if (page->type == WT_PAGE_ROW_INT ||
page->type == WT_PAGE_COL_INT) {
WT_INTL_INDEX_GET(session, page, pindex);
slot = prev ? pindex->entries - 1 : 0;
} else {
*refp = ref;
goto done;
}
}
}
done:
err: WT_LEAVE_PAGE_INDEX(session);
return (ret);
}
/*
* editor --
* Main editor routine.
*
* PUBLIC: int editor __P((WIN *, int, char *[]));
*/
int
editor(WIN *wp, int argc, char **argv)
{
extern int optind;
extern char *optarg;
const char *p;
EVENT ev;
FREF *frp;
SCR *sp;
GS *gp;
size_t len;
u_int flags;
int ch, flagchk, lflag, secure, startup, readonly, rval, silent;
char *tag_f, *wsizearg, path[256];
CHAR_T *w;
size_t wlen;
gp = wp->gp;
/* Initialize the busy routine, if not defined by the screen. */
if (gp->scr_busy == NULL)
gp->scr_busy = vs_busy;
/* Initialize the message routine, if not defined by the screen. */
if (wp->scr_msg == NULL)
wp->scr_msg = vs_msg;
/* Set initial screen type and mode based on the program name. */
readonly = 0;
if (!strcmp(gp->progname, "ex") || !strcmp(gp->progname, "nex"))
LF_INIT(SC_EX);
else {
/* Nview, view are readonly. */
if (!strcmp(gp->progname, "nview") ||
!strcmp(gp->progname, "view"))
readonly = 1;
/* Vi is the default. */
LF_INIT(SC_VI);
}
/* Convert old-style arguments into new-style ones. */
if (v_obsolete(gp->progname, argv))
return (1);
/* Parse the arguments. */
flagchk = '\0';
tag_f = wsizearg = NULL;
lflag = secure = silent = 0;
startup = 1;
/* Set the file snapshot flag. */
F_SET(gp, G_SNAPSHOT);
#ifdef DEBUG
while ((ch = getopt(argc, argv, "c:D:eFlRrSsT:t:vw:")) != EOF)
#else
while ((ch = getopt(argc, argv, "c:eFlRrSst:vw:")) != EOF)
#endif
switch (ch) {
case 'c': /* Run the command. */
/*
* XXX
* We should support multiple -c options.
*/
if (gp->c_option != NULL) {
v_estr(gp->progname, 0,
"only one -c command may be specified.");
return (1);
}
gp->c_option = optarg;
break;
#ifdef DEBUG
case 'D':
switch (optarg[0]) {
case 's':
startup = 0;
break;
case 'w':
attach(gp);
break;
default:
v_estr(gp->progname, 0,
"usage: -D requires s or w argument.");
return (1);
}
break;
#endif
case 'e': /* Ex mode. */
LF_CLR(SC_VI);
LF_SET(SC_EX);
break;
case 'F': /* No snapshot. */
v_estr(gp->progname, 0,
"-F option no longer supported.");
break;
case 'l': /* Set lisp, showmatch options. */
lflag = 1;
break;
case 'R': /* Readonly. */
readonly = 1;
break;
case 'r': /* Recover. */
if (flagchk == 't') {
v_estr(gp->progname, 0,
"only one of -r and -t may be specified.");
return (1);
}
flagchk = 'r';
break;
case 'S':
secure = 1;
break;
case 's':
silent = 1;
break;
#ifdef TRACE
case 'T': /* Trace. */
(void)vtrace_init(optarg);
break;
#endif
case 't': /* Tag. */
if (flagchk == 'r') {
v_estr(gp->progname, 0,
"only one of -r and -t may be specified.");
return (1);
}
if (flagchk == 't') {
v_estr(gp->progname, 0,
"only one tag file may be specified.");
return (1);
}
flagchk = 't';
tag_f = optarg;
break;
case 'v': /* Vi mode. */
LF_CLR(SC_EX);
LF_SET(SC_VI);
break;
case 'w':
wsizearg = optarg;
break;
case '?':
default:
(void)gp->scr_usage();
return (1);
}
argc -= optind;
argv += optind;
/*
* -s option is only meaningful to ex.
*
* If not reading from a terminal, it's like -s was specified.
*/
if (silent && !LF_ISSET(SC_EX)) {
v_estr(gp->progname, 0, "-s option is only applicable to ex.");
goto err;
}
if (LF_ISSET(SC_EX) && F_ISSET(gp, G_SCRIPTED))
silent = 1;
/*
* Build and initialize the first/current screen. This is a bit
* tricky. If an error is returned, we may or may not have a
* screen structure. If we have a screen structure, put it on a
* display queue so that the error messages get displayed.
*
* !!!
* Everything we do until we go interactive is done in ex mode.
*/
if (screen_init(gp, NULL, &sp)) {
if (sp != NULL) {
CIRCLEQ_INSERT_HEAD(&wp->scrq, sp, q);
sp->wp = wp;
}
goto err;
}
F_SET(sp, SC_EX);
CIRCLEQ_INSERT_HEAD(&wp->scrq, sp, q);
sp->wp = wp;
if (v_key_init(sp)) /* Special key initialization. */
goto err;
{ int oargs[5], *oargp = oargs;
if (lflag) { /* Command-line options. */
*oargp++ = O_LISP;
*oargp++ = O_SHOWMATCH;
}
if (readonly)
*oargp++ = O_READONLY;
if (secure)
*oargp++ = O_SECURE;
*oargp = -1; /* Options initialization. */
if (opts_init(sp, oargs))
goto err;
}
if (wsizearg != NULL) {
ARGS *av[2], a, b;
(void)snprintf(path, sizeof(path), "window=%s", wsizearg);
a.bp = (CHAR_T *)path;
a.len = strlen(path);
b.bp = NULL;
b.len = 0;
av[0] = &a;
av[1] = &b;
(void)opts_set(sp, av, NULL);
}
if (silent) { /* Ex batch mode option values. */
O_CLR(sp, O_AUTOPRINT);
O_CLR(sp, O_PROMPT);
O_CLR(sp, O_VERBOSE);
O_CLR(sp, O_WARN);
F_SET(sp, SC_EX_SILENT);
}
sp->rows = O_VAL(sp, O_LINES); /* Make ex formatting work. */
sp->cols = O_VAL(sp, O_COLUMNS);
if (!silent && startup) { /* Read EXINIT, exrc files. */
if (ex_exrc(sp))
goto err;
if (F_ISSET(sp, SC_EXIT | SC_EXIT_FORCE)) {
if (screen_end(sp))
goto err;
goto done;
}
}
/*
* List recovery files if -r specified without file arguments.
* Note, options must be initialized and startup information
* read before doing this.
*/
if (flagchk == 'r' && argv[0] == NULL) {
if (rcv_list(sp))
goto err;
if (screen_end(sp))
goto err;
goto done;
}
/*
* !!!
* Initialize the default ^D, ^U scrolling value here, after the
* user has had every opportunity to set the window option.
*
* It's historic practice that changing the value of the window
* option did not alter the default scrolling value, only giving
* a count to ^D/^U did that.
*/
sp->defscroll = (O_VAL(sp, O_WINDOW) + 1) / 2;
/*
* If we don't have a command-line option, switch into the right
* editor now, so that we position default files correctly, and
* so that any tags file file-already-locked messages are in the
* vi screen, not the ex screen.
*
* XXX
* If we have a command-line option, the error message can end
* up in the wrong place, but I think that the combination is
* unlikely.
*/
if (gp->c_option == NULL) {
F_CLR(sp, SC_EX | SC_VI);
F_SET(sp, LF_ISSET(SC_EX | SC_VI));
}
/* Open a tag file if specified. */
if (tag_f != NULL) {
CHAR2INT(sp, tag_f, strlen(tag_f) + 1, w, wlen);
if (ex_tag_first(sp, w))
goto err;
}
/*
* Append any remaining arguments as file names. Files are recovery
* files if -r specified. If the tag option or ex startup commands
* loaded a file, then any file arguments are going to come after it.
*/
if (*argv != NULL) {
if (sp->frp != NULL) {
/* Cheat -- we know we have an extra argv slot. */
MALLOC_NOMSG(sp,
*--argv, char *, strlen(sp->frp->name) + 1);
if (*argv == NULL) {
v_estr(gp->progname, errno, NULL);
goto err;
}
(void)strcpy(*argv, sp->frp->name);
}
sp->argv = sp->cargv = argv;
F_SET(sp, SC_ARGNOFREE);
if (flagchk == 'r')
F_SET(sp, SC_ARGRECOVER);
}
/*
* __wt_page_in_func --
* Acquire a hazard pointer to a page; if the page is not in-memory,
* read it from the disk and build an in-memory version.
*/
int
__wt_page_in_func(WT_SESSION_IMPL *session, WT_REF *ref, uint32_t flags
#ifdef HAVE_DIAGNOSTIC
, const char *file, int line
#endif
)
{
WT_BTREE *btree;
WT_DECL_RET;
WT_PAGE *page;
u_int sleep_cnt, wait_cnt;
int busy, cache_work, force_attempts, oldgen, stalled;
btree = S2BT(session);
stalled = 0;
for (force_attempts = oldgen = 0, sleep_cnt = wait_cnt = 0;;) {
switch (ref->state) {
case WT_REF_DISK:
case WT_REF_DELETED:
if (LF_ISSET(WT_READ_CACHE))
return (WT_NOTFOUND);
/*
* The page isn't in memory, read it. If this thread is
* allowed to do eviction work, check for space in the
* cache.
*/
if (!LF_ISSET(WT_READ_NO_EVICT))
WT_RET(__wt_cache_eviction_check(
session, 1, NULL));
WT_RET(__page_read(session, ref));
oldgen = LF_ISSET(WT_READ_WONT_NEED) ||
F_ISSET(session, WT_SESSION_NO_CACHE);
continue;
case WT_REF_READING:
if (LF_ISSET(WT_READ_CACHE))
return (WT_NOTFOUND);
if (LF_ISSET(WT_READ_NO_WAIT))
return (WT_NOTFOUND);
/* Waiting on another thread's read, stall. */
WT_STAT_FAST_CONN_INCR(session, page_read_blocked);
stalled = 1;
break;
case WT_REF_LOCKED:
if (LF_ISSET(WT_READ_NO_WAIT))
return (WT_NOTFOUND);
/* Waiting on eviction, stall. */
WT_STAT_FAST_CONN_INCR(session, page_locked_blocked);
stalled = 1;
break;
case WT_REF_SPLIT:
return (WT_RESTART);
case WT_REF_MEM:
/*
* The page is in memory.
*
* Get a hazard pointer if one is required. We cannot
* be evicting if no hazard pointer is required, we're
* done.
*/
if (F_ISSET(btree, WT_BTREE_IN_MEMORY))
goto skip_evict;
/*
* The expected reason we can't get a hazard pointer is
* because the page is being evicted, yield, try again.
*/
#ifdef HAVE_DIAGNOSTIC
WT_RET(
__wt_hazard_set(session, ref, &busy, file, line));
#else
WT_RET(__wt_hazard_set(session, ref, &busy));
#endif
if (busy) {
WT_STAT_FAST_CONN_INCR(
session, page_busy_blocked);
break;
}
/*
* If eviction is configured for this file, check to see
* if the page qualifies for forced eviction and update
* the page's generation number. If eviction isn't being
* done on this file, we're done.
*/
if (LF_ISSET(WT_READ_NO_EVICT) ||
F_ISSET(session, WT_SESSION_NO_EVICTION) ||
F_ISSET(btree, WT_BTREE_NO_EVICTION))
goto skip_evict;
/*
* Forcibly evict pages that are too big.
*/
page = ref->page;
if (force_attempts < 10 &&
__evict_force_check(session, page)) {
++force_attempts;
ret = __wt_page_release_evict(session, ref);
/* If forced eviction fails, stall. */
if (ret == EBUSY) {
ret = 0;
WT_STAT_FAST_CONN_INCR(session,
page_forcible_evict_blocked);
stalled = 1;
break;
}
WT_RET(ret);
/*
* The result of a successful forced eviction
* is a page-state transition (potentially to
* an in-memory page we can use, or a restart
* return for our caller), continue the outer
* page-acquisition loop.
*/
continue;
}
/*
* If we read the page and we are configured to not
* trash the cache, set the oldest read generation so
* the page is forcibly evicted as soon as possible.
*
* Otherwise, update the page's read generation.
*/
if (oldgen && page->read_gen == WT_READGEN_NOTSET)
__wt_page_evict_soon(page);
else if (!LF_ISSET(WT_READ_NO_GEN) &&
page->read_gen != WT_READGEN_OLDEST &&
page->read_gen < __wt_cache_read_gen(session))
page->read_gen =
__wt_cache_read_gen_bump(session);
skip_evict:
/*
* Check if we need an autocommit transaction.
* Starting a transaction can trigger eviction, so skip
* it if eviction isn't permitted.
*/
return (LF_ISSET(WT_READ_NO_EVICT) ? 0 :
__wt_txn_autocommit_check(session));
WT_ILLEGAL_VALUE(session);
}
/*
* We failed to get the page -- yield before retrying, and if
* we've yielded enough times, start sleeping so we don't burn
* CPU to no purpose.
*/
if (stalled)
wait_cnt += 1000;
else if (++wait_cnt < 1000) {
__wt_yield();
continue;
}
/*
* If stalling and this thread is allowed to do eviction work,
* check if the cache needs help. If we do work for the cache,
* substitute that for a sleep.
*/
if (!LF_ISSET(WT_READ_NO_EVICT)) {
WT_RET(
__wt_cache_eviction_check(session, 1, &cache_work));
if (cache_work)
continue;
}
sleep_cnt = WT_MIN(sleep_cnt + 1000, 10000);
WT_STAT_FAST_CONN_INCRV(session, page_sleep, sleep_cnt);
__wt_sleep(0, sleep_cnt);
}
}
/*
* search_init --
* Set up a search.
*/
static int
search_init(
SCR *sp,
dir_t dir,
CHAR_T *ptrn,
size_t plen,
CHAR_T **epp,
u_int flags)
{
recno_t lno;
int delim;
CHAR_T *p, *t;
/* If the file is empty, it's a fast search. */
if (sp->lno <= 1) {
if (db_last(sp, &lno))
return (1);
if (lno == 0) {
if (LF_ISSET(SEARCH_MSG))
search_msg(sp, S_EMPTY);
return (1);
}
}
if (LF_ISSET(SEARCH_PARSE)) { /* Parse the string. */
/*
* Use the saved pattern if no pattern specified, or if only
* one or two delimiter characters specified.
*
* !!!
* Historically, only the pattern itself was saved, vi didn't
* preserve addressing or delta information.
*/
if (ptrn == NULL)
goto prev;
if (plen == 1) {
if (epp != NULL)
*epp = ptrn + 1;
goto prev;
}
if (ptrn[0] == ptrn[1]) {
if (epp != NULL)
*epp = ptrn + 2;
/* Complain if we don't have a previous pattern. */
prev: if (sp->re == NULL) {
search_msg(sp, S_NOPREV);
return (1);
}
/* Re-compile the search pattern if necessary. */
if (!F_ISSET(sp, SC_RE_SEARCH) && re_compile(sp,
sp->re, sp->re_len, NULL, NULL, &sp->re_c,
RE_C_SEARCH |
(LF_ISSET(SEARCH_MSG) ? 0 : RE_C_SILENT)))
return (1);
/* Set the search direction. */
if (LF_ISSET(SEARCH_SET))
sp->searchdir = dir;
return (0);
}
/*
* Set the delimiter, and move forward to the terminating
* delimiter, handling escaped delimiters.
*
* QUOTING NOTE:
* Only discard an escape character if it escapes a delimiter.
*/
for (delim = *ptrn, p = t = ++ptrn;; *t++ = *p++) {
if (--plen == 0 || p[0] == delim) {
if (plen != 0)
++p;
break;
}
if (plen > 1 && p[0] == '\\' && p[1] == delim) {
++p;
--plen;
}
}
if (epp != NULL)
*epp = p;
plen = t - ptrn;
}
/* Compile the RE. */
if (re_compile(sp, ptrn, plen, &sp->re, &sp->re_len, &sp->re_c,
RE_C_SEARCH |
(LF_ISSET(SEARCH_MSG) ? 0 : RE_C_SILENT) |
(LF_ISSET(SEARCH_TAG) ? RE_C_TAG : 0) |
(LF_ISSET(SEARCH_CSCOPE) ? RE_C_CSCOPE : 0)))
return (1);
/* Set the search direction. */
if (LF_ISSET(SEARCH_SET))
sp->searchdir = dir;
return (0);
}
/*
* b_search --
* Do a backward search.
*
* PUBLIC: int b_search __P((SCR *,
* PUBLIC: MARK *, MARK *, CHAR_T *, size_t, CHAR_T **, u_int));
*/
int
b_search(
SCR *sp,
MARK *fm,
MARK *rm,
CHAR_T *ptrn,
size_t plen,
CHAR_T **eptrn,
u_int flags)
{
busy_t btype;
recno_t lno;
regmatch_t match[1];
size_t coff, last, len;
int cnt, eval, rval, wrapped;
CHAR_T *l;
if (search_init(sp, BACKWARD, ptrn, plen, eptrn, flags))
return (1);
/*
* If doing incremental search, set the "starting" position past the
* current column, so that we search a minimal distance and still
* match special patterns, e.g., \> for the end of a word. This is
* safe when the cursor is at the end of a line because we only use
* it for comparison with the location of the match.
*
* Otherwise, start searching immediately before the cursor. If in
* the first column, start search on the previous line.
*/
if (LF_ISSET(SEARCH_INCR)) {
lno = fm->lno;
coff = fm->cno + 1;
} else {
if (fm->cno == 0) {
if (fm->lno == 1 && !O_ISSET(sp, O_WRAPSCAN)) {
if (LF_ISSET(SEARCH_MSG))
search_msg(sp, S_SOF);
return (1);
}
lno = fm->lno - 1;
} else
lno = fm->lno;
coff = fm->cno;
}
btype = BUSY_ON;
for (cnt = INTERRUPT_CHECK, rval = 1, wrapped = 0;; --lno, coff = 0) {
if (cnt-- == 0) {
if (INTERRUPTED(sp))
break;
if (LF_ISSET(SEARCH_MSG)) {
search_busy(sp, btype);
btype = BUSY_UPDATE;
}
cnt = INTERRUPT_CHECK;
}
if ((wrapped && lno < fm->lno) || lno == 0) {
if (wrapped) {
if (LF_ISSET(SEARCH_MSG))
search_msg(sp, S_NOTFOUND);
break;
}
if (!O_ISSET(sp, O_WRAPSCAN)) {
if (LF_ISSET(SEARCH_MSG))
search_msg(sp, S_SOF);
break;
}
if (db_last(sp, &lno))
break;
if (lno == 0) {
if (LF_ISSET(SEARCH_MSG))
search_msg(sp, S_EMPTY);
break;
}
++lno;
wrapped = 1;
continue;
}
if (db_get(sp, lno, 0, &l, &len))
break;
/* Set the termination. */
match[0].rm_so = 0;
match[0].rm_eo = len;
#if defined(DEBUG) && 0
TRACE(sp, "B search: %lu from 0 to %qu\n", lno, match[0].rm_eo);
#endif
/* Search the line. */
eval = regexec(&sp->re_c, l, 1, match,
(match[0].rm_eo == len ? 0 : REG_NOTEOL) | REG_STARTEND);
if (eval == REG_NOMATCH)
continue;
if (eval != 0) {
if (LF_ISSET(SEARCH_MSG))
re_error(sp, eval, &sp->re_c);
else
(void)sp->gp->scr_bell(sp);
break;
}
/* Check for a match starting past the cursor. */
if (coff != 0 && match[0].rm_so >= coff)
continue;
/* Warn if the search wrapped. */
if (wrapped && LF_ISSET(SEARCH_WMSG))
search_msg(sp, S_WRAP);
#if defined(DEBUG) && 0
TRACE(sp, "B found: %qu to %qu\n",
match[0].rm_so, match[0].rm_eo);
#endif
/*
* We now have the first match on the line. Step through the
* line character by character until find the last acceptable
* match. This is painful, we need a better interface to regex
* to make this work.
*/
for (;;) {
last = match[0].rm_so++;
if (match[0].rm_so >= len)
break;
match[0].rm_eo = len;
eval = regexec(&sp->re_c, l, 1, match,
(match[0].rm_so == 0 ? 0 : REG_NOTBOL) |
REG_STARTEND);
if (eval == REG_NOMATCH)
break;
if (eval != 0) {
if (LF_ISSET(SEARCH_MSG))
re_error(sp, eval, &sp->re_c);
else
(void)sp->gp->scr_bell(sp);
goto err;
}
if (coff && match[0].rm_so >= coff)
break;
}
rm->lno = lno;
/* See comment in f_search(). */
if (!LF_ISSET(SEARCH_EOL) && last >= len)
rm->cno = len != 0 ? len - 1 : 0;
else
rm->cno = last;
rval = 0;
break;
}
err: if (LF_ISSET(SEARCH_MSG))
search_busy(sp, BUSY_OFF);
return (rval);
}
/*
* f_search --
* Do a forward search.
*
* PUBLIC: int f_search __P((SCR *,
* PUBLIC: MARK *, MARK *, CHAR_T *, size_t, CHAR_T **, u_int));
*/
int
f_search(
SCR *sp,
MARK *fm,
MARK *rm,
CHAR_T *ptrn,
size_t plen,
CHAR_T **eptrn,
u_int flags)
{
busy_t btype;
recno_t lno;
regmatch_t match[1];
size_t coff, len;
int cnt, eval, rval, wrapped;
CHAR_T *l;
if (search_init(sp, FORWARD, ptrn, plen, eptrn, flags))
return (1);
if (LF_ISSET(SEARCH_FILE)) {
lno = 1;
coff = 0;
} else {
if (db_get(sp, fm->lno, DBG_FATAL, &l, &len))
return (1);
lno = fm->lno;
/*
* If doing incremental search, start searching at the previous
* column, so that we search a minimal distance and still match
* special patterns, e.g., \< for beginning of a word.
*
* Otherwise, start searching immediately after the cursor. If
* at the end of the line, start searching on the next line.
* This is incompatible (read bug fix) with the historic vi --
* searches for the '$' pattern never moved forward, and the
* "-t foo" didn't work if the 'f' was the first character in
* the file.
*/
if (LF_ISSET(SEARCH_INCR)) {
if ((coff = fm->cno) != 0)
--coff;
} else if (fm->cno + 1 >= len) {
coff = 0;
lno = fm->lno + 1;
if (db_get(sp, lno, 0, &l, &len)) {
if (!O_ISSET(sp, O_WRAPSCAN)) {
if (LF_ISSET(SEARCH_MSG))
search_msg(sp, S_EOF);
return (1);
}
lno = 1;
}
} else
coff = fm->cno + 1;
}
btype = BUSY_ON;
for (cnt = INTERRUPT_CHECK, rval = 1, wrapped = 0;; ++lno, coff = 0) {
if (cnt-- == 0) {
if (INTERRUPTED(sp))
break;
if (LF_ISSET(SEARCH_MSG)) {
search_busy(sp, btype);
btype = BUSY_UPDATE;
}
cnt = INTERRUPT_CHECK;
}
if ((wrapped && lno > fm->lno) || db_get(sp, lno, 0, &l, &len)) {
if (wrapped) {
if (LF_ISSET(SEARCH_MSG))
search_msg(sp, S_NOTFOUND);
break;
}
if (!O_ISSET(sp, O_WRAPSCAN)) {
if (LF_ISSET(SEARCH_MSG))
search_msg(sp, S_EOF);
break;
}
lno = 0;
wrapped = 1;
continue;
}
/* If already at EOL, just keep going. */
if (len != 0 && coff == len)
continue;
/* Set the termination. */
match[0].rm_so = coff;
match[0].rm_eo = len;
#if defined(DEBUG) && 0
TRACE(sp, "F search: %lu from %u to %u\n",
lno, coff, len != 0 ? len - 1 : len);
#endif
/* Search the line. */
eval = regexec(&sp->re_c, l, 1, match,
(match[0].rm_so == 0 ? 0 : REG_NOTBOL) | REG_STARTEND);
if (eval == REG_NOMATCH)
continue;
if (eval != 0) {
if (LF_ISSET(SEARCH_MSG))
re_error(sp, eval, &sp->re_c);
else
(void)sp->gp->scr_bell(sp);
break;
}
/* Warn if the search wrapped. */
if (wrapped && LF_ISSET(SEARCH_WMSG))
search_msg(sp, S_WRAP);
#if defined(DEBUG) && 0
TRACE(sp, "F search: %qu to %qu\n",
match[0].rm_so, match[0].rm_eo);
#endif
rm->lno = lno;
rm->cno = match[0].rm_so;
/*
* If a change command, it's possible to move beyond the end
* of a line. Historic vi generally got this wrong (e.g. try
* "c?$<cr>"). Not all that sure this gets it right, there
* are lots of strange cases.
*/
if (!LF_ISSET(SEARCH_EOL) && rm->cno >= len)
rm->cno = len != 0 ? len - 1 : 0;
rval = 0;
break;
}
if (LF_ISSET(SEARCH_MSG))
search_busy(sp, BUSY_OFF);
return (rval);
}