前几天跟同事讨论如何在一次login php调用中保证error_log输出的日志都有唯一的标识头，结论是玩家帐号+当前时间+随机数，在我们当前用户量级条件下应该是满足需求的，当然，这并不是本文讨论的重点。
在确定这个简单的方案之后，我在想两个问题，也是今天本文讨论的重点：
1.error_log调用是否可以保证输出内容是完整的？
2.如果是完整的，那么是怎样保证的？
求证开始了，起初以为error_log调用中会对目标文件加文件锁，直接看源码（php5.6.12）：
from: basic_functions.c
PHPAPI int _php_error_log_ex(int opt_err, char *message, int message_len, char *opt, char *headers TSRMLS_DC) /* {{{ */
{
php_stream *stream = NULL;
switch (opt_err)
{
case 1: /*send an email */
if (!php_mail(opt, PHP error_log message, message, headers, NULL TSRMLS_CC)) {
return FAILURE;
}
break;
case 2: /*send to an address */
php_error_docref(NULL TSRMLS_CC, E_WARNING, TCP/IP option not available!);
return FAILURE;
break;
case 3: /*save to a file */
stream = php_stream_open_wrapper(opt, a, IGNORE_URL_WIN | REPORT_ERRORS, NULL);
if (!stream) {
return FAILURE;
}
php_stream_write(stream, message, message_len);
php_stream_close(stream);
break;
case 4: /* send to SAPI */
if (sapi_module.log_message) {
sapi_module.log_message(message TSRMLS_CC);
} else {
return FAILURE;
}
break;
default:
php_log_err(message TSRMLS_CC);
break;
}
return SUCCESS;
}
/* }}} */
/* Writes a buffer directly to a stream, using multiple of the chunk size */
static size_t _php_stream_write_buffer(php_stream *stream, const char *buf, size_t count TSRMLS_DC)
{
size_t didwrite = 0, towrite, justwrote;
/* if we have a seekable stream we need to ensure that data is written at the
* current stream->position. This means invalidating the read buffer and then
* performing a low-level seek */
if (stream->ops->seek && (stream->flags & PHP_STREAM_FLAG_NO_SEEK) == 0 && stream->readpos != stream->writepos) {
stream->readpos = stream->writepos = 0;
stream->ops->seek(stream, stream->position, SEEK_SET, &stream->position TSRMLS_CC);
}
while (count > 0) {
towrite = count;
if (towrite > stream->chunk_size)
towrite = stream->chunk_size;
justwrote = stream->ops->write(stream, buf, towrite TSRMLS_CC);
/* convert justwrote to an integer, since normally it is unsigned */
if ((int)justwrote > 0) {
buf += justwrote;
count -= justwrote;
didwrite += justwrote;
/* Only screw with the buffer if we can seek, otherwise we lose data
* buffered from fifos and sockets */
if (stream->ops->seek && (stream->flags & PHP_STREAM_FLAG_NO_SEEK) == 0) {
stream->position += justwrote;
}
} else {
break;
}
}
return didwrite;
}
多次write不能保证原子操作，那么单次呢？
1.from：man write
If the file was open(2)ed with <strong>O_APPEND</strong>, the file
offset is first set to the end of the file before writing. The
adjustment of the file offset and the write operation are performed
as an atomic step.
2.from：man write
Atomic/non-atomic: A write is atomic if the whole amount written in one operation is not interleaved with data from any other process. This is useful when there are multiple writers sending data to a single reader. Applications need to know how large a write request can be expected to be performed atomically. This maximum is called {PIPE_BUF}. This volume of IEEE Std 1003.1-2001 does not say whether write requests for more than {PIPE_BUF} bytes are atomic, but requires that writes of {PIPE_BUF} or fewer bytes shall be atomic.
man说的大概意思就是如果是O_APPEND模式，文件尾的定位与write调用是原子操作，不会存在write时文件尾还需要再调整，导致错位。当前这个原子性，只保证open和之后的第一次write，后续的write就不保证了。像error_log那样如果buf过长导致了多次write肯定就不保证buf一次完整输出。
继续深究，那么单一次write是原子的吗？man也给出了答案，不是的，只有要写出的数据小于等于PIPE_BUF时才保证原子操作。
问题得到了理论上的解答，下面开始实验验证：
test_error_log.php
<!--?php
$str = ;
for($i = 0; $i < (int)$argv[2]; $i++)
{
$str = $str.$argv[1];
}
for($i = 0; $i < (int)$argv[3]; $i++)
{
error_log($str.
, 3, ./append.txt);
}
?-->
filename = ./append.txt
for line in open(filename):
print len(line)
#!/bin/bash
rm -f append.txt
for ((counter=0; counter < 10; ++counter))
do
php test_error_log.php $counter $1 $2 &
done
sleep 2
#python check_line.py > a.txt
python check_line.py | sort | uniq -c
