Otdfbt

I am trying to write some custom messages in my dmesg output. I tried:

logger "Hello"

but this does not work. It exits without error, but no "Hello" appears int the output of:

dmesg

I am using a Fedora 9, and it seems that there is no syslogd/klogd daemon running. However, all my kernel messages are succesfully written in the dmesg buffer.

Any idea?

dmesg displays what is in the kernel buffer, whereas logger is for syslogd. I think if you want to print things into the kernel buffer you will need to create a driver that uses the printk() kernel function. If you just want it in /var/log/messages, then with a "normal" setup I think what you have done with logger is already fine.

The most basic example of a driver with printk() would be:

hello.c:

#include <linux/module.h>
#include <linux/kernel.h>

int init_module(void)

 printk(KERN_INFO "Hello worldn");
 return 0;


void cleanup_module(void)

 printk(KERN_INFO "Goodbye worldn");

Makefile:

obj-m += hello.o

all:
 make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules

Then:

$ make
$ sudo insmod hello.ko
$ dmesg | tail -n1
 [7089996.746366] Hello world

http://tldp.org/LDP/lkmpg/2.6/html/lkmpg.html#AEN121 for more...

You can, as root, write to /dev/kmsg to print to the kernel message buffer:

 fixnum:~# echo Some message > /dev/kmsg
 fixnum:~# dmesg | tail -n1
 [28078118.692242] Some message

I've tested this on my server and an embedded Linux device, and it works on both, so I'm just going to assume it works pretty much everywhere.

Based on Kyle's module above:

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/proc_fs.h>
#include <asm/uaccess.h>

static int pk_write(struct file *file, const char *buffer, unsigned long count, void *data)

 char string[256];
 count = count < 255 ? count : 255;

 if(copy_from_user(string, buffer, count))
 return -EFAULT;

 string[count] = ''; 
 printk(string);
 return count;



static int __init printk_init(void)

 struct proc_dir_entry *pk_file;

 pk_file = create_proc_entry("printk", 0222, NULL);
 if(pk_file == NULL)
 return -ENOMEM;

 pk_file->write_proc = pk_write;
 pk_file->owner = THIS_MODULE;

 return 0;


static void __exit printk_cleanup(void)

 remove_proc_entry("printk", NULL);


module_init(printk_init);
module_exit(printk_cleanup);
MODULE_LICENSE("GPL");

To do a printk from user space:

echo "Hello" > /proc/printk

@Calandoa's answer no longer works for Kernel +3.10. Combined his code, and the example code I found here. Then improved on the code quality...

Code saved to printk_user.c

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/proc_fs.h>
#include <asm/uaccess.h>

static ssize_t write_proc(struct file *filep, const char *buffer, size_t count, loff_t *offsetp)

 char string[256];
 count = count < 255 ? count : 255;

 if(copy_from_user(string, buffer, count) != 0) 
 return -EFAULT;
 

 string[count] = '';
 printk(string);
 return count;


static const struct file_operations proc_fops = 
 .owner = THIS_MODULE,
 .write = write_proc,
;

static int proc_init(void) 
 struct proc_dir_entry *proc_file;
 proc_file = proc_create("printk_user", 0, NULL, &proc_fops);

 if(proc_file == NULL) 
 return -ENOMEM;
 

 return 0;


static void proc_cleanup(void) 
 remove_proc_entry("printk_user", NULL);


MODULE_LICENSE("GPL"); 
module_init(proc_init);
module_exit(proc_cleanup);

Make using this Makefile

TARGET = printk_user
obj-m := $(TARGET).o

KERNEL_VERSION=$(shell uname -r)
KDIR = /lib/modules/$(KERNEL_VERSION)/build
PWD = $(shell pwd)

printk:
 $(MAKE) -C $(KDIR) M=$(PWD) modules

clean:
 $(MAKE) -C $(KDIR) M=$(PWD) clean

Based off of Kyle's answer, here is a quick tutorial showing how to do just that.

Figured I'd go ahead and include a full blown example of something that people can just compile and run for those that aren't as skilled with C based off of @BuvinJ 's answer

#include <stdio.h>
#include <string.h>
#include <fcntl.h> // open function
#include <unistd.h> // close function
#include "sys/syscall.h"


int main(); // Let's not worry about this for now

void dmesg( const char *tag, const char *msg, const int len )

 const int TAG_LEN=3;
 char buffer[128]=0;
 memcpy( &buffer[0], tag, TAG_LEN );
 memcpy( &buffer[TAG_LEN], msg, len );
 int fd_kmsg = open( "/dev/kmsg", O_WRONLY );
 write( fd_kmsg, &buffer, TAG_LEN+len );
 close( fd_kmsg );

void dmesgWarn( const char *msg, const int len ) dmesg( "<4>", msg, len ); 
void dmesgInfo( const char *msg, const int len ) dmesg( "<6>", msg, len ); 
void dmesgDebug( const char *msg, const int len ) dmesg( "<7>", msg, len ); 


int main(int argc, char **argv)

 int getmysize = strlen(argv[1]);
 printf("%dn", getmysize);

 printf("To be written: %snSize of argument: %dn", argv[1], getmysize);
 // dmesgWarn dmesgInfo or dmesgDebug
 dmesgDebug(argv[1], getmysize);
;

To run save the above as kmsg.c and gcc kmsg.c -o kmsg;sudo ./kmsg "string you want to add to /dev/kmsg"

I just wanted some quick debugging messages in a daemon written by someone else in a cross complied kernel. I ran into a compile error trying to use printk, as <linux/module.h> could not be included. Rather then battle with that excessively (to do this the right way) I cheated and used the following lazy, but functional 5 minute workaround:

void dmesg( const char *tag, const char *msg, const int len )

 const int TAG_LEN=3;
 char buffer[128]=0;
 memcpy( &buffer[0], tag, TAG_LEN );
 memcpy( &buffer[TAG_LEN], msg, len );
 int fd_kmsg = open( "/dev/kmsg", O_WRONLY );
 write( fd_kmsg, &buffer, TAG_LEN+len );
 close( fd_kmsg );

void dmesgWarn( const char *msg, const int len ) dmesg( "<4>", msg, len ); 
void dmesgInfo( const char *msg, const int len ) dmesg( "<6>", msg, len ); 
void dmesgDebug( const char *msg, const int len ) dmesg( "<7>", msg, len );