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.
7 * See the LICENSE file for redistribution information.
13 static const char sccsid
[] = "$Id: log.c,v 10.26 2002/03/02 23:12:13 skimo Exp $ (Berkeley) $Date: 2002/03/02 23:12:13 $";
16 #include <sys/types.h>
17 #include <sys/queue.h>
20 #include <bitstring.h>
31 * The log consists of records, each containing a type byte and a variable
32 * length byte string, as follows:
34 * LOG_CURSOR_INIT MARK
36 * LOG_LINE_APPEND_F db_recno_t char *
37 * LOG_LINE_APPEND_B db_recno_t char *
38 * LOG_LINE_DELETE_F db_recno_t char *
39 * LOG_LINE_DELETE_B db_recno_t char *
40 * LOG_LINE_RESET_F db_recno_t char *
41 * LOG_LINE_RESET_B db_recno_t char *
44 * We do before image physical logging. This means that the editor layer
45 * MAY NOT modify records in place, even if simply deleting or overwriting
46 * characters. Since the smallest unit of logging is a line, we're using
47 * up lots of space. This may eventually have to be reduced, probably by
48 * doing logical logging, which is a much cooler database phrase.
50 * The implementation of the historic vi 'u' command, using roll-forward and
51 * roll-back, is simple. Each set of changes has a LOG_CURSOR_INIT record,
52 * followed by a number of other records, followed by a LOG_CURSOR_END record.
53 * LOG_LINE_RESET records come in pairs. The first is a LOG_LINE_RESET_B
54 * record, and is the line before the change. The second is LOG_LINE_RESET_F,
55 * and is the line after the change. Roll-back is done by backing up to the
56 * first LOG_CURSOR_INIT record before a change. Roll-forward is done in a
59 * The 'U' command is implemented by rolling backward to a LOG_CURSOR_END
60 * record for a line different from the current one. It should be noted that
61 * this means that a subsequent 'u' command will make a change based on the
62 * new position of the log's cursor. This is okay, and, in fact, historic vi
66 static int vi_log_get
__P((SCR
*sp
, db_recno_t
*lnop
, size_t *size
));
67 static int log_cursor1
__P((SCR
*, int));
68 static void log_err
__P((SCR
*, char *, int));
69 #if defined(DEBUG) && 0
70 static void log_trace
__P((SCR
*, char *, db_recno_t
, u_char
*));
73 /* Try and restart the log on failure, i.e. if we run out of memory. */
75 log_err(sp, __FILE__, __LINE__); \
79 /* offset of CHAR_T string in log needs to be aligned on some systems
80 * because it is passed to db_set as a string
83 char data
[sizeof(u_char
) /* type */ + sizeof(db_recno_t
)];
86 #define CHAR_T_OFFSET ((char *)(((log_t*)0)->str) - (char *)0)
90 * Initialize the logging subsystem.
92 * PUBLIC: int log_init __P((SCR *, EXF *));
95 log_init(SCR
*sp
, EXF
*ep
)
99 * ep MAY NOT BE THE SAME AS sp->ep, DON'T USE THE LATTER.
101 * Initialize the buffer. The logging subsystem has its own
102 * buffers because the global ones are almost by definition
103 * going to be in use when the log runs.
107 ep
->l_cursor
.lno
= 1; /* XXX Any valid recno. */
108 ep
->l_cursor
.cno
= 0;
109 ep
->l_high
= ep
->l_cur
= 1;
111 if (db_create(&ep
->log
, 0, 0) != 0 ||
112 db_open(ep
->log
, NULL
, DB_RECNO
,
113 DB_CREATE
| VI_DB_THREAD
, S_IRUSR
| S_IWUSR
) != 0) {
114 msgq(sp
, M_SYSERR
, "009|Log file");
120 /*LOCK_INIT(sp->wp, ep);*/
127 * Close the logging subsystem.
129 * PUBLIC: int log_end __P((SCR *, EXF *));
132 log_end(SCR
*sp
, EXF
*ep
)
136 * ep MAY NOT BE THE SAME AS sp->ep, DON'T USE THE LATTER.
138 /*LOCK_END(sp->wp, ep);*/
139 if (ep
->log
!= NULL
) {
140 (void)(ep
->log
->close
)(ep
->log
, DB_NOSYNC
);
143 if (sp
->wp
->l_lp
!= NULL
) {
148 ep
->l_cursor
.lno
= 1; /* XXX Any valid recno. */
149 ep
->l_cursor
.cno
= 0;
150 ep
->l_high
= ep
->l_cur
= 1;
156 * Log the current cursor position, starting an event.
158 * PUBLIC: int log_cursor __P((SCR *));
166 if (F_ISSET(ep
, F_NOLOG
))
170 * If any changes were made since the last cursor init,
171 * put out the ending cursor record.
173 if (ep
->l_cursor
.lno
== OOBLNO
) {
174 if (ep
->l_win
&& ep
->l_win
!= sp
->wp
)
176 ep
->l_cursor
.lno
= sp
->lno
;
177 ep
->l_cursor
.cno
= sp
->cno
;
179 return (log_cursor1(sp
, LOG_CURSOR_END
));
181 ep
->l_cursor
.lno
= sp
->lno
;
182 ep
->l_cursor
.cno
= sp
->cno
;
188 * Actually push a cursor record out.
191 log_cursor1(SCR
*sp
, int type
)
199 if (type == LOG_CURSOR_INIT &&
200 LOCK_TRY(sp->wp, ep))
204 BINC_RETC(sp
, sp
->wp
->l_lp
, sp
->wp
->l_len
, sizeof(u_char
) + sizeof(MARK
));
205 sp
->wp
->l_lp
[0] = type
;
206 memmove(sp
->wp
->l_lp
+ sizeof(u_char
), &ep
->l_cursor
, sizeof(MARK
));
208 memset(&key
, 0, sizeof(key
));
209 key
.data
= &ep
->l_cur
;
210 key
.size
= sizeof(db_recno_t
);
211 memset(&data
, 0, sizeof(data
));
212 data
.data
= sp
->wp
->l_lp
;
213 data
.size
= sizeof(u_char
) + sizeof(MARK
);
214 if (ep
->log
->put(ep
->log
, NULL
, &key
, &data
, 0) == -1)
217 #if defined(DEBUG) && 0
218 vtrace(sp
, "%lu: %s: %u/%u\n", ep
->l_cur
,
219 type
== LOG_CURSOR_INIT
? "log_cursor_init" : "log_cursor_end",
222 /* Reset high water mark. */
223 ep
->l_high
= ++ep
->l_cur
;
226 if (type == LOG_CURSOR_END)
227 LOCK_UNLOCK(sp->wp, ep);
236 * PUBLIC: int log_line __P((SCR *, db_recno_t, u_int));
239 log_line(SCR
*sp
, db_recno_t lno
, u_int action
)
248 if (F_ISSET(ep
, F_NOLOG
))
254 * Kluge for vi. Clear the EXF undo flag so that the
255 * next 'u' command does a roll-back, regardless.
259 /* Put out one initial cursor record per set of changes. */
260 if (ep
->l_cursor
.lno
!= OOBLNO
) {
261 if (log_cursor1(sp
, LOG_CURSOR_INIT
))
263 ep
->l_cursor
.lno
= OOBLNO
;
265 } /*else if (ep->l_win != sp->wp) {
266 printf("log_line own: %p, this: %p\n", ep->l_win, sp->wp);
271 /* newly added for DB4 logging */
272 case LOG_LINE_APPEND_B
:
273 case LOG_LINE_DELETE_F
:
278 * Put out the changes. If it's a LOG_LINE_RESET_B call, it's a
279 * special case, avoid the caches. Also, if it fails and it's
280 * line 1, it just means that the user started with an empty file,
281 * so fake an empty length line.
283 if (action
== LOG_LINE_RESET_B
) {
284 if (db_get(sp
, lno
, DBG_NOCACHE
, &lp
, &len
)) {
285 static CHAR_T nul
= 0;
294 if (db_get(sp
, lno
, DBG_FATAL
, &lp
, &len
))
297 sp
->wp
->l_lp
, sp
->wp
->l_len
,
298 len
* sizeof(CHAR_T
) + CHAR_T_OFFSET
);
299 sp
->wp
->l_lp
[0] = action
;
300 memmove(sp
->wp
->l_lp
+ sizeof(u_char
), &lno
, sizeof(db_recno_t
));
301 MEMMOVEW(sp
->wp
->l_lp
+ CHAR_T_OFFSET
, lp
, len
);
304 memset(&key
, 0, sizeof(key
));
306 key
.size
= sizeof(db_recno_t
);
307 memset(&data
, 0, sizeof(data
));
308 data
.data
= sp
->wp
->l_lp
;
309 data
.size
= len
* sizeof(CHAR_T
) + CHAR_T_OFFSET
;
310 if (ep
->log
->put(ep
->log
, NULL
, &key
, &data
, 0) == -1)
313 #if defined(DEBUG) && 0
315 case LOG_LINE_APPEND_F
:
316 vtrace(sp
, "%u: log_line: append_f: %lu {%u}\n",
317 ep
->l_cur
, lno
, len
);
319 case LOG_LINE_APPEND_B
:
320 vtrace(sp
, "%u: log_line: append_b: %lu {%u}\n",
321 ep
->l_cur
, lno
, len
);
323 case LOG_LINE_DELETE_F
:
324 vtrace(sp
, "%lu: log_line: delete_f: %lu {%u}\n",
325 ep
->l_cur
, lno
, len
);
327 case LOG_LINE_DELETE_B
:
328 vtrace(sp
, "%lu: log_line: delete_b: %lu {%u}\n",
329 ep
->l_cur
, lno
, len
);
331 case LOG_LINE_RESET_F
:
332 vtrace(sp
, "%lu: log_line: reset_f: %lu {%u}\n",
333 ep
->l_cur
, lno
, len
);
335 case LOG_LINE_RESET_B
:
336 vtrace(sp
, "%lu: log_line: reset_b: %lu {%u}\n",
337 ep
->l_cur
, lno
, len
);
341 /* Reset high water mark. */
342 ep
->l_high
= ++ep
->l_cur
;
349 * Log a mark position. For the log to work, we assume that there
350 * aren't any operations that just put out a log record -- this
351 * would mean that undo operations would only reset marks, and not
352 * cause any other change.
354 * PUBLIC: int log_mark __P((SCR *, LMARK *));
357 log_mark(SCR
*sp
, LMARK
*lmp
)
363 if (F_ISSET(ep
, F_NOLOG
))
366 /* Put out one initial cursor record per set of changes. */
367 if (ep
->l_cursor
.lno
!= OOBLNO
) {
368 if (log_cursor1(sp
, LOG_CURSOR_INIT
))
370 ep
->l_cursor
.lno
= OOBLNO
;
374 BINC_RETC(sp
, sp
->wp
->l_lp
,
375 sp
->wp
->l_len
, sizeof(u_char
) + sizeof(LMARK
));
376 sp
->wp
->l_lp
[0] = LOG_MARK
;
377 memmove(sp
->wp
->l_lp
+ sizeof(u_char
), lmp
, sizeof(LMARK
));
379 memset(&key
, 0, sizeof(key
));
380 key
.data
= &ep
->l_cur
;
381 key
.size
= sizeof(db_recno_t
);
382 memset(&data
, 0, sizeof(data
));
383 data
.data
= sp
->wp
->l_lp
;
384 data
.size
= sizeof(u_char
) + sizeof(LMARK
);
385 if (ep
->log
->put(ep
->log
, NULL
, &key
, &data
, 0) == -1)
388 #if defined(DEBUG) && 0
389 vtrace(sp
, "%lu: mark %c: %lu/%u\n",
390 ep
->l_cur
, lmp
->name
, lmp
->lno
, lmp
->cno
);
392 /* Reset high water mark. */
393 ep
->l_high
= ++ep
->l_cur
;
399 * Get a line from the log in log buffer.
402 vi_log_get(SCR
*sp
, db_recno_t
*lnop
, size_t *size
)
412 BINC_RETC(sp
, sp
->wp
->l_lp
, sp
->wp
->l_len
, nlen
);
414 memset(&key
, 0, sizeof(key
));
415 key
.data
= lnop
; /* Initialize db request. */
416 key
.size
= sizeof(db_recno_t
);
417 memset(&data
, 0, sizeof(data
));
418 data
.data
= sp
->wp
->l_lp
;
419 data
.ulen
= sp
->wp
->l_len
;
420 data
.flags
= DB_DBT_USERMEM
;
421 switch (ep
->log
->get(ep
->log
, NULL
, &key
, &data
, 0)) {
435 * Roll the log backward one operation.
437 * PUBLIC: int log_backward __P((SCR *, MARK *));
440 log_backward(SCR
*sp
, MARK
*rp
)
451 if (F_ISSET(ep
, F_NOLOG
)) {
453 "010|Logging not being performed, undo not possible");
457 if (ep
->l_cur
== 1) {
458 msgq(sp
, M_BERR
, "011|No changes to undo");
462 if (ep
->l_win
&& ep
->l_win
!= sp
->wp
) {
463 ex_emsg(sp
, NULL
, EXM_LOCKED
);
469 F_SET(ep
, F_NOLOG
); /* Turn off logging. */
473 if (vi_log_get(sp
, &ep
->l_cur
, &size
))
475 #if defined(DEBUG) && 0
476 log_trace(sp
, "log_backward", ep
->l_cur
, data
.data
);
478 switch (*(p
= (u_char
*)sp
->wp
->l_lp
)) {
479 case LOG_CURSOR_INIT
:
481 memmove(rp
, p
+ sizeof(u_char
), sizeof(MARK
));
489 case LOG_LINE_APPEND_F
:
491 memmove(&lno
, p
+ sizeof(u_char
), sizeof(db_recno_t
));
492 if (db_delete(sp
, lno
))
494 ++sp
->rptlines
[L_DELETED
];
496 case LOG_LINE_DELETE_B
:
498 memmove(&lno
, p
+ sizeof(u_char
), sizeof(db_recno_t
));
499 if (db_insert(sp
, lno
,
500 (CHAR_T
*)(p
+ CHAR_T_OFFSET
),
501 (size
- CHAR_T_OFFSET
) / sizeof(CHAR_T
)))
503 ++sp
->rptlines
[L_ADDED
];
505 case LOG_LINE_RESET_F
:
507 case LOG_LINE_RESET_B
:
509 memmove(&lno
, p
+ sizeof(u_char
), sizeof(db_recno_t
));
511 (CHAR_T
*)(p
+ CHAR_T_OFFSET
),
512 (size
- CHAR_T_OFFSET
) / sizeof(CHAR_T
)))
514 if (sp
->rptlchange
!= lno
) {
515 sp
->rptlchange
= lno
;
516 ++sp
->rptlines
[L_CHANGED
];
521 memmove(&lm
, p
+ sizeof(u_char
), sizeof(LMARK
));
524 if (mark_set(sp
, lm
.name
, &m
, 0))
532 err
: F_CLR(ep
, F_NOLOG
);
539 * Reset the line to its original appearance.
542 * There's a bug in this code due to our not logging cursor movements
543 * unless a change was made. If you do a change, move off the line,
544 * then move back on and do a 'U', the line will be restored to the way
545 * it was before the original change.
547 * PUBLIC: int log_setline __P((SCR *));
560 if (F_ISSET(ep
, F_NOLOG
)) {
562 "012|Logging not being performed, undo not possible");
569 if (ep
->l_win
&& ep
->l_win
!= sp
->wp
) {
570 ex_emsg(sp
, NULL
, EXM_LOCKED
);
575 F_SET(ep
, F_NOLOG
); /* Turn off logging. */
579 if (vi_log_get(sp
, &ep
->l_cur
, &size
))
581 #if defined(DEBUG) && 0
582 log_trace(sp
, "log_setline", ep
->l_cur
, data
.data
);
584 switch (*(p
= (u_char
*)sp
->wp
->l_lp
)) {
585 case LOG_CURSOR_INIT
:
586 memmove(&m
, p
+ sizeof(u_char
), sizeof(MARK
));
587 if (m
.lno
!= sp
->lno
|| ep
->l_cur
== 1) {
594 memmove(&m
, p
+ sizeof(u_char
), sizeof(MARK
));
595 if (m
.lno
!= sp
->lno
) {
602 case LOG_LINE_APPEND_F
:
603 case LOG_LINE_DELETE_B
:
604 case LOG_LINE_RESET_F
:
606 case LOG_LINE_RESET_B
:
607 memmove(&lno
, p
+ sizeof(u_char
), sizeof(db_recno_t
));
608 if (lno
== sp
->lno
&&
609 db_set(sp
, lno
, (CHAR_T
*)(p
+ CHAR_T_OFFSET
),
610 (size
- CHAR_T_OFFSET
) / sizeof(CHAR_T
)))
612 if (sp
->rptlchange
!= lno
) {
613 sp
->rptlchange
= lno
;
614 ++sp
->rptlines
[L_CHANGED
];
617 memmove(&lm
, p
+ sizeof(u_char
), sizeof(LMARK
));
620 if (mark_set(sp
, lm
.name
, &m
, 0))
628 err
: F_CLR(ep
, F_NOLOG
);
635 * Roll the log forward one operation.
637 * PUBLIC: int log_forward __P((SCR *, MARK *));
640 log_forward(SCR
*sp
, MARK
*rp
)
651 if (F_ISSET(ep
, F_NOLOG
)) {
653 "013|Logging not being performed, roll-forward not possible");
657 if (ep
->l_cur
== ep
->l_high
) {
658 msgq(sp
, M_BERR
, "014|No changes to re-do");
662 if (ep
->l_win
&& ep
->l_win
!= sp
->wp
) {
663 ex_emsg(sp
, NULL
, EXM_LOCKED
);
668 F_SET(ep
, F_NOLOG
); /* Turn off logging. */
672 if (vi_log_get(sp
, &ep
->l_cur
, &size
))
674 #if defined(DEBUG) && 0
675 log_trace(sp
, "log_forward", ep
->l_cur
, data
.data
);
677 switch (*(p
= (u_char
*)sp
->wp
->l_lp
)) {
681 memmove(rp
, p
+ sizeof(u_char
), sizeof(MARK
));
687 case LOG_CURSOR_INIT
:
689 case LOG_LINE_APPEND_F
:
691 memmove(&lno
, p
+ sizeof(u_char
), sizeof(db_recno_t
));
692 if (db_insert(sp
, lno
,
693 (CHAR_T
*)(p
+ CHAR_T_OFFSET
),
694 (size
- CHAR_T_OFFSET
) / sizeof(CHAR_T
)))
696 ++sp
->rptlines
[L_ADDED
];
698 case LOG_LINE_DELETE_B
:
700 memmove(&lno
, p
+ sizeof(u_char
), sizeof(db_recno_t
));
701 if (db_delete(sp
, lno
))
703 ++sp
->rptlines
[L_DELETED
];
705 case LOG_LINE_RESET_B
:
707 case LOG_LINE_RESET_F
:
709 memmove(&lno
, p
+ sizeof(u_char
), sizeof(db_recno_t
));
711 (CHAR_T
*)(p
+ CHAR_T_OFFSET
),
712 (size
- CHAR_T_OFFSET
) / sizeof(CHAR_T
)))
714 if (sp
->rptlchange
!= lno
) {
715 sp
->rptlchange
= lno
;
716 ++sp
->rptlines
[L_CHANGED
];
721 memmove(&lm
, p
+ sizeof(u_char
), sizeof(LMARK
));
724 if (mark_set(sp
, lm
.name
, &m
, 0))
732 err
: F_CLR(ep
, F_NOLOG
);
739 * Try and restart the log on failure, i.e. if we run out of memory.
742 log_err(SCR
*sp
, char *file
, int line
)
746 msgq(sp
, M_SYSERR
, "015|%s/%d: log put error", tail(file
), line
);
748 (void)ep
->log
->close(ep
->log
, DB_NOSYNC
);
749 if (!log_init(sp
, ep
))
750 msgq(sp
, M_ERR
, "267|Log restarted");
753 #if defined(DEBUG) && 0
755 log_trace(sp
, msg
, rno
, p
)
766 case LOG_CURSOR_INIT
:
767 memmove(&m
, p
+ sizeof(u_char
), sizeof(MARK
));
768 vtrace(sp
, "%lu: %s: C_INIT: %u/%u\n", rno
, msg
, m
.lno
, m
.cno
);
771 memmove(&m
, p
+ sizeof(u_char
), sizeof(MARK
));
772 vtrace(sp
, "%lu: %s: C_END: %u/%u\n", rno
, msg
, m
.lno
, m
.cno
);
774 case LOG_LINE_APPEND_F
:
775 memmove(&lno
, p
+ sizeof(u_char
), sizeof(db_recno_t
));
776 vtrace(sp
, "%lu: %s: APPEND_F: %lu\n", rno
, msg
, lno
);
778 case LOG_LINE_APPEND_B
:
779 memmove(&lno
, p
+ sizeof(u_char
), sizeof(db_recno_t
));
780 vtrace(sp
, "%lu: %s: APPEND_B: %lu\n", rno
, msg
, lno
);
782 case LOG_LINE_DELETE_F
:
783 memmove(&lno
, p
+ sizeof(u_char
), sizeof(db_recno_t
));
784 vtrace(sp
, "%lu: %s: DELETE_F: %lu\n", rno
, msg
, lno
);
786 case LOG_LINE_DELETE_B
:
787 memmove(&lno
, p
+ sizeof(u_char
), sizeof(db_recno_t
));
788 vtrace(sp
, "%lu: %s: DELETE_B: %lu\n", rno
, msg
, lno
);
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
);
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
);
799 memmove(&lm
, p
+ sizeof(u_char
), sizeof(LMARK
));
801 "%lu: %s: MARK: %u/%u\n", rno
, msg
, lm
.lno
, lm
.cno
);