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.24 2001/06/25 15:19:10 skimo Exp $ (Berkeley) $Date: 2001/06/25 15:19:10 $";
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 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 *
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.
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
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
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
*));
72 /* Try and restart the log on failure, i.e. if we run out of memory. */
74 log_err(sp, __FILE__, __LINE__); \
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
82 char data
[sizeof(u_char
) /* type */ + sizeof(db_recno_t
)];
85 #define CHAR_T_OFFSET ((char *)(((log_t*)0)->str) - (char *)0)
89 * Initialize the logging subsystem.
91 * PUBLIC: int log_init __P((SCR *, EXF *));
94 log_init(SCR
*sp
, EXF
*ep
)
98 * ep MAY NOT BE THE SAME AS sp->ep, DON'T USE THE LATTER.
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.
106 ep
->l_cursor
.lno
= 1; /* XXX Any valid recno. */
107 ep
->l_cursor
.cno
= 0;
108 ep
->l_high
= ep
->l_cur
= 1;
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");
119 /*LOCK_INIT(sp->wp, ep);*/
126 * Close the logging subsystem.
128 * PUBLIC: int log_end __P((SCR *, EXF *));
131 log_end(SCR
*sp
, EXF
*ep
)
135 * ep MAY NOT BE THE SAME AS sp->ep, DON'T USE THE LATTER.
137 /*LOCK_END(sp->wp, ep);*/
138 if (ep
->log
!= NULL
) {
139 (void)(ep
->log
->close
)(ep
->log
,DB_NOSYNC
);
142 if (sp
->wp
->l_lp
!= NULL
) {
147 ep
->l_cursor
.lno
= 1; /* XXX Any valid recno. */
148 ep
->l_cursor
.cno
= 0;
149 ep
->l_high
= ep
->l_cur
= 1;
155 * Log the current cursor position, starting an event.
157 * PUBLIC: int log_cursor __P((SCR *));
165 if (F_ISSET(ep
, F_NOLOG
))
169 * If any changes were made since the last cursor init,
170 * put out the ending cursor record.
172 if (ep
->l_cursor
.lno
== OOBLNO
) {
173 if (ep
->l_win
&& ep
->l_win
!= sp
->wp
)
175 ep
->l_cursor
.lno
= sp
->lno
;
176 ep
->l_cursor
.cno
= sp
->cno
;
178 return (log_cursor1(sp
, LOG_CURSOR_END
));
180 ep
->l_cursor
.lno
= sp
->lno
;
181 ep
->l_cursor
.cno
= sp
->cno
;
187 * Actually push a cursor record out.
190 log_cursor1(SCR
*sp
, int type
)
198 if (type == LOG_CURSOR_INIT &&
199 LOCK_TRY(sp->wp, ep))
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
));
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)
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",
221 /* Reset high water mark. */
222 ep
->l_high
= ++ep
->l_cur
;
225 if (type == LOG_CURSOR_END)
226 LOCK_UNLOCK(sp->wp, ep);
235 * PUBLIC: int log_line __P((SCR *, db_recno_t, u_int));
238 log_line(SCR
*sp
, db_recno_t lno
, u_int action
)
247 if (F_ISSET(ep
, F_NOLOG
))
253 * Kluge for vi. Clear the EXF undo flag so that the
254 * next 'u' command does a roll-back, regardless.
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
))
262 ep
->l_cursor
.lno
= OOBLNO
;
264 } /*else if (ep->l_win != sp->wp) {
265 printf("log_line own: %p, this: %p\n", ep->l_win, sp->wp);
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.
275 if (action
== LOG_LINE_RESET_B
) {
276 if (db_get(sp
, lno
, DBG_NOCACHE
, &lp
, &len
)) {
277 static CHAR_T nul
= 0;
286 if (db_get(sp
, lno
, DBG_FATAL
, &lp
, &len
))
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
);
296 memset(&key
, 0, sizeof(key
));
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)
305 #if defined(DEBUG) && 0
307 case LOG_LINE_APPEND
:
308 vtrace(sp
, "%u: log_line: append: %lu {%u}\n",
309 ep
->l_cur
, lno
, len
);
311 case LOG_LINE_DELETE
:
312 vtrace(sp
, "%lu: log_line: delete: %lu {%u}\n",
313 ep
->l_cur
, lno
, len
);
315 case LOG_LINE_INSERT
:
316 vtrace(sp
, "%lu: log_line: insert: %lu {%u}\n",
317 ep
->l_cur
, lno
, len
);
319 case LOG_LINE_RESET_F
:
320 vtrace(sp
, "%lu: log_line: reset_f: %lu {%u}\n",
321 ep
->l_cur
, lno
, len
);
323 case LOG_LINE_RESET_B
:
324 vtrace(sp
, "%lu: log_line: reset_b: %lu {%u}\n",
325 ep
->l_cur
, lno
, len
);
329 /* Reset high water mark. */
330 ep
->l_high
= ++ep
->l_cur
;
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.
342 * PUBLIC: int log_mark __P((SCR *, LMARK *));
345 log_mark(SCR
*sp
, LMARK
*lmp
)
351 if (F_ISSET(ep
, F_NOLOG
))
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
))
358 ep
->l_cursor
.lno
= OOBLNO
;
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
));
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)
376 #if defined(DEBUG) && 0
377 vtrace(sp
, "%lu: mark %c: %lu/%u\n",
378 ep
->l_cur
, lmp
->name
, lmp
->lno
, lmp
->cno
);
380 /* Reset high water mark. */
381 ep
->l_high
= ++ep
->l_cur
;
387 * Get a line from the log in log buffer.
390 vi_log_get(SCR
*sp
, db_recno_t
*lnop
, size_t *size
)
400 BINC_RET(sp
, sp
->wp
->l_lp
, sp
->wp
->l_len
, nlen
);
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)) {
423 * Roll the log backward one operation.
425 * PUBLIC: int log_backward __P((SCR *, MARK *));
428 log_backward(SCR
*sp
, MARK
*rp
)
439 if (F_ISSET(ep
, F_NOLOG
)) {
441 "010|Logging not being performed, undo not possible");
445 if (ep
->l_cur
== 1) {
446 msgq(sp
, M_BERR
, "011|No changes to undo");
450 if (ep
->l_win
&& ep
->l_win
!= sp
->wp
) {
451 ex_emsg(sp
, NULL
, EXM_LOCKED
);
457 F_SET(ep
, F_NOLOG
); /* Turn off logging. */
461 if (vi_log_get(sp
, &ep
->l_cur
, &size
))
463 #if defined(DEBUG) && 0
464 log_trace(sp
, "log_backward", ep
->l_cur
, data
.data
);
466 switch (*(p
= (u_char
*)sp
->wp
->l_lp
)) {
467 case LOG_CURSOR_INIT
:
469 memmove(rp
, p
+ sizeof(u_char
), sizeof(MARK
));
477 case LOG_LINE_APPEND
:
478 case LOG_LINE_INSERT
:
480 memmove(&lno
, p
+ sizeof(u_char
), sizeof(db_recno_t
));
481 if (db_delete(sp
, lno
))
483 ++sp
->rptlines
[L_DELETED
];
485 case LOG_LINE_DELETE
:
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
)))
492 ++sp
->rptlines
[L_ADDED
];
494 case LOG_LINE_RESET_F
:
496 case LOG_LINE_RESET_B
:
498 memmove(&lno
, p
+ sizeof(u_char
), sizeof(db_recno_t
));
500 (CHAR_T
*)(p
+ CHAR_T_OFFSET
),
501 (size
- CHAR_T_OFFSET
) / sizeof(CHAR_T
)))
503 if (sp
->rptlchange
!= lno
) {
504 sp
->rptlchange
= lno
;
505 ++sp
->rptlines
[L_CHANGED
];
510 memmove(&lm
, p
+ sizeof(u_char
), sizeof(LMARK
));
513 if (mark_set(sp
, lm
.name
, &m
, 0))
521 err
: F_CLR(ep
, F_NOLOG
);
528 * Reset the line to its original appearance.
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.
536 * PUBLIC: int log_setline __P((SCR *));
549 if (F_ISSET(ep
, F_NOLOG
)) {
551 "012|Logging not being performed, undo not possible");
558 if (ep
->l_win
&& ep
->l_win
!= sp
->wp
) {
559 ex_emsg(sp
, NULL
, EXM_LOCKED
);
564 F_SET(ep
, F_NOLOG
); /* Turn off logging. */
568 if (vi_log_get(sp
, &ep
->l_cur
, &size
))
570 #if defined(DEBUG) && 0
571 log_trace(sp
, "log_setline", ep
->l_cur
, data
.data
);
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) {
583 memmove(&m
, p
+ sizeof(u_char
), sizeof(MARK
));
584 if (m
.lno
!= sp
->lno
) {
591 case LOG_LINE_APPEND
:
592 case LOG_LINE_INSERT
:
593 case LOG_LINE_DELETE
:
594 case LOG_LINE_RESET_F
:
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
)))
602 if (sp
->rptlchange
!= lno
) {
603 sp
->rptlchange
= lno
;
604 ++sp
->rptlines
[L_CHANGED
];
607 memmove(&lm
, p
+ sizeof(u_char
), sizeof(LMARK
));
610 if (mark_set(sp
, lm
.name
, &m
, 0))
618 err
: F_CLR(ep
, F_NOLOG
);
625 * Roll the log forward one operation.
627 * PUBLIC: int log_forward __P((SCR *, MARK *));
630 log_forward(SCR
*sp
, MARK
*rp
)
641 if (F_ISSET(ep
, F_NOLOG
)) {
643 "013|Logging not being performed, roll-forward not possible");
647 if (ep
->l_cur
== ep
->l_high
) {
648 msgq(sp
, M_BERR
, "014|No changes to re-do");
652 if (ep
->l_win
&& ep
->l_win
!= sp
->wp
) {
653 ex_emsg(sp
, NULL
, EXM_LOCKED
);
658 F_SET(ep
, F_NOLOG
); /* Turn off logging. */
662 if (vi_log_get(sp
, &ep
->l_cur
, &size
))
664 #if defined(DEBUG) && 0
665 log_trace(sp
, "log_forward", ep
->l_cur
, data
.data
);
667 switch (*(p
= (u_char
*)sp
->wp
->l_lp
)) {
671 memmove(rp
, p
+ sizeof(u_char
), sizeof(MARK
));
677 case LOG_CURSOR_INIT
:
679 /* XXXX LOG_LINE_APPEND and LOG_LINE_INSERT split
680 for now, because db_insert won't work for adding
683 case LOG_LINE_APPEND
:
685 memmove(&lno
, p
+ sizeof(u_char
), sizeof(db_recno_t
));
687 if (db_append(sp
, 1, lno
,
688 (CHAR_T
*)(p
+ CHAR_T_OFFSET
),
689 (size
- CHAR_T_OFFSET
) / sizeof(CHAR_T
)))
691 ++sp
->rptlines
[L_ADDED
];
693 case LOG_LINE_INSERT
:
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
)))
700 ++sp
->rptlines
[L_ADDED
];
702 case LOG_LINE_DELETE
:
704 memmove(&lno
, p
+ sizeof(u_char
), sizeof(db_recno_t
));
705 if (db_delete(sp
, lno
))
707 ++sp
->rptlines
[L_DELETED
];
709 case LOG_LINE_RESET_B
:
711 case LOG_LINE_RESET_F
:
713 memmove(&lno
, p
+ sizeof(u_char
), sizeof(db_recno_t
));
715 (CHAR_T
*)(p
+ CHAR_T_OFFSET
),
716 (size
- CHAR_T_OFFSET
) / sizeof(CHAR_T
)))
718 if (sp
->rptlchange
!= lno
) {
719 sp
->rptlchange
= lno
;
720 ++sp
->rptlines
[L_CHANGED
];
725 memmove(&lm
, p
+ sizeof(u_char
), sizeof(LMARK
));
728 if (mark_set(sp
, lm
.name
, &m
, 0))
736 err
: F_CLR(ep
, F_NOLOG
);
743 * Try and restart the log on failure, i.e. if we run out of memory.
746 log_err(SCR
*sp
, char *file
, int line
)
750 msgq(sp
, M_SYSERR
, "015|%s/%d: log put error", tail(file
), line
);
752 (void)ep
->log
->close(ep
->log
, DB_NOSYNC
);
753 if (!log_init(sp
, ep
))
754 msgq(sp
, M_ERR
, "267|Log restarted");
757 #if defined(DEBUG) && 0
759 log_trace(sp
, msg
, rno
, 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
);
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
);
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
);
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
);
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
);
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
);