文档章节

libubox

wulle
 wulle
发布于 2016/01/08 14:05
字数 1929
阅读 531
收藏 3

libubox是openwrt新版本中的一个基础库,在openwrt.14.07中有很多应用程序是基于libubox开发的。(如:uhttpd,libubus等)。

libubox主要提供一下两种功能:

        1、提供一套基于事件驱动的机制。

        2、提供多种开发支持接口。(如:链表、kv链表、平衡查找二叉树、md5、json)

    使用libubox开发的好处有如下几点:

        1、可以使程序基于事件驱动,从而可实现在单线程中处理多个任务。

        2、基于libubox提供的开发API可以加快开发进度的同事提高程序的稳定性。

        3、能更好的将程序融入openwrt的架构中,因为新的openwrt的很多应用和库都基于libubox开发的。

    综上所述,libubox是您玩新版openwrt必修的一个东东,相信它也值得大家去研究学习。

 事件框架

uloop.c/h:

主框架
/**
 * 初始化事件循环
 */
 int uloop_init(void)
 /**
 * 事件循环主处理入口
 */
 void uloop_run(void)
 /**
 * 销毁事件循环
 */
 void uloop_done(void)
描述符结构体
struct uloop_fd {
    uloop_fd_handler cb;    /** 描述符事件处理函数 */
    int fd;                 /** 文件描述符,调用者初始化 */
    bool eof;                       
    bool error;                     
    bool registered;        /** 是否已注册到uloop中 */     
    uint8_t flags;  
};
定时器结构体
struct uloop_timeout {    
    struct list_head list;  
    bool pending;               
    uloop_timeout_handler cb; /** 定时事件处理函数 */
    struct timeval time;      /** 时间结构体 */
};
进程结构体
struct uloop_process { 
 struct list_head list;              
    bool pending;                   
    uloop_process_handler cb;       /** 进程事件处理函数 */
    pid_t pid;                      /** 进程号*/
};
描述符事件处理函数
typedef void (*uloop_fd_handler)(struct uloop_fd *u, unsigned int events)
定时器事件处理函数
typedef void (*uloop_timeout_handler)(struct uloop_timeout *t)
进程事件处理函数
typedef void (*uloop_process_handler)(struct uloop_process *c, int ret)

事件标志
#define ULOOP_READ          (1 << 0)
#define ULOOP_WRITE         (1 << 1)
#define ULOOP_EDGE_TRIGGER  (1 << 2)
#define ULOOP_BLOCKING      (1 << 3)
#define ULOOP_EVENT_MASK    (ULOOP_READ | ULOOP_WRITE)
定时器事件
/**
 * 注册一个新定时器
 */
 int uloop_timeout_add(struct uloop_timeout *timeout)
 /**
 * 设置定时器超时时间(毫秒),并添加
 */
 int uloop_timeout_set(struct uloop_timeout *timeout, int msecs)
 /**
 * 销毁指定定时器
 */
 int uloop_timeout_cancel(struct uloop_timeout *timeout)
 /**
 * 获取定时器还剩多长时间超时
 */
 int uloop_timeout_remaining(struct uloop_timeout *timeout)
描述符事件
/**
 * 注册一个新描述符到事件处理循环
 */
 int uloop_fd_add(struct uloop_fd *sock, unsigned int flags)
 /** 
 * 从事件处理循环中销毁指定描述符
 */
 int uloop_fd_delete(struct uloop_fd *sock)
进程事件
/**
 * 注册新进程到事件处理循环
 */
 int uloop_process_add(struct uloop_process *p)
 /**
 * 从事件处理循环中销毁指定进程
 */
 int uloop_process_delete(struct uloop_process *p)
//任务队列结构体
struct runqueue {
    struct safe_list tasks_active;      /** 活动任务队列 */
    struct safe_list tasks_inactive;    /** 不活动任务队列 */
    struct uloop_timeout timeout;    
    int running_tasks;      /** 当前活动任务数目 */
    int max_running_tasks;  /** 允许最大活动任务数目 */
    bool stopped;           /** 是否停止任务队列 */
    bool empty;             /** 任务队列(包括活动和不活动)是否为空 */

    /* called when the runqueue is emptied */
    void (*empty_cb)(struct runqueue *q);
};

//任务处理函数
struct runqueue_task_type {    
    const char *name;    
    /*
     * called when a task is requested to run
     *
     * The task is removed from the list before this callback is run. It
     * can re-arm itself using runqueue_task_add.
     */
    void (*run)(struct runqueue *q, struct runqueue_task *t);   
     /*
     * called to request cancelling a task
     *
     * int type is used as an optional hint for the method to be used when
     * cancelling the task, e.g. a signal number for processes. Calls
     * runqueue_task_complete when done.
     */
    void (*cancel)(struct runqueue *q, struct runqueue_task *t, int type);    
    /*
     * called to kill a task. must not make any calls to runqueue_task_complete,
     * it has already been removed from the list.
     */
    void (*kill)(struct runqueue *q, struct runqueue_task *t);
};

//任务结构体
struct runqueue_task {    
    struct safe_list list;    
    const struct runqueue_task_type *type;    
    struct runqueue *q;    
    void (*complete)(struct runqueue *q, struct runqueue_task *t);    
    struct uloop_timeout timeout;    
    int run_timeout;    /** >0表示规定此任务执行只有run_timeout毫秒 */
    int cancel_timeout; /** >0表示规则任务延取消操作执行只有run_timeout毫秒*/
    int cancel_type;    
    bool queued;        /** 此任务是否已加入任务队列中 */
    bool running;       /** 此任务是否活动,即已在活动队列中 */
    bool cancelled;     /** 此任务是否已被取消 */
};

//进程任务结构体
struct runqueue_process {
    struct runqueue_task task;
    struct uloop_process proc;
};
任务队列操作函数

/**
 * 初始化任务队列
 */
 void runqueue_init(struct runqueue *q)
 /** 
 * 取消所有任务队列
 */
 void runqueue_cancel(struct runqueue *q);
 /** 
 * 取消活动中的任务
 */
 void runqueue_cancel_active(struct runqueue *q);
 /** 
 * 取消不活动的任务 
 */
 void runqueue_cancel_pending(struct runqueue *q);
 /**
 * 杀死所有任务
 */
 void runqueue_kill(struct runqueue *q);
 /** 
 * 停止所有任务
 */
 void runqueue_stop(struct runqueue *q);
 /**
 * 重新开始任务
 */
 void runqueue_resume(struct runqueue *q);
任务操作函数
/**
 * 添加新任务到队列尾
 *
 * @running true-加入活动队列;false-加入不活动队列
 */
 void runqueue_task_add(struct runqueue *q, struct runqueue_task *t, bool running);
 /**
 * 添加新任务到队列头
 *
 * @running true-加入活动队列;false-加入不活动队列
 */
 void runqueue_task_add_first(struct runqueue *q, struct runqueue_task *t, 
bool running);
/**
 * 完全任务
 */
 void runqueue_task_complete(struct runqueue_task *t);
 /**
 * 取消任务
 */
 void runqueue_task_cancel(struct runqueue_task *t, int type);
 /**
 * 杀死任务
 */
 void runqueue_task_kill(struct runqueue_task *t);
进程任务操作函数
void runqueue_process_add(struct runqueue *q, struct runqueue_process *p, pid_t pid);
/**
 * to be used only from runqueue_process callbacks 
 */
 void runqueue_process_cancel_cb(struct runqueue *q, struct runqueue_task *t, int type);
 void runqueue_process_kill_cb(struct runqueue *q, struct runqueue_task *t);

流缓冲管理

ustream.c/h/ustream-fd.c:

//流buffer结构体
struct ustream_buf {
    struct ustream_buf *next;    
    char *data;     /** 指向上次操作buff开始地址 */
    char *tail;     /** 指向未使用buff开始地址 */
    char *end;      /** 指向buf结束地址 */

    char head[];    /** 指向buf开始地址 */
};

//流buffer结构体的链表
struct ustream_buf_list {
    struct ustream_buf *head;       /** 指向第1块ustream_buf */
    struct ustream_buf *data_tail;  /** 指向未使用的ustream_buf */
    struct ustream_buf *tail;       /** 指向最后的ustream_buf */

    int (*alloc)(struct ustream *s, struct ustream_buf_list *l);    
    int data_bytes;    /** 已用存储空间大小 */

    int min_buffers;   /** 可存储最小的ustream_buf块个数 */
    int max_buffers;   /** 可存储最大的ustream_buf块个数 */
    int buffer_len;    /** 每块ustream_buf块存储空间大小 */

    int buffers;       /** ustream_buf块个数 */
    };
    
    //读写操作的缓冲结构及操作函数
struct ustream { 
   struct ustream_buf_list r, w;    
   struct uloop_timeout state_change;    
   struct ustream *next;   
    /*
     * notify_read: (optional)
     * called by the ustream core to notify that new data is available
     * for reading.
     * must not free the ustream from this callback
     */
    void (*notify_read)(struct ustream *s, int bytes_new);    
    /*
     * notify_write: (optional)
     * called by the ustream core to notify that some buffered data has
     * been written to the stream.
     * must not free the ustream from this callback
     */
    void (*notify_write)(struct ustream *s, int bytes);   
     /*
     * notify_state: (optional)
     * called by the ustream implementation to notify that the read
     * side of the stream is closed (eof is set) or there was a write
     * error (write_error is set).
     * will be called again after the write buffer has been emptied when
     * the read side has hit EOF.
     */
    void (*notify_state)(struct ustream *s);    
    /*
     * write:
     * must be defined by ustream implementation, accepts new write data.
     * 'more' is used to indicate that a subsequent call will provide more
     * data (useful for aggregating writes)
     * returns the number of bytes accepted, or -1 if no more writes can
     * be accepted (link error)
     */
    int (*write)(struct ustream *s, const char *buf, int len, bool more);    
    /*
     * free: (optional)
     * defined by ustream implementation, tears down the ustream and frees data
     */
    void (*free)(struct ustream *s);   
     /*
     * set_read_blocked: (optional)
     * defined by ustream implementation, called when the read_blocked flag
     * changes
     */
    void (*set_read_blocked)(struct ustream *s);    
    /*
     * poll: (optional)
     * defined by the upstream implementation, called to request polling for
     * available data.
     * returns true if data was fetched.
     */
    bool (*poll)(struct ustream *s);    
    /*
     * ustream user should set this if the input stream is expected
     * to contain string data. the core will keep all data 0-terminated.
     */
    bool string_data;     /** 此ustream是否为字符串,true-是;false-否 */
    bool write_error;     /** 写出错,true-是;false-否 */
    bool eof, eof_write_done;    
    enum read_blocked_reason read_blocked;
};    

//流描述符结构体
struct ustream_fd {
    struct ustream stream;    
    struct uloop_fd fd;
};
//流结构操作函数

/**
 * ustream_fd_init: create a file descriptor ustream (uses uloop) 
 */
 void ustream_fd_init(struct ustream_fd *s, int fd)
 /**
 * ustream_init_defaults: fill default callbacks and options 
 */
 void ustream_init_defaults(struct ustream *s)
 /**
 * ustream_free: free all buffers and data associated with a ustream 
 */
 void ustream_free(struct ustream *s)
 
 //分配len空间
char *ustream_reserve(struct ustream *s, int len, int *maxlen) 
//移除读buffer中地一个数据结构
void ustream_consume(struct ustream *s, int len)
//


双向链表

list.h:

struct list_head {
    struct list_head *next;    
    struct list_head *prev;
};

#define LIST_HEAD_INIT(name) { &(name), &(name) }
#define (name) struct list_head name = LIST_HEAD_INIT(name)
static inline void INIT_LIST_HEAD(struct list_head *list)

/** 
 * 加入链表头部
 */
 list_add(struct list_head *_new, struct list_head *head)
 /**
 * 加入链表尾部
 */
 list_add_tail(struct list_head *_new, struct list_head *head)
 
 /**
 * 把指定节点从链表中删除
 */
 list_del(struct list_head *entry)
 /**
 * 把指定节点从链表中删除,并初始此节点
 */
 list_del_init(struct list_head *entry)
 
 /**
 * 获取当前节点元素
 */
 list_entry(ptr, type, field)
 /**
 * 获取后一个节点元素
 */
 list_first_entry(ptr, type, field)
 /**
 * 获取前一个节点元素
 */
 list_last_entry(ptr, type, field)
 
 
 /**
 * 向后遍历链表,遍历过程不能操作链表,p为节点元素结构体
 */
 list_for_each_entry(p, h, field)
 /**
 * 向前遍历链表,遍历过程不能操作链表,p为链表结构体
 */
 list_for_each_prev(p, h)










© 著作权归作者所有

wulle
粉丝 1
博文 3
码字总数 3276
作品 0
成都
私信 提问
Jianhui Zhao/libuwsc

libuwsc 一个针对嵌入式Linux的基于libubox的WebSocket客户端C库。 依赖 libubox ustream-ssl - 如果你需要支持SSL mbedtls - 如果你选择mbedtls作为你的SSL后端 CyaSSl(wolfssl) - 如果你选...

Jianhui Zhao
2018/01/09
0
0
openWrt libubox组件之uloop原理分析

1. libubox概述   libubox是openwrt新版本中的一个基础库,有很多应用是基于libubox开发的,如uhttpd,netifd,ubusd等。 libubox主要提供以下两种功能:   提供一套基于事件驱动的机制; ...

老小白爱学习
2018/07/25
0
0
Jianhui Zhao/libuhttpd

libuhttpd 一个专门针对嵌入式Linux的非常小巧且快速的HTTP服务器C库,基于libubox,参考了uhttpd。 特性 action: 通过调用映射到特定路径的已注册C函数来处理请求。 小巧且快速 使用libubox...

Jianhui Zhao
2018/01/02
0
0
Jianhui Zhao/rtty

rtty 通过Web浏览器访问你的终端。项目名称里面的“r”是指“反向代理”或者“远程”。它由客户端和服务端组成。 你可以根据MAC地址通过Web浏览器访问你的任意一台终端。 服务端依赖 python...

Jianhui Zhao
2018/01/12
0
0
Yet Another Smart SNMP Agent--SmithSNMP

SmithSNMP是SmartSNMP的一个fork。SmartSNMP由笔者当时所在的景略半导体(上海)团队开发,SmithSNMP是笔者现在出户后基于前者单独维护的项目,目前在feature上领先于前者。 解释一下为何另起...

我的上铺叫路遥
2015/04/02
941
0

没有更多内容

加载失败,请刷新页面

加载更多

Android双向绑定原理简述

Android双向绑定原理简述 双向绑定涉及两个部分,即将业务状态的变化传递给UI,以及将用户输入信息传递给业务模型。 首先我们来看业务状态是如何传递给UI的。开启dataBinding后,编译器为布局...

tommwq
今天
4
0
Spring系列教程八: Spring实现事务的两种方式

一、 Spring事务概念: 事务是一系列的动作,它们综合在一起才是一个完整的工作单元,这些动作必须全部完成,如果有一个失败的话,那么事务就会回滚到最开始的状态,仿佛什么都没发生过一样。...

我叫小糖主
今天
8
0
CentOS 的基本使用

1. 使用 sudo 命令, 可以以 root 身份执行命令, 必须要在 /etc/sudoers 中定义普通用户 2. 设置 阿里云 yum 镜像, 参考 https://opsx.alibaba.com/mirror # 备份mv /etc/yum.repos.d/CentO...

北漂的我
昨天
4
0
Proxmox VE技巧 移除PVE “没有有效订阅” 的弹窗提示

登陆的时候提示没有有效的订阅You do not have a valid subscription for this server. Please visit www.proxmox.com to get a list of available options. 用的是免费版的,所以每次都提示......

以谁为师
昨天
5
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部