d/freebsd-dev
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove the "oldorder" processing. The "neworder" processing has

Browse Source 
been the default for two years now, without any problems reported.

MFC after:	3 weeks
This commit is contained in:
Garance A Drosehn 2006-06-27 00:18:15 +00:00
parent bfc788c283
commit a04de8fa95
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/head/; revision=159968
1 changed files with 16 additions and 250 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

266
usr.sbin/newsyslog/newsyslog.c
View File

@ -88,12 +88,6 @@ __FBSDID("$FreeBSD$");
#include "pathnames.h"
#include "extern.h"
/* Define this symbol to try out the "new order" for work items. */
#define TRY_NEWORDER
#ifndef USE_NEWORDER
#define USE_NEWORDER 1 /* Initial value for dbg_new_order */
#endif
/*
* Bit-values for the 'flags' parsed from a config-file entry.
*/
@ -165,12 +159,6 @@ SLIST_HEAD(swlisthead, sigwork_entry) swhead = SLIST_HEAD_INITIALIZER(swhead);
SLIST_HEAD(zwlisthead, zipwork_entry) zwhead = SLIST_HEAD_INITIALIZER(zwhead);
int dbg_at_times; /* -D Show details of 'trim_at' code */
/*
* The debug options "neworder" and "oldorder" can be used to change
* which order work is done in. Note that both options will disappear
* in the near future, and the "new" order will be the only order.
*/
int dbg_new_order = USE_NEWORDER;
int archtodir = 0; /* Archive old logfiles to other directory */
int createlogs; /* Create (non-GLOB) logfiles which do not */
@ -208,7 +196,6 @@ static char *missing_field(char *p, char *errline);
static void change_attrs(const char *, const struct conf_entry *);
static fk_entry do_entry(struct conf_entry *);
static fk_entry do_rotate(const struct conf_entry *);
#ifdef TRY_NEWORDER
static void do_sigwork(struct sigwork_entry *);
static void do_zipwork(struct zipwork_entry *);
static struct sigwork_entry *
@ -217,7 +204,6 @@ static struct zipwork_entry *
save_zipwork(const struct conf_entry *, const struct
sigwork_entry *, int, const char *);
static void set_swpid(struct sigwork_entry *, const struct conf_entry *);
#endif
static int sizefile(const char *);
static void expand_globs(struct conf_entry **work_p,
struct conf_entry **glob_p);
@ -229,10 +215,7 @@ static void parse_args(int argc, char **argv);
static int parse_doption(const char *doption);
static void usage(void);
static int log_trim(const char *logname, const struct conf_entry *log_ent);
static void compress_log(char *logname, int dowait);
static void bzcompress_log(char *logname, int dowait);
static int age_old_log(char *file);
static int send_signal(const struct conf_entry *ent);
static void savelog(char *from, char *to);
static void createdir(const struct conf_entry *ent, char *dirpart);
static void createlog(const struct conf_entry *ent);
@ -252,10 +235,8 @@ main(int argc, char **argv)
{
fk_entry free_or_keep;
struct conf_entry *p, *q;
#ifdef TRY_NEWORDER
struct sigwork_entry *stmp;
struct zipwork_entry *ztmp;
#endif
SLIST_INIT(&swhead);
SLIST_INIT(&zwhead);
@ -280,7 +261,6 @@ main(int argc, char **argv)
q = p;
}
#ifdef TRY_NEWORDER
/*
* Send signals to any processes which need a signal to tell
* them to close and re-open the log file(s) we have rotated.
@ -322,7 +302,6 @@ main(int argc, char **argv)
SLIST_REMOVE_HEAD(&swhead, sw_nextp);
free(stmp);
}
#endif /* TRY_NEWORDER */
while (wait(NULL) > 0 || errno == EINTR)
;
@ -584,102 +563,6 @@ do_entry(struct conf_entry * ent)
#undef REASON_MAX
}
/* Send a signal to the pid specified by pidfile */
static int
send_signal(const struct conf_entry *ent)
{
pid_t target_pid;
int did_notify;
FILE *f;
long minok, maxok, rval;
const char *target_name;
char *endp, *linep, line[BUFSIZ];
did_notify = 0;
f = fopen(ent->pid_file, "r");
if (f == NULL) {
warn("can't open pid file: %s", ent->pid_file);
return (did_notify);
/* NOTREACHED */
}
if (fgets(line, BUFSIZ, f) == NULL) {
/*
* XXX - If the pid file is empty, is that really a
* problem? Wouldn't that mean that the process
* has shut down? In that case there would be no
* problem with compressing the rotated log file.
*/
if (feof(f))
warnx("pid file is empty: %s", ent->pid_file);
else
warn("can't read from pid file: %s", ent->pid_file);
(void) fclose(f);
return (did_notify);
/* NOTREACHED */
}
(void) fclose(f);
target_name = "daemon";
minok = MIN_PID;
maxok = MAX_PID;
if (ent->flags & CE_SIGNALGROUP) {
/*
* If we are expected to signal a process-group when
* rotating this logfile, then the value read in should
* be the negative of a valid process ID.
*/
target_name = "process-group";
minok = -MAX_PID;
maxok = -MIN_PID;
}
errno = 0;
linep = line;
while (*linep == ' ')
linep++;
rval = strtol(linep, &endp, 10);
if (*endp != '\0' && !isspacech(*endp)) {
warnx("pid file does not start with a valid number: %s",
ent->pid_file);
rval = 0;
} else if (rval < minok || rval > maxok) {
warnx("bad value '%ld' for process number in %s",
rval, ent->pid_file);
if (verbose)
warnx("\t(expecting value between %ld and %ld)",
minok, maxok);
rval = 0;
}
if (rval == 0) {
return (did_notify);
/* NOTREACHED */
}
target_pid = rval;
if (noaction) {
did_notify = 1;
printf("\tkill -%d %d\n", ent->sig, (int) target_pid);
} else if (kill(target_pid, ent->sig)) {
/*
* XXX - Iff the error was "no such process", should that
* really be an error for us? Perhaps the process
* is already gone, in which case there would be no
* problem with compressing the rotated log file.
*/
warn("can't notify %s, pid %d", target_name,
(int) target_pid);
} else {
did_notify = 1;
if (verbose)
printf("%s pid %d notified\n", target_name,
(int) target_pid);
}
return (did_notify);
}
static void
parse_args(int argc, char **argv)
{
@ -822,20 +705,10 @@ parse_doption(const char *doption)
return (1); /* successfully parsed */
}
if (strcmp(doption, "neworder") == 0) {
#ifdef TRY_NEWORDER
dbg_new_order++;
#else
warnx("NOTE: The code for 'neworder' was not compiled in.");
#endif
return (1); /* successfully parsed */
}
if (strcmp(doption, "oldorder") == 0) {
#ifdef TRY_NEWORDER
dbg_new_order = 0;
#else
warnx("NOTE: The code for 'neworder' was not compiled in.");
#endif
/* XXX - This check could probably be dropped. */
if ((strcmp(doption, "neworder") == 0) || (strcmp(doption, "oldorder")
== 0)) {
warnx("NOTE: newsyslog always uses 'neworder'.");
return (1); /* successfully parsed */
}
@ -1485,8 +1358,9 @@ do_rotate(const struct conf_entry *ent)
char file1[MAXPATHLEN], file2[MAXPATHLEN];
char zfile1[MAXPATHLEN], zfile2[MAXPATHLEN];
char jfile1[MAXPATHLEN];
int flags, notified, need_notification, numlogs_c;
int flags, numlogs_c;
fk_entry free_or_keep;
struct sigwork_entry *swork;
struct stat st;
flags = ent->flags;
@ -1612,90 +1486,27 @@ do_rotate(const struct conf_entry *ent)
printf("Start new log...\n");
createlog(ent);
#ifdef TRY_NEWORDER
/*
* Save all signalling and file-compression to be done after log
* files from all entries have been rotated. This way any one
* process will not be sent the same signal multiple times when
* multiple log files had to be rotated.
*/
if (dbg_new_order) {
struct sigwork_entry *swork;
swork = NULL;
if (ent->pid_file != NULL)
swork = save_sigwork(ent);
if (ent->numlogs > 0 && (flags & (CE_COMPACT | CE_BZCOMPACT))) {
/*
* The zipwork_entry will include a pointer to this
* conf_entry, so the conf_entry should not be freed.
*/
free_or_keep = KEEP_ENT;
save_zipwork(ent, swork, ent->fsize, file1);
}
return (free_or_keep);
}
#endif /* TRY_NEWORDER */
/*
* Find out if there is a process to signal. If nosignal (-s) was
* specified, then do not signal any process. Note that nosignal
* will trigger a warning message if the rotated logfile needs to
* be compressed, *unless* -R was specified. This is because there
* presumably still are process(es) writing to the old logfile, but
* we assume that a -sR request comes from a process which writes
* to the logfile, and as such, that process has already made sure
* that the logfile is not presently in use.
*/
need_notification = notified = 0;
if (ent->pid_file != NULL) {
need_notification = 1;
if (!nosignal)
notified = send_signal(ent); /* the normal case! */
else if (rotatereq)
need_notification = 0;
swork = NULL;
if (ent->pid_file != NULL)
swork = save_sigwork(ent);
if (ent->numlogs > 0 && (flags & (CE_COMPACT | CE_BZCOMPACT))) {
/*
* The zipwork_entry will include a pointer to this
* conf_entry, so the conf_entry should not be freed.
*/
free_or_keep = KEEP_ENT;
save_zipwork(ent, swork, ent->fsize, file1);
}
if ((flags & CE_COMPACT) || (flags & CE_BZCOMPACT)) {
if (need_notification && !notified)
warnx(
"log %s.0 not compressed because daemon(s) not notified",
ent->log);
else if (noaction) {
printf("\tsleep 10\n");
if (flags & CE_COMPACT)
printf("\tgzip %s.0\n", ent->log);
else
printf("\tbzip2 %s.0\n", ent->log);
} else {
if (notified) {
if (verbose)
printf("small pause to allow daemon(s) to close log\n");
sleep(10);
}
if (archtodir) {
(void) snprintf(file1, sizeof(file1), "%s/%s",
dirpart, namepart);
if (flags & CE_COMPACT)
compress_log(file1,
flags & CE_COMPACTWAIT);
else if (flags & CE_BZCOMPACT)
bzcompress_log(file1,
flags & CE_COMPACTWAIT);
} else {
if (flags & CE_COMPACT)
compress_log(ent->log,
flags & CE_COMPACTWAIT);
else if (flags & CE_BZCOMPACT)
bzcompress_log(ent->log,
flags & CE_COMPACTWAIT);
}
}
}
return (free_or_keep);
}
#ifdef TRY_NEWORDER
static void
do_sigwork(struct sigwork_entry *swork)
{
@ -2011,7 +1822,6 @@ set_swpid(struct sigwork_entry *swork, const struct conf_entry *ent)
return;
}
#endif /* TRY_NEWORDER */
/* Log the fact that the logs were turned over */
static int
@ -2039,50 +1849,6 @@ log_trim(const char *logname, const struct conf_entry *log_ent)
return (0);
}
/*
* XXX - Note that both compress_log and bzcompress_log will lose the
* NODUMP flag if it was set on somelog.0. Fixing that in newsyslog
* (as opposed to fixing gzip/bzip2) will require some restructuring
* of the code. That restructuring is planned for a later update...
*/
/* Fork of gzip to compress the old log file */
static void
compress_log(char *logname, int dowait)
{
pid_t pid;
char tmp[MAXPATHLEN];
while (dowait && (wait(NULL) > 0 || errno == EINTR))
;
(void) snprintf(tmp, sizeof(tmp), "%s.0", logname);
pid = fork();
if (pid < 0)
err(1, "gzip fork");
else if (!pid) {
(void) execl(_PATH_GZIP, _PATH_GZIP, "-f", tmp, (char *)0);
err(1, _PATH_GZIP);
}
}
/* Fork of bzip2 to compress the old log file */
static void
bzcompress_log(char *logname, int dowait)
{
pid_t pid;
char tmp[MAXPATHLEN];
while (dowait && (wait(NULL) > 0 || errno == EINTR))
;
snprintf(tmp, sizeof(tmp), "%s.0", logname);
pid = fork();
if (pid < 0)
err(1, "bzip2 fork");
else if (!pid) {
execl(_PATH_BZIP2, _PATH_BZIP2, "-f", tmp, (char *)0);
err(1, _PATH_BZIP2);
}
}
/* Return size in kilobytes of a file */
static int
sizefile(const char *file)