diff --git a/src/backend/postmaster/postmaster.c b/src/backend/postmaster/postmaster.c
new file mode 100644
index 95180b2..e9b5684
*** a/src/backend/postmaster/postmaster.c
--- b/src/backend/postmaster/postmaster.c
*************** typedef struct
*** 464,469 ****
--- 464,470 ----
  
  static pid_t backend_forkexec(Port *port);
  static pid_t internal_forkexec(int argc, char *argv[], Port *port);
+ static Size get_backend_params_size(void);
  
  /* Type for a socket that can be inherited to a client process */
  #ifdef WIN32
*************** typedef int InheritableSocket;
*** 482,488 ****
--- 483,495 ----
   */
  typedef struct
  {
+ 	/*
+ 	 * read_backend_variables() relies on size to be the first field, followed
+ 	 * by port.
+ 	 */
+ 	Size		size;
  	Port		port;
+ 
  	InheritableSocket portsocket;
  	char		DataDir[MAXPGPATH];
  	pgsocket	ListenSocket[MAXLISTEN];
*************** typedef struct
*** 528,533 ****
--- 535,542 ----
  	char		my_exec_path[MAXPGPATH];
  	char		pkglib_path[MAXPGPATH];
  	char		ExtraOptions[MAXPGPATH];
+ 	int			nlogstreams;
+ 	char		log_streams[FLEXIBLE_ARRAY_MEMBER];
  } BackendParameters;
  
  static void read_backend_variables(char *id, Port *port);
*************** PostmasterMain(int argc, char *argv[])
*** 578,583 ****
--- 587,593 ----
  	bool		listen_addr_saved = false;
  	int			i;
  	char	   *output_config_variable = NULL;
+ 	LogStream  *log = &log_streams[0];
  
  	MyProcPid = PostmasterPid = getpid();
  
*************** PostmasterMain(int argc, char *argv[])
*** 1273,1279 ****
  	 * saying so, to provide a breadcrumb trail for users who may not remember
  	 * that their logging is configured to go somewhere else.
  	 */
! 	if (!(Log_destination & LOG_DESTINATION_STDERR))
  		ereport(LOG,
  				(errmsg("ending log output to stderr"),
  				 errhint("Future log output will go to log destination \"%s\".",
--- 1283,1289 ----
  	 * saying so, to provide a breadcrumb trail for users who may not remember
  	 * that their logging is configured to go somewhere else.
  	 */
! 	if (!(log->destination & LOG_DESTINATION_STDERR))
  		ereport(LOG,
  				(errmsg("ending log output to stderr"),
  				 errhint("Future log output will go to log destination \"%s\".",
*************** internal_forkexec(int argc, char *argv[]
*** 4421,4431 ****
  	static unsigned long tmpBackendFileNum = 0;
  	pid_t		pid;
  	char		tmpfilename[MAXPGPATH];
! 	BackendParameters param;
  	FILE	   *fp;
  
! 	if (!save_backend_variables(&param, port))
  		return -1;				/* log made by save_backend_variables */
  
  	/* Calculate name for temp file */
  	snprintf(tmpfilename, MAXPGPATH, "%s/%s.backend_var.%d.%lu",
--- 4431,4448 ----
  	static unsigned long tmpBackendFileNum = 0;
  	pid_t		pid;
  	char		tmpfilename[MAXPGPATH];
! 	Size		param_size;
! 	BackendParameters *param;
  	FILE	   *fp;
  
! 	param_size = get_backend_params_size();
! 	param = (BackendParameters *) palloc(param_size);
! 	if (!save_backend_variables(param, port))
! 	{
! 		pfree(param);
  		return -1;				/* log made by save_backend_variables */
+ 	}
+ 	Assert(param->size == param_size);
  
  	/* Calculate name for temp file */
  	snprintf(tmpfilename, MAXPGPATH, "%s/%s.backend_var.%d.%lu",
*************** internal_forkexec(int argc, char *argv[]
*** 4449,4466 ****
  					(errcode_for_file_access(),
  					 errmsg("could not create file \"%s\": %m",
  							tmpfilename)));
  			return -1;
  		}
  	}
  
! 	if (fwrite(&param, sizeof(param), 1, fp) != 1)
  	{
  		ereport(LOG,
  				(errcode_for_file_access(),
  				 errmsg("could not write to file \"%s\": %m", tmpfilename)));
  		FreeFile(fp);
  		return -1;
  	}
  
  	/* Release file */
  	if (FreeFile(fp))
--- 4466,4486 ----
  					(errcode_for_file_access(),
  					 errmsg("could not create file \"%s\": %m",
  							tmpfilename)));
+ 			pfree(param);
  			return -1;
  		}
  	}
  
! 	if (fwrite(param, param_size, 1, fp) != 1)
  	{
  		ereport(LOG,
  				(errcode_for_file_access(),
  				 errmsg("could not write to file \"%s\": %m", tmpfilename)));
  		FreeFile(fp);
+ 		pfree(param);
  		return -1;
  	}
+ 	pfree(param);
  
  	/* Release file */
  	if (FreeFile(fp))
*************** retry:
*** 4548,4554 ****
  		return -1;
  	}
  
! 	param = MapViewOfFile(paramHandle, FILE_MAP_WRITE, 0, 0, sizeof(BackendParameters));
  	if (!param)
  	{
  		elog(LOG, "could not map backend parameter memory: error code %lu",
--- 4568,4575 ----
  		return -1;
  	}
  
! 	param = MapViewOfFile(paramHandle, FILE_MAP_WRITE, 0, 0,
! 						  get_backend_params_size());
  	if (!param)
  	{
  		elog(LOG, "could not map backend parameter memory: error code %lu",
*************** retry:
*** 4703,4708 ****
--- 4724,4753 ----
  }
  #endif							/* WIN32 */
  
+ /*
+  * The storage space depends on the log streams. Compute how much we need.
+  */
+ static Size
+ get_backend_params_size(void)
+ {
+ 	int			i;
+ 	Size		result;
+ 
+ 	result = offsetof(BackendParameters, log_streams);
+ 	for (i = 0; i < log_streams_active; i++)
+ 	{
+ 		LogStream  *stream = &log_streams[i];
+ 
+ 		/*
+ 		 * At least the in-core value should be there.
+ 		 */
+ 		Assert(stream->line_prefix != NULL);
+ 
+ 		result += LOG_STREAM_FLAT_SIZE(stream);
+ 	}
+ 	return result;
+ }
+ 
  
  /*
   * SubPostmasterMain -- Get the fork/exec'd process into a state equivalent
*************** extern PMSignalData *PMSignalState;
*** 5938,5943 ****
--- 5983,5990 ----
  extern pgsocket pgStatSock;
  extern pg_time_t first_syslogger_file_time;
  
+ bool		log_streams_initialized = false;
+ 
  #ifndef WIN32
  #define write_inheritable_socket(dest, src, childpid) ((*(dest) = (src)), true)
  #define read_inheritable_socket(dest, src) (*(dest) = *(src))
*************** save_backend_variables(BackendParameters
*** 5959,5964 ****
--- 6006,6016 ----
  					   HANDLE childProcess, pid_t childPid)
  #endif
  {
+ 	int			i;
+ 	LogStreamFlat *flat = NULL;
+ 	Size		flat_size_max = 0;
+ 	char	   *cur;
+ 
  	memcpy(&param->port, port, sizeof(Port));
  	if (!write_inheritable_socket(&param->portsocket, port->sock, childPid))
  		return false;
*************** save_backend_variables(BackendParameters
*** 6021,6026 ****
--- 6073,6158 ----
  
  	strlcpy(param->ExtraOptions, ExtraOptions, MAXPGPATH);
  
+ 	param->nlogstreams = log_streams_active;
+ 	cur = param->log_streams;
+ 	for (i = 0; i < param->nlogstreams; i++)
+ 	{
+ 		LogStream  *stream;
+ 		Size		flat_size;
+ 
+ 		stream = &log_streams[i];
+ 		flat_size = LOG_STREAM_FLAT_SIZE(stream);
+ 		if (flat_size_max == 0)
+ 		{
+ 			/* First time through? */
+ 			Assert(flat == NULL);
+ 			flat = (LogStreamFlat *) palloc(flat_size);
+ 			flat_size_max = flat_size;
+ 		}
+ 		else if (flat_size > flat_size_max)
+ 		{
+ 			/* New maximum size? */
+ 			Assert(flat != NULL);
+ 			flat = (LogStreamFlat *) repalloc(flat, flat_size);
+ 			flat_size_max = flat_size;
+ 		}
+ 
+ 		/* Serialize the stream info. */
+ 		memset(flat, 0, flat_size);
+ 		flat->size = flat_size;
+ 		flat->syslog_fd = stream->syslog_fd;
+ 
+ 		/*
+ 		 * As for the core stream, backend will read the settings as any other
+ 		 * GUCs.
+ 		 */
+ 		if (i > 0)
+ 		{
+ 			/*
+ 			 * Check string arguments.
+ 			 */
+ 			if (stream->filename == NULL || strlen(stream->filename) == 0 ||
+ 				stream->directory == NULL || strlen(stream->directory) == 0 ||
+ 				stream->line_prefix == NULL || stream->id == NULL)
+ 				ereport(ERROR, (errmsg("log stream is not initialized properly")));
+ 
+ 			if (strlen(stream->filename) >= MAXPGPATH ||
+ 				strlen(stream->directory) >= MAXPGPATH ||
+ 				strlen(stream->line_prefix) >= MAXPGPATH ||
+ 				strlen(stream->id) >= MAXPGPATH)
+ 				ereport(ERROR,
+ 						(errmsg("Both log director and file name must be shorter than MAXPGPATH")));
+ 
+ 			flat->verbosity = stream->verbosity;
+ 			flat->destination = stream->destination;
+ 			Assert(stream->filename != NULL && strlen(stream->filename) > 0);
+ 			strcpy(flat->id, stream->id);
+ 			strcpy(flat->filename, stream->filename);
+ 			Assert(stream->directory != NULL);
+ 			if (strlen(stream->directory) > 0)
+ 				strcpy(flat->directory, stream->directory);
+ 			flat->file_mode = stream->file_mode;
+ 			flat->rotation_age = stream->rotation_age;
+ 			flat->rotation_size = stream->rotation_size;
+ 			flat->truncate_on_rotation = stream->truncate_on_rotation;
+ 			Assert(stream->line_prefix != NULL);
+ 
+ 			if (strlen(stream->line_prefix) > 0)
+ 				strcpy(flat->line_prefix, stream->line_prefix);
+ 		}
+ 
+ 		/* Copy the data. */
+ 		memcpy(cur, flat, flat_size);
+ 		cur += flat_size;
+ 	}
+ 
+ 	/* At least one (the core) stream should always exist. */
+ 	Assert(flat != NULL);
+ 	pfree(flat);
+ 
+ 	/* File space needed. */
+ 	param->size = cur - (char *) param;
+ 
  	return true;
  }
  
*************** read_inheritable_socket(SOCKET *dest, In
*** 6121,6127 ****
  static void
  read_backend_variables(char *id, Port *port)
  {
! 	BackendParameters param;
  
  #ifndef WIN32
  	/* Non-win32 implementation reads from file */
--- 6253,6261 ----
  static void
  read_backend_variables(char *id, Port *port)
  {
! 	Size		param_size,
! 				off;
! 	BackendParameters *param;
  
  #ifndef WIN32
  	/* Non-win32 implementation reads from file */
*************** read_backend_variables(char *id, Port *p
*** 6136,6142 ****
  		exit(1);
  	}
  
! 	if (fread(&param, sizeof(param), 1, fp) != 1)
  	{
  		write_stderr("could not read from backend variables file \"%s\": %s\n",
  					 id, strerror(errno));
--- 6270,6296 ----
  		exit(1);
  	}
  
! 	/*
! 	 * First, read only the size word.
! 	 */
! 	if (fread(&param_size, sizeof(Size), 1, fp) != 1)
! 	{
! 		write_stderr("could not read from backend variables file \"%s\": %s\n",
! 					 id, strerror(errno));
! 		exit(1);
! 	}
! 	/* At least one stream should be there. */
! 	Assert(param_size > offsetof(BackendParameters, log_streams));
! 
! 	param = (BackendParameters *) palloc(param_size);
! 	/* The size is needed here just for the sake of completeness. */
! 	param->size = param_size;
! 
! 	/*
! 	 * Now read the rest.
! 	 */
! 	off = offsetof(BackendParameters, port);
! 	if (fread((char *) param + off, param_size - off, 1, fp) != 1)
  	{
  		write_stderr("could not read from backend variables file \"%s\": %s\n",
  					 id, strerror(errno));
*************** read_backend_variables(char *id, Port *p
*** 6169,6175 ****
  		exit(1);
  	}
  
! 	memcpy(&param, paramp, sizeof(BackendParameters));
  
  	if (!UnmapViewOfFile(paramp))
  	{
--- 6323,6330 ----
  		exit(1);
  	}
  
! 	param = (BackendParameters *) palloc(paramp->size);
! 	memcpy(&param, paramp, paramp->size);
  
  	if (!UnmapViewOfFile(paramp))
  	{
*************** read_backend_variables(char *id, Port *p
*** 6186,6198 ****
  	}
  #endif
  
! 	restore_backend_variables(&param, port);
  }
  
  /* Restore critical backend variables from the BackendParameters struct */
  static void
  restore_backend_variables(BackendParameters *param, Port *port)
  {
  	memcpy(port, &param->port, sizeof(Port));
  	read_inheritable_socket(&port->sock, &param->portsocket);
  
--- 6341,6360 ----
  	}
  #endif
  
! 	restore_backend_variables(param, port);
! 
! 	pfree(param);
  }
  
  /* Restore critical backend variables from the BackendParameters struct */
  static void
  restore_backend_variables(BackendParameters *param, Port *port)
  {
+ 	int			i;
+ 	LogStreamFlat *flat = NULL;
+ 	Size		flat_size_max = 0;
+ 	char	   *cur;
+ 
  	memcpy(port, &param->port, sizeof(Port));
  	read_inheritable_socket(&port->sock, &param->portsocket);
  
*************** restore_backend_variables(BackendParamet
*** 6249,6254 ****
--- 6411,6494 ----
  	strlcpy(pkglib_path, param->pkglib_path, MAXPGPATH);
  
  	strlcpy(ExtraOptions, param->ExtraOptions, MAXPGPATH);
+ 
+ 	cur = param->log_streams;
+ 	for (i = 0; i < param->nlogstreams; i++)
+ 	{
+ 		Size		flat_size;
+ 		LogStream  *stream;
+ 
+ 		/* First, read the size word. */
+ 		memcpy(&flat_size, cur, sizeof(Size));
+ 
+ 		/* Make sure we have enough space. */
+ 		if (flat_size_max == 0)
+ 		{
+ 			/* First time through? */
+ 			Assert(flat == NULL);
+ 			flat = (LogStreamFlat *) palloc(flat_size);
+ 			flat_size_max = flat_size;
+ 		}
+ 		else if (flat_size > flat_size_max)
+ 		{
+ 			/* New maximum size? */
+ 			Assert(flat != NULL);
+ 			flat = (LogStreamFlat *) repalloc(flat, flat_size);
+ 			flat_size_max = flat_size;
+ 		}
+ 
+ 		/* Copy the data into an aligned address so we can access it. */
+ 		memcpy(flat, cur, flat_size);
+ 
+ 		/*
+ 		 * Copy the data into the regular LogStream instance.
+ 		 */
+ 		stream = &log_streams[i];
+ 		memset(stream, 0, sizeof(LogStream));
+ 		stream->syslog_fd = flat->syslog_fd;
+ 
+ 		/*
+ 		 * As for the core stream, backend will read the settings as any other
+ 		 * GUCs.
+ 		 */
+ 		if (i > 0)
+ 		{
+ 			stream->verbosity = flat->verbosity;
+ 			stream->destination = flat->destination;
+ 			stream->id = pstrdup(flat->id);
+ 			stream->filename = pstrdup(flat->filename);
+ 			if (strlen(flat->directory) > 0)
+ 				stream->directory = pstrdup(flat->directory);
+ 			stream->file_mode = flat->file_mode;
+ 			stream->rotation_age = flat->rotation_age;
+ 			stream->rotation_size = flat->rotation_size;
+ 			stream->truncate_on_rotation = flat->truncate_on_rotation;
+ 
+ 			if (strlen(flat->line_prefix) > 0)
+ 				stream->line_prefix = pstrdup(flat->line_prefix);
+ 		}
+ 
+ 		cur += flat_size;
+ 	}
+ 	log_streams_active = param->nlogstreams;
+ 
+ 	/*
+ 	 * SubPostmasterMain() will call process_shared_preload_libraries().  We
+ 	 * don't want get_log_stream to be called again and re-initialize the
+ 	 * existing streams.
+ 	 *
+ 	 * One problem is that there's no guarantee that extensions would receive
+ 	 * the same log stream ids: we should not expect that the same set of
+ 	 * libraries will be loaded as the set loaded earlier by postmaster, not
+ 	 * to mention the loading order. Besides that, the only way to receive
+ 	 * valid syslog_fd of particular LogStream needs is to receive it from
+ 	 * postmaster.
+ 	 */
+ 	log_streams_initialized = true;
+ 
+ 	/* At least one (the core) stream should always exist. */
+ 	Assert(flat != NULL);
+ 	pfree(flat);
  }
  
  
diff --git a/src/backend/postmaster/syslogger.c b/src/backend/postmaster/syslogger.c
new file mode 100644
index 3255b42..93c23df
*** a/src/backend/postmaster/syslogger.c
--- b/src/backend/postmaster/syslogger.c
***************
*** 45,50 ****
--- 45,51 ----
  #include "storage/latch.h"
  #include "storage/pg_shmem.h"
  #include "utils/guc.h"
+ #include "utils/memutils.h"
  #include "utils/ps_status.h"
  #include "utils/timestamp.h"
  
***************
*** 55,72 ****
   */
  #define READ_BUF_SIZE (2 * PIPE_CHUNK_SIZE)
  
- 
  /*
   * GUC parameters.  Logging_collector cannot be changed after postmaster
   * start, but the rest can change at SIGHUP.
   */
  bool		Logging_collector = false;
- int			Log_RotationAge = HOURS_PER_DAY * MINS_PER_HOUR;
- int			Log_RotationSize = 10 * 1024;
- char	   *Log_directory = NULL;
- char	   *Log_filename = NULL;
- bool		Log_truncate_on_rotation = false;
- int			Log_file_mode = S_IRUSR | S_IWUSR;
  
  /*
   * Globally visible state (used by elog.c)
--- 56,66 ----
*************** extern bool redirection_done;
*** 78,91 ****
  /*
   * Private state
   */
! static pg_time_t next_rotation_time;
  static bool pipe_eof_seen = false;
  static bool rotation_disabled = false;
! static FILE *syslogFile = NULL;
! static FILE *csvlogFile = NULL;
! NON_EXEC_STATIC pg_time_t first_syslogger_file_time = 0;
! static char *last_file_name = NULL;
! static char *last_csv_file_name = NULL;
  
  /*
   * Buffers for saving partial messages from different backends.
--- 72,86 ----
  /*
   * Private state
   */
! 
  static bool pipe_eof_seen = false;
  static bool rotation_disabled = false;
! NON_EXEC_STATIC pg_time_t first_syslogger_file_time;
! 
! LogStream	log_streams[MAXLOGSTREAMS];
! 
! /* At least the core log stream should be active. */
! int			log_streams_active = 1;
  
  /*
   * Buffers for saving partial messages from different backends.
*************** static char *last_csv_file_name = NULL;
*** 95,106 ****
--- 90,104 ----
   * the number of entries we have to examine for any one incoming message.
   * There must never be more than one entry for the same source pid.
   *
+  * stream_id is needed because of flush_pipe_input.
+  *
   * An inactive buffer is not removed from its list, just held for re-use.
   * An inactive buffer has pid == 0 and undefined contents of data.
   */
  typedef struct
  {
  	int32		pid;			/* PID of source process */
+ 	int32		stream_id;		/* Stream identifier. */
  	StringInfoData data;		/* accumulated data, as a StringInfo */
  } save_buffer;
  
*************** static CRITICAL_SECTION sysloggerSection
*** 123,151 ****
   * Flags set by interrupt handlers for later service in the main loop.
   */
  static volatile sig_atomic_t got_SIGHUP = false;
  static volatile sig_atomic_t rotation_requested = false;
  
  
  /* Local subroutines */
  #ifdef EXEC_BACKEND
  static pid_t syslogger_forkexec(void);
- static void syslogger_parseArgs(int argc, char *argv[]);
  #endif
  NON_EXEC_STATIC void SysLoggerMain(int argc, char *argv[]) pg_attribute_noreturn();
  static void process_pipe_input(char *logbuffer, int *bytes_in_logbuffer);
  static void flush_pipe_input(char *logbuffer, int *bytes_in_logbuffer);
! static void open_csvlogfile(void);
  static FILE *logfile_open(const char *filename, const char *mode,
! 			 bool allow_errors);
  
  #ifdef WIN32
  static unsigned int __stdcall pipeThread(void *arg);
  #endif
! static void logfile_rotate(bool time_based_rotation, int size_rotation_for);
! static char *logfile_getname(pg_time_t timestamp, const char *suffix);
! static void set_next_rotation_time(void);
  static void sigHupHandler(SIGNAL_ARGS);
  static void sigUsr1Handler(SIGNAL_ARGS);
  static void update_metainfo_datafile(void);
  
  
--- 121,153 ----
   * Flags set by interrupt handlers for later service in the main loop.
   */
  static volatile sig_atomic_t got_SIGHUP = false;
+ 
+ /* Rotation of all log requested by pg_rotate_logfile? */
  static volatile sig_atomic_t rotation_requested = false;
  
  
  /* Local subroutines */
  #ifdef EXEC_BACKEND
  static pid_t syslogger_forkexec(void);
  #endif
  NON_EXEC_STATIC void SysLoggerMain(int argc, char *argv[]) pg_attribute_noreturn();
  static void process_pipe_input(char *logbuffer, int *bytes_in_logbuffer);
  static void flush_pipe_input(char *logbuffer, int *bytes_in_logbuffer);
! static void open_csvlogfile(int stream_id);
  static FILE *logfile_open(const char *filename, const char *mode,
! 			 bool allow_errors, int stream_id);
  
  #ifdef WIN32
  static unsigned int __stdcall pipeThread(void *arg);
  #endif
! static void logfile_rotate(bool time_based_rotation, int size_rotation_for,
! 			   int stream_id);
! static char *logfile_getname(pg_time_t timestamp, const char *suffix,
! 				int stream_id);
! static void set_next_rotation_time(int stream_id);
  static void sigHupHandler(SIGNAL_ARGS);
  static void sigUsr1Handler(SIGNAL_ARGS);
+ 
  static void update_metainfo_datafile(void);
  
  
*************** SysLoggerMain(int argc, char *argv[])
*** 160,174 ****
  	char		logbuffer[READ_BUF_SIZE];
  	int			bytes_in_logbuffer = 0;
  #endif
- 	char	   *currentLogDir;
- 	char	   *currentLogFilename;
- 	int			currentLogRotationAge;
  	pg_time_t	now;
  
  	now = MyStartTime;
  
  #ifdef EXEC_BACKEND
! 	syslogger_parseArgs(argc, argv);
  #endif							/* EXEC_BACKEND */
  
  	am_syslogger = true;
--- 162,213 ----
  	char		logbuffer[READ_BUF_SIZE];
  	int			bytes_in_logbuffer = 0;
  #endif
  	pg_time_t	now;
+ 	int			i;
+ 	bool		timeout_valid;
  
  	now = MyStartTime;
  
+ 	/*
+ 	 * Initialize configuration parameters and status info.
+ 	 *
+ 	 * XXX Should we only do this for log_stream[0]? get_log_stream() does so
+ 	 * for the extension streams.
+ 	 */
+ 	for (i = 0; i < log_streams_active; i++)
+ 	{
+ 		LogStream  *stream = &log_streams[i];
+ 
+ 		stream->csvlog_file = NULL;
+ 		stream->rotation_needed = false;
+ 		stream->last_file_name = NULL;
+ 		stream->last_csv_file_name = NULL;
+ 	}
+ 
  #ifdef EXEC_BACKEND
! 	for (i = 0; i < log_streams_active; i++)
! 	{
! 		LogStream  *stream = &log_streams[i];
! 		int			fd = stream->syslog_fd;
! 
! #ifndef WIN32
! 		if (fd != -1)
! 		{
! 			stream->syslog_file = fdopen(fd, "a");
! 			setvbuf(stream->syslog_file, NULL, PG_IOLBF, 0);
! 		}
! #else							/* WIN32 */
! 		if (fd != 0)
! 		{
! 			fd = _open_osfhandle(fd, _O_APPEND | _O_TEXT);
! 			if (fd > 0)
! 			{
! 				stream->syslog_file = fdopen(fd, "a");
! 				setvbuf(stream->syslog_file, NULL, PG_IOLBF, 0);
! 			}
! 		}
! #endif							/* WIN32 */
! 	}
  #endif							/* EXEC_BACKEND */
  
  	am_syslogger = true;
*************** SysLoggerMain(int argc, char *argv[])
*** 271,297 ****
  #endif							/* WIN32 */
  
  	/*
! 	 * Remember active logfile's name.  We recompute this from the reference
  	 * time because passing down just the pg_time_t is a lot cheaper than
  	 * passing a whole file path in the EXEC_BACKEND case.
  	 */
! 	last_file_name = logfile_getname(first_syslogger_file_time, NULL);
  
! 	/* remember active logfile parameters */
! 	currentLogDir = pstrdup(Log_directory);
! 	currentLogFilename = pstrdup(Log_filename);
! 	currentLogRotationAge = Log_RotationAge;
! 	/* set next planned rotation time */
! 	set_next_rotation_time();
  	update_metainfo_datafile();
  
  	/* main worker loop */
  	for (;;)
  	{
- 		bool		time_based_rotation = false;
- 		int			size_rotation_for = 0;
  		long		cur_timeout;
  		int			cur_flags;
  
  #ifndef WIN32
  		int			rc;
--- 310,342 ----
  #endif							/* WIN32 */
  
  	/*
! 	 * Remember active logfile names.  We recompute this from the reference
  	 * time because passing down just the pg_time_t is a lot cheaper than
  	 * passing a whole file path in the EXEC_BACKEND case.
  	 */
! 	for (i = 0; i < log_streams_active; i++)
! 	{
! 		LogStream  *stream = &log_streams[i];
  
! 		stream->last_file_name = logfile_getname(first_syslogger_file_time,
! 												 NULL, i);
! 
! 		/* remember active logfile parameters */
! 		stream->current_dir = pstrdup(stream->directory);
! 		stream->current_filename = pstrdup(stream->filename);
! 		stream->current_rotation_age = stream->rotation_age;
! 
! 		/* set next planned rotation time */
! 		set_next_rotation_time(i);
! 	}
  	update_metainfo_datafile();
  
  	/* main worker loop */
  	for (;;)
  	{
  		long		cur_timeout;
  		int			cur_flags;
+ 		int			i;
  
  #ifndef WIN32
  		int			rc;
*************** SysLoggerMain(int argc, char *argv[])
*** 308,344 ****
  			got_SIGHUP = false;
  			ProcessConfigFile(PGC_SIGHUP);
  
! 			/*
! 			 * Check if the log directory or filename pattern changed in
! 			 * postgresql.conf. If so, force rotation to make sure we're
! 			 * writing the logfiles in the right place.
! 			 */
! 			if (strcmp(Log_directory, currentLogDir) != 0)
  			{
! 				pfree(currentLogDir);
! 				currentLogDir = pstrdup(Log_directory);
! 				rotation_requested = true;
  
  				/*
! 				 * Also, create new directory if not present; ignore errors
  				 */
! 				mkdir(Log_directory, S_IRWXU);
! 			}
! 			if (strcmp(Log_filename, currentLogFilename) != 0)
! 			{
! 				pfree(currentLogFilename);
! 				currentLogFilename = pstrdup(Log_filename);
! 				rotation_requested = true;
! 			}
  
! 			/*
! 			 * If rotation time parameter changed, reset next rotation time,
! 			 * but don't immediately force a rotation.
! 			 */
! 			if (currentLogRotationAge != Log_RotationAge)
! 			{
! 				currentLogRotationAge = Log_RotationAge;
! 				set_next_rotation_time();
  			}
  
  			/*
--- 353,395 ----
  			got_SIGHUP = false;
  			ProcessConfigFile(PGC_SIGHUP);
  
! 			for (i = 0; i < log_streams_active; i++)
  			{
! 				LogStream  *stream = &log_streams[i];
  
  				/*
! 				 * Check if the log directory or filename pattern changed in
! 				 * postgresql.conf. If so, force rotation to make sure we're
! 				 * writing the logfiles in the right place.
  				 */
! 				if (strcmp(stream->directory, stream->current_dir) != 0)
! 				{
! 					pfree(stream->current_dir);
! 					stream->current_dir = pstrdup(stream->directory);
! 					stream->rotation_needed = true;
  
! 					/*
! 					 * Also, create new directory if not present; ignore
! 					 * errors
! 					 */
! 					mkdir(stream->directory, S_IRWXU);
! 				}
! 				if (strcmp(stream->filename, stream->current_filename) != 0)
! 				{
! 					pfree(stream->current_filename);
! 					stream->current_filename = pstrdup(stream->filename);
! 					stream->rotation_needed = true;
! 				}
! 
! 				/*
! 				 * If rotation time parameter changed, reset next rotation
! 				 * time, but don't immediately force a rotation.
! 				 */
! 				if (stream->current_rotation_age != stream->rotation_age)
! 				{
! 					stream->current_rotation_age = stream->rotation_age;
! 					set_next_rotation_time(i);
! 				}
  			}
  
  			/*
*************** SysLoggerMain(int argc, char *argv[])
*** 359,397 ****
  			update_metainfo_datafile();
  		}
  
! 		if (Log_RotationAge > 0 && !rotation_disabled)
  		{
! 			/* Do a logfile rotation if it's time */
! 			now = (pg_time_t) time(NULL);
! 			if (now >= next_rotation_time)
! 				rotation_requested = time_based_rotation = true;
! 		}
  
! 		if (!rotation_requested && Log_RotationSize > 0 && !rotation_disabled)
! 		{
! 			/* Do a rotation if file is too big */
! 			if (ftell(syslogFile) >= Log_RotationSize * 1024L)
  			{
! 				rotation_requested = true;
! 				size_rotation_for |= LOG_DESTINATION_STDERR;
  			}
! 			if (csvlogFile != NULL &&
! 				ftell(csvlogFile) >= Log_RotationSize * 1024L)
  			{
! 				rotation_requested = true;
! 				size_rotation_for |= LOG_DESTINATION_CSVLOG;
  			}
- 		}
  
- 		if (rotation_requested)
- 		{
  			/*
! 			 * Force rotation when both values are zero. It means the request
! 			 * was sent by pg_rotate_logfile.
  			 */
! 			if (!time_based_rotation && size_rotation_for == 0)
! 				size_rotation_for = LOG_DESTINATION_STDERR | LOG_DESTINATION_CSVLOG;
! 			logfile_rotate(time_based_rotation, size_rotation_for);
  		}
  
  		/*
--- 410,461 ----
  			update_metainfo_datafile();
  		}
  
! 		for (i = 0; i < log_streams_active; i++)
  		{
! 			bool		time_based_rotation = false;
! 			int			size_rotation_for = 0;
! 			LogStream  *stream = &log_streams[i];
  
! 			if (stream->current_rotation_age > 0 && !rotation_disabled)
  			{
! 				/* Do a logfile rotation if it's time */
! 				now = (pg_time_t) time(NULL);
! 				if (now >= stream->next_rotation_time)
! 					stream->rotation_needed = time_based_rotation = true;
  			}
! 
! 			if (!rotation_requested && !stream->rotation_needed &&
! 				stream->rotation_size > 0 && !rotation_disabled)
  			{
! 				/* Do a rotation if file is too big */
! 				if (ftell(stream->syslog_file) >=
! 					stream->rotation_size * 1024L)
! 				{
! 					stream->rotation_needed = true;
! 					size_rotation_for |= LOG_DESTINATION_STDERR;
! 				}
! 				if (stream->csvlog_file != NULL &&
! 					ftell(stream->csvlog_file) >=
! 					stream->rotation_size * 1024L)
! 				{
! 					stream->rotation_needed = true;
! 					size_rotation_for |= LOG_DESTINATION_CSVLOG;
! 				}
  			}
  
  			/*
! 			 * Consider rotation if the current file needs it or if rotation
! 			 * of all files has been requested explicitly.
  			 */
! 			if (stream->rotation_needed || rotation_requested)
! 			{
! 				/*
! 				 * Force rotation if it's requested by pg_rotate_logfile.
! 				 */
! 				if (rotation_requested)
! 					size_rotation_for = LOG_DESTINATION_STDERR | LOG_DESTINATION_CSVLOG;
! 				logfile_rotate(time_based_rotation, size_rotation_for, i);
! 			}
  		}
  
  		/*
*************** SysLoggerMain(int argc, char *argv[])
*** 402,428 ****
  		 * next_rotation_time.
  		 *
  		 * Also note that we need to beware of overflow in calculation of the
! 		 * timeout: with large settings of Log_RotationAge, next_rotation_time
! 		 * could be more than INT_MAX msec in the future.  In that case we'll
! 		 * wait no more than INT_MAX msec, and try again.
  		 */
! 		if (Log_RotationAge > 0 && !rotation_disabled)
  		{
! 			pg_time_t	delay;
  
! 			delay = next_rotation_time - now;
! 			if (delay > 0)
  			{
! 				if (delay > INT_MAX / 1000)
! 					delay = INT_MAX / 1000;
! 				cur_timeout = delay * 1000L;	/* msec */
  			}
! 			else
! 				cur_timeout = 0;
! 			cur_flags = WL_TIMEOUT;
  		}
  		else
  		{
  			cur_timeout = -1L;
  			cur_flags = 0;
  		}
--- 466,516 ----
  		 * next_rotation_time.
  		 *
  		 * Also note that we need to beware of overflow in calculation of the
! 		 * timeout: with large settings of current_rotation_age,
! 		 * next_rotation_time could be more than INT_MAX msec in the future.
! 		 * In that case we'll wait no more than INT_MAX msec, and try again.
  		 */
! 		timeout_valid = false;
! 		for (i = 0; i < log_streams_active; i++)
  		{
! 			LogStream  *stream = &log_streams[i];
  
! 			if (stream->current_rotation_age > 0 && !rotation_disabled)
  			{
! 				pg_time_t	delay;
! 				long		timeout_tmp;
! 
! 				delay = stream->next_rotation_time - now;
! 				if (delay > 0)
! 				{
! 					if (delay > INT_MAX / 1000)
! 						delay = INT_MAX / 1000;
! 					timeout_tmp = delay * 1000L;	/* msec */
! 				}
! 				else
! 					timeout_tmp = 0;
! 
! 				/* Looking for the nearest timeout across log files. */
! 				if (!timeout_valid)
! 				{
! 					/* cur_timeout not defined yet. */
! 					cur_timeout = timeout_tmp;
! 					timeout_valid = true;
! 				}
! 				else
! 					cur_timeout = Min(cur_timeout, timeout_tmp);
  			}
! 
  		}
+ 
+ 		if (timeout_valid)
+ 			cur_flags = WL_TIMEOUT;
  		else
  		{
+ 			/*
+ 			 * No file will need rotation, so wait until data can be read from
+ 			 * the pipe.
+ 			 */
  			cur_timeout = -1L;
  			cur_flags = 0;
  		}
*************** SysLoggerMain(int argc, char *argv[])
*** 503,510 ****
  
  			/*
  			 * Normal exit from the syslogger is here.  Note that we
! 			 * deliberately do not close syslogFile before exiting; this is to
! 			 * allow for the possibility of elog messages being generated
  			 * inside proc_exit.  Regular exit() will take care of flushing
  			 * and closing stdio channels.
  			 */
--- 591,598 ----
  
  			/*
  			 * Normal exit from the syslogger is here.  Note that we
! 			 * deliberately do not close syslog_file before exiting; this is
! 			 * to allow for the possibility of elog messages being generated
  			 * inside proc_exit.  Regular exit() will take care of flushing
  			 * and closing stdio channels.
  			 */
*************** int
*** 520,526 ****
  SysLogger_Start(void)
  {
  	pid_t		sysloggerPid;
! 	char	   *filename;
  
  	if (!Logging_collector)
  		return 0;
--- 608,615 ----
  SysLogger_Start(void)
  {
  	pid_t		sysloggerPid;
! 	int			i;
! 	LogStream  *stream;
  
  	if (!Logging_collector)
  		return 0;
*************** SysLogger_Start(void)
*** 562,589 ****
  #endif
  
  	/*
! 	 * Create log directory if not present; ignore errors
  	 */
! 	mkdir(Log_directory, S_IRWXU);
  
  	/*
  	 * The initial logfile is created right in the postmaster, to verify that
! 	 * the Log_directory is writable.  We save the reference time so that the
  	 * syslogger child process can recompute this file name.
  	 *
  	 * It might look a bit strange to re-do this during a syslogger restart,
! 	 * but we must do so since the postmaster closed syslogFile after the
  	 * previous fork (and remembering that old file wouldn't be right anyway).
  	 * Note we always append here, we won't overwrite any existing file.  This
  	 * is consistent with the normal rules, because by definition this is not
  	 * a time-based rotation.
  	 */
  	first_syslogger_file_time = time(NULL);
! 	filename = logfile_getname(first_syslogger_file_time, NULL);
! 
! 	syslogFile = logfile_open(filename, "a", false);
  
! 	pfree(filename);
  
  #ifdef EXEC_BACKEND
  	switch ((sysloggerPid = syslogger_forkexec()))
--- 651,697 ----
  #endif
  
  	/*
! 	 * Although we can't check here if the streams are initialized in a
! 	 * sensible way, check at least if user (typically extension) messed any
! 	 * setting up.
  	 */
! 	for (i = 0; i < log_streams_active; i++)
! 	{
! 		stream = &log_streams[i];
! 		if (stream->directory == NULL || stream->filename == NULL ||
! 			stream->rotation_age == 0 || stream->rotation_size == 0)
! 			ereport(FATAL,
! 					(errmsg("Log stream %d is not properly initialized", i)));
! 	}
! 
! 	/*
! 	 * Create log directories if not present; ignore errors
! 	 */
! 	for (i = 0; i < log_streams_active; i++)
! 		mkdir(log_streams[i].directory, S_IRWXU);
  
  	/*
  	 * The initial logfile is created right in the postmaster, to verify that
! 	 * the log directory is writable.  We save the reference time so that the
  	 * syslogger child process can recompute this file name.
  	 *
  	 * It might look a bit strange to re-do this during a syslogger restart,
! 	 * but we must do so since the postmaster closed syslog_file after the
  	 * previous fork (and remembering that old file wouldn't be right anyway).
  	 * Note we always append here, we won't overwrite any existing file.  This
  	 * is consistent with the normal rules, because by definition this is not
  	 * a time-based rotation.
  	 */
  	first_syslogger_file_time = time(NULL);
! 	for (i = 0; i < log_streams_active; i++)
! 	{
! 		char	   *filename;
  
! 		stream = &log_streams[i];
! 		filename = logfile_getname(first_syslogger_file_time, NULL, i);
! 		stream->syslog_file = logfile_open(filename, "a", false, i);
! 		pfree(filename);
! 	}
  
  #ifdef EXEC_BACKEND
  	switch ((sysloggerPid = syslogger_forkexec()))
*************** SysLogger_Start(void)
*** 627,637 ****
  				 * Leave a breadcrumb trail when redirecting, in case the user
  				 * forgets that redirection is active and looks only at the
  				 * original stderr target file.
  				 */
  				ereport(LOG,
  						(errmsg("redirecting log output to logging collector process"),
  						 errhint("Future log output will appear in directory \"%s\".",
! 								 Log_directory)));
  
  #ifndef WIN32
  				fflush(stdout);
--- 735,748 ----
  				 * Leave a breadcrumb trail when redirecting, in case the user
  				 * forgets that redirection is active and looks only at the
  				 * original stderr target file.
+ 				 *
+ 				 * TODO Also list the extension log directories if there are
+ 				 * some?
  				 */
  				ereport(LOG,
  						(errmsg("redirecting log output to logging collector process"),
  						 errhint("Future log output will appear in directory \"%s\".",
! 								 log_streams[0].directory)));
  
  #ifndef WIN32
  				fflush(stdout);
*************** SysLogger_Start(void)
*** 674,682 ****
  				redirection_done = true;
  			}
  
! 			/* postmaster will never write the file; close it */
! 			fclose(syslogFile);
! 			syslogFile = NULL;
  			return (int) sysloggerPid;
  	}
  
--- 785,798 ----
  				redirection_done = true;
  			}
  
! 			/* postmaster will never write the files; close them */
! 			for (i = 0; i < log_streams_active; i++)
! 			{
! 				LogStream  *stream = &log_streams[i];
! 
! 				fclose(stream->syslog_file);
! 				stream->syslog_file = NULL;
! 			}
  			return (int) sysloggerPid;
  	}
  
*************** syslogger_forkexec(void)
*** 697,762 ****
  {
  	char	   *av[10];
  	int			ac = 0;
! 	char		filenobuf[32];
  
  	av[ac++] = "postgres";
  	av[ac++] = "--forklog";
  	av[ac++] = NULL;			/* filled in by postmaster_forkexec */
- 
- 	/* static variables (those not passed by write_backend_variables) */
- #ifndef WIN32
- 	if (syslogFile != NULL)
- 		snprintf(filenobuf, sizeof(filenobuf), "%d",
- 				 fileno(syslogFile));
- 	else
- 		strcpy(filenobuf, "-1");
- #else							/* WIN32 */
- 	if (syslogFile != NULL)
- 		snprintf(filenobuf, sizeof(filenobuf), "%ld",
- 				 (long) _get_osfhandle(_fileno(syslogFile)));
- 	else
- 		strcpy(filenobuf, "0");
- #endif							/* WIN32 */
- 	av[ac++] = filenobuf;
- 
  	av[ac] = NULL;
  	Assert(ac < lengthof(av));
  
! 	return postmaster_forkexec(ac, av);
! }
! 
! /*
!  * syslogger_parseArgs() -
!  *
!  * Extract data from the arglist for exec'ed syslogger process
!  */
! static void
! syslogger_parseArgs(int argc, char *argv[])
! {
! 	int			fd;
! 
! 	Assert(argc == 4);
! 	argv += 3;
  
  #ifndef WIN32
! 	fd = atoi(*argv++);
! 	if (fd != -1)
! 	{
! 		syslogFile = fdopen(fd, "a");
! 		setvbuf(syslogFile, NULL, PG_IOLBF, 0);
! 	}
  #else							/* WIN32 */
! 	fd = atoi(*argv++);
! 	if (fd != 0)
! 	{
! 		fd = _open_osfhandle(fd, _O_APPEND | _O_TEXT);
! 		if (fd > 0)
! 		{
! 			syslogFile = fdopen(fd, "a");
! 			setvbuf(syslogFile, NULL, PG_IOLBF, 0);
! 		}
! 	}
  #endif							/* WIN32 */
  }
  #endif							/* EXEC_BACKEND */
  
--- 813,845 ----
  {
  	char	   *av[10];
  	int			ac = 0;
! 	int			i;
  
  	av[ac++] = "postgres";
  	av[ac++] = "--forklog";
  	av[ac++] = NULL;			/* filled in by postmaster_forkexec */
  	av[ac] = NULL;
  	Assert(ac < lengthof(av));
  
! 	for (i = 0; i < log_streams_active; i++)
! 	{
! 		LogStream  *stream = &log_streams[i];
  
  #ifndef WIN32
! 		if (stream->syslog_file != NULL)
! 			stream->syslog_fd = fileno(stream->syslog_file);
! 		else
! 			stream->syslog_fd = -1;
  #else							/* WIN32 */
! 		if (syslog_file != NULL)
! 			stream->syslog_fd = (long)
! 				_get_osfhandle(_fileno(stream->syslog_file));
! 		else
! 			stream->syslog_fd = 0;
  #endif							/* WIN32 */
+ 	}
+ 
+ 	return postmaster_forkexec(ac, av);
  }
  #endif							/* EXEC_BACKEND */
  
*************** syslogger_parseArgs(int argc, char *argv
*** 773,786 ****
   * (hopefully atomic) chunks - such chunks are detected and reassembled here.
   *
   * The protocol has a header that starts with two nul bytes, then has a 16 bit
!  * length, the pid of the sending process, and a flag to indicate if it is
!  * the last chunk in a message. Incomplete chunks are saved until we read some
!  * more, and non-final chunks are accumulated until we get the final chunk.
   *
   * All of this is to avoid 2 problems:
   * . partial messages being written to logfiles (messes rotation), and
   * . messages from different backends being interleaved (messages garbled).
   *
   * Any non-protocol messages are written out directly. These should only come
   * from non-PostgreSQL sources, however (e.g. third party libraries writing to
   * stderr).
--- 856,874 ----
   * (hopefully atomic) chunks - such chunks are detected and reassembled here.
   *
   * The protocol has a header that starts with two nul bytes, then has a 16 bit
!  * length, the pid of the sending process, stream identifier, and a flag to
!  * indicate if it is the last chunk in a message. Incomplete chunks are saved
!  * until we read some more, and non-final chunks are accumulated until we get
!  * the final chunk.
   *
   * All of this is to avoid 2 problems:
   * . partial messages being written to logfiles (messes rotation), and
   * . messages from different backends being interleaved (messages garbled).
   *
+  * The stream identifier is in the header to ensure correct routing into log
+  * files, however message chunks of different streams sent by the same backend
+  * are not expected to be interleaved.
+  *
   * Any non-protocol messages are written out directly. These should only come
   * from non-PostgreSQL sources, however (e.g. third party libraries writing to
   * stderr).
*************** process_pipe_input(char *logbuffer, int
*** 807,812 ****
--- 895,901 ----
  		if (p.nuls[0] == '\0' && p.nuls[1] == '\0' &&
  			p.len > 0 && p.len <= PIPE_MAX_PAYLOAD &&
  			p.pid != 0 &&
+ 			p.stream_id >= 0 && p.stream_id < MAXLOGSTREAMS &&
  			(p.is_last == 't' || p.is_last == 'f' ||
  			 p.is_last == 'T' || p.is_last == 'F'))
  		{
*************** process_pipe_input(char *logbuffer, int
*** 867,872 ****
--- 956,962 ----
  						buffer_lists[p.pid % NBUFFER_LISTS] = buffer_list;
  					}
  					free_slot->pid = p.pid;
+ 					free_slot->stream_id = p.stream_id;
  					str = &(free_slot->data);
  					initStringInfo(str);
  					appendBinaryStringInfo(str,
*************** process_pipe_input(char *logbuffer, int
*** 886,892 ****
  					appendBinaryStringInfo(str,
  										   cursor + PIPE_HEADER_SIZE,
  										   p.len);
! 					write_syslogger_file(str->data, str->len, dest);
  					/* Mark the buffer unused, and reclaim string storage */
  					existing_slot->pid = 0;
  					pfree(str->data);
--- 976,983 ----
  					appendBinaryStringInfo(str,
  										   cursor + PIPE_HEADER_SIZE,
  										   p.len);
! 					write_syslogger_file(str->data, str->len, dest,
! 										 existing_slot->stream_id);
  					/* Mark the buffer unused, and reclaim string storage */
  					existing_slot->pid = 0;
  					pfree(str->data);
*************** process_pipe_input(char *logbuffer, int
*** 895,901 ****
  				{
  					/* The whole message was one chunk, evidently. */
  					write_syslogger_file(cursor + PIPE_HEADER_SIZE, p.len,
! 										 dest);
  				}
  			}
  
--- 986,992 ----
  				{
  					/* The whole message was one chunk, evidently. */
  					write_syslogger_file(cursor + PIPE_HEADER_SIZE, p.len,
! 										 dest, p.stream_id);
  				}
  			}
  
*************** process_pipe_input(char *logbuffer, int
*** 922,928 ****
  					break;
  			}
  			/* fall back on the stderr log as the destination */
! 			write_syslogger_file(cursor, chunklen, LOG_DESTINATION_STDERR);
  			cursor += chunklen;
  			count -= chunklen;
  		}
--- 1013,1019 ----
  					break;
  			}
  			/* fall back on the stderr log as the destination */
! 			write_syslogger_file(cursor, chunklen, LOG_DESTINATION_STDERR, 0);
  			cursor += chunklen;
  			count -= chunklen;
  		}
*************** flush_pipe_input(char *logbuffer, int *b
*** 960,966 ****
  				StringInfo	str = &(buf->data);
  
  				write_syslogger_file(str->data, str->len,
! 									 LOG_DESTINATION_STDERR);
  				/* Mark the buffer unused, and reclaim string storage */
  				buf->pid = 0;
  				pfree(str->data);
--- 1051,1057 ----
  				StringInfo	str = &(buf->data);
  
  				write_syslogger_file(str->data, str->len,
! 									 LOG_DESTINATION_STDERR, buf->stream_id);
  				/* Mark the buffer unused, and reclaim string storage */
  				buf->pid = 0;
  				pfree(str->data);
*************** flush_pipe_input(char *logbuffer, int *b
*** 974,984 ****
  	 */
  	if (*bytes_in_logbuffer > 0)
  		write_syslogger_file(logbuffer, *bytes_in_logbuffer,
! 							 LOG_DESTINATION_STDERR);
  	*bytes_in_logbuffer = 0;
  }
  
- 
  /* --------------------------------
   *		logfile routines
   * --------------------------------
--- 1065,1074 ----
  	 */
  	if (*bytes_in_logbuffer > 0)
  		write_syslogger_file(logbuffer, *bytes_in_logbuffer,
! 							 LOG_DESTINATION_STDERR, 0);
  	*bytes_in_logbuffer = 0;
  }
  
  /* --------------------------------
   *		logfile routines
   * --------------------------------
*************** flush_pipe_input(char *logbuffer, int *b
*** 992,1006 ****
   * even though its stderr does not point at the syslog pipe.
   */
  void
! write_syslogger_file(const char *buffer, int count, int destination)
  {
  	int			rc;
  	FILE	   *logfile;
  
! 	if (destination == LOG_DESTINATION_CSVLOG && csvlogFile == NULL)
! 		open_csvlogfile();
  
! 	logfile = destination == LOG_DESTINATION_CSVLOG ? csvlogFile : syslogFile;
  	rc = fwrite(buffer, 1, count, logfile);
  
  	/* can't use ereport here because of possible recursion */
--- 1082,1099 ----
   * even though its stderr does not point at the syslog pipe.
   */
  void
! write_syslogger_file(const char *buffer, int count, int destination,
! 					 int stream_id)
  {
  	int			rc;
  	FILE	   *logfile;
+ 	LogStream  *stream = &log_streams[stream_id];
  
! 	if (destination == LOG_DESTINATION_CSVLOG && stream->csvlog_file == NULL)
! 		open_csvlogfile(stream_id);
  
! 	logfile = destination == LOG_DESTINATION_CSVLOG ? stream->csvlog_file :
! 		stream->syslog_file;
  	rc = fwrite(buffer, 1, count, logfile);
  
  	/* can't use ereport here because of possible recursion */
*************** write_syslogger_file(const char *buffer,
*** 1008,1013 ****
--- 1101,1223 ----
  		write_stderr("could not write to log file: %s\n", strerror(errno));
  }
  
+ /*
+  * Extensions can use this function to write their output to separate log
+  * files. The value returned is to be used as an argument in the errstream()
+  * function, for example:
+  *
+  * ereport(ERROR,
+  *				(errcode(ERRCODE_UNDEFINED_CURSOR),
+  *				 errmsg("portal \"%s\" not found", stmt->portalname),
+  *				 errstream(stream_id),
+  *				 ... other errxxx() fields as needed ...));
+  *
+  * Caller is expected to pass a pointer to which the function writes a pointer
+  * to LogStream structure, which is pre-initialized according to the core log
+  * stream. Caller is expected to ensure that the log file path is eventually
+  * different from that of the postgres core log.
+  *
+  * CAUTION: Use adjust_log_stream_attr() to set string attributes of the log
+  * stream, as opposed to assigning arbitrary (char *) pointers directly.
+  *
+  * Note: The "id" argument is necessary so that repeated call of the function
+  * from the same library makes no harm. The particular scenario is that shared
+  * library can be re-loaded during child process startup due to EXEC_BACKEND
+  * technique. Once we have the identifier, we can use it to make error
+  * messages more convenient.
+  *
+  * XXX Do we need a function that validates the log stream after changes are
+  * done? Probably not, as shared library developer should know what he is
+  * doing.
+  */
+ extern int
+ get_log_stream(char *id, LogStream **stream_p)
+ {
+ 	int			result = -1;
+ 	LogStream  *stream,
+ 			   *stream_core;
+ 	int			i;
+ 
+ 	if (!process_shared_preload_libraries_in_progress)
+ 		ereport(ERROR,
+ 				(errmsg("get_log_stream() can only be called during shared "
+ 						"library preload"),
+ 				 errhint("Please check if your extension library is in "
+ 						 "\"shared_preload_libraries\"")));
+ 
+ 	if (log_streams_active >= MAXLOGSTREAMS)
+ 		ereport(ERROR,
+ 				(errmsg("The maximum number of log streams exceeded")));
+ 
+ 	if (id == NULL || strlen(id) == 0)
+ 		ereport(ERROR, (errmsg("stream id must be a non-empty string.")));
+ 
+ 	/*
+ 	 * The function is called twice in the EXEC_BACKEND case.
+ 	 */
+ #ifdef EXEC_BACKEND
+ 	if (log_streams_initialized)
+ 	{
+ 		/*
+ 		 * If 2nd time here, only find the existing id among the extension
+ 		 * streams.
+ 		 */
+ 		Assert(log_streams_active >= 1);
+ 		for (i = 1; i < log_streams_active; i++)
+ 		{
+ 			LogStream  *stream = &log_streams[i];
+ 
+ 			if (strcmp(id, stream->id) == 0)
+ 			{
+ 				result = i;
+ 				break;
+ 			}
+ 		}
+ 		Assert(result >= 0);
+ 		*stream_p = &log_streams[result];
+ 		return result;
+ 	}
+ #endif
+ 
+ 	/*
+ 	 * Make sure the id is unique. (The core stream is not supposed to have
+ 	 * id.)
+ 	 */
+ 	for (i = 1; i < log_streams_active; i++)
+ 	{
+ 		LogStream  *stream = &log_streams[i];
+ 
+ 		if (strcmp(id, stream->id))
+ 			ereport(ERROR, (errmsg("\"%s\" stream already exists", id)));
+ 	}
+ 
+ 	result = log_streams_active++;
+ 	stream = &log_streams[result];
+ 	memset(stream, 0, sizeof(LogStream));
+ 
+ 	/*
+ 	 * Set the default values.
+ 	 *
+ 	 * Duplicate the strings so that GUC does not break anything if it frees
+ 	 * the core values.
+ 	 */
+ 	stream_core = &log_streams[0];
+ 	stream->verbosity = stream_core->verbosity;
+ 	stream->destination = stream_core->destination;
+ 	adjust_log_stream_attr(&stream->id, id);
+ 	adjust_log_stream_attr(&stream->filename, stream_core->filename);
+ 	adjust_log_stream_attr(&stream->directory, stream_core->directory);
+ 	adjust_log_stream_attr(&stream->line_prefix, stream_core->line_prefix);
+ 	stream->file_mode = stream_core->file_mode;
+ 	stream->rotation_age = stream_core->rotation_age;
+ 	stream->rotation_size = stream_core->rotation_size;
+ 	stream->truncate_on_rotation = stream_core->truncate_on_rotation;
+ 
+ 	*stream_p = stream;
+ 	return result;
+ }
+ 
+ 
  #ifdef WIN32
  
  /*
*************** pipeThread(void *arg)
*** 1064,1071 ****
  		 */
  		if (Log_RotationSize > 0)
  		{
! 			if (ftell(syslogFile) >= Log_RotationSize * 1024L ||
! 				(csvlogFile != NULL && ftell(csvlogFile) >= Log_RotationSize * 1024L))
  				SetLatch(MyLatch);
  		}
  		LeaveCriticalSection(&sysloggerSection);
--- 1274,1282 ----
  		 */
  		if (Log_RotationSize > 0)
  		{
! 			if (ftell(syslog_file) >= Log_RotationSize * 1024L ||
! 				(csvlog_file != NULL &&
! 				 ftell(csvlog_file) >= Log_RotationSize * 1024L))
  				SetLatch(MyLatch);
  		}
  		LeaveCriticalSection(&sysloggerSection);
*************** pipeThread(void *arg)
*** 1095,1134 ****
   * always append in this situation.
   */
  static void
! open_csvlogfile(void)
  {
  	char	   *filename;
  
! 	filename = logfile_getname(time(NULL), ".csv");
  
! 	csvlogFile = logfile_open(filename, "a", false);
  
! 	if (last_csv_file_name != NULL) /* probably shouldn't happen */
! 		pfree(last_csv_file_name);
  
! 	last_csv_file_name = filename;
  
! 	update_metainfo_datafile();
  }
  
  /*
   * Open a new logfile with proper permissions and buffering options.
   *
!  * If allow_errors is true, we just log any open failure and return NULL
!  * (with errno still correct for the fopen failure).
!  * Otherwise, errors are treated as fatal.
   */
  static FILE *
! logfile_open(const char *filename, const char *mode, bool allow_errors)
  {
  	FILE	   *fh;
  	mode_t		oumask;
  
  	/*
  	 * Note we do not let Log_file_mode disable IWUSR, since we certainly want
  	 * to be able to write the files ourselves.
  	 */
! 	oumask = umask((mode_t) ((~(Log_file_mode | S_IWUSR)) & (S_IRWXU | S_IRWXG | S_IRWXO)));
  	fh = fopen(filename, mode);
  	umask(oumask);
  
--- 1306,1357 ----
   * always append in this situation.
   */
  static void
! open_csvlogfile(int stream_id)
  {
  	char	   *filename;
+ 	LogStream  *stream = &log_streams[stream_id];
  
! 	filename = logfile_getname(time(NULL), ".csv", stream_id);
  
! 	stream->csvlog_file = logfile_open(filename, "a", false, stream_id);
  
! 	if (stream->last_csv_file_name != NULL)
! 		/* probably shouldn't * happen */
! 		pfree(stream->last_csv_file_name);
  
! 	stream->last_csv_file_name = filename;
  
! 	if (stream_id == 0)
! 		update_metainfo_datafile();
  }
  
  /*
   * Open a new logfile with proper permissions and buffering options.
   *
!  * If allow_errors is true, we just log any open failure and return NULL (with
!  * errno still correct for the fopen failure).  Otherwise, errors are treated
!  * as fatal.
!  *
!  * TODO Should we check that no other stream uses the same file? If so,
!  * consider the best portable way. (Comparison of the file path is not good
!  * because some of the paths may be symlinks.) Can we rely on fileno() to
!  * return the same number if the same file is opened by the same process
!  * multiple times?
   */
  static FILE *
! logfile_open(const char *filename, const char *mode, bool allow_errors,
! 			 int stream_id)
  {
  	FILE	   *fh;
  	mode_t		oumask;
+ 	LogStream  *stream = &log_streams[stream_id];
+ 	int			file_mode = stream->file_mode;
  
  	/*
  	 * Note we do not let Log_file_mode disable IWUSR, since we certainly want
  	 * to be able to write the files ourselves.
  	 */
! 	oumask = umask((mode_t) ((~(file_mode | S_IWUSR)) & (S_IRWXU | S_IRWXG | S_IRWXO)));
  	fh = fopen(filename, mode);
  	umask(oumask);
  
*************** logfile_open(const char *filename, const
*** 1159,1172 ****
   * perform logfile rotation
   */
  static void
! logfile_rotate(bool time_based_rotation, int size_rotation_for)
  {
  	char	   *filename;
  	char	   *csvfilename = NULL;
  	pg_time_t	fntime;
  	FILE	   *fh;
  
! 	rotation_requested = false;
  
  	/*
  	 * When doing a time-based rotation, invent the new logfile name based on
--- 1382,1398 ----
   * perform logfile rotation
   */
  static void
! logfile_rotate(bool time_based_rotation, int size_rotation_for, int stream_id)
  {
  	char	   *filename;
  	char	   *csvfilename = NULL;
  	pg_time_t	fntime;
  	FILE	   *fh;
+ 	LogStream  *stream = &log_streams[stream_id];
  
! 	Assert(stream_id < log_streams_active);
! 
! 	stream->rotation_needed = false;
  
  	/*
  	 * When doing a time-based rotation, invent the new logfile name based on
*************** logfile_rotate(bool time_based_rotation,
*** 1174,1185 ****
  	 * file name when we don't do the rotation immediately.
  	 */
  	if (time_based_rotation)
! 		fntime = next_rotation_time;
  	else
  		fntime = time(NULL);
! 	filename = logfile_getname(fntime, NULL);
! 	if (csvlogFile != NULL)
! 		csvfilename = logfile_getname(fntime, ".csv");
  
  	/*
  	 * Decide whether to overwrite or append.  We can overwrite if (a)
--- 1400,1411 ----
  	 * file name when we don't do the rotation immediately.
  	 */
  	if (time_based_rotation)
! 		fntime = stream->next_rotation_time;
  	else
  		fntime = time(NULL);
! 	filename = logfile_getname(fntime, NULL, stream_id);
! 	if (stream->csvlog_file != NULL)
! 		csvfilename = logfile_getname(fntime, ".csv", stream_id);
  
  	/*
  	 * Decide whether to overwrite or append.  We can overwrite if (a)
*************** logfile_rotate(bool time_based_rotation,
*** 1191,1209 ****
  	 */
  	if (time_based_rotation || (size_rotation_for & LOG_DESTINATION_STDERR))
  	{
! 		if (Log_truncate_on_rotation && time_based_rotation &&
! 			last_file_name != NULL &&
! 			strcmp(filename, last_file_name) != 0)
! 			fh = logfile_open(filename, "w", true);
  		else
! 			fh = logfile_open(filename, "a", true);
  
  		if (!fh)
  		{
  			/*
  			 * ENFILE/EMFILE are not too surprising on a busy system; just
  			 * keep using the old file till we manage to get a new one.
! 			 * Otherwise, assume something's wrong with Log_directory and stop
  			 * trying to create files.
  			 */
  			if (errno != ENFILE && errno != EMFILE)
--- 1417,1435 ----
  	 */
  	if (time_based_rotation || (size_rotation_for & LOG_DESTINATION_STDERR))
  	{
! 		if (stream->truncate_on_rotation && time_based_rotation &&
! 			stream->last_file_name != NULL &&
! 			strcmp(filename, stream->last_file_name) != 0)
! 			fh = logfile_open(filename, "w", true, stream_id);
  		else
! 			fh = logfile_open(filename, "a", true, stream_id);
  
  		if (!fh)
  		{
  			/*
  			 * ENFILE/EMFILE are not too surprising on a busy system; just
  			 * keep using the old file till we manage to get a new one.
! 			 * Otherwise, assume something's wrong with log directory and stop
  			 * trying to create files.
  			 */
  			if (errno != ENFILE && errno != EMFILE)
*************** logfile_rotate(bool time_based_rotation,
*** 1220,1253 ****
  			return;
  		}
  
! 		fclose(syslogFile);
! 		syslogFile = fh;
  
  		/* instead of pfree'ing filename, remember it for next time */
! 		if (last_file_name != NULL)
! 			pfree(last_file_name);
! 		last_file_name = filename;
  		filename = NULL;
  	}
  
  	/* Same as above, but for csv file. */
  
! 	if (csvlogFile != NULL &&
  		(time_based_rotation || (size_rotation_for & LOG_DESTINATION_CSVLOG)))
  	{
! 		if (Log_truncate_on_rotation && time_based_rotation &&
! 			last_csv_file_name != NULL &&
! 			strcmp(csvfilename, last_csv_file_name) != 0)
! 			fh = logfile_open(csvfilename, "w", true);
  		else
! 			fh = logfile_open(csvfilename, "a", true);
  
  		if (!fh)
  		{
  			/*
  			 * ENFILE/EMFILE are not too surprising on a busy system; just
  			 * keep using the old file till we manage to get a new one.
! 			 * Otherwise, assume something's wrong with Log_directory and stop
  			 * trying to create files.
  			 */
  			if (errno != ENFILE && errno != EMFILE)
--- 1446,1479 ----
  			return;
  		}
  
! 		fclose(stream->syslog_file);
! 		stream->syslog_file = fh;
  
  		/* instead of pfree'ing filename, remember it for next time */
! 		if (stream->last_file_name != NULL)
! 			pfree(stream->last_file_name);
! 		stream->last_file_name = filename;
  		filename = NULL;
  	}
  
  	/* Same as above, but for csv file. */
  
! 	if (stream->csvlog_file != NULL &&
  		(time_based_rotation || (size_rotation_for & LOG_DESTINATION_CSVLOG)))
  	{
! 		if (stream->truncate_on_rotation && time_based_rotation &&
! 			stream->last_csv_file_name != NULL &&
! 			strcmp(csvfilename, stream->last_csv_file_name) != 0)
! 			fh = logfile_open(csvfilename, "w", true, stream_id);
  		else
! 			fh = logfile_open(csvfilename, "a", true, stream_id);
  
  		if (!fh)
  		{
  			/*
  			 * ENFILE/EMFILE are not too surprising on a busy system; just
  			 * keep using the old file till we manage to get a new one.
! 			 * Otherwise, assume something's wrong with log directory and stop
  			 * trying to create files.
  			 */
  			if (errno != ENFILE && errno != EMFILE)
*************** logfile_rotate(bool time_based_rotation,
*** 1264,1276 ****
  			return;
  		}
  
! 		fclose(csvlogFile);
! 		csvlogFile = fh;
  
  		/* instead of pfree'ing filename, remember it for next time */
! 		if (last_csv_file_name != NULL)
! 			pfree(last_csv_file_name);
! 		last_csv_file_name = csvfilename;
  		csvfilename = NULL;
  	}
  
--- 1490,1502 ----
  			return;
  		}
  
! 		fclose(stream->csvlog_file);
! 		stream->csvlog_file = fh;
  
  		/* instead of pfree'ing filename, remember it for next time */
! 		if (stream->last_csv_file_name != NULL)
! 			pfree(stream->last_csv_file_name);
! 		stream->last_csv_file_name = csvfilename;
  		csvfilename = NULL;
  	}
  
*************** logfile_rotate(bool time_based_rotation,
*** 1279,1287 ****
  	if (csvfilename)
  		pfree(csvfilename);
  
! 	update_metainfo_datafile();
  
! 	set_next_rotation_time();
  }
  
  
--- 1505,1514 ----
  	if (csvfilename)
  		pfree(csvfilename);
  
! 	if (stream_id == 0)
! 		update_metainfo_datafile();
  
! 	set_next_rotation_time(stream_id);
  }
  
  
*************** logfile_rotate(bool time_based_rotation,
*** 1294,1312 ****
   * Result is palloc'd.
   */
  static char *
! logfile_getname(pg_time_t timestamp, const char *suffix)
  {
  	char	   *filename;
  	int			len;
  
  	filename = palloc(MAXPGPATH);
  
! 	snprintf(filename, MAXPGPATH, "%s/", Log_directory);
  
  	len = strlen(filename);
  
! 	/* treat Log_filename as a strftime pattern */
! 	pg_strftime(filename + len, MAXPGPATH - len, Log_filename,
  				pg_localtime(&timestamp, log_timezone));
  
  	if (suffix != NULL)
--- 1521,1540 ----
   * Result is palloc'd.
   */
  static char *
! logfile_getname(pg_time_t timestamp, const char *suffix, int stream_id)
  {
  	char	   *filename;
  	int			len;
+ 	LogStream  *stream = &log_streams[stream_id];
  
  	filename = palloc(MAXPGPATH);
  
! 	snprintf(filename, MAXPGPATH, "%s/", stream->directory);
  
  	len = strlen(filename);
  
! 	/* treat log filename as a strftime pattern */
! 	pg_strftime(filename + len, MAXPGPATH - len, stream->filename,
  				pg_localtime(&timestamp, log_timezone));
  
  	if (suffix != NULL)
*************** logfile_getname(pg_time_t timestamp, con
*** 1324,1337 ****
   * Determine the next planned rotation time, and store in next_rotation_time.
   */
  static void
! set_next_rotation_time(void)
  {
  	pg_time_t	now;
  	struct pg_tm *tm;
  	int			rotinterval;
  
  	/* nothing to do if time-based rotation is disabled */
! 	if (Log_RotationAge <= 0)
  		return;
  
  	/*
--- 1552,1566 ----
   * Determine the next planned rotation time, and store in next_rotation_time.
   */
  static void
! set_next_rotation_time(int stream_id)
  {
  	pg_time_t	now;
  	struct pg_tm *tm;
  	int			rotinterval;
+ 	LogStream  *stream = &log_streams[stream_id];
  
  	/* nothing to do if time-based rotation is disabled */
! 	if (stream->rotation_age <= 0)
  		return;
  
  	/*
*************** set_next_rotation_time(void)
*** 1340,1353 ****
  	 * fairly loosely.  In this version we align to log_timezone rather than
  	 * GMT.
  	 */
! 	rotinterval = Log_RotationAge * SECS_PER_MINUTE;	/* convert to seconds */
  	now = (pg_time_t) time(NULL);
  	tm = pg_localtime(&now, log_timezone);
  	now += tm->tm_gmtoff;
  	now -= now % rotinterval;
  	now += rotinterval;
  	now -= tm->tm_gmtoff;
! 	next_rotation_time = now;
  }
  
  /*
--- 1569,1584 ----
  	 * fairly loosely.  In this version we align to log_timezone rather than
  	 * GMT.
  	 */
! 	rotinterval = stream->rotation_age *
! 		SECS_PER_MINUTE;		/* convert to seconds */
  	now = (pg_time_t) time(NULL);
  	tm = pg_localtime(&now, log_timezone);
  	now += tm->tm_gmtoff;
  	now -= now % rotinterval;
  	now += rotinterval;
  	now -= tm->tm_gmtoff;
! 
! 	stream->next_rotation_time = now;
  }
  
  /*
*************** set_next_rotation_time(void)
*** 1356,1369 ****
   * when there is time-based logfile rotation.  Filenames are stored in a
   * temporary file and which is renamed into the final destination for
   * atomicity.
   */
  static void
  update_metainfo_datafile(void)
  {
  	FILE	   *fh;
  
! 	if (!(Log_destination & LOG_DESTINATION_STDERR) &&
! 		!(Log_destination & LOG_DESTINATION_CSVLOG))
  	{
  		if (unlink(LOG_METAINFO_DATAFILE) < 0 && errno != ENOENT)
  			ereport(LOG,
--- 1587,1608 ----
   * when there is time-based logfile rotation.  Filenames are stored in a
   * temporary file and which is renamed into the final destination for
   * atomicity.
+  *
+  * TODO Should the extension logs be included? If so, how can we generate a
+  * unique prefix for them? (stream_id is not suitable because an extension can
+  * receive different id after cluster restart).
   */
  static void
  update_metainfo_datafile(void)
  {
  	FILE	   *fh;
+ 	LogStream  *stream_core = &log_streams[0];
+ 	char	   *last_file_name = stream_core->last_file_name;
+ 	char	   *last_csv_file_name = stream_core->last_csv_file_name;
+ 	LogStream  *log = &log_streams[0];
  
! 	if (!(log->destination & LOG_DESTINATION_STDERR) &&
! 		!(log->destination & LOG_DESTINATION_CSVLOG))
  	{
  		if (unlink(LOG_METAINFO_DATAFILE) < 0 && errno != ENOENT)
  			ereport(LOG,
*************** update_metainfo_datafile(void)
*** 1373,1379 ****
  		return;
  	}
  
! 	if ((fh = logfile_open(LOG_METAINFO_DATAFILE_TMP, "w", true)) == NULL)
  	{
  		ereport(LOG,
  				(errcode_for_file_access(),
--- 1612,1621 ----
  		return;
  	}
  
! 	/*
! 	 * Pass 0 for stream_id so that log_directory GUC controls file mode.
! 	 */
! 	if ((fh = logfile_open(LOG_METAINFO_DATAFILE_TMP, "w", true, 0)) == NULL)
  	{
  		ereport(LOG,
  				(errcode_for_file_access(),
*************** update_metainfo_datafile(void)
*** 1382,1388 ****
  		return;
  	}
  
! 	if (last_file_name && (Log_destination & LOG_DESTINATION_STDERR))
  	{
  		if (fprintf(fh, "stderr %s\n", last_file_name) < 0)
  		{
--- 1624,1630 ----
  		return;
  	}
  
! 	if (last_file_name && (log->destination & LOG_DESTINATION_STDERR))
  	{
  		if (fprintf(fh, "stderr %s\n", last_file_name) < 0)
  		{
*************** update_metainfo_datafile(void)
*** 1395,1401 ****
  		}
  	}
  
! 	if (last_csv_file_name && (Log_destination & LOG_DESTINATION_CSVLOG))
  	{
  		if (fprintf(fh, "csvlog %s\n", last_csv_file_name) < 0)
  		{
--- 1637,1643 ----
  		}
  	}
  
! 	if (last_csv_file_name && (log->destination & LOG_DESTINATION_CSVLOG))
  	{
  		if (fprintf(fh, "csvlog %s\n", last_csv_file_name) < 0)
  		{
diff --git a/src/backend/utils/adt/genfile.c b/src/backend/utils/adt/genfile.c
new file mode 100644
index 5285aa5..96b7256
*** a/src/backend/utils/adt/genfile.c
--- b/src/backend/utils/adt/genfile.c
*************** convert_and_check_filename(text *arg)
*** 66,77 ****
  		 * Allow absolute paths if within DataDir or Log_directory, even
  		 * though Log_directory might be outside DataDir.
  		 */
! 		if (!path_is_prefix_of_path(DataDir, filename) &&
! 			(!is_absolute_path(Log_directory) ||
! 			 !path_is_prefix_of_path(Log_directory, filename)))
! 			ereport(ERROR,
! 					(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
! 					 (errmsg("absolute path not allowed"))));
  	}
  	else if (!path_is_relative_and_below_cwd(filename))
  		ereport(ERROR,
--- 66,95 ----
  		 * Allow absolute paths if within DataDir or Log_directory, even
  		 * though Log_directory might be outside DataDir.
  		 */
! 		if (!path_is_prefix_of_path(DataDir, filename))
! 		{
! 			int			i;
! 			bool		accept = false;
! 
! 			for (i = 0; i < log_streams_active; i++)
! 			{
! 				LogStream  *stream = &log_streams[i];
! 
! 				if (!is_absolute_path(stream->directory))
! 					continue;
! 
! 				if (path_is_prefix_of_path(stream->directory, filename))
! 				{
! 					accept = true;
! 					break;
! 				}
! 			}
! 
! 			if (!accept)
! 				ereport(ERROR,
! 						(errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
! 						 (errmsg("absolute path not allowed"))));
! 		}
  	}
  	else if (!path_is_relative_and_below_cwd(filename))
  		ereport(ERROR,
*************** pg_ls_dir_files(FunctionCallInfo fcinfo,
*** 558,564 ****
  Datum
  pg_ls_logdir(PG_FUNCTION_ARGS)
  {
! 	return pg_ls_dir_files(fcinfo, Log_directory);
  }
  
  /* Function to return the list of files in the WAL directory */
--- 576,584 ----
  Datum
  pg_ls_logdir(PG_FUNCTION_ARGS)
  {
! 	LogStream  *stream = &log_streams[0];
! 
! 	return pg_ls_dir_files(fcinfo, stream->directory);
  }
  
  /* Function to return the list of files in the WAL directory */
diff --git a/src/backend/utils/error/elog.c b/src/backend/utils/error/elog.c
new file mode 100644
index 918db0a..ffdd0e8
*** a/src/backend/utils/error/elog.c
--- b/src/backend/utils/error/elog.c
*************** extern bool redirection_done;
*** 100,110 ****
   */
  emit_log_hook_type emit_log_hook = NULL;
  
  /* GUC parameters */
- int			Log_error_verbosity = PGERROR_VERBOSE;
- char	   *Log_line_prefix = NULL; /* format for extra log line info */
- int			Log_destination = LOG_DESTINATION_STDERR;
  char	   *Log_destination_string = NULL;
  bool		syslog_sequence_numbers = true;
  bool		syslog_split_messages = true;
  
--- 100,109 ----
   */
  emit_log_hook_type emit_log_hook = NULL;
  
+ 
  /* GUC parameters */
  char	   *Log_destination_string = NULL;
+ 
  bool		syslog_sequence_numbers = true;
  bool		syslog_split_messages = true;
  
*************** static const char *process_log_prefix_pa
*** 175,181 ****
  static void log_line_prefix(StringInfo buf, ErrorData *edata);
  static void write_csvlog(ErrorData *edata);
  static void send_message_to_server_log(ErrorData *edata);
! static void write_pipe_chunks(char *data, int len, int dest);
  static void send_message_to_frontend(ErrorData *edata);
  static char *expand_fmt_string(const char *fmt, ErrorData *edata);
  static const char *useful_strerror(int errnum);
--- 174,180 ----
  static void log_line_prefix(StringInfo buf, ErrorData *edata);
  static void write_csvlog(ErrorData *edata);
  static void send_message_to_server_log(ErrorData *edata);
! static void write_pipe_chunks(char *data, int len, int dest, int stream_id);
  static void send_message_to_frontend(ErrorData *edata);
  static char *expand_fmt_string(const char *fmt, ErrorData *edata);
  static const char *useful_strerror(int errnum);
*************** errfinish(int dummy,...)
*** 468,473 ****
--- 467,478 ----
  	}
  
  	/*
+ 	 * A serious error should find its way to the core log.
+ 	 */
+ 	if (elevel >= FATAL)
+ 		edata->syslogger_stream = 0;
+ 
+ 	/*
  	 * If we are doing FATAL or PANIC, abort any old-style COPY OUT in
  	 * progress, so that we can report the message before dying.  (Without
  	 * this, pq_putmessage will refuse to send the message at all, which is
*************** err_generic_string(int field, const char
*** 1221,1226 ****
--- 1226,1251 ----
  }
  
  /*
+  * errstream --- set identifier of the server log file the message should be
+  * written into.
+  */
+ int
+ errstream(const int stream_id)
+ {
+ 	ErrorData  *edata = &errordata[errordata_stack_depth];
+ 
+ 	/* we don't bother incrementing recursion_depth */
+ 	CHECK_STACK_DEPTH();
+ 
+ 	if (stream_id < 0 || stream_id >= log_streams_active)
+ 		elog(ERROR, "invalid syslogger stream: %d", stream_id);
+ 
+ 	edata->syslogger_stream = stream_id;
+ 
+ 	return 0;					/* return value does not matter */
+ }
+ 
+ /*
   * set_errdata_field --- set an ErrorData string field
   */
  static void
*************** log_line_prefix(StringInfo buf, ErrorDat
*** 2319,2324 ****
--- 2344,2350 ----
  	static int	log_my_pid = 0;
  	int			padding;
  	const char *p;
+ 	char	   *line_prefix = log_streams[edata->syslogger_stream].line_prefix;
  
  	/*
  	 * This is one of the few places where we'd rather not inherit a static
*************** log_line_prefix(StringInfo buf, ErrorDat
*** 2334,2343 ****
  	}
  	log_line_number++;
  
! 	if (Log_line_prefix == NULL)
  		return;					/* in case guc hasn't run yet */
  
! 	for (p = Log_line_prefix; *p != '\0'; p++)
  	{
  		if (*p != '%')
  		{
--- 2360,2369 ----
  	}
  	log_line_number++;
  
! 	if (line_prefix == NULL)
  		return;					/* in case guc hasn't run yet */
  
! 	for (p = line_prefix; *p != '\0'; p++)
  	{
  		if (*p != '%')
  		{
*************** write_csvlog(ErrorData *edata)
*** 2648,2653 ****
--- 2674,2680 ----
  {
  	StringInfoData buf;
  	bool		print_stmt = false;
+ 	LogStream  *log = &log_streams[edata->syslogger_stream];
  
  	/* static counter for line numbers */
  	static long log_line_number = 0;
*************** write_csvlog(ErrorData *edata)
*** 2803,2809 ****
  	appendStringInfoChar(&buf, ',');
  
  	/* file error location */
! 	if (Log_error_verbosity >= PGERROR_VERBOSE)
  	{
  		StringInfoData msgbuf;
  
--- 2830,2836 ----
  	appendStringInfoChar(&buf, ',');
  
  	/* file error location */
! 	if (log->verbosity >= PGERROR_VERBOSE)
  	{
  		StringInfoData msgbuf;
  
*************** write_csvlog(ErrorData *edata)
*** 2829,2837 ****
  
  	/* If in the syslogger process, try to write messages direct to file */
  	if (am_syslogger)
! 		write_syslogger_file(buf.data, buf.len, LOG_DESTINATION_CSVLOG);
  	else
! 		write_pipe_chunks(buf.data, buf.len, LOG_DESTINATION_CSVLOG);
  
  	pfree(buf.data);
  }
--- 2856,2865 ----
  
  	/* If in the syslogger process, try to write messages direct to file */
  	if (am_syslogger)
! 		write_syslogger_file(buf.data, buf.len, LOG_DESTINATION_CSVLOG, 0);
  	else
! 		write_pipe_chunks(buf.data, buf.len, LOG_DESTINATION_CSVLOG,
! 						  edata->syslogger_stream);
  
  	pfree(buf.data);
  }
*************** static void
*** 2864,2869 ****
--- 2892,2898 ----
  send_message_to_server_log(ErrorData *edata)
  {
  	StringInfoData buf;
+ 	LogStream  *log = &log_streams[edata->syslogger_stream];
  
  	initStringInfo(&buf);
  
*************** send_message_to_server_log(ErrorData *ed
*** 2873,2879 ****
  	log_line_prefix(&buf, edata);
  	appendStringInfo(&buf, "%s:  ", _(error_severity(edata->elevel)));
  
! 	if (Log_error_verbosity >= PGERROR_VERBOSE)
  		appendStringInfo(&buf, "%s: ", unpack_sql_state(edata->sqlerrcode));
  
  	if (edata->message)
--- 2902,2908 ----
  	log_line_prefix(&buf, edata);
  	appendStringInfo(&buf, "%s:  ", _(error_severity(edata->elevel)));
  
! 	if (log->verbosity >= PGERROR_VERBOSE)
  		appendStringInfo(&buf, "%s: ", unpack_sql_state(edata->sqlerrcode));
  
  	if (edata->message)
*************** send_message_to_server_log(ErrorData *ed
*** 2890,2896 ****
  
  	appendStringInfoChar(&buf, '\n');
  
! 	if (Log_error_verbosity >= PGERROR_DEFAULT)
  	{
  		if (edata->detail_log)
  		{
--- 2919,2925 ----
  
  	appendStringInfoChar(&buf, '\n');
  
! 	if (log->verbosity >= PGERROR_DEFAULT)
  	{
  		if (edata->detail_log)
  		{
*************** send_message_to_server_log(ErrorData *ed
*** 2927,2933 ****
  			append_with_tabs(&buf, edata->context);
  			appendStringInfoChar(&buf, '\n');
  		}
! 		if (Log_error_verbosity >= PGERROR_VERBOSE)
  		{
  			/* assume no newlines in funcname or filename... */
  			if (edata->funcname && edata->filename)
--- 2956,2962 ----
  			append_with_tabs(&buf, edata->context);
  			appendStringInfoChar(&buf, '\n');
  		}
! 		if (log->verbosity >= PGERROR_VERBOSE)
  		{
  			/* assume no newlines in funcname or filename... */
  			if (edata->funcname && edata->filename)
*************** send_message_to_server_log(ErrorData *ed
*** 2961,2967 ****
  
  #ifdef HAVE_SYSLOG
  	/* Write to syslog, if enabled */
! 	if (Log_destination & LOG_DESTINATION_SYSLOG)
  	{
  		int			syslog_level;
  
--- 2990,2996 ----
  
  #ifdef HAVE_SYSLOG
  	/* Write to syslog, if enabled */
! 	if (log->destination & LOG_DESTINATION_SYSLOG)
  	{
  		int			syslog_level;
  
*************** send_message_to_server_log(ErrorData *ed
*** 3001,3014 ****
  
  #ifdef WIN32
  	/* Write to eventlog, if enabled */
! 	if (Log_destination & LOG_DESTINATION_EVENTLOG)
  	{
  		write_eventlog(edata->elevel, buf.data, buf.len);
  	}
  #endif							/* WIN32 */
  
  	/* Write to stderr, if enabled */
! 	if ((Log_destination & LOG_DESTINATION_STDERR) || whereToSendOutput == DestDebug)
  	{
  		/*
  		 * Use the chunking protocol if we know the syslogger should be
--- 3030,3043 ----
  
  #ifdef WIN32
  	/* Write to eventlog, if enabled */
! 	if (log->destination & LOG_DESTINATION_EVENTLOG)
  	{
  		write_eventlog(edata->elevel, buf.data, buf.len);
  	}
  #endif							/* WIN32 */
  
  	/* Write to stderr, if enabled */
! 	if ((log->destination & LOG_DESTINATION_STDERR) || whereToSendOutput == DestDebug)
  	{
  		/*
  		 * Use the chunking protocol if we know the syslogger should be
*************** send_message_to_server_log(ErrorData *ed
*** 3016,3022 ****
  		 * Otherwise, just do a vanilla write to stderr.
  		 */
  		if (redirection_done && !am_syslogger)
! 			write_pipe_chunks(buf.data, buf.len, LOG_DESTINATION_STDERR);
  #ifdef WIN32
  
  		/*
--- 3045,3052 ----
  		 * Otherwise, just do a vanilla write to stderr.
  		 */
  		if (redirection_done && !am_syslogger)
! 			write_pipe_chunks(buf.data, buf.len, LOG_DESTINATION_STDERR,
! 							  edata->syslogger_stream);
  #ifdef WIN32
  
  		/*
*************** send_message_to_server_log(ErrorData *ed
*** 3035,3044 ****
  
  	/* If in the syslogger process, try to write messages direct to file */
  	if (am_syslogger)
! 		write_syslogger_file(buf.data, buf.len, LOG_DESTINATION_STDERR);
  
  	/* Write to CSV log if enabled */
! 	if (Log_destination & LOG_DESTINATION_CSVLOG)
  	{
  		if (redirection_done || am_syslogger)
  		{
--- 3065,3074 ----
  
  	/* If in the syslogger process, try to write messages direct to file */
  	if (am_syslogger)
! 		write_syslogger_file(buf.data, buf.len, LOG_DESTINATION_STDERR, 0);
  
  	/* Write to CSV log if enabled */
! 	if (log->destination & LOG_DESTINATION_CSVLOG)
  	{
  		if (redirection_done || am_syslogger)
  		{
*************** send_message_to_server_log(ErrorData *ed
*** 3055,3061 ****
  			 * syslogger not up (yet), so just dump the message to stderr,
  			 * unless we already did so above.
  			 */
! 			if (!(Log_destination & LOG_DESTINATION_STDERR) &&
  				whereToSendOutput != DestDebug)
  				write_console(buf.data, buf.len);
  			pfree(buf.data);
--- 3085,3091 ----
  			 * syslogger not up (yet), so just dump the message to stderr,
  			 * unless we already did so above.
  			 */
! 			if (!(log->destination & LOG_DESTINATION_STDERR) &&
  				whereToSendOutput != DestDebug)
  				write_console(buf.data, buf.len);
  			pfree(buf.data);
*************** send_message_to_server_log(ErrorData *ed
*** 3088,3094 ****
   * rc to void to shut up the compiler.
   */
  static void
! write_pipe_chunks(char *data, int len, int dest)
  {
  	PipeProtoChunk p;
  	int			fd = fileno(stderr);
--- 3118,3124 ----
   * rc to void to shut up the compiler.
   */
  static void
! write_pipe_chunks(char *data, int len, int dest, int stream_id)
  {
  	PipeProtoChunk p;
  	int			fd = fileno(stderr);
*************** write_pipe_chunks(char *data, int len, i
*** 3096,3103 ****
--- 3126,3136 ----
  
  	Assert(len > 0);
  
+ 	StaticAssertStmt(PIPE_MAX_PAYLOAD > 0, "PipeProtoHeader is too big");
+ 
  	p.proto.nuls[0] = p.proto.nuls[1] = '\0';
  	p.proto.pid = MyProcPid;
+ 	p.proto.stream_id = (unsigned char) stream_id;
  
  	/* write all but the last chunk */
  	while (len > PIPE_MAX_PAYLOAD)
diff --git a/src/backend/utils/misc/guc.c b/src/backend/utils/misc/guc.c
new file mode 100644
index 246fea8..1b9c404
*** a/src/backend/utils/misc/guc.c
--- b/src/backend/utils/misc/guc.c
*************** static struct config_bool ConfigureNames
*** 1449,1455 ****
  			gettext_noop("Truncate existing log files of same name during log rotation."),
  			NULL
  		},
! 		&Log_truncate_on_rotation,
  		false,
  		NULL, NULL, NULL
  	},
--- 1449,1455 ----
  			gettext_noop("Truncate existing log files of same name during log rotation."),
  			NULL
  		},
! 		&log_streams[0].truncate_on_rotation,
  		false,
  		NULL, NULL, NULL
  	},
*************** static struct config_int ConfigureNamesI
*** 1903,1909 ****
  						 "(To use the customary octal format the number must "
  						 "start with a 0 (zero).)")
  		},
! 		&Log_file_mode,
  		0600, 0000, 0777,
  		NULL, NULL, show_log_file_mode
  	},
--- 1903,1909 ----
  						 "(To use the customary octal format the number must "
  						 "start with a 0 (zero).)")
  		},
! 		&log_streams[0].file_mode,
  		0600, 0000, 0777,
  		NULL, NULL, show_log_file_mode
  	},
*************** static struct config_int ConfigureNamesI
*** 2536,2542 ****
  			NULL,
  			GUC_UNIT_MIN
  		},
! 		&Log_RotationAge,
  		HOURS_PER_DAY * MINS_PER_HOUR, 0, INT_MAX / SECS_PER_MINUTE,
  		NULL, NULL, NULL
  	},
--- 2536,2542 ----
  			NULL,
  			GUC_UNIT_MIN
  		},
! 		&log_streams[0].rotation_age,
  		HOURS_PER_DAY * MINS_PER_HOUR, 0, INT_MAX / SECS_PER_MINUTE,
  		NULL, NULL, NULL
  	},
*************** static struct config_int ConfigureNamesI
*** 2547,2553 ****
  			NULL,
  			GUC_UNIT_KB
  		},
! 		&Log_RotationSize,
  		10 * 1024, 0, INT_MAX / 1024,
  		NULL, NULL, NULL
  	},
--- 2547,2553 ----
  			NULL,
  			GUC_UNIT_KB
  		},
! 		&log_streams[0].rotation_size,
  		10 * 1024, 0, INT_MAX / 1024,
  		NULL, NULL, NULL
  	},
*************** static struct config_string ConfigureNam
*** 3081,3087 ****
  			gettext_noop("Controls information prefixed to each log line."),
  			gettext_noop("If blank, no prefix is used.")
  		},
! 		&Log_line_prefix,
  		"%m [%p] ",
  		NULL, NULL, NULL
  	},
--- 3081,3087 ----
  			gettext_noop("Controls information prefixed to each log line."),
  			gettext_noop("If blank, no prefix is used.")
  		},
! 		&log_streams[0].line_prefix,
  		"%m [%p] ",
  		NULL, NULL, NULL
  	},
*************** static struct config_string ConfigureNam
*** 3340,3347 ****
  						 "or as absolute path."),
  			GUC_SUPERUSER_ONLY
  		},
! 		&Log_directory,
! 		"log",
  		check_canonical_path, NULL, NULL
  	},
  	{
--- 3340,3347 ----
  						 "or as absolute path."),
  			GUC_SUPERUSER_ONLY
  		},
! 		&log_streams[0].directory,
! 		"pg_log",
  		check_canonical_path, NULL, NULL
  	},
  	{
*************** static struct config_string ConfigureNam
*** 3350,3356 ****
  			NULL,
  			GUC_SUPERUSER_ONLY
  		},
! 		&Log_filename,
  		"postgresql-%Y-%m-%d_%H%M%S.log",
  		NULL, NULL, NULL
  	},
--- 3350,3356 ----
  			NULL,
  			GUC_SUPERUSER_ONLY
  		},
! 		&log_streams[0].filename,
  		"postgresql-%Y-%m-%d_%H%M%S.log",
  		NULL, NULL, NULL
  	},
*************** static struct config_enum ConfigureNames
*** 3727,3733 ****
  			gettext_noop("Sets the verbosity of logged messages."),
  			NULL
  		},
! 		&Log_error_verbosity,
  		PGERROR_DEFAULT, log_error_verbosity_options,
  		NULL, NULL, NULL
  	},
--- 3727,3733 ----
  			gettext_noop("Sets the verbosity of logged messages."),
  			NULL
  		},
! 		&log_streams[0].verbosity,
  		PGERROR_DEFAULT, log_error_verbosity_options,
  		NULL, NULL, NULL
  	},
*************** check_log_destination(char **newval, voi
*** 10109,10115 ****
  static void
  assign_log_destination(const char *newval, void *extra)
  {
! 	Log_destination = *((int *) extra);
  }
  
  static void
--- 10109,10117 ----
  static void
  assign_log_destination(const char *newval, void *extra)
  {
! 	LogStream  *log = &log_streams[0];
! 
! 	log->destination = *((int *) extra);
  }
  
  static void
*************** show_log_file_mode(void)
*** 10506,10512 ****
  {
  	static char buf[8];
  
! 	snprintf(buf, sizeof(buf), "%04o", Log_file_mode);
  	return buf;
  }
  
--- 10508,10514 ----
  {
  	static char buf[8];
  
! 	snprintf(buf, sizeof(buf), "%04o", log_streams[0].file_mode);
  	return buf;
  }
  
diff --git a/src/include/postmaster/syslogger.h b/src/include/postmaster/syslogger.h
new file mode 100644
index f4248ef..17df307
*** a/src/include/postmaster/syslogger.h
--- b/src/include/postmaster/syslogger.h
*************** typedef struct
*** 46,51 ****
--- 46,52 ----
  	char		nuls[2];		/* always \0\0 */
  	uint16		len;			/* size of this chunk (counts data only) */
  	int32		pid;			/* writer's pid */
+ 	unsigned char stream_id;	/* 0 for core, > 0 for extensions */
  	char		is_last;		/* last chunk of message? 't' or 'f' ('T' or
  								 * 'F' for CSV case) */
  	char		data[FLEXIBLE_ARRAY_MEMBER];	/* data payload starts here */
*************** typedef union
*** 60,74 ****
  #define PIPE_HEADER_SIZE  offsetof(PipeProtoHeader, data)
  #define PIPE_MAX_PAYLOAD  ((int) (PIPE_CHUNK_SIZE - PIPE_HEADER_SIZE))
  
  
  /* GUC options */
  extern bool Logging_collector;
! extern int	Log_RotationAge;
! extern int	Log_RotationSize;
! extern PGDLLIMPORT char *Log_directory;
! extern PGDLLIMPORT char *Log_filename;
! extern bool Log_truncate_on_rotation;
! extern int	Log_file_mode;
  
  extern bool am_syslogger;
  
--- 61,158 ----
  #define PIPE_HEADER_SIZE  offsetof(PipeProtoHeader, data)
  #define PIPE_MAX_PAYLOAD  ((int) (PIPE_CHUNK_SIZE - PIPE_HEADER_SIZE))
  
+ /*
+  * The maximum number of log streams the syslogger can collect data from.
+  *
+  * If increasing this, make sure the new value fits in the stream_id field of
+  * PipeProtoHeader.
+  */
+ #define MAXLOGSTREAMS 8
  
  /* GUC options */
  extern bool Logging_collector;
! 
! /*
!  * ereport() associates each message with particular stream so that messages
!  * from various sources can be logged to separate files. Each stream can
!  * actually end up in multiple files, as specified by log destination
!  * (LOG_DESTINATION_STDERR, LOG_DESTINATION_CSVLOG, ...).
!  */
! typedef struct LogStream
! {
! 	/*
! 	 * The following variables can take their value from the related GUCs.
! 	 */
! 	int			verbosity;
! 	int			destination;
! 	char	   *directory;
! 	char	   *filename;
! 	int			file_mode;
! 	int			rotation_age;
! 	int			rotation_size;
! 	bool		truncate_on_rotation;
! 	char	   *line_prefix;
! 
! 	char	   *id;
! 
! 	pg_time_t	next_rotation_time;
! 	bool		rotation_needed;
! 	int			current_rotation_age;
! 	FILE	   *syslog_file;
! #ifdef EXEC_BACKEND
! #ifndef WIN32
! 	int			syslog_fd;
! #else							/* WIN32 */
! 	long		syslog_fd;
! #endif							/* WIN32 */
! #endif							/* EXEC_BACKEND */
! 	FILE	   *csvlog_file;
! 	char	   *last_file_name;
! 	char	   *last_csv_file_name;
! 	char	   *current_dir;
! 	char	   *current_filename;
! } LogStream;
! 
! #ifdef EXEC_BACKEND
! extern bool log_streams_initialized;
! 
! /*
!  * directory, filename and line_prefix need to be passed in the EXEC_BACKEND
!  * case, so store the actual strings, not just pointers. Since there's no size
!  * limit on line_prefix, put it at the end of the structure.
!  */
! typedef struct LogStreamFlat
! {
! 	Size		size;
! 	int			verbosity;
! 	int			destination;
! 	char		directory[MAXPGPATH];
! 	char		filename[MAXPGPATH];
! 	char		id[MAXPGPATH];
! 	int			file_mode;
! 	int			rotation_age;
! 	int			rotation_size;
! 	bool		truncate_on_rotation;
! 
! #ifndef WIN32
! 	int			syslog_fd;
! #else							/* WIN32 */
! 	long		syslog_fd;
! #endif							/* WIN32 */
! 
! 	char		line_prefix[FLEXIBLE_ARRAY_MEMBER];
! } LogStreamFlat;
! 
! /*
!  * The structures are stored w/o alignment, so the next one can immediately
!  * follow the end of line_prefix.
!  */
! #define LOG_STREAM_FLAT_SIZE(s) (offsetof(LogStreamFlat, line_prefix) + \
! 								 strlen((s)->line_prefix) + 1)
! #endif							/* EXEC_BACKEND */
! 
! extern LogStream log_streams[MAXLOGSTREAMS];
! extern int	log_streams_active;
  
  extern bool am_syslogger;
  
*************** extern HANDLE syslogPipe[2];
*** 81,87 ****
  
  extern int	SysLogger_Start(void);
  
! extern void write_syslogger_file(const char *buffer, int count, int dest);
  
  #ifdef EXEC_BACKEND
  extern void SysLoggerMain(int argc, char *argv[]) pg_attribute_noreturn();
--- 165,183 ----
  
  extern int	SysLogger_Start(void);
  
! extern void write_syslogger_file(const char *buffer, int count, int dest,
! 					 int stream_id);
! extern int	get_log_stream(char *id, LogStream **stream_p);
! 
! /*
!  * Convenience macro to set string attributes of LogStream.
!  *
!  * String values that caller sets must be allocated in the TopMemoryContext or
!  * malloc'd. (The latter is true if pointers to the stream fields are passed
!  * to GUC framework).
!  */
! #define adjust_log_stream_attr(oldval_p, newval) \
! 	(*(oldval_p) = MemoryContextStrdup(TopMemoryContext, (newval)))
  
  #ifdef EXEC_BACKEND
  extern void SysLoggerMain(int argc, char *argv[]) pg_attribute_noreturn();
diff --git a/src/include/utils/elog.h b/src/include/utils/elog.h
new file mode 100644
index 7bfd25a..bd582e5
*** a/src/include/utils/elog.h
--- b/src/include/utils/elog.h
*************** extern int	internalerrposition(int curso
*** 177,182 ****
--- 177,183 ----
  extern int	internalerrquery(const char *query);
  
  extern int	err_generic_string(int field, const char *str);
+ extern int	errstream(const int stream_id);
  
  extern int	geterrcode(void);
  extern int	geterrposition(void);
*************** typedef struct ErrorData
*** 330,335 ****
--- 331,337 ----
  {
  	int			elevel;			/* error level */
  	bool		output_to_server;	/* will report to server log? */
+ 	int			syslogger_stream;	/* stream identifier. > 0 for extension */
  	bool		output_to_client;	/* will report to client? */
  	bool		show_funcname;	/* true to force funcname inclusion */
  	bool		hide_stmt;		/* true to prevent STATEMENT: inclusion */
*************** typedef enum
*** 384,393 ****
  	PGERROR_VERBOSE				/* all the facts, ma'am */
  }			PGErrorVerbosity;
  
- extern int	Log_error_verbosity;
- extern char *Log_line_prefix;
- extern int	Log_destination;
  extern char *Log_destination_string;
  extern bool syslog_sequence_numbers;
  extern bool syslog_split_messages;
  
--- 386,393 ----
  	PGERROR_VERBOSE				/* all the facts, ma'am */
  }			PGErrorVerbosity;
  
  extern char *Log_destination_string;
+ 
  extern bool syslog_sequence_numbers;
  extern bool syslog_split_messages;
  
diff --git a/src/tools/pgindent/typedefs.list b/src/tools/pgindent/typedefs.list
new file mode 100644
index 17ba2bd..642e1a4
*** a/src/tools/pgindent/typedefs.list
--- b/src/tools/pgindent/typedefs.list
*************** yyscan_t
*** 3209,3211 ****
--- 3209,3213 ----
  z_stream
  z_streamp
  zic_t
+ LogStream
+ LogStreamFlat
