我的虚拟文件系统（linux)

bierdaci

不知道该不该发这里，是我从proc改来的,懂内核源码的交流交流

hello.c

1. 
   
2. 
   
3. #include "hello.h"
   
4. 
   
5. struct inode * hello_get_inode(struct super_block *, int, struct hello_dir_entry *);
   
6. 
   
7. /*这个函数是直接从linux复制过来的，作用就是显示目录里的文件名，没有这个
   
8. 函数也行只是你用ls、dir命令看不到目录下的文件。*/
   
9. int hello_readdir(struct file * filp, void * dirent, filldir_t filldir)
   
10. {
    
11. printk("hello_readdir\n");
    
12.         struct hello_dir_entry * de;
    
13.         unsigned int ino;
    
14.         int i;
    
15.         struct inode *inode = filp->;f_dentry->;d_inode;
    
16. 
    
17.         ino = inode->;i_ino;
    
18.         de = (struct hello_dir_entry *) inode->;u.generic_ip;
    
19.         if (!de)
    
20.                 return -EINVAL;
    
21.         i = filp->;f_pos;
    
22.         switch (i) {
    
23.                 case 0:
    
24.                         if (filldir(dirent, ".", 1, i, ino, DT_DIR) < 0)
    
25.                                 return 0;
    
26.                         i++;
    
27.                         filp->;f_pos++;
    
28.                         /* fall through */
    
29.                 case 1:
    
30.                         if (filldir(dirent, "..", 2, i,
    
31.                                     filp->;f_dentry->;d_parent->;d_inode->;i_ino,
    
32.                                     DT_DIR) < 0)
    
33.                                 return 0;
    
34.                         i++;
    
35.                         filp->;f_pos++;
    
36.                         /* fall through */
    
37.                 default:
    
38.                         de = de->;subdir;
    
39.                         i -= 2;
    
40.                         for (;;) {
    
41.                                 if (!de)
    
42.                                         return 1;
    
43.                                 if (!i)
    
44.                                         break;
    
45.                                 de = de->;next;
    
46.                                 i--;
    
47.                         }
    
48. 
    
49.                         do {
    
50.                                 if (filldir(dirent, de->;name, de->;namelen, filp->;f_pos,
    
51.                                             de->;low_ino, de->;mode >;>; 12) < 0)
    
52.                                         return 0;
    
53.                                 filp->;f_pos++;
    
54.                                 de = de->;next;
    
55.                         } while (de);
    
56.         }
    
57.         return 1;
    
58. }
    
59. 
    
60. int hello_d_revalidate(struct dentry *res, int i){printk("d_revalidate\n");return 0;}
    
61. int hello_d_hash(struct dentry *res, struct qstr *name){printk("d_hash\n");return 0;}
    
62. int hello_d_compare(struct dentry *res, struct qstr *name, struct qstr *old)
    
63. {printk("d_compare\n");return 0;}
    
64. int hello_d_delete(struct dentry *res){printk("d_delete\n");return 0;}
    
65. void hello_d_release(struct dentry *res){printk("d_release\n");}
    
66. void hello_d_iput(struct dentry *res, struct inode *inode){printk("d_iput\n");}
    
67. 
    
68. struct dentry_operations hello_lookup_dops = {
    
69.         /*d_revalidate:        hello_d_revalidate,
    
70.         d_hash:                hello_d_hash,
    
71.         d_compare:        hello_d_compare,*/
    
72.         d_delete:        hello_d_delete,
    
73.         d_release:        hello_d_release,
    
74.         /*d_iput:                hello_d_iput*/
    
75. };
    
76. 
    
77. /*读文件节点，这个函数是被real_lookup函数调用的，具体调用是这里dir->;i_op->;lookup(dir, dentry);作用是从磁盘读文件节点填充inode结构。我这里用hello_dir_entry结构填充的*/
    
78. 
    
79. struct dentry *hello_lookup(struct inode * dir, struct dentry *dentry)
    
80. {
    
81.         struct inode *inode;
    
82.         struct hello_dir_entry * de;
    
83.         int error;
    
84. 
    
85.         error = -ENOENT;
    
86.         inode = NULL;
    
87.         de = (struct hello_dir_entry *) dir->;u.generic_ip;
    
88.         if (de) {
    
89.                 for (de = de->;subdir; de ; de = de->;next) {
    
90.                         if (!de || !de->;low_ino)
    
91.                                 continue;
    
92.                         if (de->;namelen != dentry->;d_name.len)
    
93.                                 continue;
    
94.                         if (!memcmp(dentry->;d_name.name, de->;name, de->;namelen)) {
    
95.                                 int ino = de->;low_ino;
    
96.                                 error = -EINVAL;
    
97.                                 inode = hello_get_inode(dir->;i_sb, ino, de);
    
98.                                 break;
    
99.                         }
    
100.                 }
     
101.         }
     
102. 
     
103.         if (inode) {
     
104.                 dentry->;d_op = &hello_lookup_dops;
     
105.                 d_add(dentry, inode);
     
106.                 return NULL;
     
107.         }
     
108.         return ERR_PTR(error);
     
109. }
     
110. /************************************************************************************************************/
     
111. static struct inode_operations hello_root_inode_operations = {
     
112.         lookup:                hello_lookup,
     
113. };
     
114. 
     
115. static struct file_operations hello_file_operations = {
     
116.         readdir:        hello_readdir,
     
117. };       
     
118. 
     
119. struct hello_dir_entry hello_root = {
     
120.         low_ino:        HELLO_ROOT_INO,
     
121.         namelen:        5,
     
122.         name:                "/hello",
     
123.         mode:                S_IFDIR | S_IRUGO | S_IXUGO,
     
124.         nlink:                2,
     
125.         hello_iops:        &hello_root_inode_operations,
     
126.         hello_fops:        &hello_file_operations,
     
127.         parent:        &hello_root,
     
128. };
     
129. 
     
130. /*填充inode结构*/
     
131. struct inode * hello_get_inode(struct super_block * sb, int ino,
     
132.         struct hello_dir_entry * de)
     
133. {
     
134. printk("hello_get_inode\n");
     
135.         struct inode * inode;
     
136. 
     
137.         de_get(de);
     
138.         inode = iget(sb, ino);
     
139.         if (!inode)
     
140.                 goto out_fail;
     
141.         inode->;u.generic_ip = (void *) de;
     
142.         if (de) {
     
143.                 if (de->;mode) {
     
144.                         inode->;i_mode = de->;mode;
     
145.                         inode->;i_uid = de->;uid;
     
146.                         inode->;i_gid = de->;gid;
     
147.                 }
     
148.                 if (de->;size)
     
149.                         inode->;i_size = de->;size;
     
150.                 if (de->;nlink)
     
151.                         inode->;i_nlink = de->;nlink;
     
152.                 if (de->;owner)
     
153.                         __MOD_INC_USE_COUNT(de->;owner);
     
154.                 if (de->;hello_iops)
     
155.                         inode->;i_op = de->;hello_iops;
     
156.                 if (de->;hello_fops)
     
157.                         inode->;i_fop = de->;hello_fops;
     
158.         }
     
159. 
     
160. out:
     
161.         return inode;
     
162. 
     
163. out_fail:
     
164.         de_put(de);
     
165.         goto out;
     
166. }                       
     
167. 
     
168. /***********************************************************************************************************/
     
169. 
     
170. void d_instantiate(struct dentry *entry, struct inode * inode)
     
171. {
     
172. printk("d_instantiate\n");
     
173.         if (!list_empty(&entry->;d_alias)) BUG();
     
174.         spin_lock(&dcache_lock);
     
175.         if (inode)
     
176.                 list_add(&entry->;d_alias, &inode->;i_dentry);
     
177.         entry->;d_inode = inode;
     
178.         spin_unlock(&dcache_lock);
     
179. }
     
180. /*创建根目录的dentry结构*/
     
181. 
     
182. struct dentry * d_alloc_root(struct inode * root_inode)
     
183. {
     
184.         struct dentry *res = NULL;
     
185. printk("d_alloc_root\n");
     
186.         if (root_inode) {
     
187.                 res = d_alloc(NULL, &(const struct qstr) { "/", 1, 0 });
     
188.                 if (res) {
     
189.                         res->;d_sb = root_inode->;i_sb;
     
190.                         res->;d_parent = res;
     
191.                         d_instantiate(res, root_inode);/*把根目录的inode结构安装到dentry结构里*/
     
192.                 }
     
193.         }
     
194.         return res;
     
195. }
     
196. 
     
197. void force_delete(struct inode *inode)
     
198. {
     
199. printk("force_delete\n");
     
200.         struct hello_dir_entry *de = inode->;u.generic_ip;
     
201.        
     
202.         if (atomic_read(&inode->;i_count) == 1)
     
203.                 inode->;i_nlink = 0;
     
204.         if (atomic_dec_and_test(&de->;count))
     
205.                 printk("hello_root.count: %d\n", atomic_read(&de->;count));
     
206. }
     
207. 
     
208. static void hello_delete_inode(struct inode *inode)
     
209. {
     
210. printk("hello_delete_inode\n");
     
211.         struct hello_dir_entry *de = inode->;u.generic_ip;
     
212.         inode->;i_state = I_CLEAR;
     
213.         /*if (de) {
     
214.                 if (de->;owner)
     
215.                         __MOD_DEC_USE_COUNT(de->;owner);
     
216.                 de_put(de);
     
217.         }*/
     
218. }
     
219. 
     
220. static void hello_read_inode(struct inode * inode)
     
221. {
     
222. printk("hello_read_inode\n");
     
223.         inode->;i_mtime = inode->;i_atime = inode->;i_ctime = CURRENT_TIME;
     
224. }
     
225. 
     
226. static int hello_statfs(struct super_block *sb, struct statfs *buf)
     
227. {
     
228. printk("hello_statfs\n");
     
229.         return 0;
     
230. }
     
231. 
     
232. void hello_write_super(struct super_block *s)
     
233. {
     
234.         printk("write_super\n");
     
235. }
     
236. 
     
237. static struct super_operations hello_sops = {
     
238.         read_inode:        hello_read_inode,
     
239.         put_inode:        force_delete,
     
240.         delete_inode:        hello_delete_inode,
     
241.         write_super:        hello_write_super,
     
242.         /*statfs:                hello_statfs,*/
     
243. };
     
244. 
     
245. struct dentry_operations hello_dops = {
     
246.         /*d_revalidate:        hello_d_revalidate,
     
247.         d_hash:                hello_d_hash,
     
248.         d_compare:        hello_d_compare,*/
     
249.         /*d_delete:        hello_d_delete,*/
     
250.         d_release:        hello_d_release,
     
251.         /*d_iput:                hello_d_iput*/
     
252. };
     
253. 
     
254. /*创建超级块*/
     
255. struct super_block *hello_read_super(struct super_block *s, void *data,
     
256.                                     int silent)
     
257. {
     
258. printk("hello_read_super\n");       
     
259.         struct inode * root_inode;
     
260. 
     
261.         s->;s_blocksize = 1024;
     
262.         s->;s_blocksize_bits = 10;
     
263.         s->;s_magic = 0;
     
264.         s->;s_op = &hello_sops;
     
265.         root_inode = hello_get_inode(s, HELLO_ROOT_INO, &hello_root);
     
266.         if (!root_inode)
     
267.                 goto out_no_root;
     
268. 
     
269.         s->;s_root = d_alloc_root(root_inode);
     
270.         if (!s->;s_root)
     
271.                 goto out_no_root;
     
272.         s->;s_root->;d_op = &hello_dops;
     
273.         return s;
     
274. 
     
275. out_no_root:
     
276.         printk("hello_read_super: get root inode failed\n");
     
277.         iput(root_inode);
     
278.         return NULL;
     
279. }
     
280. 
     
281. 
     

复制代码

hello.h

1. 
   
2. #include <linux/kernel.h>;
   
3. #include <linux/module.h>;
   
4. 
   
5. #include <linux/fs.h>;
   
6. #include <linux/wrapper.h>;
   
7. #include <linux/slab.h>;
   
8. #include <linux/wait.h>;
   
9. #include <linux/poll.h>;
   
10. 
    
11. #include <linux/mm.h>;
    
12. #include <linux/pagemap.h>;
    
13. 
    
14. #include <asm/uaccess.h>;
    
15. #include <asm/semaphore.h>;
    
16. 
    
17. 
    
18. #define HELLO_ROOT_INO 1
    
19.        
    
20. typedef        int (read_hello_t)(char *page, char **start, off_t off,
    
21.                           int count, int *eof, void *data);
    
22. typedef        int (write_hello_t)(struct file *file, const char *buffer,
    
23.                            unsigned long count, void *data);
    
24. typedef int (get_info_t)(char *, char **, off_t, int);
    
25. 
    
26. struct hello_dir_entry {
    
27.         unsigned short low_ino;
    
28.         unsigned short namelen;
    
29.         const char *name;
    
30.         mode_t mode;
    
31.         nlink_t nlink;
    
32.         uid_t uid;
    
33.         gid_t gid;
    
34.         unsigned long size;
    
35.         struct inode_operations * hello_iops;
    
36.         struct file_operations * hello_fops;
    
37.         get_info_t *get_info;
    
38.         struct module *owner;
    
39.         struct hello_dir_entry *next, *parent, *subdir;
    
40.         void *data;
    
41.         read_hello_t *read_hello;
    
42.         write_hello_t *write_hello;
    
43.         atomic_t count;                /* use count */
    
44.         int deleted;                /* delete flag */
    
45.         kdev_t        rdev;
    
46. };
    
47. 
    
48. extern struct hello_dir_entry hello_root;
    
49. extern struct dentry *hello_lookup(struct inode *, struct dentry *);
    
50. extern int hello_misc_init(void);
    
51. extern struct super_block *hello_read_super(struct super_block *, void *, int);
    
52. extern void de_put(struct hello_dir_entry *);
    
53. extern struct hello_dir_entry * de_get(struct hello_dir_entry *);
    
54. extern int hello_readdir(struct file *, void *, filldir_t);
    
55. 
    

复制代码

/*这个文件的作用是创建虚拟文件树结构，相当于磁盘上的文件树，这里我就不注释了，有兴趣的自己看看吧，挺简单的*/
hello_entry.c

1. 
   
2. #include "hello.h"
   
3. 
   
4. static struct inode_operations hello_dir_inode_operations = {
   
5.         lookup:                hello_lookup,
   
6. };
   
7. 
   
8. struct hello_dir_entry * de_get(struct hello_dir_entry *de)
   
9. {
   
10. printk("de_get\n");
    
11.         if (de)
    
12.                 atomic_inc(&de->;count);
    
13.         return de;
    
14. }
    
15. 
    
16. void inline free_hello_entry(struct hello_dir_entry *de)
    
17. {
    
18. printk("free_hello_entry\n");
    
19.         kfree(de);
    
20. }
    
21. 
    
22. void de_put(struct hello_dir_entry *de)
    
23. {
    
24. printk("de_put\n");
    
25.         if (de) {               
    
26.                 if (!atomic_read(&de->;count)) {
    
27.                         printk("de_put: entry %s already free!\n", de->;name);
    
28.                         return;
    
29.                 }
    
30. 
    
31.                 if (atomic_dec_and_test(&de->;count))
    
32.                         free_hello_entry(de);
    
33.         }
    
34. }
    
35. 
    
36. static ssize_t
    
37. hello_file_read(struct file * file, char * buf, size_t nbytes, loff_t *ppos)
    
38. {
    
39.         struct inode * inode = file->;f_dentry->;d_inode;
    
40.         char         *page;
    
41.         ssize_t        n;
    
42.         char        *start;
    
43.         struct hello_dir_entry * dp;
    
44. 
    
45.         dp = (struct hello_dir_entry *) inode->;u.generic_ip;
    
46.         if (!(page = (char*) __get_free_page(GFP_KERNEL)))
    
47.                 return -ENOMEM;
    
48. 
    
49.         n = dp->;read_hello(page, &start, *ppos,0,  NULL, NULL);
    
50.         copy_to_user(buf, page, n);
    
51. 
    
52.         free_page((unsigned long) page);
    
53.         return n;
    
54. }
    
55. 
    
56. static ssize_t
    
57. hello_file_write(struct file * file, const char * buffer,
    
58.                 size_t count, loff_t *ppos)
    
59. {
    
60.         struct inode *inode = file->;f_dentry->;d_inode;
    
61.         struct hello_dir_entry * dp;
    
62.        
    
63.         dp = (struct hello_dir_entry *) inode->;u.generic_ip;
    
64. 
    
65.         if (!dp->;write_hello)
    
66.                 return -EIO;
    
67. 
    
68.         /* FIXME: does this routine need ppos?  probably... */
    
69.         return dp->;write_hello(file, buffer, count, dp->;data);
    
70. }
    
71. 
    
72. 
    
73. static loff_t
    
74. hello_file_lseek(struct file * file, loff_t offset, int origin)
    
75. {
    
76.         long long retval;
    
77. 
    
78.         switch (origin) {
    
79.                 case 2:
    
80.                         offset += file->;f_dentry->;d_inode->;i_size;
    
81.                         break;
    
82.                 case 1:
    
83.                         offset += file->;f_pos;
    
84.         }
    
85.         retval = -EINVAL;
    
86.         if (offset>;=0 && offset<=file->;f_dentry->;d_inode->;i_sb->;s_maxbytes) {
    
87.                 if (offset != file->;f_pos) {
    
88.                         file->;f_pos = offset;
    
89.                         file->;f_reada = 0;
    
90.                 }
    
91.                 retval = offset;
    
92.         }
    
93.         return retval;
    
94. }
    
95. 
    
96. static struct file_operations hello_file_operations = {
    
97.         llseek:                hello_file_lseek,
    
98.         read:                hello_file_read,
    
99.         write:                hello_file_write,
    
100. };
     
101. 
     
102. static int hello_register(struct hello_dir_entry * dir, struct hello_dir_entry * dp)
     
103. {
     
104. printk("hello_register\n");
     
105.         dp->;low_ino = 2;
     
106.         dp->;next = dir->;subdir;
     
107.         dp->;parent = dir;
     
108.         dir->;subdir = dp;
     
109.         if (S_ISDIR(dp->;mode)) {
     
110.                 if (dp->;hello_iops == NULL) {
     
111.                         dp->;hello_fops = NULL;
     
112.                         dp->;hello_iops = &hello_dir_inode_operations;
     
113.                 }
     
114.                 dir->;nlink++;
     
115.         } else if (S_ISREG(dp->;mode)) {
     
116.                 if (dp->;hello_fops == NULL)
     
117.                         dp->;hello_fops = &hello_file_operations;
     
118.         }
     
119. 
     
120.         return 0;
     
121. }
     
122. 
     
123. static struct hello_dir_entry *hello_create(struct hello_dir_entry **parent,
     
124.                                           const char *name,
     
125.                                           mode_t mode,
     
126.                                           nlink_t nlink)
     
127. {
     
128. printk("hello_create\n");
     
129.         struct hello_dir_entry *ent = NULL;
     
130.         const char *fn = name;
     
131.         int len;
     
132. 
     
133.         len = strlen(name);
     
134.         *parent = &hello_root;
     
135. 
     
136.         ent = kmalloc(sizeof(struct hello_dir_entry) + len + 1, GFP_KERNEL);
     
137.         if (!ent) goto out;
     
138. 
     
139.         memset(ent, 0, sizeof(struct hello_dir_entry));
     
140.         memcpy(((char *) ent) + sizeof(struct hello_dir_entry), fn, len + 1);
     
141.         ent->;name = ((char *) ent) + sizeof(*ent);
     
142.         ent->;namelen = len;
     
143.         ent->;mode = mode;
     
144.         ent->;nlink = nlink;
     
145. out:
     
146.         return ent;
     
147. }
     
148. 
     
149. 
     
150. struct hello_dir_entry *create_hello_entry(const char *name, mode_t mode,
     
151.                                          struct hello_dir_entry *parent)
     
152. {
     
153. printk("create_hello_entry\n");
     
154.         struct hello_dir_entry *ent;
     
155.         nlink_t nlink;
     
156. 
     
157.         if (S_ISDIR(mode)) {
     
158.                 if ((mode & S_IALLUGO) == 0)
     
159.                         mode |= S_IRUGO | S_IXUGO;
     
160.                 nlink = 2;
     
161.         } else {
     
162.                 if ((mode & S_IFMT) == 0)
     
163.                         mode |= S_IFREG;
     
164.                 if ((mode & S_IALLUGO) == 0)
     
165.                         mode |= S_IRUGO;
     
166.                 nlink = 1;
     
167.         }
     
168. 
     
169.         ent = hello_create(&parent,name,mode,nlink);
     
170.         if (ent) {
     
171.                 if (hello_register(parent, ent) < 0) {
     
172.                         kfree(ent);
     
173.                         ent = NULL;
     
174.                 }
     
175.         }
     
176.         return ent;
     
177. }
     
178. 
     
179. static inline struct hello_dir_entry *hello_read_entry(const char *name,
     
180.         mode_t mode, struct hello_dir_entry *base,
     
181.         read_hello_t *read_hello, void * data)
     
182. {
     
183. printk("hello_dir_entry\n");
     
184.         struct hello_dir_entry *res=create_hello_entry(name,mode,base);
     
185.         if (res) {
     
186.                 res->;read_hello=read_hello;
     
187.                 res->;write_hello = NULL;
     
188.                 res->;data=data;
     
189.         }
     
190.         return res;
     
191. }
     
192. 
     
193. /************************************************************************************************************/
     
194. int read_hello(char *page, char **start, off_t off, int count, int *eof, void *data)
     
195. {
     
196.         strcpy(page, "hello world!");
     
197.         return 13;
     
198. }
     
199. 
     
200. int hello_misc_init(void)
     
201. {
     
202. printk("hello_misc_init\n");
     
203.         struct hello_dir_entry *err;
     
204.         err = hello_read_entry("zhang", 0, NULL, read_hello, NULL);
     
205.         return !err;
     
206. }               
     
207. 
     

复制代码

mount.c

1. 
   
2. #include "hello.h"
   
3. /*加载模块并安装文件系统*/
   
4. 
   
5. static DECLARE_FSTYPE(hello_fs_type, "hello", hello_read_super, FS_SINGLE);
   
6. struct vfsmount *mnt;
   
7. 
   
8. int hello_root_init(void)
   
9. {
   
10.         struct nameidata nd;
    
11.         int err;
    
12.         err = register_filesystem(&hello_fs_type);
    
13. printk("register_filesystem\n");
    
14.         if (err)
    
15.                 return err;
    
16.         mnt = kern_mount(&hello_fs_type);/*安装文件系统*/
    
17. printk("kern_mount\n");
    
18.         err = PTR_ERR(mnt);
    
19.         if (IS_ERR(mnt))
    
20.                 goto out;
    
21.         hello_misc_init();
    
22. 
    
23. MOD_DEC_USE_COUNT;
    
24.         char *name, *type;
    
25.         name = kmalloc(10, GFP_KERNEL);
    
26.         type = kmalloc(10, GFP_KERNEL);
    
27.         strcpy(name, "/hello");
    
28.         strcpy(type, "hello");
    
29.         long (*do_mount)(char *, char *, char *, unsigned long, void *) = (void*)0xc01603f0;/*0xc0166ad0;*/
    
30.         do_mount(NULL, name, type, 0, NULL);
    
31.         kfree(name);
    
32.         kfree(type);
    
33.         /*if (err)
    
34.                 goto out;
    
35.         */
    
36. 
    
37.         return 0;
    
38. out:
    
39.         mntput(mnt);
    
40.         unregister_filesystem(&hello_fs_type);
    
41.         return err;
    
42. }
    
43. 
    
44. 
    
45. int init_module(void)
    
46. {
    
47. printk("init_module\n");
    
48.         hello_root_init();
    
49.         return 0;
    
50. }
    
51. 
    
52. void cleanup_module()
    
53. {
    
54. printk("cleanup_module\n");
    
55.         mntput(mnt);
    
56.         unregister_filesystem(&hello_fs_type);
    
57. }
    
58. 
    

复制代码

Makefile

1. 
   
2. CC = gcc
   
3. CFLAGS = -O -Wall -D__KERNEL__ -DMODULE
   
4. #INCLUDEDIR =  /usr/local/linux-2.4.22/include
   
5. 
   
6. INCLUDEDIR =  /usr/src/linux-2.4.20-8/include
   
7. CFLAGS += -I$(INCLUDEDIR)
   
8. 
   
9. myfs.o:                mount.o hello_entry.o hello.o
   
10.         $(LD) -m elf_i386 -r -o myfs.o mount.o hello_entry.o hello.o
    
11. 
    
12. mount.o:        mount.c hello.h /usr/include/linux/version.h
    
13.         $(CC) $(CFLAGS) -c mount.c
    
14.        
    
15. hello_entry.o:        hello_entry.c hello.h /usr/include/linux/version.h
    
16.         $(CC) $(CFLAGS) -c hello_entry.c
    
17.        
    
18. hello.o:        hello.c hello.h /usr/include/linux/version.h
    
19.         $(CC) $(CFLAGS) -c hello.c
    
20. 
    

复制代码

测试程序read.c

1. 
   
2. #include <sys/ioctl.h>;
   
3. #include <sys/types.h>;
   
4. #include <sys/stat.h>;
   
5. #include <fcntl.h>;
   
6. 
   
7. 
   
8. int main()
   
9. {
   
10.         int fp;
    
11.         char buf[11];
    
12.         buf[10] = 0;
    
13.         int i;
    
14.        
    
15.         if ((fp = open("/hello/zhang", O_RDWR)) == 0) {
    
16.                 printf("Could not opened!\n");
    
17.                 return -1;
    
18.         }
    
19.         else
    
20.                 printf("File open ok!\n");
    
21.         read(fp, buf, 13);
    
22.         printf("%s\n", buf);
    
23.         close(fp);
    
24. }
    
25. 
    

复制代码

JohnBull

成功了吗?

bierdaci

呵呵，当然成功了，不过我只建了一个文件，本来想把我的管道和共享内存都放上去，只是懒得动了

bierdaci

你要试的话，需要在Sysmap文件找到 do_mount的地址，就像我这样的long (*do_mount)(char *, char *, char *, unsigned long, void *) = (void*)0xc01603f0;
是不是有点可笑呀，呵呵
还有为了简单没有实现搜索目录，只能在hello目录下建文件

JohnBull版主要是感兴趣，我可以把我实现的共享内存给你看看，一起交流交流，很少能遇到个对内核感趣的

JohnBull

加精!坚决加精!

bierdaci

[quote]原帖由 "JohnBull"]加精!坚决加精![/quote 发表：

谢谢版主

bierdaci

对了还有得在根目录下建一个hello目录

lozity

感觉晕
看不懂

xhl

我也晕，但很佩服楼主，支持下！

bierdaci

[quote]原帖由 "xhl"]我也晕，但很佩服楼主，支持下！[/quote 发表：


谢谢支持，小弟一定会继续努力，希望多几个能和我一起讨论内核编程的兄弟