linuxstructpath

❶ 在linux操作系统内核实现里经常使用的红黑树

在linux操作系统内核实现里经常使用的红黑树如下：

二叉树，按中序遍历后为一递增数组，自平衡意味着树的高度有一个上限，对于红黑树，其为2log(n+1)，所以时间复杂度为最差为Olog(n)。

赋予二叉搜索树自平衡特性的方法有多种，红黑树通过一下4条约束实现自平衡:

Every node is either red or black.

All NIL nodes (figure 1) are considered black.

A red node does not have a red child.

Everypathfrom a given node to any of its descendant NIL nodes goes through the same number of black nodes.

其中根节点为黑色。

红黑树的搜索与二叉搜索树无异，但是插入和删除可能会违背上述四条原则。需要用到左旋右旋操作。左旋右旋上图，可以看到左旋右旋本身不改变二叉搜索树的特性，旋转后必要时改变节点的颜色可消除插入或者删除带来的红冲突和黑冲突，有时红黑树的重新平衡需要迭代进行。

红黑树比较适合的应用场景:

需要动态插入、删除、查找的场景，包括但不限于：

某些数据库的增删改查，比如select * from xxx where 这类条件检索。

linux内核中进程通过红黑树组织管理，便于快速插入、删除、查找进程的task_struct。

linux内存中内存的管理：分配和回收。用红黑树组织已经分配的内存块，当应用程序调用free释放内存的时候，可以根据内存地址在红黑树中快速找到目标内存块。

hashmap中(key,value)增、删、改查的实现；java 8就采用了RBTree替代链表。

Ext3文件系统，通过红黑树组织目录项。

❷ FILE的类型

在不同的系统中，FILE结构体的内部不尽相同

如Linux 2.6.23内核中
struct file {
union {
struct list_head fu_list;
struct rcu_head fu_rcuhead;
} f_u;
struct path f_path;
#define f_dentry f_path.dentry
#define f_vfsmnt f_path.mnt
const struct file_operations *f_op;
atomic_t f_count;
unsigned int f_flags;
mode_t f_mode;
loff_t f_pos;
struct fown_struct f_owner;
unsigned int f_uid, f_gid;
struct file_ra_state f_ra;

unsigned long f_version;
#ifdef CONFIG_SECURITY
void *f_security;
#endif
/* needed for tty driver, and maybe others */
void *private_data;

#ifdef CONFIG_EPOLL
/* Used by fs/eventpoll.c to link all the hooks to this file */
struct list_head f_ep_links;
spinlock_t f_ep_lock;
#endif /* #ifdef CONFIG_EPOLL */
struct address_space *f_mapping;
};

❸ 请有各位大虾帮我分析下面关于LINUX文件系统编程的代码，然后回答几个问题

(1)num=read(0,buffer,MAX); write(fd,buffer,num);
表示从标准输入设备中（键盘输入） 读取数据放入buffer 再写到“file1”中
0代表标准输入设备， 1代表标准输出设备 ， 2，代表错误输出设备
（2）execv( path , argv ) 用来执行path字符串所代表的文件路径文 argv是执行命令
总的来说就是执行 ls -l file1这个命令 这个命令执行后 会列出file1的文件属性
包括访问权限

❹ 在linux编程中若一个用户程序希望将一组数据传递给kernel有几种方式

教科书里的代码例子都已作古，所以看到的代码不能当真，领会意思就行了
比如以前的init进程的启动代码
execve(init_filename,argv_init,envp_init);

现在改为
static void run_init_process(char *init_filename)
{
argv_init[0] = init_filename;
kernel_execve(init_filename, argv_init, envp_init);
}

好的，聪明人就发现，linux内核中调用用户空间的程序可以使用init这样的方式，调用 kernel_execve
不过内核还是提供了更好的辅助接口call_usermodehelper，自然最后也是调用kernel_execve

调用特定的内核函数（系统调用）是 GNU/Linux 中软件开发的原本就有的组成部分。但如果方向反过来呢，内核空间调用用户空间？确实有一些有这种特性的应用程序需要每天使用。例如，当内核找到一个设备， 这时需要加载某个模块，进程如何处理？动态模块加载在内核通过 usermode-helper 进程进行。
让我们从探索 usermode-helper 应用程序编程接口（API）以及在内核中使用的例子开始。 然后，使用 API 构造一个示例应用程序，以便更好地理解其工作原理与局限。
usermode-helper API
usermode-helper API 是个很简单的 API，其选项为用户熟知。例如，要创建一个用户空间进程，通常只要设置名称为 executable，选项都为 executable，以及一组环境变量（指向 execve 主页）。创建内核进程也是一样。但由于创建内核空间进程，还需要设置一些额外选项。

内核版本
本文探讨的是 2.6.27 版内核的 usermode-helper API。
表 1 展示的是 usermode-helper API 中一组关键的内核函数

表 1. usermode-helper API 中的核心函数

API 函数
描述

call_usermodehelper_setup 准备 user-land 调用的处理函数
call_usermodehelper_setkeys 设置 helper 的会话密钥
call_usermodehelper_setcleanup 为 helper 设置一个清空函数
call_usermodehelper_stdinpipe 为 helper 创建 stdin 管道
call_usermodehelper_exec 调用 user-land
表 2 中还有一些简化函数，它们封装了的几个内核函数（用一个调用代替多个调用）。这些简化函数在很多情况下都很有用，因此尽可能使用他们。

表 2. usermode-helper API 的简化

API 函数
描述

call_usermodehelper 调用 user-land
call_usermodehelper_pipe 使用 stdin 管道调用 user-land
call_usermodehelper_keys 使用会话密钥调用 user-land
让我们先浏览一遍这些核心函数，然后探索简化函数提供了哪些功能。核心 API 使用了一个称为subprocess_info 结构的处理函数引用进行操作。该结构（可在 ./kernel/kmod.c 中找到）集合了给定的 usermode-helper 实例的所有必需元素。该结构引用从 call_usermodehelper_setup 调用返回。该结构（以及后续调用）将会在 call_usermodehelper_setkeys（用于存储凭证）、call_usermodehelper_setcleanup 以及 call_usermodehelper_stdinpipe 的调用中进一步配置。最后，一旦配置完成，就可通过调用 call_usermodehelper_exec 来调用配置好的用户模式应用程序。

声明
该方法提供了一个从内核调用用户空间应用程序必需的函数。尽管这项功能有合理用途，还应仔细考虑是否需要其他实现。这是一个方法，但其他方法会更合适。
核心函数提供了最大程度的控制，其中 helper 函数在单个调用中完成了大部分工作。管道相关调用（call_usermodehelper_stdinpipe 和 helper 函数 call_usermodehelper_pipe）创建了一个相联管道供 helper 使用。具体地说，创建了管道（内核中的文件结构）。用户空间应用程序对管道可读，内核对管道可写。对于本文，核心转储只是使用 usermode-helper 管道的应用程序。在该应用程序（./fs/exec.c do_coremp()）中，核心转储通过管道从内核空间写到用户空间。
这些函数与 sub_processinfo 以及 subprocess_info 结构的细节之间的关系如图 1 所示。
图 1. Usermode-helper API 关系

表 2 中的简化函数内部执行 call_usermodehelper_setup 函数和 call_usermodehelper_exec 函数。表 2 中最后两个调用分别调用的是 call_usermodehelper_setkeys 和 call_usermodehelper_stdinpipe。可以在 ./kernel/kmod.c 找到 call_usermodehelper_pipe 和 call_usermodehelper 的代码，在 ./include/linux/kmod.h 中找到 call_usermodhelper_keys 的代码。
为什么要从内核调用用户空间应用程序？
现在让我们看一看 usermode-helper API 所使用的内核空间。表 3 提供的并不是专门的应用程序列表，而是一些有趣应用的示例。

表 3. 内核中的 usermode-helper API 应用程序

应用程序
源文件位置

内核模块调用 ./kernel/kmod.c
电源管理 ./kernel/sys.c
控制组 ./kernel/cgroup.c
安全密匙生成 ./security/keys/request_key.c
内核事件交付 ./lib/kobject_uevent.c
最直接的 usermode-helper API 应用程序是从内核空间加载内核模块。request_mole 函数封装了 usermode-helper API 的功能并提供了简单的接口。在一个常用的模块中，内核指定一个设备或所需服务并调用 request_mole 来加载模块。通过使用 usermode-helper API，模块通过 modprobe 加载到内核（应用程序通过 request_mole 在用户空间被调用）。
与模块加载类似的应用程序是设备热插拔（在运行时添加或删除设备）。该特性是通过使用 usermode-helper API，调用用户空间的 /sbin/hotplug 工具实现的。
关于 usermode-helper API 的一个有趣的应用程序（通过 request_mole） 是文本搜索 API（./lib/textsearch.c）。该应用程序在内核中提供了一个可配置的文本搜索基础架构。该应用程序使用 usermode-helper API 将搜索算法当作可加载模块进行动态加载。在 2.6.30 内核版本中，支持三个算法，包括 Boyer-Moore（./lib/ts_bm.c），简单固定状态机方法（./lib/ts_fsm.c），以及 Knuth-Morris-Pratt 算法（./lib/ts_kmp.c）。
usermode-helper API 还支持 Linux 按照顺序关闭系统。当需要系统关闭电源时，内核调用用户空间的 /sbin/poweroff 命令来完成。其他应用程序如 表 3 所示，表中附有其源文件位置。
Usermode-helper API 内部
在 kernel/kmod.c 中可以找到 usermode-helper API 的源代码 和 API（展示了主要的用作内核空间的内核模块加载器）。这个实现使用 kernel_execve 完成脏工作（dirty work）。请注意 kernel_execve是在启动时开启 init 进程的函数，而且未使用 usermode-helper API。
usermode-helper API 的实现相当简单直观（见图 2）。usermode-helper 从调用call_usermodehelper_exec 开始执行（它用于从预先配置好的 subprocess_info 结构中清除用户空间应用程序）。该函数接受两个参数：subprocess_info 结构引用和一个枚举类型（不等待、等待进程中止及等待进程完全结束）。subprocess_info（或者是，该结构的 work_struct 元素）然后被压入工作队列（khelper_wq），然后队列异步执行调用。

图 2. usermode-helper API 内部实现

当一个元素放入 khelper_wq 时，工作队列的处理函数就被调用（本例中是__call_usermodehelper），它在 khelper 线程中运行。该函数从将 subprocess_info 结构出队开始，此结构包含所有用户空间调用所需信息。该路径下一步取决于 wait 枚举变量。如果请求者想要等整个进程结束，包含用户空间调用（UMH_WAIT_PROC）或者是根本不等待（UMH_NO_WAIT），那么会从 wait_for_helper 函数创建一个内核线程。否则，请求者只是等待用户空间应用程序被调用（UMH_WAIT_EXEC），但并不完全。这种情况下，会为____call_usermodehelper() 创建一个内核线程。
在 wait_for_helper 线程中，会安装一个 SIGCHLD 信号处理函数，并为 ____call_usermodehelper 创建另一个内核线程。但在 wait_for_helper 线程中，会调用 sys_wait4 来等待____call_usermodehelper 内核线程（由 SIGCHLD 信号指示）结束。然后线程执行必要的清除工作（为UMH_NO_WAIT 释放结构空间或简单地向 call_usermodehelper_exec() 回送一个完成报告）。
函数 ____call_usermodehelper 是实际让应用程序在用户空间启动的地方。该函数首先解锁所有信号并设置会话密钥环。它还安装了 stdin 管道（如果有请求）。进行了一些安装以后，用户空间应用程序通过 kernel_execve（来自 kernel/syscall.c）被调用，此文件包含此前定义的 path、argv 清单（包含用户空间应用程序名称）以及环境。当该进程完成后，此线程通过调用 do_exit() 而产生。
该进程还使用了 Linux 的 completion，它是像信号一样的操作。当 call_usermodehelper_exec 函数被调用后，就会声明 completion。当 subprocess_info 结构放入 khelper_wq 后，会调用wait_for_completion（使用 completion 变量作为参数）。请注意此变量会存储到 subprocess_info 结构作为 complete 字段。当子线程想要唤醒 call_usermodehelper_exec 函数，会调用内核方法complete，并判断来自 subprocess_info 结构的 completion 变量。该调用会解锁此函数使其能继续。可以在 include/linux/completion.h 中找到 API 的实现。
应用程序示例
现在，让我们看看 usermode-helper API 的简单应用。首先看一下标准 API，然后学习如何使用 helper 函数使事情更简单。
在该例中，首先开发了一个简单的调用 API 的可加载内核模块。清单 1 展示了样板模块功能，定义了模块入口和出口函数。这两个函数根据模块的 modprobe（模块入口函数）或 insmod（模块入口函数），以及 rmmod（模块出口函数）被调用。

清单 1. 模块样板函数

#include
#include
#include

MODULE_LICENSE( "GPL" );

static int __init mod_entry_func( void )
{
return umh_test();
}

static void __exit mod_exit_func( void )
{
return;
}

mole_init( mod_entry_func );
mole_exit( mod_exit_func );

usermode-helper API 的使用如 清单 2 所示，其中有详细描述。函数开始是声明所需变量和结构。以subprocess_info 结构开始，它包含所有的执行用户空间调用的信息。该调用在调用call_usermodehelper_setup 时初始化。下一步，定义参数列表，使 argv 被调用。该列表与普通 C 程序中的 argv 列表类似，定义了应用程序（数组第一个元素）和参数列表。需要 NULL 终止符来提示列表末尾。请注意这里的 argc 变量（参数数量）是隐式的，因为 argv 列表的长度已经知道。该例中，应用程序名是 /usr/bin/logger，参数是 help!，然后是 NULL 终止符。下一个所需变量是环境数组（envp）。该数组是一组定义用户空间应用程序执行环境的参数列表。本例中，定义一些常用的参数，这些参数用于定义 shell 并以 NULL 条目结束。

清单 2. 简单的 usermode_helper API 测试

static int umh_test( void )
{
struct subprocess_info *sub_info;
char *argv[] = { "/usr/bin/logger", "help!", NULL };
static char *envp[] = {
"HOME=/",
"TERM=linux",
"PATH=/sbin:/bin:/usr/sbin:/usr/bin", NULL };

sub_info = call_usermodehelper_setup( argv[0], argv, envp, GFP_ATOMIC );
if (sub_info == NULL) return -ENOMEM;

return call_usermodehelper_exec( sub_info, UMH_WAIT_PROC );
}

下一步，调用 call_usermodehelper_setup 来创建已初始化的 subprocess_info 结构。请注意使用了先前初始化的变量以及指示用于内存初始化的 GFP 屏蔽第四个参数。在安装函数内部，调用了kzalloc（分配内核内存并清零）。该函数需要 GFP_ATOMIC 或 GFP_KERNEL 标志（前者定义调用不可以休眠，后者定义可以休眠）。快速测试新结构（即，非 NULL）后，使用 call_usermodehelper_exec 函数继续调用。该函数使用 subprocess_info 结构以及定义是否等待的枚举变量（在 “Usermode-helper API 内部” 一节中有描述）。全部完成！ 模块一旦加载，就可以在 /var/log/messages 文件中看到信息。
还可以通过 call_usermodehelper API 函数进一步简化进程，它同时执行 call_usermodehelper_setup和 call_usermodehelper_exec 函数。如清单 3 所示，它不仅删除函数，还消除了调用者管理subprocess_info 结构的必要性。

清单 3. 更简单的 usermode-helper API 测试

static int umh_test( void )
{
char *argv[] = { "/usr/bin/logger", "help!", NULL };
static char *envp[] = {
"HOME=/",
"TERM=linux",
"PATH=/sbin:/bin:/usr/sbin:/usr/bin", NULL };

return call_usermodehelper( argv[0], argv, envp, UMH_WAIT_PROC );
}

请注意在清单 3 中，有着同样的安装并调用（例如初始化 argv 和 envp 数组）的需求。此处惟一的区别是 helper 函数执行 setup 和 exec 函数。

❺ linux操作系统中 使用系统调用的一般方式是怎样的

给个例子给你看看吧，这里是linux中一个C语言程序，他用到了linux提供的系统调用,很长的程序了，或许你没耐心看，我在最后给你列出那些地方用了系统调用
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

#define BUFF_LEN 1024
#define RET_ERROR 1
#define RET_OK 0

typedef struct msg_send_struct { //这就是一个消息的数据结构
long my_type; //我们就是根据这个字段来区分每块消息的
char my_text[BUFF_LEN];
} msg_send_struct;

int main() {
char * path = "/";
int i_porject_id = 7;
key_t key;
msg_send_struct msg_send; //定义发送消息

int i_ret;
int i_msg_id;
int i_flag = 0666|IPC_CREAT; //为消息管道的创建指定参数，IPC_CREAT表示这个消息队列是创建，而不是搜索已经存在的消息队列

key = ftok(path, i_porject_id);//为消息队列生成一个key，当然你也可以手动指定，当你运气很好没有和已经窜在的消息队列的key起冲突的时候
if(key == 1) {
printf("building key error\n");
exit(1);
}

i_msg_id = msgget(key, i_flag);//根据你的参数决定是创建还是搜索KEY值得消息队列

if(i_msg_id == -1) {
printf("create msg queue error\n");
exit(1);
}
printf("i_msg_id = %d\n", i_msg_id);

msg_send.my_type = 1;
strcpy(msg_send.my_text, "hello world"); //初始化消息
i_ret = msgsnd(i_msg_id, &msg_send, strlen("hello world") + 1, IPC_NOWAIT);//开始发送，nowait表示如果队列中消息满了当前进程不等待直接返回错误，反之很容易理解吧

if(i_ret == -1) {
printf("msg send error\n");
exit(1);
}

exit(0);
}

下面是系统调用：
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>这些头文件可不是库函数，他里面就是linux提供的系统调用。

key = ftok(path, i_porject_id);//为消息队列生成一个key，当然你也可以手动指定，当你运气很好没有和已经窜在的消息队列的key起冲突的时候
linux中系统调用，利用文件系统和ID来创建KEY。

i_msg_id = msgget(key, i_flag);//根据i_flag值决定是创建还是寻找消息队列的系统调用。

i_ret = msgsnd(i_msg_id, &msg_send, strlen("hello world") + 1, IPC_NOWAIT);//发送消息的系统调用msgsnd函数。

这里涉及到进程通信中的消息队列内容，如果不明白没什么关系，可以看出来他和C的库函数调用一模一样，只不过实现方式，这需要你的知识积累到一定程度，有很大差别。对于一个程序员来说，我们看不出什么他们和库函数有什么区别，这算是一种对我们的透明性。

补充：这个例子是我写来学习进程通信内容的，由于采用了linux系统调用，所以只能在linux下面运行，还有就是我没有考虑权限问题，所以要编译请用超级用户root，由于消息队列的特性，这个程序没有释放队列（我把释放代码写在了接受消息的程序中)，第2次运行就会报消息队列不能创建的错误。

❻ Ubuntu下make编译，出现“error: ‘struct file’ has no member named ‘f_dentry’”

宏定义一个d_path 换掉f_dentry

❼ linux内核态，在LSM框架中的文件操作hook接口中如何获取一个正在被操作的文件的内容（linux4.4版本）

LSM是Linux Secrity Mole的简称，即linux安全模块。其是一种轻量级通用访
问控制框架，适合于多种访问控制模型在它上面以内核可加载模块的形实现。用
户可以根据自己的需求选择合适的安全模块加载到内核上实现。

LSM设计思想：
LSM的设计思想：在最少改变内核代码的情况下，提供一个能够成功实现强制访
问控制模块需要的结构或者接口。LSM避免了利用如在systrace系统调用中的出
现过的系统调用干预，因为它不能扩展到多处理器内核，并且它受制于参数替换
攻击。还有LSM在设计时做了两点考虑：对不使用的人来说尽量少引入麻烦，对
使用的人来说要带来效率。以Linus Torvalds为代表的内核开发人员对Linux安

全模块（LSM）提出了三点要求：
1、真正的通用，当使用一个不同的安全模型的时候，只需要加载一个不同的内
核模块。
2、概念上简单，对Linux内核影响最小，高效，并且。
3、能够支持现存的POSIX.1e capabilities逻辑，作为一个可选的安全模块。
还有，针对linux上提出的各种不同的Linux安全增强系统对Linux安全模块（LSM
）提出的要求是：能够允许他们以可加载内核模块的形式重新实现其安全功能，

并且不会在安全性方面带来明显的损失，也不会带来额外的系统开销。
LSM框架结构：
LSM框架主要由五部分构成：
1、在特定的内核数据结构中加入安全域。
2、在内核源代码中不同的关键点插入对安全钩子函数的调用。
3、加入一个通用的安全系统调用。
4、提供了函数允许内核模块注册为安全模块或者注销。
5、5、将capabilities逻辑的大部分移植为一个可选的安全模块。
安全域是一个void*类型的指针，它使得安全模块把安全信息和内核内部对象联
系起来。下面列出被修改加入了安全域的内核数据结构，以及各自所代表的内核

内部对象：
task_struct结构：代表任务（进程）
linux_binprm结构：代表程序
super_block结构：代表文件系统
inode结构：代表管道，文件，或者Socket套接字
file结构：代表打开的文件
sk_buff结构：代表网络缓冲区（包）
net_device结构：代表网络设备
kern_ipc_perm结构：代表Semaphore信号，共享内存段，或者消息队列
msg_msg：代表单个的消息

Linux安全模块（LSM）提供了两类对安全钩子函数的调用：一类管理内核对象的
安全域，另一类仲裁对这些内核对象的访问。对安全钩子函数的调用通过钩子来
实现，钩子是全局表security_ops中的函数指针，这个全局表的类型是
security_operations结构，这个结构定义在include/linux/security.h这个头
文件中。
LSM接口的核心是security_ops，当系统启动时，他们被初始化为传统的DAC策略
。传统DAC访问控制是指控制系统中的主体（如进程）对系统中的客体（如文件
目录、文件）的访问（读、写和执行等）。自主访问控制DAC 是指主体（进程，
用户）对客体（文件、目录、特殊设备文件、IPC等）的访问权限是由客体的属
主或超级用户决定的，而且此权限一旦确定，将作为以后判断主体对客体是否有

访问权限的依据。
在加载安全模块时，我们必需先对模块进行注册，我们可以使用
register_security()函数向LSM注册一个安全模块。在我们的模块被加载成
功后，就可以进行访问控制操作。如果此时还有一个安全模块要使用
register_security()函数进行加载，则会出现错误，直到使用
unregister_security()函数向框架注销后，下一个模块才可以载入。当然LS
M还提供了mod_reg_security()函数和mod_unreg_security()函数，可以连续注
册多个安全模块。如果有其他后来的模块需要载入，可以通过mod_reg_security
（）向第一个模块注册，形成支持不同策略的模块栈。
注：以上出现的函数均基于2.6.22以前的版本，对于后续的版本，出现了
register_security()函数未被导出或者取消掉了unregister_security()函数。
LSM执行过程：
根据下图的执行步骤：用户在执行系统调用时，先通过原有的内核接口依次执行
功能性的错误检查，接着进行传统的DAC检查，并在即将访问内核的内部对象之
前，通过LSM钩子函数调用LSM。LSM再调用具体的访问控制策略来决定访问的合
法性。图三显示了LSM钩子的调用：

图三：基于LSM的内核对象访问过程

Lilinux安全模块（LSM）主要支持"限制型"的访问控制决策：当Linux内核授予
文件或目录访问权限时，Linux安全模块（LSM）可能会拒绝，而当 Linux内核拒
绝访问时，可以跳过LSM。

========

使用LSM实现自己的访问控制

首先对LSM 进行简单介绍。虽然linux下的各位基本都知道一些，但是还要罗嗦
一下。
LSM中文全称是linux安全模块。英文全称：linux security mole.
LSM是一种轻量级、通用的访问控制框架，适合多种访问控制模型以内核模块的
形式实现。其特点是通用、简单、高效、支持POSIX。1e能力机制。
LSM的架构图如下：

通过系统调用进入内核之后，系统首先进行传统的权限检查（传统权限检查主要
是基于用户的，用户通过验证之后就可以访问资源），通过之后才会进行强制访
问控制。（强制访问控制是不允许主体干涉的一种访问控制，其采用安全标识、
信息分级等信息敏感性进行访问控制。并且通过比较主体的级别和资源的敏感性
来确定是否允许访问。比如说系统设置A用户不允许访问文件B，即便A是文件B的
所有者，访问也是受限制的。）从图上看来，LSM实现访问控制主要通过安全模
块的钩子函数实现。

LSM框架主要由五部分组成：这个网上资料很多。
在关键的特定内核数据结构中加入了安全域；
在内核源码中不同的关键点处插入对安全钩子函数的调用；
提供了一个通用的安全系统调用；
提供了注册和注销函数，使得访问控制策略可以以内核模块方式实现；
将capabilities逻辑的大部分功能移植为一个可选的安全模块。

我们这里重点结合源码对LSM框架进行解释。我使用的源码是3.5.4
首先介绍安全域字段，它是一个空类型的指针，在内核中的很多内核结构中都存
在，比如inode、superblock、dentry、file等等。类型字段为void *
security;
那么安全域怎么和安全模块中的信息关联起来？
当安全模块加载之后，安全域中的指针便指向安全模块中的安全信息。这里以
selinux为例进行介绍。
内核里面security/selinux/include/objsec.h中定义了不同对象的安全信息，
格式为XXX_security_strut.

上面的文件的安全信息里面包含打开文件描述符时的安全ID、文件所有者的安全
ID等等。
要联系安全模块中安全信息和安全域需要几个控制钩子函数。这些钩子函数实现
了对内核关键信息的设置和管理。这里主要介绍alloc_security、
free_security。
selinux里面通过实现安全信息空间分配实现关联。比如以文件安全信息为例
这里分配空间成功之后，通过file->f_security = fsec实现了关联。
撤销关联是在安全模块卸载之后调用file_free_security.

这里具体通过设置file->f_secrity为NULL，然后释放安全信息结构实现。
现在来看看内核如何实现selinux的访问控制。这里主要就是实现LSM里面的钩子
函数了。LSM里面给出了结构体security_operations，里面给出了很多钩子函数
，实现了相关钩子函数就可以实现访问控制了。

上面的函数就实现了file_permission钩子函数。可以看下inode结构体的获得，
感受内核是通过文件->目录项->inode。该函数主要实现自己的访问控制策略就
OK 了。
哪selinux来说，在获得文件安全ID之后，主要对掩码和文件打开时相关的安全
信息进行检测，符合就通过访问控制。
selinux基本实现了LSM里面的所有钩子函数，待钩子函数实现后，对LSM里面钩
子域进行填充就OK了。

做完以上这些还需要注册安全模块到LSM，这里注册和注销使用了
register_security和unregister_security。
比如selinux在注册时使用语句register_security(&selinux_ops)实现。

接下来通过上面的分析我们可以实现简单的基于LSM的访问控制。
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/mole.h>
#include <linux/fs.h>
#include <linux/security.h>
#include <linux/types.h>
#include <asm/uaccess.h>
#include <linux/fcntl.h>
#include <linux/uaccess.h>
#include <linux/file.h>
#include <linux/namei.h>

static int lsm_test_file_permission(struct file *file,int mask)
{
int path=0;
struct file *filp;
struct nameidata nd;

path = path_lookup(FILENAME,LOOKUP_FOLLOW,&nd);

if(!mask)
return 0;

if(path)
{
printk("lookup file failed!\n");
return -1;
}

filp = filp_open("/home/yuyunchao/code/sb.c",O_RDONLY,0);
{
printk("open failed!\n");
}
return 0;
}

static struct security_operations lsm_test_security_ops = {
.file_permission = lsm_test_file_permission,
};

static int __init lsm_file_init(void)
{
if(register_security(&lsm_test_security_ops)){
printk("register error ..........\n");
return -1;
}

printk("lsm_file init..\n ");
return 0;
}

static void __exit lsm_file_exit(void)
{
if(unregister_security(&lsm_test_security_ops)){
printk("unregister error................\n");
return ;
}

printk("mole exit.......\n");
}

MODULE_LICENSE("GPL");
mole_init(lsm_file_init);
mole_exit(lsm_file_exit);
========

LSM(Linux Security Mole)应用方法（简单例子）

LSM在内核中很多地方已经插入了hook函数，并且在security.c函数中声明了
security_ops结构，要实现你自己的安全模块，只需要定义你自己的struct
security_operations，并且用register_security注册即可，下面举个简单例子
：
test.c代码如下：
/*
* Test Linux Security Mole
*
* Author: penghuan <[email protected]>
*
* Copyright (C) 2010 UbuntuKylin, Ltd.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2, as
* published by the Free Software Foundation.
*
*/

#include <linux/security.h>
#include <linux/sysctl.h>
#include <linux/ptrace.h>
#include <linux/prctl.h>
#include <linux/ratelimit.h>
#include <linux/workqueue.h>
#include <linux/file.h>
#include <linux/fs.h>
#include <linux/dcache.h>
#include <linux/path.h>

int test_file_permission(struct file *file, int mask)
{
char *name = file->f_path.dentry->d_name.name;
if(!strcmp(name, "test.txt"))
{
file->f_flags |= O_RDONLY;
printk("you can have your control code here!\n");
}
return 0;
}

static struct security_operations test_security_ops = {
.name = "test",

.file_permission = test_file_permission,
};

static __init int test_init(void)
{
printk("enter test init!\n");

printk(KERN_INFO "Test: becoming......\n")

if (register_security(&test_security_ops))
panic("Test: kernel registration failed.\n");

return 0;
}

security_initcall(test_init);

将该文件以模块的形式放到security/下编译进内核，启用新的内核后，当你操
作文件test.txt时，通过dmesg命令就能再终端看到”you can have your
control code here!“输出
所以一般的做法是：定义你自己的struct security_operations，实现你自己的
hook函数，具体有哪些hook函数可以查询include/linux/security.h文件，然后
调用register_security来用你的test_security_ops初始化全局的security_ops
指针

楼主，我刚开始研究LSM，但网上资料太少，您这个代码，我编译成ko文件老是
有警告，并且insmod时，说Unknown symbol register_security。我最近看了看
内核模块变成，没有对内核进行太深入的了解。不知能否把LSM的实验步骤给出
的再详细点，谢谢。

你需要把代码编进内核

是需要把那段源码拷到内核目录下，然后重新编译内核？。。没有不编译内核的
方法吗？。。直接按照模块进行编译。另外那个test.txt放在哪个文件夹里？。

是需要把那段源码拷到内核目录下，然后重新编译内核？。。没有不编译内核的
方法吗？。。直接按照模块进行 ...

是的，你去网上找下怎么把模块编进内核，lsm模块不能以模块方式加载，涉及
安全；test.txt是测试文件，当你把代码编进内核后，用新内核启动，然后操作
test.txt文件，就会有输出，test.txt随便放哪里

楼主，您好，我刚开始学习lsm模块，把您的模块编译进内核，新的内核加载后
，register_security总是失败，请问下可能是什么原因导致的。我的内核版本
是3.13.11。

register＿security的返回值是-11

========

LSM在Linux中的实现方式
LSM(Linux Secure Model)一种轻量级访问控制机制.
其实现方式有如在系统调用中加入一个后门....
方式如下:
static struct file *__dentry_open(struct dentry *dentry, struct

vfsmount *mnt,
struct file *f,
int (*open)(struct inode *, struct file *),
const struct cred *cred)
{
struct inode *inode;
int error;
...............................................................
error = security_dentry_open(f, cred); //LSM机制实现方式,在此加入了

一个LSM函数.

//security_dentry_open的实现如下,相当于一个接口,对一个函数指针再

//封装一下.

//只返回是与否,这样的控制信息.
if (error)
goto cleanup_all;
................................................................
return f;
cleanup_all:
.................................................................
return ERR_PTR(error);
}
//========简单封装一个指针结构体===========================
int security_dentry_open(struct file *file, const struct cred *cred)
{
int ret;
ret = security_ops->dentry_open(file, cred);
if (ret)
return ret;
return fsnotify_perm(file, MAY_OPEN);
}

========

利用LSM实现更安全的linux

LSM的全称是Linux Security Moles，它是linux内核中用来支持更灵活的

安全策略的一个底层框架，虽然听起来比较复杂，但是可以就把它理解成一组安

插在linux内核的钩子函数和一些预留的被称为安全域的数据结构，下面先说说

这个框架的由来吧。

linux本身的机制就保证了linux拥有更好的安全机制，但是在这个机制下面

，还是隐藏了许多的问题：

1、权限粒度太大。用过linux的人应该对0644这样的访问权限设置不陌生，

它对能够操作这个文件的用户做了限制，但是这个只是限制到了组，而没有更进

一步的细分，当然，如果LSM只是用来限制这个的话，那么也就太没意思了，因

为实现文件更细的控制粒度，ACL就能够很出色的完成，顺便提一下，ACL有一个

分配的限制，如果哪位朋友需要用ACL进行粒度更细的访问权限控制的话，可能

需要注意一下这方面的东西。

2、root用户的权限太大。在linux中，root用户就是至高无上的，他拥有对

机器的完全控制权限，可以做他想做的一切事情。但是很多时候，我们可能并不

希望有root有这么大的权限，比如在现在比较流行的云存储中，用户肯定不希望

服务提供商能够随意访问我们的文件，那么这个时候，就需要对root用户进行一

定的设置了。

由于这些问题的存在，所以出现了像SE Linux(Securiy Enhanced Linux )

这样的增强补丁。但是每个系统对于具体安全细节的控制不尽相同， 所以Linus

Tovalds 提出应该要有一个 Linux 内核所能接受的安全框架来支持这些安全策

略，这个安全框架应该提供包含内核数据结构中的透明安全域以及用来控制、维

护安全域操作的安全钩子，于是就有了LSM。

LSM在内核中的位置，可以用下图来表示：

当用户态程序调用某些操作系统提供的函数的时候，比如read()函数，其会

对应于内核中的一个系统调用，然后该首先会进行一些常规的错误检测，接着进

行DAC（Discretionary Access Control）检测，再接着它会进行LSM检测。从上

图中能够看出来，LSM其实是一个非常底层的安全策略框架，利用LSM，可以接管

所有的系统调用，这样，我们就能对包括root在内的所有用户的权限进行控制，

并且实现粒度更细的访问权限控制。

当系统初始化的时候，LSM就是一个空的框架，它不提供任何的检测，其所

做的全部工作几乎就是返回0，当然，有些不带返回值的函数除外。而我们则可

以针对自己特定的需求来编写LSM，然后将我们编写的LSM钩子函数，通过其数据

结构struct security_operations注册到系统中去，这样，我们的LSM检测就开

始起作用了。
更多信息可参考《Linux就该这么学》

❽ linux下用简单c语言代码怎么实现实现文件夹所有内容的复制

||#include <sys/stat.h>
#include <unistd.h>
// 目录
int isdir(char *path)
{
struct stat buf;
int cc;
cc=stat(path,&buf);
if(!cc && (buf.st_mode & S_IFDIR)) return(1);
return(cc);
}
// 可读普通文件
int isrfile(char *path)
{
struct stat buf;
int cc;
int euid,egid;
cc=stat(path,&buf);
if(!cc) {
if((buf.st_mode & S_IFMT) != S_IFREG) return 0;
euid=geteuid();
egid=getegid();
if(euid==0) {
if(buf.st_mode & S_IRUSR || buf.st_mode & S_IRGRP ||
buf.st_mode & S_IROTH)
return 1;
else return 0;
}
if((buf.st_mode & S_IROTH)!=0) return 1;
if((buf.st_gid == egid) && ((buf.st_mode & S_IRGRP)!=0))
return 1;
if((buf.st_uid == euid) && ((buf.st_mode & S_IRUSR)!=0))
return 1;

}
return cc;
} 【江西新华】

❾ linux struct path 怎么找安装点

你可以这样，通过struct inode* inode = file->f_inode;struct dentry * xx = inode->i_dentry;然后通过dentry结构体指针的parent或child来path_walk一下，当然，出现文件链接的时候，就比较麻烦了。