net/tux/logger.c

   1 /*
   2  * TUX - Integrated Application Protocols Layer and Object Cache
   3  *
   4  * Copyright (C) 2000, 2001, Ingo Molnar <mingo@redhat.com>
   5  *
   6  * Cleaned up logger output for Alpha.
   7  * -- Phil Ezolt (Phillip.Ezolt@compaq.com) & Bill Carr (wcarr92@yahoo.com)
   8  *
   9  * logger.c: log requests finished by TUX.
  10  */
  11
  12 #define __KERNEL_SYSCALLS__
  13 #include <net/tux.h>
  14
  15 /****************************************************************
  16  *      This program is free software; you can redistribute it and/or modify
  17  *      it under the terms of the GNU General Public License as published by
  18  *      the Free Software Foundation; either version 2, or (at your option)
  19  *      any later version.
  20  *
  21  *      This program is distributed in the hope that it will be useful,
  22  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24  *      GNU General Public License for more details.
  25  *
  26  *      You should have received a copy of the GNU General Public License
  27  *      along with this program; if not, write to the Free Software
  28  *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  29  *
  30  ****************************************************************/
  31
  32 static spinlock_t log_lock = SPIN_LOCK_UNLOCKED;
  33 static unsigned int log_head, log_tail;
  34 static char * log_buffer = NULL;
  35 static DECLARE_WAIT_QUEUE_HEAD(log_wait);
  36 static DECLARE_WAIT_QUEUE_HEAD(log_full);
  37 static int logger_pid = 0;
  38
  39 /*
  40  * High-speed TUX logging architecture:
  41  *
  42  * All fast threads share a common log-ringbuffer. (default size 1MB)
  43  * Log entries are binary and are padded to be cacheline aligned, this
  44  * ensures that there is no cache-pingpong between fast threads.
  45  *
  46  * The logger thread writes out pending log entries within 1 second
  47  * (buffer-cache writes data out within 5 seconds). The logger thread
  48  * gets activated once we have more than 25% of the log ringbuffer
  49  * filled - or the 1 second log timeout expires. Fast threads block
  50  * if if more than 95% of the ringbuffer is filled and unblock only
  51  * if used logbuffer space drops below 90%.
  52  *
  53  * This architecture guarantees that 1) logging is reliable (no
  54  * log entry is ever lost), 2) timely (touches disk within 6 seconds),
  55  * 3) in the log-contention case the saturation behavior is still
  56  * write-clustered, but 4) if the logger thread can keep up then
  57  * the coupling is completely asynchron and parallel.
  58  *
  59  * The binary log format gives us about 50% saved IO/memory bandwith
  60  * and 50% less on-disk used log space than the traditional W3C ASCII
  61  * format.
  62  *
  63  * (We might switch to raw IO though to write the logfile.)
  64  */
  65
  66 #define SOFT_LIMIT              (LOG_LEN*25/100)
  67 #define HARD_LIMIT              (LOG_LEN*95/100)
  68 #define HARD_RELAX_LIMIT        (LOG_LEN*90/100)
  69
  70 unsigned int tux_logentry_align_order = 5;
  71
  72 #if SMP_CACHE_BYTES == 8
  73 # define TUX_LOGENTRY_ALIGN 3
  74 #else
  75 #if SMP_CACHE_BYTES == 16
  76 # define TUX_LOGENTRY_ALIGN 4
  77 #else
  78 #if SMP_CACHE_BYTES == 32
  79 # define TUX_LOGENTRY_ALIGN 5
  80 #else
  81 #if SMP_CACHE_BYTES == 64
  82 # define TUX_LOGENTRY_ALIGN 6
  83 #else
  84 #if SMP_CACHE_BYTES == 128
  85 # define TUX_LOGENTRY_ALIGN 7
  86 #else
  87 #if SMP_CACHE_BYTES == 256
  88 # define TUX_LOGENTRY_ALIGN 8
  89 #else
  90 #error Add entry!
  91 #endif
  92 #endif
  93 #endif
  94 #endif
  95 #endif
  96 #endif
  97
  98 #define ROUND_UP(x) (((((x)-1) >> TUX_LOGENTRY_ALIGN) + 1) \
  99                                         << TUX_LOGENTRY_ALIGN)
 100
 101 static void __throttle_logging (void)
 102 {
 103         DECLARE_WAITQUEUE(wait, current);
 104         int pending;
 105
 106         add_wait_queue(&log_full, &wait);
 107         for (;;) {
 108                 static unsigned long last_warning = 0;
 109
 110                 if (jiffies - last_warning > 10*HZ) {
 111                         last_warning = jiffies;
 112                         printk(KERN_NOTICE "TUX: log buffer overflow, have to throttle TUX thread!\n");
 113                 }
 114
 115                 current->state = TASK_INTERRUPTIBLE;
 116
 117                 spin_lock(&log_lock);
 118                 pending = log_head-log_tail;
 119                 spin_unlock(&log_lock);
 120
 121                 if ((pending % LOG_LEN) < HARD_LIMIT)
 122                         break;
 123
 124                 schedule();
 125         }
 126         current->state = TASK_RUNNING;
 127         remove_wait_queue(&log_full, &wait);
 128 }
 129
 130 #if CONFIG_TUX_DEBUG
 131 #define CHECK_LOGPTR(ptr) \
 132 do { \
 133         if ((ptr < log_buffer) || (ptr > log_buffer + LOG_LEN)) { \
 134                 printk(KERN_ERR "TUX: ouch: log ptr %p > %p + %ld!\n", \
 135                         ptr, log_buffer, LOG_LEN); \
 136                 TUX_BUG(); \
 137         } \
 138 } while (0)
 139 #else
 140 #define CHECK_LOGPTR(ptr) do { } while (0)
 141 #endif
 142
 143 void __log_request (tux_req_t *req)
 144 {
 145         char *str, *next;
 146         const char *uri_str;
 147         unsigned int inc, len, uri_len, pending, next_head, def_vhost_len = 0;
 148         unsigned long flags;
 149
 150         if (req->proto->pre_log)
 151                 req->proto->pre_log(req);
 152         /*
 153          * Log the reply status (success, or type of failure)
 154          */
 155         if (!tux_log_incomplete && (!req->status || (req->bytes_sent == -1))) {
 156
 157                 Dprintk("not logging req %p: {%s} [%d/%d]\n", req, req->uri_str, req->status, req->bytes_sent);
 158                 return;
 159         }
 160         Dprintk("uri: {%s} [%d]\n", req->uri_str, req->uri_len);
 161
 162 #define NO_URI "<none>"
 163         if (req->uri_len) {
 164                 uri_len = req->uri_len;
 165                 uri_str = req->uri_str;
 166         } else {
 167                 uri_str = NO_URI;
 168                 uri_len = sizeof(NO_URI)-1;
 169         }
 170         len = uri_len + 1;
 171
 172         if (req->virtual) {
 173                 if (req->host_len)
 174                         len += req->host_len;
 175                 else {
 176                         def_vhost_len = strlen(tux_default_vhost);
 177                         len += def_vhost_len;
 178                 }
 179         }
 180
 181         Dprintk("method_str: {%s} [%d]\n", req->method_str, req->method_len);
 182         len += req->method_len + 1;
 183
 184         Dprintk("version_str: {%s} [%d]\n", req->version_str, req->version_len);
 185         len += req->version_len + 1;
 186
 187 #if CONFIG_TUX_EXTENDED_LOG
 188         Dprintk("user_agent_str: {%s} [%d]\n", req->user_agent_str, req->user_agent_len);
 189         len += req->user_agent_len + 1;
 190 #endif
 191         if (tux_referer_logging) {
 192                 Dprintk("referer_str: {%s} [%d]\n", req->referer_str, req->referer_len);
 193                 len += req->referer_len;
 194         }
 195         len++;
 196
 197         inc = 5*sizeof(u32) + len;
 198 #if CONFIG_TUX_EXTENDED_LOG
 199         inc += 7*sizeof(u32);
 200 #endif
 201
 202         spin_lock_irqsave(&log_lock, flags);
 203
 204         next_head = ROUND_UP(log_head + inc);
 205
 206         if (next_head < LOG_LEN) {
 207                 str = log_buffer + log_head;
 208                 if (str > log_buffer + LOG_LEN)
 209                         TUX_BUG();
 210                 log_head = next_head;
 211         } else {
 212                 if (log_head < LOG_LEN)
 213                         memset(log_buffer+log_head, 0, LOG_LEN-log_head);
 214                 str = log_buffer;
 215                 log_head = ROUND_UP(inc);
 216         }
 217
 218         if (str < log_buffer || str+inc >= log_buffer+LOG_LEN)
 219                 TUX_BUG();
 220
 221         /*
 222          * Log record signature - this makes finding the next entry
 223          * easier (since record length is variable), and makes the
 224          * binary logfile more robust against potential data corruption
 225          * and other damage. The signature also servers as a log format
 226          * version identifier.
 227          */
 228 #if CONFIG_TUX_EXTENDED_LOG
 229         *(u32 *)str = 0x2223beef;
 230 #else
 231         *(u32 *)str = 0x1112beef;
 232 #endif
 233         str += sizeof(u32);
 234         CHECK_LOGPTR(str);
 235
 236         *(u32 *)str = 0;
 237         /*
 238          * Log the client IP address:
 239          */
 240         if (tux_ip_logging)
 241                 *(u32 *)str = req->client_addr;
 242         str += sizeof(u32);
 243         CHECK_LOGPTR(str);
 244
 245 #if CONFIG_TUX_EXTENDED_LOG
 246         /*
 247          * Log the client port number:
 248          */
 249         *(u32 *)str = 0;
 250         if (tux_ip_logging)
 251                 *(u32 *)str = req->client_port;
 252         str += sizeof(u32);
 253         CHECK_LOGPTR(str);
 254 #endif
 255
 256         /*
 257          * Log the request timestamp, in units of 'seconds since 1970'.
 258          */
 259         *(u32 *)str = CURRENT_TIME.tv_sec;
 260         str += sizeof(u32);
 261         CHECK_LOGPTR(str);
 262
 263 #if CONFIG_TUX_EXTENDED_LOG
 264         *(u32 *)str = req->accept_timestamp; str += sizeof(u32);
 265         *(u32 *)str = req->parse_timestamp; str += sizeof(u32);
 266         *(u32 *)str = req->output_timestamp; str += sizeof(u32);
 267         *(u32 *)str = req->flush_timestamp; str += sizeof(u32);
 268         *(u32 *)str = req->had_cachemiss; str += sizeof(u32);
 269         *(u32 *)str = req->keep_alive; str += sizeof(u32);
 270 #endif
 271         /*
 272          * Log the requested file size (in fact, log actual bytes sent.)
 273          */
 274         *(u32 *)str = req->bytes_sent;
 275         str += sizeof(u32);
 276         CHECK_LOGPTR(str);
 277
 278         *(u32 *)str = req->status;
 279         str += sizeof(u32);
 280         CHECK_LOGPTR(str);
 281
 282         /*
 283          * Zero-terminated method, (base) URI, query and version string.
 284          */
 285         if (req->method_len) {
 286                 memcpy(str, req->method_str, req->method_len);
 287                 str += req->method_len;
 288                 CHECK_LOGPTR(str);
 289         }
 290         *str++ = 0;
 291
 292         if (req->virtual) {
 293                 if (req->host_len) {
 294                         memcpy(str, req->host, req->host_len);
 295                         str += req->host_len;
 296                 } else {
 297                         memcpy(str, tux_default_vhost, def_vhost_len);
 298                         str += def_vhost_len;
 299                 }
 300                 CHECK_LOGPTR(str);
 301         }
 302
 303         memcpy(str, uri_str, uri_len);
 304         str += uri_len;
 305         *str++ = 0;
 306
 307         CHECK_LOGPTR(str);
 308
 309         if (req->version_len) {
 310                 memcpy(str, req->version_str, req->version_len);
 311                 str += req->version_len;
 312                 CHECK_LOGPTR(str);
 313         }
 314         *str++ = 0;
 315 #if CONFIG_TUX_EXTENDED_LOG
 316         if (req->user_agent_len) {
 317                 memcpy(str, req->user_agent_str, req->user_agent_len);
 318                 str += req->user_agent_len;
 319                 CHECK_LOGPTR(str);
 320         }
 321         *str++ = 0;
 322 #endif
 323         CHECK_LOGPTR(str);
 324
 325         if (tux_referer_logging && req->referer_len) {
 326                 memcpy(str, req->referer_str, req->referer_len);
 327                 str += req->referer_len;
 328                 CHECK_LOGPTR(str);
 329         }
 330         *str++ = 0;
 331         CHECK_LOGPTR(str);
 332         /*
 333          * pad with spaces to next cacheline, with an ending newline.
 334          * (not needed for the user-space log utility, but results in
 335          * a more readable binary log file, and reduces the amount
 336          * of cache pingpong.)
 337          */
 338         next = (char *)ROUND_UP((unsigned long)str);
 339
 340         CHECK_LOGPTR(next);
 341         len = next-str;
 342         memset(str, ' ', len);
 343
 344         pending = (log_head-log_tail) % LOG_LEN;
 345         spin_unlock_irqrestore(&log_lock, flags);
 346
 347         if (pending >= SOFT_LIMIT)
 348                 wake_up(&log_wait);
 349
 350         if (pending >= HARD_LIMIT)
 351                 __throttle_logging();
 352 }
 353
 354 void tux_push_pending (struct sock *sk)
 355 {
 356         struct tcp_opt *tp = tcp_sk(sk);
 357
 358         Dprintk("pushing pending frames on sock %p.\n", sk);
 359         lock_sock(sk);
 360         if ((sk->sk_state == TCP_ESTABLISHED) && !sk->sk_err) {
 361                 tp->ack.pingpong = tux_ack_pingpong;
 362                 tp->nonagle = 1;
 363                 __tcp_push_pending_frames(sk, tp, tcp_current_mss(sk, 0), TCP_NAGLE_OFF);
 364         }
 365         release_sock(sk);
 366 }
 367
 368 inline void tux_push_req (tux_req_t *req)
 369 {
 370         if (req->sock)
 371                 tux_push_pending(req->sock->sk);
 372         if (req->data_sock)
 373                 tux_push_pending(req->data_sock->sk);
 374 }
 375
 376 void __put_data_sock (tux_req_t *req)
 377 {
 378         unlink_tux_data_socket(req);
 379         if (req->data_sock->file)
 380                 fput(req->data_sock->file);
 381         else
 382                 sock_release(req->data_sock);
 383         req->data_sock = NULL;
 384 }
 385
 386 void flush_request (tux_req_t *req, int cachemiss)
 387 {
 388         struct socket *sock;
 389         struct sock *sk;
 390         int keep_alive;
 391
 392         if (cachemiss)
 393                 TUX_BUG();
 394         __set_task_state(current, TASK_RUNNING);
 395
 396         if (req->magic != TUX_MAGIC)
 397                 TUX_BUG();
 398         if (req->ti->thread != current)
 399                 TUX_BUG();
 400 #if CONFIG_TUX_DEBUG
 401         if (req->bytes_expected && (req->bytes_sent != req->bytes_expected)) {
 402                 printk("hm, bytes_expected: %d != bytes_sent: %d!\n",
 403                         req->bytes_expected, req->bytes_sent);
 404                 TUX_BUG();
 405         }
 406 #endif
 407         SET_TIMESTAMP(req->flush_timestamp);
 408
 409         log_request(req);
 410         sock = req->sock;
 411         sk = NULL;
 412         if (sock)
 413                 sk = sock->sk;
 414         Dprintk("FLUSHING req %p <%p> (sock %p, sk %p) (keepalive: %d, status: %d)\n", req, __builtin_return_address(0), sock, sk, req->keep_alive, req->status);
 415         if (req->in_file->f_pos)
 416                 /*TUX_BUG()*/;
 417         release_req_dentry(req);
 418         req->private = 0;
 419
 420         if (req->docroot_dentry) {
 421                 dput(req->docroot_dentry);
 422                 req->docroot_dentry = NULL;
 423                 if (!req->docroot_mnt)
 424                         TUX_BUG();
 425         }
 426         if (req->docroot_mnt) {
 427                 mntput(req->docroot_mnt);
 428                 req->docroot_mnt = NULL;
 429         }
 430
 431         req->offset_start = 0;
 432         req->offset_end = 0;
 433         req->output_len = 0;
 434         req->total_file_len = 0;
 435         req->lendigits = 0;
 436         req->mtime = 0;
 437         req->etaglen = 0;
 438         req->etag[0] = 0;
 439         req->ftp_command = 0;
 440
 441         if (req->postponed)
 442                 TUX_BUG();
 443         if (test_bit(0, &req->idle_input))
 444                 TUX_BUG();
 445         if (test_bit(0, &req->wait_output_space))
 446                 TUX_BUG();
 447         if (req->parsed_len)
 448                 trunc_headers(req);
 449         if (req->parsed_len)
 450                 TUX_BUG();
 451         req->attr = NULL;
 452         req->usermode = 0;
 453         req->usermodule_idx = 0;
 454         req->atom_idx = 0;
 455         if (req->module_dentry) {
 456                 dput(req->module_dentry);
 457                 req->module_dentry = NULL;
 458         }
 459         if (req->headers)
 460                 kfree(req->headers);
 461         req->headers = NULL;
 462         req->headers_len = 0;
 463
 464         req->method = METHOD_NONE;
 465         req->method_len = 0;
 466         req->method_str = NULL;
 467         req->version = 0;
 468         req->version_str = NULL;
 469         req->version_len = 0;
 470
 471         req->uri_str = NULL;
 472         req->uri_len = 0;
 473
 474         req->objectname[0] = 0;
 475         req->objectname_len = 0;
 476
 477         req->query_str = NULL;
 478         req->query_len = 0;
 479
 480         req->cookies_str = NULL;
 481         req->cookies_len = 0;
 482         req->parse_cookies = 0;
 483
 484         req->contentlen_str = NULL;
 485         req->contentlen_len = 0;
 486         req->content_len = 0;
 487
 488         req->user_agent_str = NULL;
 489         req->user_agent_len = 0;
 490
 491         req->may_send_gzip = 0;
 492         req->content_gzipped = 0;
 493
 494         req->content_type_str = NULL;
 495         req->content_type_len = 0;
 496
 497         req->accept_str = NULL;
 498         req->accept_len = 0;
 499
 500         req->accept_charset_str = NULL;
 501         req->accept_charset_len = 0;
 502
 503         req->accept_encoding_str = NULL;
 504         req->accept_encoding_len = 0;
 505
 506         req->accept_language_str = NULL;
 507         req->accept_language_len = 0;
 508
 509         req->cache_control_str = NULL;
 510         req->cache_control_len = 0;
 511
 512         req->if_modified_since_str = NULL;
 513         req->if_modified_since_len = 0;
 514
 515         req->if_none_match_str = NULL;
 516         req->if_none_match_len = 0;
 517
 518         req->if_range_str = NULL;
 519         req->if_range_len = 0;
 520
 521         req->negotiate_str = NULL;
 522         req->negotiate_len = 0;
 523
 524         req->pragma_str = NULL;
 525         req->pragma_len = 0;
 526
 527         req->referer_str = NULL;
 528         req->referer_len = 0;
 529
 530         req->post_data_str = NULL;
 531         req->post_data_len = 0;
 532
 533         SET_TIMESTAMP(req->accept_timestamp);
 534 #if CONFIG_TUX_EXTENDED_LOG
 535         req->parse_timestamp = 0;
 536         req->output_timestamp = 0;
 537         req->flush_timestamp = 0;
 538 #endif
 539         req->status = 0;
 540
 541         req->total_bytes += req->bytes_sent;
 542         req->bytes_sent = 0;
 543 #if CONFIG_TUX_DEBUG
 544         req->bytes_expected = 0;
 545 #endif
 546         req->body_len = 0;
 547         keep_alive = req->keep_alive;
 548         clear_keepalive(req);
 549         req->had_cachemiss = 0;
 550         // first_timestamp and total_bytes is kept!
 551         req->event = 0;
 552         req->lookup_dir = 0;
 553         req->lookup_404 = 0;
 554
 555         req->error = 0;
 556         req->user_error = 0;
 557
 558         if (req->abuf.page)
 559                 __free_page(req->abuf.page);
 560         memset(&req->abuf, 0, sizeof(req->abuf));
 561
 562         if (sk && keep_alive) {
 563                 add_tux_atom(req, parse_request);
 564                 if (skb_queue_empty(&sk->sk_receive_queue)) {
 565                         spin_lock_irq(&req->ti->work_lock);
 566                         add_keepalive_timer(req);
 567                         if (test_and_set_bit(0, &req->idle_input))
 568                                 TUX_BUG();
 569                         /*
 570                          * Avoid the race with the event callback:
 571                          */
 572                         if (skb_queue_empty(&sk->sk_receive_queue) ||
 573                                    !test_and_clear_bit(0, &req->idle_input)) {
 574                                 INC_STAT(nr_idle_input_pending);
 575                                 spin_unlock_irq(&req->ti->work_lock);
 576                                 tux_push_req(req);
 577                                 goto out;
 578                         }
 579                         del_keepalive_timer(req);
 580                         spin_unlock_irq(&req->ti->work_lock);
 581                 }
 582                 Dprintk("KEEPALIVE PENDING req %p <%p> (sock %p, sk %p) (keepalive: %d, status: %d)\n", req, __builtin_return_address(0), req->sock, req->sock->sk, req->keep_alive, req->status);
 583                 add_req_to_workqueue(req);
 584                 INC_STAT(nr_keepalive_optimized);
 585                 goto out;
 586         }
 587
 588         del_timer_sync(&req->keepalive_timer);
 589         del_timer_sync(&req->output_timer);
 590
 591         if (timer_pending(&req->keepalive_timer))
 592                 TUX_BUG();
 593         if (timer_pending(&req->output_timer))
 594                 TUX_BUG();
 595         if (!list_empty(&req->lru))
 596                 TUX_BUG();
 597         req->nr_keepalives = 0;
 598         req->client_addr = 0;
 599         req->client_port = 0;
 600         req->virtual = 0;
 601         req->ftp_offset_start = 0;
 602
 603         req->host[0] = 0;
 604         req->host_len = 0;
 605
 606         if (req->cwd_dentry) {
 607                 dput(req->cwd_dentry);
 608                 req->cwd_dentry = NULL;
 609                 if (!req->cwd_mnt)
 610                         TUX_BUG();
 611         }
 612         if (req->cwd_mnt) {
 613                 mntput(req->cwd_mnt);
 614                 req->cwd_mnt = NULL;
 615         }
 616         put_data_sock(req);
 617         req->prev_pos = 0;
 618         req->curroff = 0;
 619         req->total = 0;
 620         if (req->dirp0) {
 621                 kfree(req->dirp0);
 622                 req->dirp0 = NULL;
 623         }
 624
 625         if (sk)
 626                 unlink_tux_socket(req);
 627         req->sock = NULL;
 628         /*
 629          * Close potential user-space file descriptors.
 630          */
 631         {
 632                 int fd = req->fd, ret;
 633
 634                 if (fd != -1) {
 635                         Dprintk("closing req->fd: %d\n", fd);
 636                         req->fd = -1;
 637                         ret = tux_close(fd);
 638                         if (ret)
 639                                 TUX_BUG();
 640                 } else
 641                         if (sock)
 642                                 sock_release(sock);
 643         }
 644         kfree_req(req);
 645 out:
 646         ;
 647 }
 648
 649 static int warn_once = 1;
 650
 651 static loff_t log_filp_last_index;
 652
 653 static unsigned int writeout_log (void)
 654 {
 655         unsigned int len, pending, next_log_tail;
 656         mm_segment_t oldmm = get_fs();
 657         struct file *log_filp;
 658         char * str;
 659         unsigned int ret;
 660         struct inode *inode;
 661         struct address_space *mapping;
 662
 663         if (tux_logging)
 664                 Dprintk("TUX logger: opening log file {%s}.\n", tux_logfile);
 665         log_filp = tux_open_file(tux_logfile, O_CREAT|O_APPEND|O_WRONLY|O_LARGEFILE);
 666         if (!log_filp) {
 667                 if (warn_once) {
 668                         printk(KERN_ERR "TUX: could not open log file {%s}!\n",
 669                                 tux_logfile);
 670                         warn_once = 0;
 671                 }
 672                 __set_current_state(TASK_INTERRUPTIBLE);
 673                 schedule_timeout(HZ);
 674                 return 0;
 675         }
 676         spin_lock(&log_lock);
 677         str = log_buffer + log_tail;
 678         if (log_head < log_tail) {
 679                 len = LOG_LEN-log_tail;
 680                 next_log_tail = 0;
 681         } else {
 682                 len = log_head-log_tail;
 683                 next_log_tail = log_head;
 684         }
 685         if (!len)
 686                 goto out;
 687         spin_unlock(&log_lock);
 688
 689         set_fs(KERNEL_DS);
 690         ret = log_filp->f_op->write(log_filp, str, len, &log_filp->f_pos);
 691         set_fs(oldmm);
 692
 693         if (len != ret) {
 694                 if (ret == -ENOSPC) {
 695                         printk(KERN_ERR "TUX: trying to write TUX logfile %s, but filesystem is full! Lost %d bytes of log data.\n", tux_logfile, len);
 696                 } else {
 697                         printk(KERN_ERR "TUX: log write %d != %d.\n", ret, len);
 698                         printk(KERN_ERR "TUX: log_filp: %p, str: %p, len: %d str[len-1]: %d.\n", log_filp, str, len, str[len-1]);
 699                 }
 700                 goto out_lock;
 701         }
 702
 703         /*
 704          * Sync log data to disk:
 705          */
 706         inode = log_filp->f_dentry->d_inode;
 707         mapping = inode->i_mapping;
 708         if (mapping->nrpages > 256) {   /* batch stuff up */
 709                 down(&inode->i_sem);
 710                 filemap_fdatawrite(inode->i_mapping);
 711
 712                 /*
 713                  * Now nuke old pagecache up to the place where we just
 714                  * started the I/O.   There's no point in trying to invalidate
 715                  * pages after that, because they're currently in-flight.
 716                  */
 717                 invalidate_mapping_pages(mapping, 0, log_filp_last_index);
 718                 log_filp_last_index = log_filp->f_pos >> PAGE_CACHE_SHIFT;
 719                 up(&inode->i_sem);
 720         }
 721
 722 out_lock:
 723         spin_lock(&log_lock);
 724 out:
 725         log_tail = next_log_tail;
 726         pending = (log_head-log_tail) % LOG_LEN;
 727         spin_unlock(&log_lock);
 728
 729         if (pending < HARD_LIMIT)
 730                 wake_up(&log_full);
 731
 732         fput(log_filp);
 733         return pending;
 734 }
 735
 736 static DECLARE_WAIT_QUEUE_HEAD(stop_logger_wait);
 737 static int stop_logger = 0;
 738
 739 static int logger_thread (void *data)
 740 {
 741         DECLARE_WAITQUEUE(wait, current);
 742         mm_segment_t oldmm;
 743
 744         daemonize("TUX logger");
 745
 746         oldmm = get_fs();
 747         set_fs(KERNEL_DS);
 748         printk(KERN_NOTICE "TUX: logger thread started.\n");
 749 #if CONFIG_SMP
 750         {
 751                 cpumask_t map;
 752
 753                 cpus_and(map, cpu_online_map, tux_log_cpu_mask);
 754                 if (!(cpus_empty(map)))
 755                         set_cpus_allowed(current, map);
 756
 757         }
 758 #endif
 759
 760
 761         spin_lock_irq(&current->sighand->siglock);
 762         siginitsetinv(&current->blocked, 0);
 763         recalc_sigpending();
 764         spin_unlock_irq(&current->sighand->siglock);
 765
 766         if (log_buffer)
 767                 TUX_BUG();
 768         log_buffer = vmalloc(LOG_LEN);
 769         memset(log_buffer, 0, LOG_LEN);
 770         log_head = log_tail = 0;
 771
 772         current->signal->rlim[RLIMIT_FSIZE].rlim_cur = RLIM_INFINITY;
 773
 774         add_wait_queue(&log_wait, &wait);
 775         for (;;) {
 776                 if (tux_logging)
 777                         Dprintk("logger does writeout - stop:%d.\n", stop_logger);
 778
 779                 while (writeout_log() >= SOFT_LIMIT) {
 780                         if (stop_logger)
 781                                 break;
 782                 }
 783                 if (stop_logger)
 784                         break;
 785                         /* nothing */;
 786
 787                 if (tux_logging)
 788                         Dprintk("logger does sleep - stop:%d.\n", stop_logger);
 789                 __set_current_state(TASK_INTERRUPTIBLE);
 790                 if (log_head != log_tail) {
 791                         __set_current_state(TASK_RUNNING);
 792                         continue;
 793                 }
 794                 schedule_timeout(HZ);
 795                 if (tux_logging)
 796                         Dprintk("logger back from sleep - stop:%d.\n", stop_logger);
 797                 if (signal_pending(current))
 798                         flush_all_signals();
 799         }
 800         remove_wait_queue(&log_wait, &wait);
 801
 802         vfree(log_buffer);
 803         log_buffer = NULL;
 804         stop_logger = 0;
 805         wake_up(&stop_logger_wait);
 806
 807         set_fs(oldmm);
 808
 809         return 0;
 810 }
 811
 812 void start_log_thread (void)
 813 {
 814         warn_once = 1;
 815
 816         logger_pid = kernel_thread(logger_thread, NULL, 0);
 817         if (logger_pid < 0)
 818                 TUX_BUG();
 819 }
 820
 821 void stop_log_thread (void)
 822 {
 823         DECLARE_WAITQUEUE(wait, current);
 824
 825         Dprintk("stopping logger thread %d ...\n", logger_pid);
 826
 827         __set_current_state(TASK_UNINTERRUPTIBLE);
 828         add_wait_queue(&stop_logger_wait, &wait);
 829         stop_logger = 1;
 830         wake_up(&log_wait);
 831         schedule();
 832         __set_current_state(TASK_RUNNING);
 833         remove_wait_queue(&stop_logger_wait, &wait);
 834
 835         Dprintk("logger thread stopped!\n");
 836 }