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 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 ep
->log
= dbopen(NULL
, O_CREAT
| O_NONBLOCK
| O_RDWR
,
111 S_IRUSR
| S_IWUSR
, DB_RECNO
, NULL
);
112 if (ep
->log
== NULL
) {
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
);
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_RETC(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
, &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 /* newly added for DB4 logging */
271 case LOG_LINE_APPEND_B
:
272 case LOG_LINE_DELETE_F
:
277 * Put out the changes. If it's a LOG_LINE_RESET_B call, it's a
278 * special case, avoid the caches. Also, if it fails and it's
279 * line 1, it just means that the user started with an empty file,
280 * so fake an empty length line.
282 if (action
== LOG_LINE_RESET_B
) {
283 if (db_get(sp
, lno
, DBG_NOCACHE
, &lp
, &len
)) {
284 static CHAR_T nul
= 0;
293 if (db_get(sp
, lno
, DBG_FATAL
, &lp
, &len
))
296 sp
->wp
->l_lp
, sp
->wp
->l_len
,
297 len
* sizeof(CHAR_T
) + CHAR_T_OFFSET
);
298 sp
->wp
->l_lp
[0] = action
;
299 memmove(sp
->wp
->l_lp
+ sizeof(u_char
), &lno
, sizeof(db_recno_t
));
300 MEMMOVEW(sp
->wp
->l_lp
+ CHAR_T_OFFSET
, lp
, len
);
303 memset(&key
, 0, sizeof(key
));
305 key
.size
= sizeof(db_recno_t
);
306 memset(&data
, 0, sizeof(data
));
307 data
.data
= sp
->wp
->l_lp
;
308 data
.size
= len
* sizeof(CHAR_T
) + CHAR_T_OFFSET
;
309 if (ep
->log
->put(ep
->log
, &key
, &data
, 0) == -1)
312 #if defined(DEBUG) && 0
314 case LOG_LINE_APPEND_F
:
315 vtrace(sp
, "%u: log_line: append_f: %lu {%u}\n",
316 ep
->l_cur
, lno
, len
);
318 case LOG_LINE_APPEND_B
:
319 vtrace(sp
, "%u: log_line: append_b: %lu {%u}\n",
320 ep
->l_cur
, lno
, len
);
322 case LOG_LINE_DELETE_F
:
323 vtrace(sp
, "%lu: log_line: delete_f: %lu {%u}\n",
324 ep
->l_cur
, lno
, len
);
326 case LOG_LINE_DELETE_B
:
327 vtrace(sp
, "%lu: log_line: delete_b: %lu {%u}\n",
328 ep
->l_cur
, lno
, len
);
330 case LOG_LINE_RESET_F
:
331 vtrace(sp
, "%lu: log_line: reset_f: %lu {%u}\n",
332 ep
->l_cur
, lno
, len
);
334 case LOG_LINE_RESET_B
:
335 vtrace(sp
, "%lu: log_line: reset_b: %lu {%u}\n",
336 ep
->l_cur
, lno
, len
);
340 /* Reset high water mark. */
341 ep
->l_high
= ++ep
->l_cur
;
348 * Log a mark position. For the log to work, we assume that there
349 * aren't any operations that just put out a log record -- this
350 * would mean that undo operations would only reset marks, and not
351 * cause any other change.
353 * PUBLIC: int log_mark __P((SCR *, LMARK *));
356 log_mark(SCR
*sp
, LMARK
*lmp
)
362 if (F_ISSET(ep
, F_NOLOG
))
365 /* Put out one initial cursor record per set of changes. */
366 if (ep
->l_cursor
.lno
!= OOBLNO
) {
367 if (log_cursor1(sp
, LOG_CURSOR_INIT
))
369 ep
->l_cursor
.lno
= OOBLNO
;
373 BINC_RETC(sp
, sp
->wp
->l_lp
,
374 sp
->wp
->l_len
, sizeof(u_char
) + sizeof(LMARK
));
375 sp
->wp
->l_lp
[0] = LOG_MARK
;
376 memmove(sp
->wp
->l_lp
+ sizeof(u_char
), lmp
, sizeof(LMARK
));
378 memset(&key
, 0, sizeof(key
));
379 key
.data
= &ep
->l_cur
;
380 key
.size
= sizeof(db_recno_t
);
381 memset(&data
, 0, sizeof(data
));
382 data
.data
= sp
->wp
->l_lp
;
383 data
.size
= sizeof(u_char
) + sizeof(LMARK
);
384 if (ep
->log
->put(ep
->log
, &key
, &data
, 0) == -1)
387 #if defined(DEBUG) && 0
388 vtrace(sp
, "%lu: mark %c: %lu/%u\n",
389 ep
->l_cur
, lmp
->name
, lmp
->lno
, lmp
->cno
);
391 /* Reset high water mark. */
392 ep
->l_high
= ++ep
->l_cur
;
398 * Roll the log backward one operation.
400 * PUBLIC: int log_backward __P((SCR *, MARK *));
403 log_backward(SCR
*sp
, MARK
*rp
)
414 if (F_ISSET(ep
, F_NOLOG
)) {
416 "010|Logging not being performed, undo not possible");
420 if (ep
->l_cur
== 1) {
421 msgq(sp
, M_BERR
, "011|No changes to undo");
425 if (ep
->l_win
&& ep
->l_win
!= sp
->wp
) {
426 ex_emsg(sp
, NULL
, EXM_LOCKED
);
432 F_SET(ep
, F_NOLOG
); /* Turn off logging. */
434 key
.data
= &ep
->l_cur
; /* Initialize db request. */
435 key
.size
= sizeof(recno_t
);
438 if (ep
->log
->get(ep
->log
, &key
, &data
, 0))
440 #if defined(DEBUG) && 0
441 log_trace(sp
, "log_backward", ep
->l_cur
, data
.data
);
443 switch (*(p
= (u_char
*)data
.data
)) {
444 case LOG_CURSOR_INIT
:
446 memmove(rp
, p
+ sizeof(u_char
), sizeof(MARK
));
454 case LOG_LINE_APPEND_F
:
456 memmove(&lno
, p
+ sizeof(u_char
), sizeof(db_recno_t
));
457 if (db_delete(sp
, lno
))
459 ++sp
->rptlines
[L_DELETED
];
461 case LOG_LINE_DELETE_B
:
463 memmove(&lno
, p
+ sizeof(u_char
), sizeof(db_recno_t
));
464 if (db_insert(sp
, lno
,
465 (CHAR_T
*)(p
+ CHAR_T_OFFSET
),
466 (data
.size
- CHAR_T_OFFSET
) / sizeof(CHAR_T
)))
468 ++sp
->rptlines
[L_ADDED
];
470 case LOG_LINE_RESET_F
:
472 case LOG_LINE_RESET_B
:
474 memmove(&lno
, p
+ sizeof(u_char
), sizeof(db_recno_t
));
476 (CHAR_T
*)(p
+ CHAR_T_OFFSET
),
477 (data
.size
- CHAR_T_OFFSET
) / sizeof(CHAR_T
)))
479 if (sp
->rptlchange
!= lno
) {
480 sp
->rptlchange
= lno
;
481 ++sp
->rptlines
[L_CHANGED
];
486 memmove(&lm
, p
+ sizeof(u_char
), sizeof(LMARK
));
489 if (mark_set(sp
, lm
.name
, &m
, 0))
497 err
: F_CLR(ep
, F_NOLOG
);
504 * Reset the line to its original appearance.
507 * There's a bug in this code due to our not logging cursor movements
508 * unless a change was made. If you do a change, move off the line,
509 * then move back on and do a 'U', the line will be restored to the way
510 * it was before the original change.
512 * PUBLIC: int log_setline __P((SCR *));
525 if (F_ISSET(ep
, F_NOLOG
)) {
527 "012|Logging not being performed, undo not possible");
534 if (ep
->l_win
&& ep
->l_win
!= sp
->wp
) {
535 ex_emsg(sp
, NULL
, EXM_LOCKED
);
540 F_SET(ep
, F_NOLOG
); /* Turn off logging. */
542 key
.data
= &ep
->l_cur
; /* Initialize db request. */
543 key
.size
= sizeof(recno_t
);
547 if (ep
->log
->get(ep
->log
, &key
, &data
, 0))
549 #if defined(DEBUG) && 0
550 log_trace(sp
, "log_setline", ep
->l_cur
, data
.data
);
552 switch (*(p
= (u_char
*)data
.data
)) {
553 case LOG_CURSOR_INIT
:
554 memmove(&m
, p
+ sizeof(u_char
), sizeof(MARK
));
555 if (m
.lno
!= sp
->lno
|| ep
->l_cur
== 1) {
562 memmove(&m
, p
+ sizeof(u_char
), sizeof(MARK
));
563 if (m
.lno
!= sp
->lno
) {
570 case LOG_LINE_APPEND_F
:
571 case LOG_LINE_DELETE_B
:
572 case LOG_LINE_RESET_F
:
574 case LOG_LINE_RESET_B
:
575 memmove(&lno
, p
+ sizeof(u_char
), sizeof(db_recno_t
));
576 if (lno
== sp
->lno
&&
577 db_set(sp
, lno
, (CHAR_T
*)(p
+ CHAR_T_OFFSET
),
578 (data
.size
- CHAR_T_OFFSET
) / sizeof(CHAR_T
)))
580 if (sp
->rptlchange
!= lno
) {
581 sp
->rptlchange
= lno
;
582 ++sp
->rptlines
[L_CHANGED
];
585 memmove(&lm
, p
+ sizeof(u_char
), sizeof(LMARK
));
588 if (mark_set(sp
, lm
.name
, &m
, 0))
596 err
: F_CLR(ep
, F_NOLOG
);
603 * Roll the log forward one operation.
605 * PUBLIC: int log_forward __P((SCR *, MARK *));
608 log_forward(SCR
*sp
, MARK
*rp
)
619 if (F_ISSET(ep
, F_NOLOG
)) {
621 "013|Logging not being performed, roll-forward not possible");
625 if (ep
->l_cur
== ep
->l_high
) {
626 msgq(sp
, M_BERR
, "014|No changes to re-do");
630 if (ep
->l_win
&& ep
->l_win
!= sp
->wp
) {
631 ex_emsg(sp
, NULL
, EXM_LOCKED
);
636 F_SET(ep
, F_NOLOG
); /* Turn off logging. */
638 key
.data
= &ep
->l_cur
; /* Initialize db request. */
639 key
.size
= sizeof(recno_t
);
642 if (ep
->log
->get(ep
->log
, &key
, &data
, 0))
644 #if defined(DEBUG) && 0
645 log_trace(sp
, "log_forward", ep
->l_cur
, data
.data
);
647 switch (*(p
= (u_char
*)data
.data
)) {
651 memmove(rp
, p
+ sizeof(u_char
), sizeof(MARK
));
657 case LOG_CURSOR_INIT
:
659 case LOG_LINE_APPEND_F
:
661 memmove(&lno
, p
+ sizeof(u_char
), sizeof(db_recno_t
));
662 if (db_insert(sp
, lno
,
663 (CHAR_T
*)(p
+ CHAR_T_OFFSET
),
664 (data
.size
- CHAR_T_OFFSET
) / sizeof(CHAR_T
)))
666 ++sp
->rptlines
[L_ADDED
];
668 case LOG_LINE_DELETE_B
:
670 memmove(&lno
, p
+ sizeof(u_char
), sizeof(db_recno_t
));
671 if (db_delete(sp
, lno
))
673 ++sp
->rptlines
[L_DELETED
];
675 case LOG_LINE_RESET_B
:
677 case LOG_LINE_RESET_F
:
679 memmove(&lno
, p
+ sizeof(u_char
), sizeof(db_recno_t
));
681 (CHAR_T
*)(p
+ CHAR_T_OFFSET
),
682 (data
.size
- CHAR_T_OFFSET
) / sizeof(CHAR_T
)))
684 if (sp
->rptlchange
!= lno
) {
685 sp
->rptlchange
= lno
;
686 ++sp
->rptlines
[L_CHANGED
];
691 memmove(&lm
, p
+ sizeof(u_char
), sizeof(LMARK
));
694 if (mark_set(sp
, lm
.name
, &m
, 0))
702 err
: F_CLR(ep
, F_NOLOG
);
709 * Try and restart the log on failure, i.e. if we run out of memory.
712 log_err(SCR
*sp
, char *file
, int line
)
716 msgq(sp
, M_SYSERR
, "015|%s/%d: log put error", tail(file
), line
);
718 (void)ep
->log
->close(ep
->log
);
719 if (!log_init(sp
, ep
))
720 msgq(sp
, M_ERR
, "267|Log restarted");
723 #if defined(DEBUG) && 0
725 log_trace(sp
, msg
, rno
, p
)
736 case LOG_CURSOR_INIT
:
737 memmove(&m
, p
+ sizeof(u_char
), sizeof(MARK
));
738 vtrace(sp
, "%lu: %s: C_INIT: %u/%u\n", rno
, msg
, m
.lno
, m
.cno
);
741 memmove(&m
, p
+ sizeof(u_char
), sizeof(MARK
));
742 vtrace(sp
, "%lu: %s: C_END: %u/%u\n", rno
, msg
, m
.lno
, m
.cno
);
744 case LOG_LINE_APPEND_F
:
745 memmove(&lno
, p
+ sizeof(u_char
), sizeof(db_recno_t
));
746 vtrace(sp
, "%lu: %s: APPEND_F: %lu\n", rno
, msg
, lno
);
748 case LOG_LINE_APPEND_B
:
749 memmove(&lno
, p
+ sizeof(u_char
), sizeof(db_recno_t
));
750 vtrace(sp
, "%lu: %s: APPEND_B: %lu\n", rno
, msg
, lno
);
752 case LOG_LINE_DELETE_F
:
753 memmove(&lno
, p
+ sizeof(u_char
), sizeof(db_recno_t
));
754 vtrace(sp
, "%lu: %s: DELETE_F: %lu\n", rno
, msg
, lno
);
756 case LOG_LINE_DELETE_B
:
757 memmove(&lno
, p
+ sizeof(u_char
), sizeof(db_recno_t
));
758 vtrace(sp
, "%lu: %s: DELETE_B: %lu\n", rno
, msg
, lno
);
760 case LOG_LINE_RESET_F
:
761 memmove(&lno
, p
+ sizeof(u_char
), sizeof(db_recno_t
));
762 vtrace(sp
, "%lu: %s: RESET_F: %lu\n", rno
, msg
, lno
);
764 case LOG_LINE_RESET_B
:
765 memmove(&lno
, p
+ sizeof(u_char
), sizeof(db_recno_t
));
766 vtrace(sp
, "%lu: %s: RESET_B: %lu\n", rno
, msg
, lno
);
769 memmove(&lm
, p
+ sizeof(u_char
), sizeof(LMARK
));
771 "%lu: %s: MARK: %u/%u\n", rno
, msg
, lm
.lno
, lm
.cno
);