读/dev/kmem错误

sailer_sh

RHEL3，内核与gcc全部是系统自带。
程序中相关代码：

1. 
   
2.         fd_kmem = open("/dev/kmem", O_RDWR);
   
3.         ptr_idt = get_addr_idt();
   
4.         descriptor = (struct descriptor_idt *) malloc(sizeof(struct descriptor_idt));
   
5.         ......
   
6.         readkmem(descriptor, ptr_idt + 8 * x, sizeof(struct descriptor_idt));
   
7. 
   
8.         ......
   
9. 
   
10. void readkmem(void *m, unsigned off, int size)
    
11. {
    
12.         int i;
    
13.         if (lseek(fd_kmem, off, SEEK_SET) != off) {
    
14.                 fprintf(stderr, "Error lseek. Are you root? \n");
    
15.                 exit(-1);
    
16.         }
    
17.         if (read(fd_kmem, m, size) != size) {
    
18.                 fprintf(stderr, "Error read kmem\n");
    
19.                 exit(-1);
    
20.         }
    
21. }
    
22. 
    
23. unsigned long get_addr_idt(void)
    
24. {
    
25.         unsigned char idtr[6];
    
26.         unsigned long idt;
    
27.         __asm__ volatile ("sidt %0":"=m" (idtr));
    
28.         idt = *((unsigned long *) &idtr[2]);
    
29.         return (idt);
    
30. }
    

复制代码

每次运行都会提示"Error read kmem"，调试发现read(fd_kmem, m, size)的返回值总是0。
不知道为什么？

[ 本帖最后由 sailer_sh 于 2006-3-20 18:08 编辑 ]

sailer_sh

原帖由 jobman 于 2006-3-22 10:42 发表

1. ptr_idt + 8 * 0 = ffc18000

复制代码

这个不对，idt 不会跑到这里来吧，别的没有问题，估计和你的平台有关，是ia－32吗？

我用普通的PC p4 1.8G，vmware exp server下的SLES9和RHEL3下跑这个程序。

刚在一台kernel 2.4.9-34，gcc 2.96的box（应该是redhat的某个版本）上跑这个程序，把llseek(）改成lseek()，编译后运行正常。
我正在一台PC上装SLES9，装好以后再试试。

[ 本帖最后由 sailer_sh 于 2006-3-22 10:54 编辑 ]

jobman

1. ptr_idt + 8 * 0 = ffc18000

复制代码

这个不对，idt 不会跑到这里来吧，别的没有问题，估计和你的平台有关，是ia－32吗？

sailer_sh

原帖由 jobman 于 2006-3-21 16:52 发表
sailer_sh
能把 strace 的结果发上来看看么？

程序里使用了llseek()函数：

linux:~ # strace ./checkidt -A

1. 
   
2. execve("./checkidt", ["./checkidt", "-A"], [/* 57 vars */]) = 0
   
3. uname({sys="Linux", node="linux", ...}) = 0
   
4. brk(0)                                  = 0x804c000
   
5. open("/etc/ld.so.preload", O_RDONLY)    = -1 ENOENT (No such file or directory)
   
6. old_mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x40017000
   
7. open("/etc/ld.so.cache", O_RDONLY)      = 3
   
8. fstat64(3, {st_mode=S_IFREG|0644, st_size=66499, ...}) = 0
   
9. old_mmap(NULL, 66499, PROT_READ, MAP_PRIVATE, 3, 0) = 0x40018000
   
10. close(3)                                = 0
    
11. open("/lib/tls/libc.so.6", O_RDONLY)    = 3
    
12. read(3, "\177ELF\1\1\1\0\0\0\0\0\0\0\0\0\3\0\3\0\1\0\0\0@S\1\000"..., 512) = 512
    
13. fstat64(3, {st_mode=S_IFREG|0755, st_size=1345545, ...}) = 0
    
14. old_mmap(NULL, 1128748, PROT_READ|PROT_EXEC, MAP_PRIVATE, 3, 0) = 0x40029000
    
15. madvise(0x40029000, 1128748, MADV_SEQUENTIAL|0x1) = 0
    
16. old_mmap(0x40132000, 32768, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED, 3, 0x109000) = 0x40132000
    
17. old_mmap(0x4013a000, 10540, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0x4013a000
    
18. close(3)                                = 0
    
19. set_thread_area({entry_number:-1 -> 6, base_addr:0x400179a0, limit:1048575, seg_32bit:1, contents:0, read_exec_only:0, limit_in_pages:1, seg_not_present:0, useable:1}) = 0
    
20. munmap(0x40018000, 66499)               = 0
    
21. brk(0)                                  = 0x804c000
    
22. brk(0x806d000)                          = 0x806d000
    
23. brk(0)                                  = 0x806d000
    
24. fstat64(1, {st_mode=S_IFCHR|0620, st_rdev=makedev(136, 0), ...}) = 0
    
25. mmap2(NULL, 4096, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x40018000
    
26. write(1, "\n", 1
    
27. )                       = 1
    
28. open("/dev/kmem", O_RDWR)               = 3
    
29. write(1, "fd_kmem= 3, show_all_info = -1, "..., 56fd_kmem= 3, show_all_info = -1, show_all_descriptor = 1
    
30. ) = 56
    
31. write(1, "Int *** Stub Address *** Segment"..., 51Int *** Stub Address *** Segment *** DPL *** Type
    
32. ) = 51
    
33. write(1, "--------------------------------"..., 52---------------------------------------------------
    
34. ) = 52
    
35. write(1, "sizeof(descriptor) = 4, ptr_idt "..., 86sizeof(descriptor) = 4, ptr_idt + 8 * 0 = ffc18000, sizeof(struct descriptor_idt) = 8
    
36. ) = 86
    
37. _llseek(3, 4290871296, 0xbffff3e0, 0x8048e47 /* SEEK_??? */) = -1 EINVAL (Invalid argument)
    
38. write(2, "Error lseek. Are you root? \n", 28Error lseek. Are you root?
    
39. ) = 28
    
40. munmap(0x40018000, 4096)                = 0
    
41. exit_group(-1)                          = ?
    

复制代码

如果程序里改用lseek()函数，输出的后几行：

1. 
   
2. write(1, "--------------------------------"..., 52---------------------------------------------------
   
3. ) = 52
   
4. write(1, "sizeof(descriptor) = 4, ptr_idt "..., 86sizeof(descriptor) = 4, ptr_idt + 8 * 0 = ffc18000, sizeof(struct descriptor_idt) = 8
   
5. ) = 86
   
6. lseek(3, 4290871296, SEEK_SET)          = 4290871296
   
7. read(3, "", 8)                          = 0
   
8. write(2, "Error read kmem 1\n", 18Error read kmem 1
   
9. )     = 18
   
10. write(2, "read: Success\n", 14read: Success
    
11. )         = 14
    
12. write(1, "read = 0, size = 8, fd_kmem= 3, "..., 46read = 0, size = 8, fd_kmem= 3, sizeof(m) = 4
    
13. ) = 46
    
14. munmap(0x40018000, 4096)                = 0
    
15. exit_group(-1)  
    

复制代码

[ 本帖最后由 sailer_sh 于 2006-3-21 18:11 编辑 ]

jobman

sailer_sh
能把 strace 的结果发上来看看么？

jobman

原帖由 lenn 于 2006-3-21 16:46 发表


晕死,发在这个版,都以为是驱动程序或者核心态的了,用户状态访问这个文件没有意义啊.用户态应该访问
/dev/mem吧

用户态才需要kmem，核心态要设备节点干什么啊，直接读了。

lenn

原帖由 jobman 于 2006-3-21 16:40 发表


他现在是在用户态，不在核心态，不需要段超越。

晕死,发在这个版,都以为是驱动程序或者核心态的了,用户状态访问这个文件没有意义啊.用户态应该访问
/dev/mem吧

jobman

原帖由 lenn 于 2006-3-21 16:04 发表
这样看看:
void readkmem (void *m,unsigned off,int sz)
{
        mm_segment_t old_fs_value=get_fs();
        set_fs(get_ds());
        if (lseek(kmem,off,0)!=off) {
                printk(&quo ...

他现在是在用户态，不在核心态，不需要段超越。

sailer_sh

原帖由 lenn 于 2006-3-21 16:04 发表
这样看看:
void readkmem (void *m,unsigned off,int sz)
{
        mm_segment_t old_fs_value=get_fs();
        set_fs(get_ds());
        if (lseek(kmem,off,0)!=off) {
                printk(&quo ...

谢谢！
请教你这个程序代码中mm_segment_t从哪里来？
还有，你这两段代码是单独的程序？还是插入源程序。

我把源程序贴出来：

1. 
   
2. /*
   
3.    * CheckIDT V1.1
   
4.    * Play with IDT from userland
   
5.    * It's a tripwire kind for IDT
   
6.    * kad 2002
   
7.    *
   
8.    * gcc -Wall -o checkidt checkidt.c
   
9.    */
   
10. 
    
11. #include <stdio.h>
    
12. #include <stdlib.h>
    
13. #include <unistd.h>
    
14. #include <linux/unistd.h>
    
15. #include <sys/types.h>
    
16. #include <sys/stat.h>
    
17. #include <fcntl.h>
    
18. #include <asm/segment.h>
    
19. #include <string.h>
    
20. #include <error.h>
    
21. 
    
22. #define NORMAL          "\033[0m"
    
23. #define NOIR            "\033[30m"
    
24. #define ROUGE           "\033[31m"
    
25. #define VERT            "\033[32m"
    
26. #define JAUNE           "\033[33m"
    
27. #define BLEU            "\033[34m"
    
28. #define MAUVE           "\033[35m"
    
29. #define BLEU_CLAIR      "\033[36m"
    
30. #define SYSTEM          "System gate"
    
31. #define INTERRUPT       "Interrupt gate"
    
32. #define TRAP            "Trap gate"
    
33. #define DEFAULT_FILE    "Safe_idt"
    
34. #define DEFAULT_MAP        "/boot/System.map"
    
35. 
    
36. /***********GLOBAL**************/
    
37. int fd_kmem;
    
38. unsigned long ptr_idt;
    
39. /******************************/
    
40. 
    
41. struct {
    
42.                 unsigned short limit;
    
43.                         unsigned int base;
    
44. } __attribute__ ((packed)) idtr;
    
45. 
    
46. struct descriptor_idt {
    
47.         unsigned short offset_low, seg_selector;
    
48.         unsigned char reserved, flag;
    
49.         unsigned short offset_high;
    
50. };
    
51. 
    
52. struct Mode {
    
53.         int show_idt_addr;
    
54.         int show_all_info;
    
55.         int read_file_archive;
    
56.         int create_file_archive;
    
57.         char out_filename[20];
    
58.         int compare_idt;
    
59.         int restore_idt;
    
60.         char in_filename[20];
    
61.         int show_all_descriptor;
    
62.         int resolve;
    
63.         char map_filename[40];
    
64. };
    
65. 
    
66. unsigned long get_addr_idt(void)
    
67. {
    
68.         __asm__ volatile ("sidt %0":"=m" (idtr));
    
69.         return idtr.base;
    
70. }
    
71. 
    
72. unsigned short get_size_idt(void)
    
73. {
    
74.         __asm__ volatile ("sidt %0":"=m" (idtr));
    
75.         return idtr.limit;
    
76. }
    
77. 
    
78. char *get_segment(unsigned short selecteur)
    
79. {
    
80.         if (selecteur == __KERNEL_CS) {
    
81.                 return ("KERNEL_CS");
    
82.         }
    
83.         if (selecteur == __KERNEL_DS) {
    
84.                 return ("KERNEL_DS");
    
85.         }
    
86.         if (selecteur == __USER_CS) {
    
87.                 return ("USER_CS");
    
88.         }
    
89.         if (selecteur == __USER_DS) {
    
90.                 return ("USER_DS");
    
91.         } else {
    
92.                 return("UNKNOW\n");
    
93.         }
    
94. }
    
95. 
    
96. 
    
97. void readkmem(void *m, unsigned off, int size)
    
98. {
    
99.         int i;
    
100.         if (llseek(fd_kmem, off, SEEK_SET) != off) {
     
101.                 fprintf(stderr, "Error lseek. Are you root? \n");
     
102.                 exit(-1);
     
103.         }
     
104.         if ((i = read(fd_kmem, m, size)) != size) {
     
105.                 fprintf(stderr, "Error read kmem 1\n");
     
106.                 perror("read");
     
107.                 printf("read = %d, size = %d, fd_kmem= %d, sizeof(m) = %d\n", i, size, fd_kmem, sizeof(m));
     
108.                 exit(-1);
     
109.         }
     
110. }
     
111. 
     
112. void writekmem(void *m, unsigned off, int size)
     
113. {
     
114.         if (llseek(fd_kmem, off, SEEK_SET) != off) {
     
115.                 fprintf(stderr, "Error lseek. Are you root? \n");
     
116.                 exit(-1);
     
117.         }
     
118.         if (write(fd_kmem, m, size) != size) {
     
119.                 fprintf(stderr, "Error read kmem 2\n");
     
120.                 exit(-1);
     
121.         }
     
122. }
     
123. 
     
124. void resolv(char *file, unsigned long stub_addr, char *name)
     
125. {
     
126.         FILE *fd;
     
127.         char buf[100], addr[30];
     
128.         char *ptr, *ptr_begin, *ptr_end;
     
129.         snprintf(addr, 30, "%s", (char *) stub_addr);
     
130.         if (!(fd = fopen(file, "r"))) {
     
131.                 fprintf(stderr,
     
132.                         "Can't open map file. You can specify a map file -S option or change #define in source\n");
     
133.                 exit(-1);
     
134.         }
     
135.         while (fgets(buf, 100, fd) != NULL) {
     
136.                 ptr = strstr(buf, addr);
     
137.                 if (ptr) {
     
138.                         bzero(name, 30);
     
139.                         ptr_begin = strstr(buf, " ");
     
140.                         ptr_begin = strstr(ptr_begin + 1, " ");
     
141.                         ptr_end = strstr(ptr_begin + 1, "\n");
     
142.                         strncpy(name, ptr_begin + 1,
     
143.                                 ptr_end - ptr_begin - 1);
     
144.                         break;
     
145.                 }
     
146.         }
     
147.         if (strlen(name) == 0)
     
148.                 strcpy(name, ROUGE "can't resolve" NORMAL);
     
149.         fclose(fd);
     
150. }
     
151. 
     
152. void show_all_info(int interrupt, int all_descriptor, char *file,
     
153.                    int resolve)
     
154. {
     
155.         struct descriptor_idt *descriptor;
     
156.         unsigned long stub_addr;
     
157.         unsigned short selecteur;
     
158.         char type[15];
     
159.         char segment[15];
     
160.         char name[30];
     
161.         int x;
     
162.         int dpl;
     
163.         bzero(name, strlen(name));
     
164.         descriptor = (struct descriptor_idt *)
     
165.             malloc(sizeof(struct descriptor_idt));
     
166.         if (descriptor == NULL)
     
167.                 printf("malloc error");
     
168.         printf("Int *** Stub Address *** Segment *** DPL *** Type ");
     
169.         if (resolve >= 0) {
     
170.                 printf("            Handler Name\n");
     
171.                 printf
     
172.                     ("-------------------------------------------------------------------------\n");
     
173.         } else {
     
174.                 printf("\n");
     
175.                 printf
     
176.                     ("---------------------------------------------------\n");
     
177.         }
     
178. 
     
179.         if (interrupt >= 0) {
     
180.                 printf("sizeof(descriptor) = %d, ptr_idt + 8 * interrupt = %u, sizeof(descriptor_idt) = %d\n", sizeof(descriptor), (unsigned)ptr_idt + 8 * interrupt, sizeof(struct descriptor_idt));
     
181.                 readkmem(descriptor, ptr_idt + 8 * interrupt,
     
182.                          sizeof(struct descriptor_idt));
     
183.                 stub_addr =
     
184.                     (unsigned long) (descriptor->offset_high << 16) +
     
185.                     descriptor->offset_low;
     
186.                 selecteur = (unsigned short) descriptor->seg_selector;
     
187.                 if (descriptor->flag & 64)
     
188.                         dpl = 3;
     
189.                 else
     
190.                         dpl = 0;
     
191.                 if (descriptor->flag & 1) {
     
192.                         if (dpl)
     
193.                                 strncpy(type, SYSTEM, sizeof(SYSTEM));
     
194.                         else
     
195.                                 strncpy(type, TRAP, sizeof(TRAP));
     
196.                 } else
     
197.                         strncpy(type, INTERRUPT, sizeof(INTERRUPT));
     
198.                 strcpy(segment, get_segment(selecteur));
     
199. 
     
200.                 if (resolve >= 0) {
     
201.                         resolv(file, stub_addr, name);
     
202.                         printf("%-7i 0x%-14.8x %-12s%-8i%-16s %s\n",
     
203.                                interrupt, (unsigned)stub_addr, segment, dpl, type,
     
204.                                name);
     
205.                 } else {
     
206.                         printf("%-7i 0x%-14.8x %-12s %-7i%s\n", interrupt,
     
207.                                (unsigned)stub_addr, segment, dpl, type);
     
208.                 }
     
209.         }
     
210.         if (all_descriptor >= 0) {
     
211.                 for (x = 0; x < (get_size_idt() + 1) / 8; x++) {
     
212.                         printf("sizeof(descriptor) = %d, ptr_idt + 8 * %d = %x, sizeof(struct descriptor_idt) = %d\n", sizeof(descriptor), x, (unsigned)ptr_idt + 8 * x, sizeof(struct descriptor_idt));
     
213.                         readkmem(descriptor, ptr_idt + 8 * x,
     
214.                                  sizeof(struct descriptor_idt));
     
215.                         stub_addr =
     
216.                             (unsigned long) (descriptor->
     
217.                                              offset_high << 16) +
     
218.                             descriptor->offset_low;
     
219.                         if (stub_addr != 0) {
     
220.                                 selecteur =
     
221.                                     (unsigned short) descriptor->
     
222.                                     seg_selector;
     
223.                                 if (descriptor->flag & 64)
     
224.                                         dpl = 3;
     
225.                                 else
     
226.                                         dpl = 0;
     
227.                                 if (descriptor->flag & 1) {
     
228.                                         if (dpl)
     
229.                                                 strncpy(type, SYSTEM,
     
230.                                                         sizeof(SYSTEM));
     
231.                                         else
     
232.                                                 strncpy(type, TRAP,
     
233.                                                         sizeof(TRAP));
     
234.                                 } else
     
235.                                         strncpy(type, INTERRUPT,
     
236.                                                 sizeof(INTERRUPT));
     
237.                                 strcpy(segment, get_segment(selecteur));
     
238.                                 if (resolve >= 0) {
     
239.                                         bzero(name, strlen(name));
     
240.                                         resolv(file, stub_addr, name);
     
241.                                         printf
     
242.                                             ("%-7i 0x%-14.8x %-12s%-8i%-16s %s\n",
     
243.                                              x, (unsigned)stub_addr, segment, dpl,
     
244.                                              type, name);
     
245.                                 } else {
     
246.                                         printf
     
247.                                             ("%-7i 0x%-14.8x %-12s %-7i%s\n",
     
248.                                              x, (unsigned)stub_addr, segment, dpl,
     
249.                                              type);
     
250.                                 }
     
251.                         }
     
252.                 }
     
253.         }
     
254.         free(descriptor);
     
255. }
     
256. 
     
257. void create_archive(char *file)
     
258. {
     
259.         FILE *file_idt;
     
260.         struct descriptor_idt *descriptor;
     
261.         int x;
     
262.         descriptor = (struct descriptor_idt *)
     
263.             malloc(sizeof(struct descriptor_idt));
     
264.         if (!(file_idt = fopen(file, "w"))) {
     
265.                 fprintf(stderr, "Error while opening file\n");
     
266.                 exit(-1);
     
267.         }
     
268.         for (x = 0; x < (get_size_idt() + 1) / 8; x++) {
     
269.                 readkmem(descriptor, ptr_idt + 8 * x,
     
270.                          sizeof(struct descriptor_idt));
     
271.                 fwrite(descriptor, sizeof(struct descriptor_idt), 1,
     
272.                        file_idt);
     
273.         }
     
274.         free(descriptor);
     
275.         fclose(file_idt);
     
276.         fprintf(stderr, "Creating file archive idt done \n");
     
277. }
     
278. 
     
279. void read_archive(char *file)
     
280. {
     
281.         FILE *file_idt;
     
282.         int x;
     
283.         struct descriptor_idt *descriptor;
     
284.         unsigned long stub_addr;
     
285.         descriptor = (struct descriptor_idt *)
     
286.             malloc(sizeof(struct descriptor_idt));
     
287.         if (!(file_idt = fopen(file, "r"))) {
     
288.                 fprintf(stderr, "Error, check if the file exist\n");
     
289.                 exit(-1);
     
290.         }
     
291.         for (x = 0; x < (get_size_idt() + 1) / 8; x++) {
     
292.                 fread(descriptor, sizeof(struct descriptor_idt), 1,
     
293.                       file_idt);
     
294.                 stub_addr =
     
295.                     (unsigned long) (descriptor->offset_high << 16) +
     
296.                     descriptor->offset_low;
     
297.                 printf("Interruption : %i  -- Stub addresse : 0x%.8x\n", x,
     
298.                        (unsigned)stub_addr);
     
299.         }
     
300.         free(descriptor);
     
301.         fclose(file_idt);
     
302. }
     
303. 
     
304. void compare_idt(char *file, int restore_idt)
     
305. {
     
306.         FILE *file_idt;
     
307.         int x, change = 0;
     
308.         //int result;
     
309.         struct descriptor_idt *save_descriptor, *actual_descriptor;
     
310.         unsigned long save_stub_addr, actual_stub_addr;
     
311.         //unsigned short *offset;
     
312.         save_descriptor = (struct descriptor_idt *)
     
313.             malloc(sizeof(struct descriptor_idt));
     
314.         actual_descriptor = (struct descriptor_idt *)
     
315.             malloc(sizeof(struct descriptor_idt));
     
316.         file_idt = fopen(file, "r");
     
317.         for (x = 0; x < (get_size_idt() + 1) / 8; x++) {
     
318.                 fread(save_descriptor, sizeof(struct descriptor_idt), 1,
     
319.                       file_idt);
     
320.                 save_stub_addr =
     
321.                     (unsigned long) (save_descriptor->offset_high << 16) +
     
322.                     save_descriptor->offset_low;
     
323.                 readkmem(actual_descriptor, ptr_idt + 8 * x,
     
324.                          sizeof(struct descriptor_idt));
     
325.                 actual_stub_addr =
     
326.                     (unsigned long) (actual_descriptor->
     
327.                                      offset_high << 16) +
     
328.                     actual_descriptor->offset_low;
     
329.                 if (actual_stub_addr != save_stub_addr) {
     
330.                         if (restore_idt < 1) {
     
331.                                 fprintf(stderr,
     
332.                                         VERT
     
333.                                         "Hey stub address of interrupt %i has changed!!!\n"
     
334.                                         NORMAL, x);
     
335.                                 fprintf(stderr, "Old Value : 0x%.8x\n",
     
336.                                         (unsigned) save_stub_addr);
     
337.                                 fprintf(stderr, "New Value : 0x%.8x\n",
     
338.                                         (unsigned) actual_stub_addr);
     
339.                                 change = 1;
     
340.                         } else {
     
341.                                 fprintf(stderr,
     
342.                                         VERT
     
343.                                         "Restore old stub address of interrupt %i\n"
     
344.                                         NORMAL, x);
     
345.                                 actual_descriptor->offset_high =
     
346.                                     (unsigned short) (save_stub_addr >>
     
347.                                                       16);
     
348.                                 actual_descriptor->offset_low =
     
349.                                     (unsigned short) (save_stub_addr &
     
350.                                                       0x0000FFFF);
     
351.                                 writekmem(actual_descriptor,
     
352.                                           ptr_idt + 8 * x,
     
353.                                           sizeof(struct descriptor_idt));
     
354.                                 change = 1;
     
355.                         }
     
356.                 }
     
357.         }
     
358.         if (!change)
     
359.                 fprintf(stderr, VERT "All values are same\n" NORMAL);
     
360. }
     
361. 
     
362. void initialize_value(struct Mode *mode)
     
363. {
     
364.         mode->show_idt_addr = -1;
     
365.         mode->show_all_info = -1;
     
366.         mode->show_all_descriptor = -1;
     
367.         mode->create_file_archive = -1;
     
368.         mode->read_file_archive = -1;
     
369.         strncpy(mode->out_filename, DEFAULT_FILE, strlen(DEFAULT_FILE));
     
370.         mode->compare_idt = -1;
     
371.         mode->restore_idt = -1;
     
372.         strncpy(mode->in_filename, DEFAULT_FILE, strlen(DEFAULT_FILE));
     
373.         strncpy(mode->map_filename, DEFAULT_MAP, strlen(DEFAULT_MAP));
     
374.         mode->resolve = -1;
     
375. }
     
376. 
     
377. void usage()
     
378. {
     
379.         fprintf(stderr, "CheckIDT V 1.1 by kad\n");
     
380.         fprintf(stderr, "---------------------\n");
     
381.         fprintf(stderr, "Option : \n");
     
382.         fprintf(stderr,
     
383.                 "       -a nb    show all info about one interrupt\n");
     
384.         fprintf(stderr,
     
385.                 "       -A       showw all info about all interrupt\n");
     
386.         fprintf(stderr, "       -I       show IDT address \n");
     
387.         fprintf(stderr, "       -c       create file archive\n");
     
388.         fprintf(stderr, "       -r       read file archive\n");
     
389.         fprintf(stderr,
     
390.                 "       -o file  output filename (for creating file archive)\n");
     
391.         fprintf(stderr, "       -C       compare save idt & new idt\n");
     
392.         fprintf(stderr, "       -R       restore IDT\n");
     
393.         fprintf(stderr,
     
394.                 "       -i file  input filename to compare or read\n");
     
395.         fprintf(stderr,
     
396.                 "       -s         resolve symbol thanks to /boot/System.map\n");
     
397.         fprintf(stderr, "       -S file    specify a map file\n\n");
     
398.         exit(1);
     
399. }
     
400. 
     
401. int main(int argc, char **argv)
     
402. {
     
403.         int option;
     
404.         struct Mode *mode;
     
405.         if (argc < 2) {
     
406.                 usage();
     
407.         }
     
408. 
     
409.         mode = (struct Mode *) malloc(sizeof(struct Mode));
     
410.         initialize_value(mode);
     
411. 
     
412.         while ((option = getopt(argc, argv, "hIa:Aco:Ci:rRsS:")) != -1) {
     
413.                 switch (option) {
     
414.                 case 'h':
     
415.                         usage();
     
416.                         exit(1);
     
417.                 case 'I':
     
418.                         mode->show_idt_addr = 1;
     
419.                         break;
     
420.                 case 'a':
     
421.                         mode->show_all_info = atoi(optarg);
     
422.                         break;
     
423.                 case 'A':
     
424.                         mode->show_all_descriptor = 1;
     
425.                         break;
     
426.                 case 'c':
     
427.                         mode->create_file_archive = 1;
     
428.                         break;
     
429.                 case 'r':
     
430.                         mode->read_file_archive = 1;
     
431.                         break;
     
432.                 case 'R':
     
433.                         mode->restore_idt = 1;
     
434.                         break;
     
435.                 case 'o':
     
436.                         bzero(mode->out_filename,
     
437.                               sizeof(mode->out_filename));
     
438.                         if (strlen(optarg) > 20) {
     
439.                                 fprintf(stderr, "Filename too long\n");
     
440.                                 exit(-1);
     
441.                         }
     
442.                         strncpy(mode->out_filename, optarg,
     
443.                                 strlen(optarg));
     
444.                         break;
     
445.                 case 'C':
     
446.                         mode->compare_idt = 1;
     
447.                         break;
     
448.                 case 'i':
     
449.                         bzero(mode->in_filename,
     
450.                               sizeof(mode->in_filename));
     
451.                         if (strlen(optarg) > 20) {
     
452.                                 fprintf(stderr, "Filename too long\n");
     
453.                                 exit(-1);
     
454.                         }
     
455.                         strncpy(mode->in_filename, optarg, strlen(optarg));
     
456.                         break;
     
457.                 case 's':
     
458.                         mode->resolve = 1;
     
459.                         break;
     
460.                 case 'S':
     
461.                         bzero(mode->map_filename,
     
462.                               sizeof(mode->map_filename));
     
463.                         if (strlen(optarg) > 40) {
     
464.                                 fprintf(stderr, "Filename too long\n");
     
465.                                 exit(-1);
     
466.                         }
     
467.                         if (optarg)
     
468.                                 strncpy(mode->map_filename, optarg,
     
469.                                         strlen(optarg));
     
470.                         break;
     
471.                 }
     
472.         }
     
473.         printf("\n");
     
474.         ptr_idt = get_addr_idt();
     
475.         if (mode->show_idt_addr >= 0) {
     
476.                 fprintf(stdout, "Addresse IDT : 0x%x\n", (unsigned)ptr_idt);
     
477.         }
     
478.         fd_kmem = open("/dev/kmem", O_RDWR);
     
479.         printf("fd_kmem= %d, show_all_info = %d, show_all_descriptor = %d\n", fd_kmem, mode->show_all_info, mode->show_all_descriptor);
     
480.         if (mode->show_all_info >= 0 || mode->show_all_descriptor >= 0) {
     
481.                 show_all_info(mode->show_all_info,
     
482.                               mode->show_all_descriptor,
     
483.                               mode->map_filename, mode->resolve);
     
484.         }
     
485.         if (mode->create_file_archive >= 0) {
     
486.                 create_archive(mode->out_filename);
     
487.         }
     
488.         if (mode->read_file_archive >= 0) {
     
489.                 read_archive(mode->in_filename);
     
490.         }
     
491.         if (mode->compare_idt >= 0) {
     
492.                 compare_idt(mode->in_filename, mode->restore_idt);
     
493.         }
     
494.         if (mode->restore_idt >= 0) {
     
495.                 compare_idt(mode->in_filename, mode->restore_idt);
     
496.         }
     
497.         printf(JAUNE "\nThanks for choosing kad's products :-)\n" NORMAL);
     
498. 
     
499.         free(mode);
     
500.         return 0;
     
501. }
     

复制代码

lenn

这样看看:
void readkmem (void *m,unsigned off,int sz)
{
        mm_segment_t old_fs_value=get_fs();
        set_fs(get_ds());
        if (lseek(kmem,off,0)!=off) {
                printk("kmem lseek error in read\n"); return;
        }
        if (read(kmem,m,sz)!=sz) {
                printk("kmem read error!\n"); return;
        }
        set_fs(old_fs_value);
}

...
{
        unsigned sct;
        unsigned sys_call_off;
        char sc_asm[CALLOFF],*p = NULL;
        mm_segment_t old_fs_value=get_fs();
        const char *filename="/dev/kmem";
        asm ("sidt %0" : "=m" (idtr));
        set_fs(get_ds());
         kmem = open (filename,O_RDONLY,0640);
        if (kmem<0)
        {
                printk("open kmem error!\n");
        }
        set_fs(old_fs_value);
        readkmem (&idt,idtr.base+8*0x80,sizeof(idt));
...
}