Changeset 241 for ksyslog/trunk


Ignore:
Timestamp:
10/01/13 03:38:02 (11 years ago)
Author:
atzm
Message:

add nr_written and nr_dropped

Location:
ksyslog/trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • ksyslog/trunk/ksyslog.c

    r240 r241  
    2626static struct proc_dir_entry *ksyslog_proc_queue = NULL; 
    2727static struct proc_dir_entry *ksyslog_proc_nr_queued = NULL; 
     28static struct proc_dir_entry *ksyslog_proc_nr_written = NULL; 
     29static struct proc_dir_entry *ksyslog_proc_nr_dropped = NULL; 
    2830#endif 
    2931 
     
    3133static ushort ksyslog_port = 514; 
    3234static char *ksyslog_path = "/var/log/ksyslog.log"; 
    33 static uint ksyslog_queue_max = 2048; 
     35static ulong ksyslog_queue_length = 2048; 
    3436static ulong ksyslog_flush_interval = 45;  /* milliseconds */ 
    3537 
     
    3739module_param(ksyslog_port, ushort, 0444); 
    3840module_param(ksyslog_path, charp, 0644); 
    39 module_param(ksyslog_queue_max, uint, 0644); 
     41module_param(ksyslog_queue_length, ulong, 0644); 
    4042module_param(ksyslog_flush_interval, ulong, 0644); 
     43 
     44static void 
     45ksyslog_queue_init(struct ksyslog_queue *queue) 
     46{ 
     47        memset(queue, 0, sizeof(*queue)); 
     48        INIT_LIST_HEAD(&queue->head); 
     49        atomic64_set(&queue->nr_queued, 0); 
     50        atomic64_set(&queue->nr_written, 0); 
     51        atomic64_set(&queue->nr_dropped, 0); 
     52} 
    4153 
    4254static int 
     
    214226ksyslog_entry_add(struct ksyslog_queue *queue, struct ksyslog_entry *entry) 
    215227{ 
    216         if (unlikely(queue->length >= ksyslog_queue_max)) 
     228        if (unlikely(atomic64_read(&queue->nr_queued) >= ksyslog_queue_length)) 
    217229                return -ENOBUFS; 
    218230        list_add_tail_rcu(&entry->list, &queue->head); 
    219         WARN_ON(++queue->length > ksyslog_queue_max); 
     231        WARN_ON(atomic64_inc_return(&queue->nr_queued) > ksyslog_queue_length); 
    220232        return 0; 
    221233} 
     
    224236ksyslog_entry_del(struct ksyslog_queue *queue, struct ksyslog_entry *entry, bool free) 
    225237{ 
    226         WARN_ON(--queue->length < 0); 
     238        WARN_ON(atomic64_dec_return(&queue->nr_queued) < 0); 
    227239        list_del_rcu(&entry->list); 
    228240        if (free) 
     
    247259                ksyslog_entry_del(from, entry, false); 
    248260                if (unlikely(ksyslog_entry_add(to, entry))) { 
     261                        atomic64_inc(&from->nr_dropped); 
     262                        atomic64_inc(&to->nr_dropped); 
    249263                        ksyslog_drop_warning(entry); 
    250264                        call_rcu(&entry->rcu, ksyslog_entry_free); 
     
    272286        struct ksyslog_queue write_queue; 
    273287 
    274         memset(&write_queue, 0, sizeof(write_queue)); 
    275         INIT_LIST_HEAD(&write_queue.head); 
     288        ksyslog_queue_init(&write_queue); 
    276289 
    277290        spin_lock_bh(&ksyslog_queue_lock); 
     
    279292        spin_unlock_bh(&ksyslog_queue_lock); 
    280293 
    281         if (write_queue.length <= 0) 
     294        if (atomic64_read(&write_queue.nr_queued) <= 0) 
    282295                goto out; 
    283296 
     
    310323                } 
    311324 
     325                atomic64_inc(&ksyslog_queue.nr_written); 
    312326                kfree(buf); 
    313327                call_rcu(&entry->rcu, ksyslog_entry_free); 
     
    317331                spin_lock_bh(&ksyslog_queue_lock); 
    318332                if (unlikely(ksyslog_entry_add(&ksyslog_queue, entry))) { 
     333                        atomic64_inc(&ksyslog_queue.nr_dropped); 
    319334                        ksyslog_drop_warning(entry); 
    320335                        call_rcu(&entry->rcu, ksyslog_entry_free); 
     
    338353        struct ksyslog_entry *entry; 
    339354 
    340         err = skb_linearize(skb); 
    341         if (unlikely(err)) 
    342                 goto out; 
     355        if (unlikely(skb_linearize(skb))) 
     356                goto err; 
    343357 
    344358        iph = ip_hdr(skb); 
    345359        udph = udp_hdr(skb); 
    346360 
    347         if (unlikely(!skb_pull(skb, sizeof(*udph)))) { 
    348                 err = -EINVAL; 
    349                 goto out; 
    350         } 
     361        if (unlikely(!skb_pull(skb, sizeof(*udph)))) 
     362                goto err; 
    351363 
    352364        entry = ksyslog_entry_create(skb, iph, udph); 
    353         if (unlikely(IS_ERR(entry))) { 
    354                 err = PTR_ERR(entry); 
    355                 goto out; 
    356         } 
     365        if (unlikely(IS_ERR(entry))) 
     366                goto err; 
    357367 
    358368        spin_lock_bh(&ksyslog_queue_lock); 
     
    360370        spin_unlock_bh(&ksyslog_queue_lock); 
    361371 
    362         if (unlikely(err)) 
     372        if (unlikely(err)) { 
     373                ksyslog_drop_warning(entry); 
    363374                ksyslog_entry_free(&entry->rcu); 
     375                goto err; 
     376        } 
    364377 
    365378out: 
    366         if (unlikely(err)) 
    367                 UDP_INC_STATS_BH(sock_net(sk), UDP_MIB_INERRORS, IS_UDPLITE(sk)); 
    368  
    369379        consume_skb(skb); 
    370380        return 0; 
     381 
     382err: 
     383        atomic64_inc(&ksyslog_queue.nr_dropped); 
     384        goto out; 
    371385} 
    372386 
     
    446460ksyslog_nr_queued_seq_show(struct seq_file *seq, void *v) 
    447461{ 
    448         seq_printf(seq, "%u\n", ksyslog_queue.length); 
     462        seq_printf(seq, "%lu\n", atomic64_read(&ksyslog_queue.nr_queued)); 
    449463        return 0; 
    450464} 
     
    454468{ 
    455469        return single_open(file, ksyslog_nr_queued_seq_show, PDE(inode)->data); 
     470} 
     471 
     472static int 
     473ksyslog_nr_written_seq_show(struct seq_file *seq, void *v) 
     474{ 
     475        seq_printf(seq, "%lu\n", atomic64_read(&ksyslog_queue.nr_written)); 
     476        return 0; 
     477} 
     478 
     479static int 
     480ksyslog_nr_written_seq_open(struct inode *inode, struct file *file) 
     481{ 
     482        return single_open(file, ksyslog_nr_written_seq_show, PDE(inode)->data); 
     483} 
     484 
     485static int 
     486ksyslog_nr_dropped_seq_show(struct seq_file *seq, void *v) 
     487{ 
     488        seq_printf(seq, "%lu\n", atomic64_read(&ksyslog_queue.nr_dropped)); 
     489        return 0; 
     490} 
     491 
     492static int 
     493ksyslog_nr_dropped_seq_open(struct inode *inode, struct file *file) 
     494{ 
     495        return single_open(file, ksyslog_nr_dropped_seq_show, PDE(inode)->data); 
    456496} 
    457497 
     
    464504}; 
    465505 
     506static struct file_operations ksyslog_nr_written_fops = { 
     507        .owner   = THIS_MODULE, 
     508        .open    = ksyslog_nr_written_seq_open, 
     509        .read    = seq_read, 
     510        .llseek  = seq_lseek, 
     511        .release = single_release, 
     512}; 
     513 
     514static struct file_operations ksyslog_nr_dropped_fops = { 
     515        .owner   = THIS_MODULE, 
     516        .open    = ksyslog_nr_dropped_seq_open, 
     517        .read    = seq_read, 
     518        .llseek  = seq_lseek, 
     519        .release = single_release, 
     520}; 
     521 
     522static void 
     523ksyslog_proc_destroy(void) 
     524{ 
     525        if (ksyslog_proc_queue) 
     526                remove_proc_entry(ksyslog_proc_queue->name, ksyslog_proc_queue->parent); 
     527        ksyslog_proc_queue = NULL; 
     528 
     529        if (ksyslog_proc_nr_queued) 
     530                remove_proc_entry(ksyslog_proc_nr_queued->name, ksyslog_proc_nr_queued->parent); 
     531        ksyslog_proc_nr_queued = NULL; 
     532 
     533        if (ksyslog_proc_nr_written) 
     534                remove_proc_entry(ksyslog_proc_nr_written->name, ksyslog_proc_nr_written->parent); 
     535        ksyslog_proc_nr_written = NULL; 
     536 
     537        if (ksyslog_proc_nr_dropped) 
     538                remove_proc_entry(ksyslog_proc_nr_dropped->name, ksyslog_proc_nr_dropped->parent); 
     539        ksyslog_proc_nr_dropped = NULL; 
     540 
     541        if (ksyslog_procdir) 
     542                remove_proc_entry(ksyslog_procdir->name, ksyslog_procdir->parent); 
     543        ksyslog_procdir = NULL; 
     544} 
     545 
    466546static int 
    467547ksyslog_proc_init(void) 
     
    470550        if (ksyslog_procdir == NULL) { 
    471551                pr_err("proc_mkdir failed\n"); 
    472                 return -ENOMEM; 
     552                goto err; 
    473553        } 
    474554 
     
    476556                                              &ksyslog_queue_fops, &ksyslog_queue.head); 
    477557        if (ksyslog_proc_queue == NULL) { 
    478                 remove_proc_entry(ksyslog_procdir->name, ksyslog_procdir->parent); 
    479                 pr_err("proc_create_data failed\n"); 
    480                 return -ENOMEM; 
     558                pr_err("proc_create(queue) failed\n"); 
     559                goto err; 
    481560        } 
    482561 
    483562        ksyslog_proc_nr_queued = proc_create("nr_queued", S_IRUGO, ksyslog_procdir, 
    484                                              &ksyslog_nr_queued_fops); 
     563                                              &ksyslog_nr_queued_fops); 
    485564        if (ksyslog_proc_nr_queued == NULL) { 
    486                 remove_proc_entry(ksyslog_proc_queue->name, ksyslog_proc_queue->parent); 
    487                 remove_proc_entry(ksyslog_procdir->name, ksyslog_procdir->parent); 
    488                 pr_err("proc_create failed\n"); 
    489                 return -ENOMEM; 
    490         } 
    491  
    492         return 0; 
    493 } 
    494  
    495 static void 
    496 ksyslog_proc_destroy(void) 
    497 { 
    498         if (ksyslog_proc_nr_queued) 
    499                 remove_proc_entry(ksyslog_proc_nr_queued->name, ksyslog_proc_nr_queued->parent); 
    500         ksyslog_proc_nr_queued = NULL; 
    501  
    502         if (ksyslog_proc_queue) 
    503                 remove_proc_entry(ksyslog_proc_queue->name, ksyslog_proc_queue->parent); 
    504         ksyslog_proc_queue = NULL; 
    505  
    506         if (ksyslog_procdir) 
    507                 remove_proc_entry(ksyslog_procdir->name, ksyslog_procdir->parent); 
    508         ksyslog_procdir = NULL; 
     565                pr_err("proc_create(nr_queued) failed\n"); 
     566                goto err; 
     567        } 
     568 
     569        ksyslog_proc_nr_written = proc_create("nr_written", S_IRUGO, ksyslog_procdir, 
     570                                              &ksyslog_nr_written_fops); 
     571        if (ksyslog_proc_nr_written == NULL) { 
     572                pr_err("proc_create(nr_written) failed\n"); 
     573                goto err; 
     574        } 
     575 
     576        ksyslog_proc_nr_dropped = proc_create("nr_dropped", S_IRUGO, ksyslog_procdir, 
     577                                              &ksyslog_nr_dropped_fops); 
     578        if (ksyslog_proc_nr_dropped == NULL) { 
     579                pr_err("proc_create(nr_dropped) failed\n"); 
     580                goto err; 
     581        } 
     582 
     583        return 0; 
     584 
     585err: 
     586        ksyslog_proc_destroy(); 
     587        return -ENOMEM; 
    509588} 
    510589#endif 
     
    537616        struct sockaddr_in sin; 
    538617 
    539         INIT_LIST_HEAD(&ksyslog_queue.head); 
     618        ksyslog_queue_init(&ksyslog_queue); 
    540619 
    541620#ifdef CONFIG_PROC_FS 
  • ksyslog/trunk/ksyslog.h

    r236 r241  
    7474struct ksyslog_queue { 
    7575        struct list_head head; 
    76         unsigned int length; 
     76        atomic64_t nr_queued; 
     77        atomic64_t nr_written; 
     78        atomic64_t nr_dropped; 
    7779}; 
    7880 
Note: See TracChangeset for help on using the changeset viewer.