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.13 2000/07/14 14:29:16 skimo Exp $ (Berkeley) $Date: 2000/07/14 14:29:16 $";
  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      log_cursor1 __P((SCR *, int));
  66 static void     log_err __P((SCR *, char *, int));
  67 #if defined(DEBUG) && 0
  68 static void     log_trace __P((SCR *, char *, db_recno_t, u_char *));
  69 #endif
  70
  71 /* Try and restart the log on failure, i.e. if we run out of memory. */
  72 #define LOG_ERR {                                                       \
  73         log_err(sp, __FILE__, __LINE__);                                \
  74         return (1);                                                     \
  75 }
  76
  77 /*
  78  * log_init --
  79  *      Initialize the logging subsystem.
  80  *
  81  * PUBLIC: int log_init __P((SCR *, EXF *));
  82  */
  83 int
  84 log_init(sp, ep)
  85         SCR *sp;
  86         EXF *ep;
  87 {
  88         /*
  89          * !!!
  90          * ep MAY NOT BE THE SAME AS sp->ep, DON'T USE THE LATTER.
  91          *
  92          * Initialize the buffer.  The logging subsystem has its own
  93          * buffers because the global ones are almost by definition
  94          * going to be in use when the log runs.
  95          */
  96         ep->l_lp = NULL;
  97         ep->l_len = 0;
  98         ep->l_cursor.lno = 1;           /* XXX Any valid recno. */
  99         ep->l_cursor.cno = 0;
 100         ep->l_high = ep->l_cur = 1;
 101
 102         if (db_create(&ep->log, sp->gp->env, 0) != 0 ||
 103             ep->log->open(ep->log, NULL, NULL, DB_RECNO, DB_CREATE,
 104             S_IRUSR | S_IWUSR) != 0) {
 105                 msgq(sp, M_SYSERR, "009|Log file");
 106                 F_SET(ep, F_NOLOG);
 107                 return (1);
 108         }
 109
 110         return (0);
 111 }
 112
 113 /*
 114  * log_end --
 115  *      Close the logging subsystem.
 116  *
 117  * PUBLIC: int log_end __P((SCR *, EXF *));
 118  */
 119 int
 120 log_end(sp, ep)
 121         SCR *sp;
 122         EXF *ep;
 123 {
 124         /*
 125          * !!!
 126          * ep MAY NOT BE THE SAME AS sp->ep, DON'T USE THE LATTER.
 127          */
 128         if (ep->log != NULL) {
 129                 (void)(ep->log->close)(ep->log,DB_NOSYNC);
 130                 ep->log = NULL;
 131         }
 132         if (ep->l_lp != NULL) {
 133                 free(ep->l_lp);
 134                 ep->l_lp = NULL;
 135         }
 136         ep->l_len = 0;
 137         ep->l_cursor.lno = 1;           /* XXX Any valid recno. */
 138         ep->l_cursor.cno = 0;
 139         ep->l_high = ep->l_cur = 1;
 140         return (0);
 141 }
 142
 143 /*
 144  * log_cursor --
 145  *      Log the current cursor position, starting an event.
 146  *
 147  * PUBLIC: int log_cursor __P((SCR *));
 148  */
 149 int
 150 log_cursor(sp)
 151         SCR *sp;
 152 {
 153         EXF *ep;
 154
 155         ep = sp->ep;
 156         if (F_ISSET(ep, F_NOLOG))
 157                 return (0);
 158
 159         /*
 160          * If any changes were made since the last cursor init,
 161          * put out the ending cursor record.
 162          */
 163         if (ep->l_cursor.lno == OOBLNO) {
 164                 ep->l_cursor.lno = sp->lno;
 165                 ep->l_cursor.cno = sp->cno;
 166                 return (log_cursor1(sp, LOG_CURSOR_END));
 167         }
 168         ep->l_cursor.lno = sp->lno;
 169         ep->l_cursor.cno = sp->cno;
 170         return (0);
 171 }
 172
 173 /*
 174  * log_cursor1 --
 175  *      Actually push a cursor record out.
 176  */
 177 static int
 178 log_cursor1(sp, type)
 179         SCR *sp;
 180         int type;
 181 {
 182         DBT data, key;
 183         EXF *ep;
 184
 185         ep = sp->ep;
 186         BINC_RET(sp, ep->l_lp, ep->l_len, sizeof(u_char) + sizeof(MARK));
 187         ep->l_lp[0] = type;
 188         memmove(ep->l_lp + sizeof(u_char), &ep->l_cursor, sizeof(MARK));
 189
 190         memset(&key, 0, sizeof(key));
 191         key.data = &ep->l_cur;
 192         key.size = sizeof(db_recno_t);
 193         memset(&data, 0, sizeof(data));
 194         data.data = ep->l_lp;
 195         data.size = sizeof(u_char) + sizeof(MARK);
 196         if (ep->log->put(ep->log, NULL, &key, &data, 0) == -1)
 197                 LOG_ERR;
 198
 199 #if defined(DEBUG) && 0
 200         vtrace(sp, "%lu: %s: %u/%u\n", ep->l_cur,
 201             type == LOG_CURSOR_INIT ? "log_cursor_init" : "log_cursor_end",
 202             sp->lno, sp->cno);
 203 #endif
 204         /* Reset high water mark. */
 205         ep->l_high = ++ep->l_cur;
 206
 207         return (0);
 208 }
 209
 210 /*
 211  * log_line --
 212  *      Log a line change.
 213  *
 214  * PUBLIC: int log_line __P((SCR *, db_recno_t, u_int));
 215  */
 216 int
 217 log_line(sp, lno, action)
 218         SCR *sp;
 219         db_recno_t lno;
 220         u_int action;
 221 {
 222         DBT data, key;
 223         EXF *ep;
 224         size_t len;
 225         CHAR_T *lp;
 226
 227         ep = sp->ep;
 228         if (F_ISSET(ep, F_NOLOG))
 229                 return (0);
 230
 231         /*
 232          * XXX
 233          *
 234          * Kluge for vi.  Clear the EXF undo flag so that the
 235          * next 'u' command does a roll-back, regardless.
 236          */
 237         F_CLR(ep, F_UNDO);
 238
 239         /* Put out one initial cursor record per set of changes. */
 240         if (ep->l_cursor.lno != OOBLNO) {
 241                 if (log_cursor1(sp, LOG_CURSOR_INIT))
 242                         return (1);
 243                 ep->l_cursor.lno = OOBLNO;
 244         }
 245
 246         /*
 247          * Put out the changes.  If it's a LOG_LINE_RESET_B call, it's a
 248          * special case, avoid the caches.  Also, if it fails and it's
 249          * line 1, it just means that the user started with an empty file,
 250          * so fake an empty length line.
 251          */
 252         if (action == LOG_LINE_RESET_B) {
 253                 if (db_get(sp, lno, DBG_NOCACHE, &lp, &len)) {
 254                         static CHAR_T nul = 0;
 255                         if (lno != 1) {
 256                                 db_err(sp, lno);
 257                                 return (1);
 258                         }
 259                         len = 0;
 260                         lp = &nul;
 261                 }
 262         } else
 263                 if (db_get(sp, lno, DBG_FATAL, &lp, &len))
 264                         return (1);
 265         BINC_RET(sp,
 266             ep->l_lp, ep->l_len, len + sizeof(u_char) + sizeof(db_recno_t));
 267         ep->l_lp[0] = action;
 268         memmove(ep->l_lp + sizeof(u_char), &lno, sizeof(db_recno_t));
 269         memmove(ep->l_lp + sizeof(u_char) + sizeof(db_recno_t), lp, len);
 270
 271         memset(&key, 0, sizeof(key));
 272         key.data = &ep->l_cur;
 273         key.size = sizeof(db_recno_t);
 274         memset(&data, 0, sizeof(data));
 275         data.data = ep->l_lp;
 276         data.size = len + sizeof(u_char) + sizeof(db_recno_t);
 277         if (ep->log->put(ep->log, NULL, &key, &data, 0) == -1)
 278                 LOG_ERR;
 279
 280 #if defined(DEBUG) && 0
 281         switch (action) {
 282         case LOG_LINE_APPEND:
 283                 vtrace(sp, "%u: log_line: append: %lu {%u}\n",
 284                     ep->l_cur, lno, len);
 285                 break;
 286         case LOG_LINE_DELETE:
 287                 vtrace(sp, "%lu: log_line: delete: %lu {%u}\n",
 288                     ep->l_cur, lno, len);
 289                 break;
 290         case LOG_LINE_INSERT:
 291                 vtrace(sp, "%lu: log_line: insert: %lu {%u}\n",
 292                     ep->l_cur, lno, len);
 293                 break;
 294         case LOG_LINE_RESET_F:
 295                 vtrace(sp, "%lu: log_line: reset_f: %lu {%u}\n",
 296                     ep->l_cur, lno, len);
 297                 break;
 298         case LOG_LINE_RESET_B:
 299                 vtrace(sp, "%lu: log_line: reset_b: %lu {%u}\n",
 300                     ep->l_cur, lno, len);
 301                 break;
 302         }
 303 #endif
 304         /* Reset high water mark. */
 305         ep->l_high = ++ep->l_cur;
 306
 307         return (0);
 308 }
 309
 310 /*
 311  * log_mark --
 312  *      Log a mark position.  For the log to work, we assume that there
 313  *      aren't any operations that just put out a log record -- this
 314  *      would mean that undo operations would only reset marks, and not
 315  *      cause any other change.
 316  *
 317  * PUBLIC: int log_mark __P((SCR *, LMARK *));
 318  */
 319 int
 320 log_mark(sp, lmp)
 321         SCR *sp;
 322         LMARK *lmp;
 323 {
 324         DBT data, key;
 325         EXF *ep;
 326
 327         ep = sp->ep;
 328         if (F_ISSET(ep, F_NOLOG))
 329                 return (0);
 330
 331         /* Put out one initial cursor record per set of changes. */
 332         if (ep->l_cursor.lno != OOBLNO) {
 333                 if (log_cursor1(sp, LOG_CURSOR_INIT))
 334                         return (1);
 335                 ep->l_cursor.lno = OOBLNO;
 336         }
 337
 338         BINC_RET(sp, ep->l_lp,
 339             ep->l_len, sizeof(u_char) + sizeof(LMARK));
 340         ep->l_lp[0] = LOG_MARK;
 341         memmove(ep->l_lp + sizeof(u_char), lmp, sizeof(LMARK));
 342
 343         memset(&key, 0, sizeof(key));
 344         key.data = &ep->l_cur;
 345         key.size = sizeof(db_recno_t);
 346         memset(&data, 0, sizeof(data));
 347         data.data = ep->l_lp;
 348         data.size = sizeof(u_char) + sizeof(LMARK);
 349         if (ep->log->put(ep->log, NULL, &key, &data, 0) == -1)
 350                 LOG_ERR;
 351
 352 #if defined(DEBUG) && 0
 353         vtrace(sp, "%lu: mark %c: %lu/%u\n",
 354             ep->l_cur, lmp->name, lmp->lno, lmp->cno);
 355 #endif
 356         /* Reset high water mark. */
 357         ep->l_high = ++ep->l_cur;
 358         return (0);
 359 }
 360
 361 /*
 362  * Log_backward --
 363  *      Roll the log backward one operation.
 364  *
 365  * PUBLIC: int log_backward __P((SCR *, MARK *));
 366  */
 367 int
 368 log_backward(sp, rp)
 369         SCR *sp;
 370         MARK *rp;
 371 {
 372         DBT key, data;
 373         EXF *ep;
 374         LMARK lm;
 375         MARK m;
 376         db_recno_t lno;
 377         int didop;
 378         u_char *p;
 379
 380         ep = sp->ep;
 381         if (F_ISSET(ep, F_NOLOG)) {
 382                 msgq(sp, M_ERR,
 383                     "010|Logging not being performed, undo not possible");
 384                 return (1);
 385         }
 386
 387         if (ep->l_cur == 1) {
 388                 msgq(sp, M_BERR, "011|No changes to undo");
 389                 return (1);
 390         }
 391
 392         F_SET(ep, F_NOLOG);             /* Turn off logging. */
 393
 394         memset(&key, 0, sizeof(key));
 395         key.data = &ep->l_cur;          /* Initialize db request. */
 396         key.size = sizeof(db_recno_t);
 397         memset(&data, 0, sizeof(data));
 398         for (didop = 0;;) {
 399                 --ep->l_cur;
 400                 if (ep->log->get(ep->log, NULL, &key, &data, 0))
 401                         LOG_ERR;
 402 #if defined(DEBUG) && 0
 403                 log_trace(sp, "log_backward", ep->l_cur, data.data);
 404 #endif
 405                 switch (*(p = (u_char *)data.data)) {
 406                 case LOG_CURSOR_INIT:
 407                         if (didop) {
 408                                 memmove(rp, p + sizeof(u_char), sizeof(MARK));
 409                                 F_CLR(ep, F_NOLOG);
 410                                 return (0);
 411                         }
 412                         break;
 413                 case LOG_CURSOR_END:
 414                         break;
 415                 case LOG_LINE_APPEND:
 416                 case LOG_LINE_INSERT:
 417                         didop = 1;
 418                         memmove(&lno, p + sizeof(u_char), sizeof(db_recno_t));
 419                         if (db_delete(sp, lno))
 420                                 goto err;
 421                         ++sp->rptlines[L_DELETED];
 422                         break;
 423                 case LOG_LINE_DELETE:
 424                         didop = 1;
 425                         memmove(&lno, p + sizeof(u_char), sizeof(db_recno_t));
 426                         if (db_insert(sp, lno,
 427                             (CHAR_T *)(p + sizeof(u_char) +
 428                             sizeof(db_recno_t)), data.size - sizeof(u_char) -
 429                             sizeof(db_recno_t)))
 430                                 goto err;
 431                         ++sp->rptlines[L_ADDED];
 432                         break;
 433                 case LOG_LINE_RESET_F:
 434                         break;
 435                 case LOG_LINE_RESET_B:
 436                         didop = 1;
 437                         memmove(&lno, p + sizeof(u_char), sizeof(db_recno_t));
 438                         if (db_set(sp, lno,
 439                             (CHAR_T *)(p + sizeof(u_char) +
 440                             sizeof(db_recno_t)), data.size - sizeof(u_char) -
 441                             sizeof(db_recno_t)))
 442                                 goto err;
 443                         if (sp->rptlchange != lno) {
 444                                 sp->rptlchange = lno;
 445                                 ++sp->rptlines[L_CHANGED];
 446                         }
 447                         break;
 448                 case LOG_MARK:
 449                         didop = 1;
 450                         memmove(&lm, p + sizeof(u_char), sizeof(LMARK));
 451                         m.lno = lm.lno;
 452                         m.cno = lm.cno;
 453                         if (mark_set(sp, lm.name, &m, 0))
 454                                 goto err;
 455                         break;
 456                 default:
 457                         abort();
 458                 }
 459         }
 460
 461 err:    F_CLR(ep, F_NOLOG);
 462         return (1);
 463 }
 464
 465 /*
 466  * Log_setline --
 467  *      Reset the line to its original appearance.
 468  *
 469  * XXX
 470  * There's a bug in this code due to our not logging cursor movements
 471  * unless a change was made.  If you do a change, move off the line,
 472  * then move back on and do a 'U', the line will be restored to the way
 473  * it was before the original change.
 474  *
 475  * PUBLIC: int log_setline __P((SCR *));
 476  */
 477 int
 478 log_setline(sp)
 479         SCR *sp;
 480 {
 481         DBT key, data;
 482         EXF *ep;
 483         LMARK lm;
 484         MARK m;
 485         db_recno_t lno;
 486         u_char *p;
 487
 488         ep = sp->ep;
 489         if (F_ISSET(ep, F_NOLOG)) {
 490                 msgq(sp, M_ERR,
 491                     "012|Logging not being performed, undo not possible");
 492                 return (1);
 493         }
 494
 495         if (ep->l_cur == 1)
 496                 return (1);
 497
 498         F_SET(ep, F_NOLOG);             /* Turn off logging. */
 499
 500         memset(&key, 0, sizeof(key));
 501         key.data = &ep->l_cur;          /* Initialize db request. */
 502         key.size = sizeof(db_recno_t);
 503         memset(&data, 0, sizeof(data));
 504
 505         for (;;) {
 506                 --ep->l_cur;
 507                 if (ep->log->get(ep->log, NULL, &key, &data, 0))
 508                         LOG_ERR;
 509 #if defined(DEBUG) && 0
 510                 log_trace(sp, "log_setline", ep->l_cur, data.data);
 511 #endif
 512                 switch (*(p = (u_char *)data.data)) {
 513                 case LOG_CURSOR_INIT:
 514                         memmove(&m, p + sizeof(u_char), sizeof(MARK));
 515                         if (m.lno != sp->lno || ep->l_cur == 1) {
 516                                 F_CLR(ep, F_NOLOG);
 517                                 return (0);
 518                         }
 519                         break;
 520                 case LOG_CURSOR_END:
 521                         memmove(&m, p + sizeof(u_char), sizeof(MARK));
 522                         if (m.lno != sp->lno) {
 523                                 ++ep->l_cur;
 524                                 F_CLR(ep, F_NOLOG);
 525                                 return (0);
 526                         }
 527                         break;
 528                 case LOG_LINE_APPEND:
 529                 case LOG_LINE_INSERT:
 530                 case LOG_LINE_DELETE:
 531                 case LOG_LINE_RESET_F:
 532                         break;
 533                 case LOG_LINE_RESET_B:
 534                         memmove(&lno, p + sizeof(u_char), sizeof(db_recno_t));
 535                         if (lno == sp->lno &&
 536                             db_set(sp, lno, (CHAR_T *)(p + sizeof(u_char) +
 537                             sizeof(db_recno_t)), data.size - sizeof(u_char) -
 538                             sizeof(db_recno_t)))
 539                                 goto err;
 540                         if (sp->rptlchange != lno) {
 541                                 sp->rptlchange = lno;
 542                                 ++sp->rptlines[L_CHANGED];
 543                         }
 544                 case LOG_MARK:
 545                         memmove(&lm, p + sizeof(u_char), sizeof(LMARK));
 546                         m.lno = lm.lno;
 547                         m.cno = lm.cno;
 548                         if (mark_set(sp, lm.name, &m, 0))
 549                                 goto err;
 550                         break;
 551                 default:
 552                         abort();
 553                 }
 554         }
 555
 556 err:    F_CLR(ep, F_NOLOG);
 557         return (1);
 558 }
 559
 560 /*
 561  * Log_forward --
 562  *      Roll the log forward one operation.
 563  *
 564  * PUBLIC: int log_forward __P((SCR *, MARK *));
 565  */
 566 int
 567 log_forward(sp, rp)
 568         SCR *sp;
 569         MARK *rp;
 570 {
 571         DBT key, data;
 572         EXF *ep;
 573         LMARK lm;
 574         MARK m;
 575         db_recno_t lno;
 576         int didop;
 577         u_char *p;
 578
 579         ep = sp->ep;
 580         if (F_ISSET(ep, F_NOLOG)) {
 581                 msgq(sp, M_ERR,
 582             "013|Logging not being performed, roll-forward not possible");
 583                 return (1);
 584         }
 585
 586         if (ep->l_cur == ep->l_high) {
 587                 msgq(sp, M_BERR, "014|No changes to re-do");
 588                 return (1);
 589         }
 590
 591         F_SET(ep, F_NOLOG);             /* Turn off logging. */
 592
 593         memset(&key, 0, sizeof(key));
 594         key.data = &ep->l_cur;          /* Initialize db request. */
 595         key.size = sizeof(db_recno_t);
 596         memset(&data, 0, sizeof(data));
 597         for (didop = 0;;) {
 598                 ++ep->l_cur;
 599                 if (ep->log->get(ep->log, NULL, &key, &data, 0))
 600                         LOG_ERR;
 601 #if defined(DEBUG) && 0
 602                 log_trace(sp, "log_forward", ep->l_cur, data.data);
 603 #endif
 604                 switch (*(p = (u_char *)data.data)) {
 605                 case LOG_CURSOR_END:
 606                         if (didop) {
 607                                 ++ep->l_cur;
 608                                 memmove(rp, p + sizeof(u_char), sizeof(MARK));
 609                                 F_CLR(ep, F_NOLOG);
 610                                 return (0);
 611                         }
 612                         break;
 613                 case LOG_CURSOR_INIT:
 614                         break;
 615                 /* XXXX LOG_LINE_APPEND and LOG_LINE_INSERT split
 616                    for now, because db_insert won't work for adding
 617                    last line
 618                  */
 619                 case LOG_LINE_APPEND:
 620                         didop = 1;
 621                         memmove(&lno, p + sizeof(u_char), sizeof(db_recno_t));
 622                         --lno;
 623                         if (db_append(sp, 1, lno,
 624                             (CHAR_T *)(p + sizeof(u_char) +
 625                             sizeof(db_recno_t)), data.size - sizeof(u_char) -
 626                             sizeof(db_recno_t)))
 627                                 goto err;
 628                         ++sp->rptlines[L_ADDED];
 629                         break;
 630                 case LOG_LINE_INSERT:
 631                         didop = 1;
 632                         memmove(&lno, p + sizeof(u_char), sizeof(db_recno_t));
 633                         if (db_insert(sp, lno,
 634                             (CHAR_T *)(p + sizeof(u_char) +
 635                             sizeof(db_recno_t)), data.size - sizeof(u_char) -
 636                             sizeof(db_recno_t)))
 637                                 goto err;
 638                         ++sp->rptlines[L_ADDED];
 639                         break;
 640                 case LOG_LINE_DELETE:
 641                         didop = 1;
 642                         memmove(&lno, p + sizeof(u_char), sizeof(db_recno_t));
 643                         if (db_delete(sp, lno))
 644                                 goto err;
 645                         ++sp->rptlines[L_DELETED];
 646                         break;
 647                 case LOG_LINE_RESET_B:
 648                         break;
 649                 case LOG_LINE_RESET_F:
 650                         didop = 1;
 651                         memmove(&lno, p + sizeof(u_char), sizeof(db_recno_t));
 652                         if (db_set(sp, lno,
 653                             (CHAR_T *)(p + sizeof(u_char) +
 654                             sizeof(db_recno_t)), data.size - sizeof(u_char) -
 655                             sizeof(db_recno_t)))
 656                                 goto err;
 657                         if (sp->rptlchange != lno) {
 658                                 sp->rptlchange = lno;
 659                                 ++sp->rptlines[L_CHANGED];
 660                         }
 661                         break;
 662                 case LOG_MARK:
 663                         didop = 1;
 664                         memmove(&lm, p + sizeof(u_char), sizeof(LMARK));
 665                         m.lno = lm.lno;
 666                         m.cno = lm.cno;
 667                         if (mark_set(sp, lm.name, &m, 0))
 668                                 goto err;
 669                         break;
 670                 default:
 671                         abort();
 672                 }
 673         }
 674
 675 err:    F_CLR(ep, F_NOLOG);
 676         return (1);
 677 }
 678
 679 /*
 680  * log_err --
 681  *      Try and restart the log on failure, i.e. if we run out of memory.
 682  */
 683 static void
 684 log_err(sp, file, line)
 685         SCR *sp;
 686         char *file;
 687         int line;
 688 {
 689         EXF *ep;
 690
 691         msgq(sp, M_SYSERR, "015|%s/%d: log put error", tail(file), line);
 692         ep = sp->ep;
 693         (void)ep->log->close(ep->log, DB_NOSYNC);
 694         if (!log_init(sp, ep))
 695                 msgq(sp, M_ERR, "267|Log restarted");
 696 }
 697
 698 #if defined(DEBUG) && 0
 699 static void
 700 log_trace(sp, msg, rno, p)
 701         SCR *sp;
 702         char *msg;
 703         db_recno_t rno;
 704         u_char *p;
 705 {
 706         LMARK lm;
 707         MARK m;
 708         db_recno_t lno;
 709
 710         switch (*p) {
 711         case LOG_CURSOR_INIT:
 712                 memmove(&m, p + sizeof(u_char), sizeof(MARK));
 713                 vtrace(sp, "%lu: %s:  C_INIT: %u/%u\n", rno, msg, m.lno, m.cno);
 714                 break;
 715         case LOG_CURSOR_END:
 716                 memmove(&m, p + sizeof(u_char), sizeof(MARK));
 717                 vtrace(sp, "%lu: %s:   C_END: %u/%u\n", rno, msg, m.lno, m.cno);
 718                 break;
 719         case LOG_LINE_APPEND:
 720                 memmove(&lno, p + sizeof(u_char), sizeof(db_recno_t));
 721                 vtrace(sp, "%lu: %s:  APPEND: %lu\n", rno, msg, lno);
 722                 break;
 723         case LOG_LINE_INSERT:
 724                 memmove(&lno, p + sizeof(u_char), sizeof(db_recno_t));
 725                 vtrace(sp, "%lu: %s:  INSERT: %lu\n", rno, msg, lno);
 726                 break;
 727         case LOG_LINE_DELETE:
 728                 memmove(&lno, p + sizeof(u_char), sizeof(db_recno_t));
 729                 vtrace(sp, "%lu: %s:  DELETE: %lu\n", rno, msg, lno);
 730                 break;
 731         case LOG_LINE_RESET_F:
 732                 memmove(&lno, p + sizeof(u_char), sizeof(db_recno_t));
 733                 vtrace(sp, "%lu: %s: RESET_F: %lu\n", rno, msg, lno);
 734                 break;
 735         case LOG_LINE_RESET_B:
 736                 memmove(&lno, p + sizeof(u_char), sizeof(db_recno_t));
 737                 vtrace(sp, "%lu: %s: RESET_B: %lu\n", rno, msg, lno);
 738                 break;
 739         case LOG_MARK:
 740                 memmove(&lm, p + sizeof(u_char), sizeof(LMARK));
 741                 vtrace(sp,
 742                     "%lu: %s:    MARK: %u/%u\n", rno, msg, lm.lno, lm.cno);
 743                 break;
 744         default:
 745                 abort();
 746         }
 747 }
 748 #endif