common/log.c

   1 /*-
   2  * Copyright (c) 1992, 1993, 1994
   3  *      The Regents of the University of California.  All rights reserved.
   4  * Copyright (c) 1992, 1993, 1994, 1995, 1996
   5  *      Keith Bostic.  All rights reserved.
   6  *
   7  * See the LICENSE file for redistribution information.
   8  */
   9
  10 #include "config.h"
  11
  12 #ifndef lint
  13 static const char sccsid[] = "$Id: log.c,v 10.24 2001/06/25 15:19:10 skimo Exp $ (Berkeley) $Date: 2001/06/25 15:19:10 $";
  14 #endif /* not lint */
  15
  16 #include <sys/types.h>
  17 #include <sys/queue.h>
  18 #include <sys/stat.h>
  19
  20 #include <bitstring.h>
  21 #include <errno.h>
  22 #include <fcntl.h>
  23 #include <limits.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27
  28 #include "common.h"
  29
  30 /*
  31  * The log consists of records, each containing a type byte and a variable
  32  * length byte string, as follows:
  33  *
  34  *      LOG_CURSOR_INIT         MARK
  35  *      LOG_CURSOR_END          MARK
  36  *      LOG_LINE_APPEND         db_recno_t              char *
  37  *      LOG_LINE_DELETE         db_recno_t              char *
  38  *      LOG_LINE_INSERT         db_recno_t              char *
  39  *      LOG_LINE_RESET_F        db_recno_t              char *
  40  *      LOG_LINE_RESET_B        db_recno_t              char *
  41  *      LOG_MARK                LMARK
  42  *
  43  * We do before image physical logging.  This means that the editor layer
  44  * MAY NOT modify records in place, even if simply deleting or overwriting
  45  * characters.  Since the smallest unit of logging is a line, we're using
  46  * up lots of space.  This may eventually have to be reduced, probably by
  47  * doing logical logging, which is a much cooler database phrase.
  48  *
  49  * The implementation of the historic vi 'u' command, using roll-forward and
  50  * roll-back, is simple.  Each set of changes has a LOG_CURSOR_INIT record,
  51  * followed by a number of other records, followed by a LOG_CURSOR_END record.
  52  * LOG_LINE_RESET records come in pairs.  The first is a LOG_LINE_RESET_B
  53  * record, and is the line before the change.  The second is LOG_LINE_RESET_F,
  54  * and is the line after the change.  Roll-back is done by backing up to the
  55  * first LOG_CURSOR_INIT record before a change.  Roll-forward is done in a
  56  * similar fashion.
  57  *
  58  * The 'U' command is implemented by rolling backward to a LOG_CURSOR_END
  59  * record for a line different from the current one.  It should be noted that
  60  * this means that a subsequent 'u' command will make a change based on the
  61  * new position of the log's cursor.  This is okay, and, in fact, historic vi
  62  * behaved that way.
  63  */
  64
  65 static int      vi_log_get __P((SCR *sp, db_recno_t *lnop, size_t *size));
  66 static int      log_cursor1 __P((SCR *, int));
  67 static void     log_err __P((SCR *, char *, int));
  68 #if defined(DEBUG) && 0
  69 static void     log_trace __P((SCR *, char *, db_recno_t, u_char *));
  70 #endif
  71
  72 /* Try and restart the log on failure, i.e. if we run out of memory. */
  73 #define LOG_ERR {                                                       \
  74         log_err(sp, __FILE__, __LINE__);                                \
  75         return (1);                                                     \
  76 }
  77
  78 /* offset of CHAR_T string in log needs to be aligned on some systems
  79  * because it is passed to db_set as a string
  80  */
  81 typedef struct {
  82     char    data[sizeof(u_char) /* type */ + sizeof(db_recno_t)];
  83     CHAR_T  str[1];
  84 } log_t;
  85 #define CHAR_T_OFFSET ((char *)(((log_t*)0)->str) - (char *)0)
  86
  87 /*
  88  * log_init --
  89  *      Initialize the logging subsystem.
  90  *
  91  * PUBLIC: int log_init __P((SCR *, EXF *));
  92  */
  93 int
  94 log_init(SCR *sp, EXF *ep)
  95 {
  96         /*
  97          * !!!
  98          * ep MAY NOT BE THE SAME AS sp->ep, DON'T USE THE LATTER.
  99          *
 100          * Initialize the buffer.  The logging subsystem has its own
 101          * buffers because the global ones are almost by definition
 102          * going to be in use when the log runs.
 103          */
 104         sp->wp->l_lp = NULL;
 105         sp->wp->l_len = 0;
 106         ep->l_cursor.lno = 1;           /* XXX Any valid recno. */
 107         ep->l_cursor.cno = 0;
 108         ep->l_high = ep->l_cur = 1;
 109
 110         if (db_create(&ep->log, sp->gp->env, 0) != 0 ||
 111             ep->log->open(ep->log, NULL, NULL, DB_RECNO,
 112                           DB_CREATE | VI_DB_THREAD, S_IRUSR | S_IWUSR) != 0) {
 113                 msgq(sp, M_SYSERR, "009|Log file");
 114                 F_SET(ep, F_NOLOG);
 115                 return (1);
 116         }
 117
 118         ep->l_win = NULL;
 119         /*LOCK_INIT(sp->wp, ep);*/
 120
 121         return (0);
 122 }
 123
 124 /*
 125  * log_end --
 126  *      Close the logging subsystem.
 127  *
 128  * PUBLIC: int log_end __P((SCR *, EXF *));
 129  */
 130 int
 131 log_end(SCR *sp, EXF *ep)
 132 {
 133         /*
 134          * !!!
 135          * ep MAY NOT BE THE SAME AS sp->ep, DON'T USE THE LATTER.
 136          */
 137         /*LOCK_END(sp->wp, ep);*/
 138         if (ep->log != NULL) {
 139                 (void)(ep->log->close)(ep->log,DB_NOSYNC);
 140                 ep->log = NULL;
 141         }
 142         if (sp->wp->l_lp != NULL) {
 143                 free(sp->wp->l_lp);
 144                 sp->wp->l_lp = NULL;
 145         }
 146         sp->wp->l_len = 0;
 147         ep->l_cursor.lno = 1;           /* XXX Any valid recno. */
 148         ep->l_cursor.cno = 0;
 149         ep->l_high = ep->l_cur = 1;
 150         return (0);
 151 }
 152
 153 /*
 154  * log_cursor --
 155  *      Log the current cursor position, starting an event.
 156  *
 157  * PUBLIC: int log_cursor __P((SCR *));
 158  */
 159 int
 160 log_cursor(SCR *sp)
 161 {
 162         EXF *ep;
 163
 164         ep = sp->ep;
 165         if (F_ISSET(ep, F_NOLOG))
 166                 return (0);
 167
 168         /*
 169          * If any changes were made since the last cursor init,
 170          * put out the ending cursor record.
 171          */
 172         if (ep->l_cursor.lno == OOBLNO) {
 173                 if (ep->l_win && ep->l_win != sp->wp)
 174                         return 0;
 175                 ep->l_cursor.lno = sp->lno;
 176                 ep->l_cursor.cno = sp->cno;
 177                 ep->l_win = NULL;
 178                 return (log_cursor1(sp, LOG_CURSOR_END));
 179         }
 180         ep->l_cursor.lno = sp->lno;
 181         ep->l_cursor.cno = sp->cno;
 182         return (0);
 183 }
 184
 185 /*
 186  * log_cursor1 --
 187  *      Actually push a cursor record out.
 188  */
 189 static int
 190 log_cursor1(SCR *sp, int type)
 191 {
 192         DBT data, key;
 193         EXF *ep;
 194
 195         ep = sp->ep;
 196
 197         /*
 198         if (type == LOG_CURSOR_INIT &&
 199             LOCK_TRY(sp->wp, ep))
 200                 return 1;
 201         */
 202
 203         BINC_RET(sp, sp->wp->l_lp, sp->wp->l_len, sizeof(u_char) + sizeof(MARK));
 204         sp->wp->l_lp[0] = type;
 205         memmove(sp->wp->l_lp + sizeof(u_char), &ep->l_cursor, sizeof(MARK));
 206
 207         memset(&key, 0, sizeof(key));
 208         key.data = &ep->l_cur;
 209         key.size = sizeof(db_recno_t);
 210         memset(&data, 0, sizeof(data));
 211         data.data = sp->wp->l_lp;
 212         data.size = sizeof(u_char) + sizeof(MARK);
 213         if (ep->log->put(ep->log, NULL, &key, &data, 0) == -1)
 214                 LOG_ERR;
 215
 216 #if defined(DEBUG) && 0
 217         vtrace(sp, "%lu: %s: %u/%u\n", ep->l_cur,
 218             type == LOG_CURSOR_INIT ? "log_cursor_init" : "log_cursor_end",
 219             sp->lno, sp->cno);
 220 #endif
 221         /* Reset high water mark. */
 222         ep->l_high = ++ep->l_cur;
 223
 224         /*
 225         if (type == LOG_CURSOR_END)
 226                 LOCK_UNLOCK(sp->wp, ep);
 227         */
 228         return (0);
 229 }
 230
 231 /*
 232  * log_line --
 233  *      Log a line change.
 234  *
 235  * PUBLIC: int log_line __P((SCR *, db_recno_t, u_int));
 236  */
 237 int
 238 log_line(SCR *sp, db_recno_t lno, u_int action)
 239 {
 240         DBT data, key;
 241         EXF *ep;
 242         size_t len;
 243         CHAR_T *lp;
 244         db_recno_t lcur;
 245
 246         ep = sp->ep;
 247         if (F_ISSET(ep, F_NOLOG))
 248                 return (0);
 249
 250         /*
 251          * XXX
 252          *
 253          * Kluge for vi.  Clear the EXF undo flag so that the
 254          * next 'u' command does a roll-back, regardless.
 255          */
 256         F_CLR(ep, F_UNDO);
 257
 258         /* Put out one initial cursor record per set of changes. */
 259         if (ep->l_cursor.lno != OOBLNO) {
 260                 if (log_cursor1(sp, LOG_CURSOR_INIT))
 261                         return (1);
 262                 ep->l_cursor.lno = OOBLNO;
 263                 ep->l_win = sp->wp;
 264         } /*else if (ep->l_win != sp->wp) {
 265                 printf("log_line own: %p, this: %p\n", ep->l_win, sp->wp);
 266                 return 1;
 267         }*/
 268
 269         /*
 270          * Put out the changes.  If it's a LOG_LINE_RESET_B call, it's a
 271          * special case, avoid the caches.  Also, if it fails and it's
 272          * line 1, it just means that the user started with an empty file,
 273          * so fake an empty length line.
 274          */
 275         if (action == LOG_LINE_RESET_B) {
 276                 if (db_get(sp, lno, DBG_NOCACHE, &lp, &len)) {
 277                         static CHAR_T nul = 0;
 278                         if (lno != 1) {
 279                                 db_err(sp, lno);
 280                                 return (1);
 281                         }
 282                         len = 0;
 283                         lp = &nul;
 284                 }
 285         } else
 286                 if (db_get(sp, lno, DBG_FATAL, &lp, &len))
 287                         return (1);
 288         BINC_RET(sp,
 289             sp->wp->l_lp, sp->wp->l_len,
 290             len * sizeof(CHAR_T) + CHAR_T_OFFSET);
 291         sp->wp->l_lp[0] = action;
 292         memmove(sp->wp->l_lp + sizeof(u_char), &lno, sizeof(db_recno_t));
 293         MEMMOVEW(sp->wp->l_lp + CHAR_T_OFFSET, lp, len);
 294
 295         lcur = ep->l_cur;
 296         memset(&key, 0, sizeof(key));
 297         key.data = &lcur;
 298         key.size = sizeof(db_recno_t);
 299         memset(&data, 0, sizeof(data));
 300         data.data = sp->wp->l_lp;
 301         data.size = len * sizeof(CHAR_T) + CHAR_T_OFFSET;
 302         if (ep->log->put(ep->log, NULL, &key, &data, 0) == -1)
 303                 LOG_ERR;
 304
 305 #if defined(DEBUG) && 0
 306         switch (action) {
 307         case LOG_LINE_APPEND:
 308                 vtrace(sp, "%u: log_line: append: %lu {%u}\n",
 309                     ep->l_cur, lno, len);
 310                 break;
 311         case LOG_LINE_DELETE:
 312                 vtrace(sp, "%lu: log_line: delete: %lu {%u}\n",
 313                     ep->l_cur, lno, len);
 314                 break;
 315         case LOG_LINE_INSERT:
 316                 vtrace(sp, "%lu: log_line: insert: %lu {%u}\n",
 317                     ep->l_cur, lno, len);
 318                 break;
 319         case LOG_LINE_RESET_F:
 320                 vtrace(sp, "%lu: log_line: reset_f: %lu {%u}\n",
 321                     ep->l_cur, lno, len);
 322                 break;
 323         case LOG_LINE_RESET_B:
 324                 vtrace(sp, "%lu: log_line: reset_b: %lu {%u}\n",
 325                     ep->l_cur, lno, len);
 326                 break;
 327         }
 328 #endif
 329         /* Reset high water mark. */
 330         ep->l_high = ++ep->l_cur;
 331
 332         return (0);
 333 }
 334
 335 /*
 336  * log_mark --
 337  *      Log a mark position.  For the log to work, we assume that there
 338  *      aren't any operations that just put out a log record -- this
 339  *      would mean that undo operations would only reset marks, and not
 340  *      cause any other change.
 341  *
 342  * PUBLIC: int log_mark __P((SCR *, LMARK *));
 343  */
 344 int
 345 log_mark(SCR *sp, LMARK *lmp)
 346 {
 347         DBT data, key;
 348         EXF *ep;
 349
 350         ep = sp->ep;
 351         if (F_ISSET(ep, F_NOLOG))
 352                 return (0);
 353
 354         /* Put out one initial cursor record per set of changes. */
 355         if (ep->l_cursor.lno != OOBLNO) {
 356                 if (log_cursor1(sp, LOG_CURSOR_INIT))
 357                         return (1);
 358                 ep->l_cursor.lno = OOBLNO;
 359                 ep->l_win = sp->wp;
 360         }
 361
 362         BINC_RET(sp, sp->wp->l_lp,
 363             sp->wp->l_len, sizeof(u_char) + sizeof(LMARK));
 364         sp->wp->l_lp[0] = LOG_MARK;
 365         memmove(sp->wp->l_lp + sizeof(u_char), lmp, sizeof(LMARK));
 366
 367         memset(&key, 0, sizeof(key));
 368         key.data = &ep->l_cur;
 369         key.size = sizeof(db_recno_t);
 370         memset(&data, 0, sizeof(data));
 371         data.data = sp->wp->l_lp;
 372         data.size = sizeof(u_char) + sizeof(LMARK);
 373         if (ep->log->put(ep->log, NULL, &key, &data, 0) == -1)
 374                 LOG_ERR;
 375
 376 #if defined(DEBUG) && 0
 377         vtrace(sp, "%lu: mark %c: %lu/%u\n",
 378             ep->l_cur, lmp->name, lmp->lno, lmp->cno);
 379 #endif
 380         /* Reset high water mark. */
 381         ep->l_high = ++ep->l_cur;
 382         return (0);
 383 }
 384
 385 /*
 386  * vi_log_get --
 387  *      Get a line from the log in log buffer.
 388  */
 389 static int
 390 vi_log_get(SCR *sp, db_recno_t *lnop, size_t *size)
 391 {
 392         DBT key, data;
 393         size_t nlen;
 394         EXF *ep;
 395
 396         ep = sp->ep;
 397
 398         nlen = 1024;
 399 retry:
 400         BINC_RET(sp, sp->wp->l_lp, sp->wp->l_len, nlen);
 401
 402         memset(&key, 0, sizeof(key));
 403         key.data = lnop;                /* Initialize db request. */
 404         key.size = sizeof(db_recno_t);
 405         memset(&data, 0, sizeof(data));
 406         data.data = sp->wp->l_lp;
 407         data.ulen = sp->wp->l_len;
 408         data.flags = DB_DBT_USERMEM;
 409         switch (ep->log->get(ep->log, NULL, &key, &data, 0)) {
 410         case ENOMEM:
 411                 nlen = data.size;
 412                 goto retry;
 413         case 0:
 414                 *size = data.size;
 415                 return 0;
 416         default:
 417                 return 1;
 418         }
 419 }
 420
 421 /*
 422  * Log_backward --
 423  *      Roll the log backward one operation.
 424  *
 425  * PUBLIC: int log_backward __P((SCR *, MARK *));
 426  */
 427 int
 428 log_backward(SCR *sp, MARK *rp)
 429 {
 430         EXF *ep;
 431         LMARK lm;
 432         MARK m;
 433         db_recno_t lno;
 434         int didop;
 435         u_char *p;
 436         size_t size;
 437
 438         ep = sp->ep;
 439         if (F_ISSET(ep, F_NOLOG)) {
 440                 msgq(sp, M_ERR,
 441                     "010|Logging not being performed, undo not possible");
 442                 return (1);
 443         }
 444
 445         if (ep->l_cur == 1) {
 446                 msgq(sp, M_BERR, "011|No changes to undo");
 447                 return (1);
 448         }
 449
 450         if (ep->l_win && ep->l_win != sp->wp) {
 451                 ex_emsg(sp, NULL, EXM_LOCKED);
 452                 return 1;
 453         }
 454         ep->l_win = sp->wp;
 455
 456
 457         F_SET(ep, F_NOLOG);             /* Turn off logging. */
 458
 459         for (didop = 0;;) {
 460                 --ep->l_cur;
 461                 if (vi_log_get(sp, &ep->l_cur, &size))
 462                         LOG_ERR;
 463 #if defined(DEBUG) && 0
 464                 log_trace(sp, "log_backward", ep->l_cur, data.data);
 465 #endif
 466                 switch (*(p = (u_char *)sp->wp->l_lp)) {
 467                 case LOG_CURSOR_INIT:
 468                         if (didop) {
 469                                 memmove(rp, p + sizeof(u_char), sizeof(MARK));
 470                                 F_CLR(ep, F_NOLOG);
 471                                 ep->l_win = NULL;
 472                                 return (0);
 473                         }
 474                         break;
 475                 case LOG_CURSOR_END:
 476                         break;
 477                 case LOG_LINE_APPEND:
 478                 case LOG_LINE_INSERT:
 479                         didop = 1;
 480                         memmove(&lno, p + sizeof(u_char), sizeof(db_recno_t));
 481                         if (db_delete(sp, lno))
 482                                 goto err;
 483                         ++sp->rptlines[L_DELETED];
 484                         break;
 485                 case LOG_LINE_DELETE:
 486                         didop = 1;
 487                         memmove(&lno, p + sizeof(u_char), sizeof(db_recno_t));
 488                         if (db_insert(sp, lno,
 489                             (CHAR_T *)(p + CHAR_T_OFFSET),
 490                             (size - CHAR_T_OFFSET) / sizeof(CHAR_T)))
 491                                 goto err;
 492                         ++sp->rptlines[L_ADDED];
 493                         break;
 494                 case LOG_LINE_RESET_F:
 495                         break;
 496                 case LOG_LINE_RESET_B:
 497                         didop = 1;
 498                         memmove(&lno, p + sizeof(u_char), sizeof(db_recno_t));
 499                         if (db_set(sp, lno,
 500                             (CHAR_T *)(p + CHAR_T_OFFSET),
 501                             (size - CHAR_T_OFFSET) / sizeof(CHAR_T)))
 502                                 goto err;
 503                         if (sp->rptlchange != lno) {
 504                                 sp->rptlchange = lno;
 505                                 ++sp->rptlines[L_CHANGED];
 506                         }
 507                         break;
 508                 case LOG_MARK:
 509                         didop = 1;
 510                         memmove(&lm, p + sizeof(u_char), sizeof(LMARK));
 511                         m.lno = lm.lno;
 512                         m.cno = lm.cno;
 513                         if (mark_set(sp, lm.name, &m, 0))
 514                                 goto err;
 515                         break;
 516                 default:
 517                         abort();
 518                 }
 519         }
 520
 521 err:    F_CLR(ep, F_NOLOG);
 522         ep->l_win = NULL;
 523         return (1);
 524 }
 525
 526 /*
 527  * Log_setline --
 528  *      Reset the line to its original appearance.
 529  *
 530  * XXX
 531  * There's a bug in this code due to our not logging cursor movements
 532  * unless a change was made.  If you do a change, move off the line,
 533  * then move back on and do a 'U', the line will be restored to the way
 534  * it was before the original change.
 535  *
 536  * PUBLIC: int log_setline __P((SCR *));
 537  */
 538 int
 539 log_setline(SCR *sp)
 540 {
 541         EXF *ep;
 542         LMARK lm;
 543         MARK m;
 544         db_recno_t lno;
 545         u_char *p;
 546         size_t size;
 547
 548         ep = sp->ep;
 549         if (F_ISSET(ep, F_NOLOG)) {
 550                 msgq(sp, M_ERR,
 551                     "012|Logging not being performed, undo not possible");
 552                 return (1);
 553         }
 554
 555         if (ep->l_cur == 1)
 556                 return (1);
 557
 558         if (ep->l_win && ep->l_win != sp->wp) {
 559                 ex_emsg(sp, NULL, EXM_LOCKED);
 560                 return 1;
 561         }
 562         ep->l_win = sp->wp;
 563
 564         F_SET(ep, F_NOLOG);             /* Turn off logging. */
 565
 566         for (;;) {
 567                 --ep->l_cur;
 568                 if (vi_log_get(sp, &ep->l_cur, &size))
 569                         LOG_ERR;
 570 #if defined(DEBUG) && 0
 571                 log_trace(sp, "log_setline", ep->l_cur, data.data);
 572 #endif
 573                 switch (*(p = (u_char *)sp->wp->l_lp)) {
 574                 case LOG_CURSOR_INIT:
 575                         memmove(&m, p + sizeof(u_char), sizeof(MARK));
 576                         if (m.lno != sp->lno || ep->l_cur == 1) {
 577                                 F_CLR(ep, F_NOLOG);
 578                                 ep->l_win = NULL;
 579                                 return (0);
 580                         }
 581                         break;
 582                 case LOG_CURSOR_END:
 583                         memmove(&m, p + sizeof(u_char), sizeof(MARK));
 584                         if (m.lno != sp->lno) {
 585                                 ++ep->l_cur;
 586                                 F_CLR(ep, F_NOLOG);
 587                                 ep->l_win = NULL;
 588                                 return (0);
 589                         }
 590                         break;
 591                 case LOG_LINE_APPEND:
 592                 case LOG_LINE_INSERT:
 593                 case LOG_LINE_DELETE:
 594                 case LOG_LINE_RESET_F:
 595                         break;
 596                 case LOG_LINE_RESET_B:
 597                         memmove(&lno, p + sizeof(u_char), sizeof(db_recno_t));
 598                         if (lno == sp->lno &&
 599                             db_set(sp, lno, (CHAR_T *)(p + CHAR_T_OFFSET),
 600                                 (size - CHAR_T_OFFSET) / sizeof(CHAR_T)))
 601                                 goto err;
 602                         if (sp->rptlchange != lno) {
 603                                 sp->rptlchange = lno;
 604                                 ++sp->rptlines[L_CHANGED];
 605                         }
 606                 case LOG_MARK:
 607                         memmove(&lm, p + sizeof(u_char), sizeof(LMARK));
 608                         m.lno = lm.lno;
 609                         m.cno = lm.cno;
 610                         if (mark_set(sp, lm.name, &m, 0))
 611                                 goto err;
 612                         break;
 613                 default:
 614                         abort();
 615                 }
 616         }
 617
 618 err:    F_CLR(ep, F_NOLOG);
 619         ep->l_win = NULL;
 620         return (1);
 621 }
 622
 623 /*
 624  * Log_forward --
 625  *      Roll the log forward one operation.
 626  *
 627  * PUBLIC: int log_forward __P((SCR *, MARK *));
 628  */
 629 int
 630 log_forward(SCR *sp, MARK *rp)
 631 {
 632         EXF *ep;
 633         LMARK lm;
 634         MARK m;
 635         db_recno_t lno;
 636         int didop;
 637         u_char *p;
 638         size_t size;
 639
 640         ep = sp->ep;
 641         if (F_ISSET(ep, F_NOLOG)) {
 642                 msgq(sp, M_ERR,
 643             "013|Logging not being performed, roll-forward not possible");
 644                 return (1);
 645         }
 646
 647         if (ep->l_cur == ep->l_high) {
 648                 msgq(sp, M_BERR, "014|No changes to re-do");
 649                 return (1);
 650         }
 651
 652         if (ep->l_win && ep->l_win != sp->wp) {
 653                 ex_emsg(sp, NULL, EXM_LOCKED);
 654                 return 1;
 655         }
 656         ep->l_win = sp->wp;
 657
 658         F_SET(ep, F_NOLOG);             /* Turn off logging. */
 659
 660         for (didop = 0;;) {
 661                 ++ep->l_cur;
 662                 if (vi_log_get(sp, &ep->l_cur, &size))
 663                         LOG_ERR;
 664 #if defined(DEBUG) && 0
 665                 log_trace(sp, "log_forward", ep->l_cur, data.data);
 666 #endif
 667                 switch (*(p = (u_char *)sp->wp->l_lp)) {
 668                 case LOG_CURSOR_END:
 669                         if (didop) {
 670                                 ++ep->l_cur;
 671                                 memmove(rp, p + sizeof(u_char), sizeof(MARK));
 672                                 F_CLR(ep, F_NOLOG);
 673                                 ep->l_win = NULL;
 674                                 return (0);
 675                         }
 676                         break;
 677                 case LOG_CURSOR_INIT:
 678                         break;
 679                 /* XXXX LOG_LINE_APPEND and LOG_LINE_INSERT split
 680                    for now, because db_insert won't work for adding
 681                    last line
 682                  */
 683                 case LOG_LINE_APPEND:
 684                         didop = 1;
 685                         memmove(&lno, p + sizeof(u_char), sizeof(db_recno_t));
 686                         --lno;
 687                         if (db_append(sp, 1, lno,
 688                             (CHAR_T *)(p + CHAR_T_OFFSET),
 689                             (size - CHAR_T_OFFSET) / sizeof(CHAR_T)))
 690                                 goto err;
 691                         ++sp->rptlines[L_ADDED];
 692                         break;
 693                 case LOG_LINE_INSERT:
 694                         didop = 1;
 695                         memmove(&lno, p + sizeof(u_char), sizeof(db_recno_t));
 696                         if (db_insert(sp, lno,
 697                             (CHAR_T *)(p + CHAR_T_OFFSET),
 698                             (size - CHAR_T_OFFSET) / sizeof(CHAR_T)))
 699                                 goto err;
 700                         ++sp->rptlines[L_ADDED];
 701                         break;
 702                 case LOG_LINE_DELETE:
 703                         didop = 1;
 704                         memmove(&lno, p + sizeof(u_char), sizeof(db_recno_t));
 705                         if (db_delete(sp, lno))
 706                                 goto err;
 707                         ++sp->rptlines[L_DELETED];
 708                         break;
 709                 case LOG_LINE_RESET_B:
 710                         break;
 711                 case LOG_LINE_RESET_F:
 712                         didop = 1;
 713                         memmove(&lno, p + sizeof(u_char), sizeof(db_recno_t));
 714                         if (db_set(sp, lno,
 715                             (CHAR_T *)(p + CHAR_T_OFFSET),
 716                             (size - CHAR_T_OFFSET) / sizeof(CHAR_T)))
 717                                 goto err;
 718                         if (sp->rptlchange != lno) {
 719                                 sp->rptlchange = lno;
 720                                 ++sp->rptlines[L_CHANGED];
 721                         }
 722                         break;
 723                 case LOG_MARK:
 724                         didop = 1;
 725                         memmove(&lm, p + sizeof(u_char), sizeof(LMARK));
 726                         m.lno = lm.lno;
 727                         m.cno = lm.cno;
 728                         if (mark_set(sp, lm.name, &m, 0))
 729                                 goto err;
 730                         break;
 731                 default:
 732                         abort();
 733                 }
 734         }
 735
 736 err:    F_CLR(ep, F_NOLOG);
 737         ep->l_win = NULL;
 738         return (1);
 739 }
 740
 741 /*
 742  * log_err --
 743  *      Try and restart the log on failure, i.e. if we run out of memory.
 744  */
 745 static void
 746 log_err(SCR *sp, char *file, int line)
 747 {
 748         EXF *ep;
 749
 750         msgq(sp, M_SYSERR, "015|%s/%d: log put error", tail(file), line);
 751         ep = sp->ep;
 752         (void)ep->log->close(ep->log, DB_NOSYNC);
 753         if (!log_init(sp, ep))
 754                 msgq(sp, M_ERR, "267|Log restarted");
 755 }
 756
 757 #if defined(DEBUG) && 0
 758 static void
 759 log_trace(sp, msg, rno, p)
 760         SCR *sp;
 761         char *msg;
 762         db_recno_t rno;
 763         u_char *p;
 764 {
 765         LMARK lm;
 766         MARK m;
 767         db_recno_t lno;
 768
 769         switch (*p) {
 770         case LOG_CURSOR_INIT:
 771                 memmove(&m, p + sizeof(u_char), sizeof(MARK));
 772                 vtrace(sp, "%lu: %s:  C_INIT: %u/%u\n", rno, msg, m.lno, m.cno);
 773                 break;
 774         case LOG_CURSOR_END:
 775                 memmove(&m, p + sizeof(u_char), sizeof(MARK));
 776                 vtrace(sp, "%lu: %s:   C_END: %u/%u\n", rno, msg, m.lno, m.cno);
 777                 break;
 778         case LOG_LINE_APPEND:
 779                 memmove(&lno, p + sizeof(u_char), sizeof(db_recno_t));
 780                 vtrace(sp, "%lu: %s:  APPEND: %lu\n", rno, msg, lno);
 781                 break;
 782         case LOG_LINE_INSERT:
 783                 memmove(&lno, p + sizeof(u_char), sizeof(db_recno_t));
 784                 vtrace(sp, "%lu: %s:  INSERT: %lu\n", rno, msg, lno);
 785                 break;
 786         case LOG_LINE_DELETE:
 787                 memmove(&lno, p + sizeof(u_char), sizeof(db_recno_t));
 788                 vtrace(sp, "%lu: %s:  DELETE: %lu\n", rno, msg, lno);
 789                 break;
 790         case LOG_LINE_RESET_F:
 791                 memmove(&lno, p + sizeof(u_char), sizeof(db_recno_t));
 792                 vtrace(sp, "%lu: %s: RESET_F: %lu\n", rno, msg, lno);
 793                 break;
 794         case LOG_LINE_RESET_B:
 795                 memmove(&lno, p + sizeof(u_char), sizeof(db_recno_t));
 796                 vtrace(sp, "%lu: %s: RESET_B: %lu\n", rno, msg, lno);
 797                 break;
 798         case LOG_MARK:
 799                 memmove(&lm, p + sizeof(u_char), sizeof(LMARK));
 800                 vtrace(sp,
 801                     "%lu: %s:    MARK: %u/%u\n", rno, msg, lm.lno, lm.cno);
 802                 break;
 803         default:
 804                 abort();
 805         }
 806 }
 807 #endif