Kernel API 3 - Linux Driver Model #

1 Kernel API 3 - Linux Driver Model

1.1 리눅스 디바이스 드라이버 개요

1.2 디바이스 드라이버의 객체 개념

1.2.1 subsystem, kset, ktype, kobj의 관계

1.3 kref

1.3.1 kref API

1.3.1.1 struct kref

1.3.1.2 kref_init

1.3.1.3 kref_get

1.3.1.4 kref_put

1.4 kobject

1.4.1 kobject API

1.4.1.1 kobject_set_name

1.4.1.2 kobject_name

1.4.1.3 kobject_init

1.4.1.4 kobject_cleanup

1.4.1.5 kobject_add

1.4.1.6 kobject_del

1.4.1.7 kobject_register

1.4.1.8 kobject_unregister

1.4.1.9 kobject_get

1.4.1.10 kobject_put

1.4.1.11 kobject_get_path

1.5 kset

1.5.1 kset API

1.5.1.1 struct kset

1.5.1.2 kset_init

1.5.1.3 kset_add

1.5.1.4 kset_register

1.5.1.5 kset_unregister

1.5.1.6 to_kset

1.5.1.7 kset_get

1.5.1.8 kset_put

1.6 ktype

1.7 sysfs

1.7.1 /sys

1.7.2 sysfs

1.7.2.1 sysfs_create_dir

1.7.2.2 sysfs_remove_dir

1.7.2.3 sysfs_rename_dir

1.7.2.4 sysfs_create_file

1.7.2.5 sysfs_update_file

1.7.2.6 sysfs_remove_file

1.7.2.7 sysfs_create_link

1.7.2.8 sysfs_remove_link

1.7.2.9 sysfs_create_bin_file

1.7.2.10 sysfs_remove_bin_file

1.7.2.11 struct attribute_group

1.7.2.12 sysfs_create_group

1.7.2.13 sysfs_remove_group

1.7.3 사용자를 위한

1.7.4 sysfs를 이용한 dev 노드 만들기

1.8 subsystem

1.8.1 subsystem 개요

1.8.2 subsystem과 kset과의 관계

1.8.3 subsystem on sysfs

1.8.4 subsystem API

1.8.4.1 decl_subsys

1.8.4.2 subsystem_init

1.8.4.3 subsystem_register

1.8.4.4 subsystem_unregister

1.8.4.5 subsystem_get

1.8.5 subsystem_put

1.9 kobj_map

1.9.1 kobj_map API

1.9.1.1 kobj_probe_t

1.9.1.2 struct kboj_map

1.9.1.3 kobj_map

1.9.1.4 kobj_unmap

1.9.1.5 kobj_lookup

1.9.1.6 kobj_map_init

1.10 bus

1.10.1 bus on sysfs

1.10.2 bus API

1.10.2.1 bus_register

1.10.2.2 bus_unregister

1.10.2.3 bus_for_each_dev

1.10.2.4 bus_for_each_drv

1.10.2.5 BUS_ATTR

1.10.2.6 bus_create_file

1.10.2.7 bus_remove_file

1.11 device

1.11.1 device on sysfs

1.11.2 device API

1.11.2.1 struct device

1.11.2.2 device_register

1.11.2.3 device_unregister

1.11.2.4 DEVICE_ATTR

1.11.2.5 device_create_file

1.11.2.6 device_remove_file

1.11.2.7 device_initalize

1.11.2.8 device_add

1.11.2.9 device_del

1.12 driver

1.12.1 driver API

1.12.1.1 struct device_driver

1.12.1.2 driver_register

1.12.1.3 driver_unregister

1.12.1.4 DRIVER_ATTR

1.12.1.5 driver_create_file

1.12.1.6 driver_remove_file

1.13 class

1.13.1 class on sysfs

1.13.2 class

1.13.3 클래스 등록하기

1.13.3.1 struct class

1.13.3.2 struct class_device

1.13.3.3 class_simple_create (obsolete)

1.13.3.4 class_simple_destroy (obsolete)

1.13.3.5 class_simple_device_add (obsolete)

1.13.3.6 class_simple_device_remove (obsolete)

1.13.3.7 class_create

1.13.3.8 class_destroy

1.13.3.9 class_device_create

1.13.3.10 class_device_destroy

1.13.3.11 class_register

1.13.3.12 class_unregister

1.13.3.13 class_get

1.13.3.14 class_put

1.13.3.15 struct class_attribute

1.13.3.16 CLASS_ATTR

1.13.3.17 class_create_file

1.13.3.18 class_remove_file

1.13.3.19 class_get_devdata

1.13.3.20 class_set_devdata

1.13.3.21 class_devce_register

1.13.3.22 class_device_unregister

1.13.3.23 class_device_initialize

1.13.3.24 class_device_add

1.13.3.25 class_device_del

1.13.3.26 class_device_rename

1.13.3.27 class_device_get

1.13.3.28 class_device_put

1.13.3.29 struct classs_device_attribute

1.13.3.30 CLASS_DEVICE_ATTR

1.13.3.31 class_device_create_file

1.13.3.32 class_device_remove_file

1.13.3.33 class_device_create_bin_file

1.13.3.34 class_device_remove_bin_file

1.13.3.35 struct class_interface

1.13.3.36 class_interface_register

1.13.3.37 class_interface_unregister

1.13.4 class의 사용 예

1.13.4.1 클래스 생성

1.13.4.2 클래스 디바이스 생성/제거

1.13.4.3 클래스 제거

1.14 hotplug

1.15 udev

1.16 References

struct kref {
  atomic_t refcount;
};

struct kref {
  atomic_t refcount;
};

void kref_init(struct kref *kref);

void kref_get(struct kref *kref);

int kref_put(struct kref *kref, void(*release)(struct kref *kref));

struct kobject {
  char  *k_name;
  char   name[KOBJ_NAME_LEN];
  struct kref kref;
  struct list_head entry;
  struct kobject *parent;
  struct kset *kset;
  struct kobj_type *ktype;
  struct dentry *dentry;
};

int kobject_set_name(struct kobject *kobj, const char *fmt, ...)

reval = kobject_set_name(&bus->subsys.kset.kobj, "%s", bus->name);
if (retval)
  goto out;

char * kobject_name(struct kobject *kobj);

void kobject_init(struct kobject *kobj);

vodi kobject_cleanup(struct kobject *);

int kobject_add(struct kobject *kobj);

void kobject_del(struct kobject *);

int kobject_register(struct kobject *);

void kobject_unregister(struct kobject *);

struct kobject *kobject_get(struct kobject *);

void kobject_put(struct kobject *);

char *kobject_get_path(struct kobject *kobj, int gfp_mask);

struct kset {
  struct subsystem *subsys;
  struct kobj_type *ktype;
  struct list_head list;
  struct kobject kobj;
  struct kset_hotplug_ops *hotplug_ops;
};

struct kset {
  struct subsystem *subsys;
  struct kobj_type *ktype;
  struct list_head list;
  spinlock_t       list_lock;
  struct kobject kobj;
  struct kset_uevent_ops *uevent_ops;
};

void kset_init(struct kset *k);

int kset_add(struct kset *k);

int kset_register(struct kset *k);

void kset_unregister(struct kset *k);

struct kset *to_kset(struct kobject *kobj);

struct kset *kset_get(struct kset *k);

void kset_put(struct kset *k);

struct kobj_type {
  void (*release)(struct kobject *);
  struct sysfs_ops *sysfs_ops;
  struct attribute **default_attrs;
};

struct sysfs_ops {
  ssize_t (*show)(struct kobject *, struct atrribute *, char *);
  ssize_t (*store)(struct kobject *, struct attribute *, const char *, size_t);
};

int sysfs_create_dir(struct kobject *kobj);

void sysfs_remove_dir(struct kobject *kobj);

int sysfs_rename_dir(struct kobject *kobj, const char *new_name);

int sysfs_create_file(struct kobject *, const struct attribute *);

int driver_create_file(struct device_driver *drv, struct driver_attribute *attr)
{
  int error;
  if (get_driver(drv)) {
    error = sysfs_create_file(&drv->kobj, &attr->attr);
    put_driver(drv);
  } else
    error = -EINVAL;
  return error;
}

int sysfs_update_file(struct kobject *kobj, const struct attribute *attr);

void sysfs_remove_file(struct kobject *, const struct attribute *);

void driver_remove_file(struct device_driver *drv, struct driver_attribute *attr)
{
  if(get_driver(drv)) {
    sysfs_remove_file(&drv->kobj, &attr->attr);
    put_driver(drv);
  }
}

int sysfs_create_link(struct kobject *kobj, struct kobject *target,
                      const char *name);

int bus_add_device(struct device *dev)
{
  struct bus_type *bus = get_bus(dev->bus);
  int error = 0;

  if (bus) {
    ...
    sysfs_create_link(&bus->device.kobj, &dev->kobj, dev->bus_id);
  }
  return error;
}

void sysfs_remove_link(struct kobject *kobj, char *name);

int sysfs_create_bin_file(struct kobject *kobj, struct bin_attribute *attr);

int sysfs_remove_bin_file(struct kobject *kobj, struct bin_attribute *attr);

struct attribute_group {
  const char *name;
  struct attribute **attrs;
};

int sysfs_create_group(struct kobject *, const struct atrribute_group *);

static ssize_t state_show(struct device *dev, struct device_attribute *attr,
                          char *buf)
{
  ...
}

static ssize_t state_store(struct device *dev, struct device_attribute *attr,
                           const char *buf, size_t n)
{
  ...
}

static DEVICE_ATTR(state, 0644, state_show, state_store);

static struct attribute *power_attrs[] = {
  &dev_attr_state.attr,
  NULL,
};

static struct attribute_group pm_attr_group = {
  .name = "power",
  .attrs = power_attrs,
};

int dpm_sysfs_add(struct device *dev)
{
  return sysfs_create_group(&dev->kobj, &pm_attr_group);
}

void dpm_sysfs_remove(struct device *dev)
{
  sysfs_remove_group(&dev->kboj, &pm_attr_group);
}

void sysfs_remove_group(struct kobject *, const struct attribute_group *);

static ssize_t state_show(struct device *dev, struct device_attribute *attr,
                          char *buf)
{
  ...
}

static ssize_t state_store(struct device *dev, struct device_attribute *attr,
                           const char *buf, size_t n)
{
  ...
}

static DEVICE_ATTR(state, 0644, state_show, state_store);

static struct attribute *power_attrs[] = {
  &dev_attr_state.attr,
  NULL,
};

static struct attribute_group pm_attr_group = {
  .name = "power",
  .attrs = power_attrs,
};

int dpm_sysfs_add(struct device *dev)
{
  return sysfs_create_group(&dev->kobj, &pm_attr_group);
}

void dpm_sysfs_remove(struct device *dev)
{
  sysfs_remove_group(&dev->kboj, &pm_attr_group);
}

find /sys/block /sys/class -name dev -printf '%h\n' |
while read d
do
    n=${d//*\//}
    i=$(<$d/dev)
    mknod $n ${d:5:1} ${i/:/ }
done

struct subsystem {
  struct kset kset;
  struct rw_semaphore rwsem;
};

delc_subsys(name, type, hotplug_ops);

...

 1: static struct kobj_type ktype_block = {
 2:   .release = disk_release,
 3:   .sysfs_ops = &disk_sysfs_ops,
 4:   .default_attrs = default_attrs,
 5: };

...

 6: static struct kset_hotplug_ops block_hotplug_ops = {
 7:   .filter = block_hotplug_filter,
 8:   .hotplug = block_hotplug,
 9: };

/* declare block subsys */
10: static decl_subsys(block, &ktype_block, &block_hotplug_ops);

void subsystem_init(struct subsystem *subsys);

int subsystem_register(struct subsystem *s);

void subsystem_unregister(struct subsystem *subsys);

struct subsystem *subsys_get(struct subsystem *subsys);

void subsys_put(struct subsystem *subsys);

typedef struct kobject *kobj_probe_t(dev_t, int *, void *);

struct kobj_map {
  struct probe {
    struct probe *next;
    dev_t dev;
    unsigned long range;
    struct module *owner;
    kobj_probe_t *get;
    int (*lock)(dev_t, void *);
    void *data;
  }probe[255];
  struct semaphore *sem;
};

int kobj_map(struct kobj_map *domain, dev_t dev, unsigned long range,
             struct module *, kobj_probe_t *probe,
             int (*lock)(dev_t dev, void *), void *data);

int cdev_add(struct cdev *p, dev_t dev, unsigned count)
{
  ...
  return kobj_map(cdev_map, dev, count, NULL, exact_match, exact_lock, p);
}

void blk_register_region(dev_t dev, unsigned long range, struct module *module,
                         struct kobject *(*probe)(dev_t, int *, void *),
                         int (*lock)(dev_t, void *), void *data)
{
  kobj_map(bdev_map, dev, range, module, probe, lock, data);
}

void kboj_unmap(struct kobj_map *, dev_t, unsigned long);

struct kobject *kobj_lookup(struct kobj_map *domain, dev_t dev, int *index);

int chrdev_open(struct inode *inode, struct file *filp)
{
  ...
  if (!p) {
    ...
    kobj = kobj_lookup(cdev_map, inode->i_rdev, &idx);
    ...
  }
  ...
}

struct gendisk *get_gendisk(dev_t dev, int *part)
{
  struct kobject *kobj = kobj_lookup(bdev_map, dev, part);
  return kboj ? to_disk(kobj) : NULL;
}

struct kobj_map *kobj_map_init(kobj_probe_t *, struct semaphore *);

void __init chrdev_init(void)
{
  cdev_map = kobj_map_init(base_probe, &chrdev_lock);
}

static int __init genhd_device_init(void)
{
  bdev_map = kobj_map_init(base_probe, &block_subsys_sem);
  ...
}

struct bus_type {
  const char       *name;

  struct subsystem subsys;
  struct kset      drivers;
  struct kset      devices;
  struct klist     klist_devices;
  struct klist     klist_drivers;

  struct bus_attribute    *bus_attrs;
  struct device_attribute *dev_attrs;
  struct driver_attribute *drv_attrs;

  int (*match)(struct device *dev, struct device_driver *drv);
  int (*uevent)(struct device *dev, char **envp,
                int num_envp, char *buffer, int buffer_size);
  int (*probe)(struct device *dev);
  int (*remove)(struct device *dev);
  int (*shutdown)(struct device *dev);
  int (*suspend)(struct device *dev, pm_message_t state);
  int (*resume)(struct device *dev);
};

int bus_register(struct bus_type *bus);

static struct bus_type mmc_bus_type = {
  .name       = "mmc",
  .dev_attrs  = mmc_dev_attrs,
  .match      = mmc_bus_match,
  .uevent     = mmc_bus_uvent,
  .probe      = mmc_bus_probe,
  .remove     = mmc_bus_remove,
  .suspend    = mmc_bus_suspend,
  .resume     = mmc_bus_resume,
};

static init __init mmc_init(void)
{
  int ret = bus_register(&mmc_bus_type);
  if (ret == 0) {
    ret = class_register(&mmc_host_class);
    if (ret)
      bus_unregister(&mmc_bus_type);
  }
  return ret;
}

void bus_unregister(struct bus_type *bus);

int buf_for_each_dev(struct bus_type *bus, struct device *start, void *data,
                     int (*fn)(struct device *, void *));

int bus_for_each_drv(struct bus_type *bus, struct device_driver *start,
                     void *data, int (*fn)(struct device_driver *, void *));

BUS_ATTR(name, mode, show, store);

int bus_create_file(struct bus_type *bus, struct bus_attribute *attr);

void bus_remove_file(struct bus_type *bus, struct bus_attribute *attr);

struct device {
  ...
  struct device *parent;

  struct kobject kobj;
  char bus_id[BUS_ID_SIZE];
  ...

  struct bus_type *bus;
  struct device_driver *driver;

  void *driver_data;
  void *platform_data;

  void *firmware_data;

  ...

  void (*release)(struct device *dev);
};

int device_register(struct device *dev);

void device_unregister(struct device *dev);

DEVICE_ATTR(name, mode, show, store);

ssize_t show(struct device *dev, struct device_attribute *attr,
                        char *buf);
ssize_t store(struct device *dev, struct device_attribute *attr,
                         const char *buf, size_t count);

int device_create_file(struct device *dev, struct device_attribute *attr);

void device_remove_file(struct device *dev, struct device_attribute *attr);

void device_initialize(struct device *dev);

int device_add(struct device *dev);

void device_del(struct device *dev);

struct device_driver {
  char *name;
  struct bus_type *bus;

  struct completion unloaded;
  struct kobject kobj;
  struct list_head devices;

  struct module *owner;

  int (*probe) (struct device *dev);
  int (*remove) (struct device *dev);
  void (*shutdown) (struct device *dev);
  int (*suspend) (struct device *dev, pm_message_t state, u32 level);
  int (*resume) (struct device *dev, u32 level);
};

  struct klist      klist_devices;
  struct klist_node knode_bus;

  int (*suspend)    (struct device *dev, pm_message_t state);
  int (*resume)     (struct device *dev);

struct class {
  const char *name;
  struct module *owner;

  struct subsystem subsys;
  struct list_head children;
  struct list_head interfaces;
  struct semaphore sem;

  struct class_attribute *class_attrs;
  struct class_device_attribute *class_dev_attrs;

  int (*hotplug)(struct class_device *dev, char **envp,
                 int num_envp, char *buffer, int buffer_size);
  void (*release)(struct class_device *dev);
  void (*class_release)(struct class *class);
};

struct class_device {
  struct list_head node;

  struct kobject   kobj;
  struct class    *class;
  dev_t            devt;
  struct class_device_attribute *devt_attr;
  struct device   *dev;
  void            *class_data;

  char class_id[BUS_ID_SIZE];
};

struct class_device {
  struct list_head node;

  struct kobject   kobj;
  struct class    *class;
  dev_t            devt;
  struct class_device_attribute *devt_attr;
  struct device   *dev;
  void            *class_data;
  struct class_device *parent;

  void (*release)(struct class_device *dev);
  int  (*hotplug)(struct class_device *dev, char **envp,
                  int num_envp, char *buffer, int buffer_size);
  char class_id[BUS_ID_SIZE];
};

struct class_simple *class_simpel_create(struct module *owner, char *name)

void class_simple_destroy(struct class_simple *cs)

struct class_device *class_simple_device_add(struct class_simple *cs, dev_t dev,
                                              struct device, const char *fmt, ...)

void class_simple_device_remove(dev_t dev)

struct class *class_create(struct module *owner, char *name)

void class_destroy(struct class *cls)

struct *xxx_class;
EXPORT_SYMBOL(xxx_class);

static void __exit cleanup_xxx(void)
{
  ...
  class_destroy(xxx_class);
}

static int __init init_xxx(void)
{
  ...
  xxx_class = class_create(THIS_MODULE, "xxx");
  if (IS_ERR(sound_class))
    return PTR_ERR(sound_class);

  return 0;
}

struct class_device *class_device_create(struct class *cls, dev_t devt,
                                         struct device *device, char *fmt, ...)

static int sound_insert_unit(...)
{
  ...
  if (...)
    ...
  else
    sprintf(s->name, "sound/%s%d", name, r / SOUND_STEP);
  ...
  class_device_create(sound_class, MKDEV(SOUND_MAJOR, s->unit_minor),
                      NULL, s->name+6);
  ...
}

void class_device_destroy(struct class *cls, dev_t devt)

static void sound_remove_unit(...)
{
  ...
  if (p) {
    ...
    class_device_destroy(sound_class, MKDEV(SOUND_MAJOR, p->unit_minor));
    ...
  }
}

int class_register(struct class *cls);

static void backlight_class_release(struct class_device *dev)
{
  struct backlight_device *bd = to_backlight_device(dev);
  kfree(bd);
}

static struct class backlight_class = {
  .name    = "backlight",
  .release = backlight_class_release,
};

static int __init backlight_class_init(void)
{
  return class_register(&backlight_class);
}

void class_unregister(struct class *cls);

static void __exit backlight_class_exit(void)
{
  class_unregister(&backlight_class);
}

struct class * class_get(struct class *cls);

void class_put(struct class *cls);

struct class_attribute {
  struct attribute attr;
  ssize_t (*show)(struct class *, char *buf);
  ssize_t (*store)(struct class *, const char *buf, size_t count);
};

CLASS_ATTR(name, mode, show, store);

int class_create_file(struct class *cls, const struct class_attribute *attr);

void class_remove_file(struct class *cls, const struct class_attribue *attr);

void * class_get_devdata(struct class_device *dev);

void class_set_devdata(struct class_device *dev, void *data);

int class_device_register(struct class_device *class_dev);

static struct xxx_device {
  ...
  struct class_device class_dev;
  ...
};

  memset(&dev->class_dev, 0, sizeof(dev->class_dev));
  dev->class_dev.class = &xxx_class;
  strlcpy(dev->class_dev.class_id, xxx_name, KOBJ_NAME_LEN);
  class_set_devdata(&dev->class_dev, xxx_data)

  ret = class_device_register(&dev->class_dev);
  if (unlikely(ret)) {
    ...
    return ERR_PTR(ret);
  }

void class_device_unregister(struct class_device *);

void class_device_initialize(struct class_device *);

int class_device_add(struct class_device *);

void class_device_del(struct class_device *);

int class_device_rename(struct class_device *, char *);

struct class_device * class_device_get(struct class_device *);

void class_device_put(struct class_device *);

struct class_device_attribute {
  struct attribute        attr;
  ssize_t (*show)(struct class_device *, char * buf);
  ssize_t (*store)(struct class_device *, const char * buf, size_t count);
};

CLASS_DEVICE_ATTR(_name,_mode,_show,_store)

int class_device_create_file(struct class_device *class_dev,
                             const struct class_device_attribute *attr);

#define DECLARE_ATTR(_name,_mode,_show,_store) \
{ \
  .attr  = { .name = __stringify(_name), .mode = _mode, .owner = THIS_MODULE } \
  .show  = _show, \
  .store = _store, \
}

static struct class_device_attribute bl_class_device_attributes[] = {
  DECLARE_ATTR(power, 0644, backlight_show_power, backlight_store_power),
  DECLARE_ATTR(brightness, 0644, backlight_show_brightness, backlight_store_brightness),
  DECLARE_ATTR(max_brightness, 0644, backlight_show_max_brightness, NULL),
};

int backlight_device *backlight_device_register(...)
{
  ...
  for (i = 0; i < ARRAY_SIZE(bl_class_device_attributes); i++) {
    rc = class_device_create_file(&new_bd->class_dev,
                                  &bl_class_device_attributes[i]);
    if (unlikely(rc)) {
      while (--i >= 0)
        class_device_remove_file(&new_bd->class_dev,
                                 &bl_class_device_attributes[i]);
      ...
    }
  }
  ...
}

void class_device_remove_file(struct class_device *class_dev,
                               const struct class_device_attribute *attr);

  for (i = 0; i < ARRAY_SIZE(bl_calss_device_attributes); i++)
    class_device_remove_file(&bd->class_dev,
                             &bl_class_device_attributes[i]);

int class_device_create_bin_file(struct class_device *, struct bin_attribute *);

void class_device_remove_bin_file(struct class_device *, struct bin_attribute *);

struct class_interface {
  struct list_head node;
  struct class *class;

  int (*add) (struct class_device *)
  void *(remove) (struct class_device *);
};

int class_interface_register(struct class_interface *);

void class_interface_unregister(struct class_interface *);

static int __init init_mtdchar(void)
{
  if (register_chrdev(...)) {
    ...
  }

  mtd_class = class_create(THIS_MODULE, "mtd");

  if (IS_ERR(mtd_class)) {
    ...
  }

  register_mtd_user(&notifier);
  return 0;
}

static void mtd_notify_add(struct mtd_info *mtd)
{
  if (!mtd)
    return;

  class_device_create(mtd_class, MKDEV(MTD_CHAR_MAJOR, mtd->index*2),
                      NULL, "mtd%d", mtd->index);
  class_device_create(mtd_class, MKDEV(MTD_CHAR_MAJOR, mtd->index*2+1),
                      NULL, "mtd%dro", mtd->index);
}

static void mtd_notify_remove(struct mtd_info *mtd)
{
  if (!mtd)
    return;

  class_device_destroy(mtd_class, MKDEV(MTD_CHAR_MAJOR, mtd->index*2));
  class_device_destroy(mtd_class, MKDEV(MTD_CHAR_MAJOR, mtd->index*2+1));
}

static struct mtd_notifier notifier = {
  .add = mtd_notify_add,
  .remove = mtd_notify_remove,
};

static void __exit cleanup_mtdchar(void)
{
  unregister_mtd_user(&notifier);
  class_destroy(mtd_class);
  unregister_chrdev(MTD_CHAR_MAJOR, "mtd");
}

#include <linux/netlink.h>

#ifndef NETLINK_KOBJECT_UEVENT
#define NETLINK_KOBJECT_UEVENT   15
#endif

int main(int argc, char *argv[])
{
  int sock;
  struct sockaddr_nl snl;
  int retval;

  if (getuid() != 0) {
    fprintf(stderr, "need to be root, exit\n");
    exit(1);
  }

  memset(&snl, 0x00, sizeof(struct sockaddr_nl));
  snl.nl_family = AF_NETLINK;
  snl.nl_pid = getpid();
  snl.nl_groups = 0xffff;

  sock = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_KOBJECT_UEVENT);
  if (sock == -1) {
    fprintf(stderr, "error getting socket, exit\n");
    exit(1);
  }

  retval = bind(sock, (struct sockaddr *)&snl,
                sizeof(struct sockaddr_nl));
  if (retval < 0) {
    fprintf(stderr, "bind failed, exit\n");
    goto exit;
  }

  while(1) {
    char buf[1024];
    char object[MAX_OBJECT];
    char *signal;
    char *pos;
    int len;

    len = recv(sock, &buf, sizeof(buf), 0);
    if (len < 0) {
      fprintf(stderr, "error receiving message\n");
      continue;
    }

    buf[len] = '\0';

    /* sending object */
    pos = strchar(buf, '@');
    pos[0] = '\0';

    signal = buf;
    object = &pos[1];

    ...
  }

  ...
exit:
  close(sock);
  exit(1);
}