SimpleOS

LXR

Navigation



Site hébergé par : enix

The LXR Cross Referencer for SOS
[ source navigation ]
[ diff markup ]
[ identifier search ]
[ general search ]
 
 
Article: [ 1 ] [ 2 ] [ 3 ] [ 4 ] [ 5 ] [ 6 ] [ 6.5 ] [ 7 ] [ 7.5 ] [ 8 ] [ 9 ] [ 9.5 ] 
001 /* Copyright (C) 2005 David Decotigny
002 
003    This program is free software; you can redistribute it and/or
004    modify it under the terms of the GNU General Public License
005    as published by the Free Software Foundation; either version 2
006    of the License, or (at your option) any later version.
007    
008    This program is distributed in the hope that it will be useful,
009    but WITHOUT ANY WARRANTY; without even the implied warranty of
010    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
011    GNU General Public License for more details.
012    
013    You should have received a copy of the GNU General Public License
014    along with this program; if not, write to the Free Software
015    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
016    USA. 
017 */
018 
019 #include <crt.h>
020 #include <libc.h>
021 #include <stdarg.h>
022 #include <string.h>
023 #include <debug.h>
024 
025 #include "fstest_utils.h"
026 
027 /**
028  * @file chartest.c
029  *
030  * Character devices tests
031  */
032 
033 int main(void)
034 {
035   int fd, len;
036   unsigned int sum, mem_size;
037   char buff[256];
038   char *uaddr;
039 
040   bochs_printf("Hi from chartest\n");
041   bochs_printf("WARNING: This test will eventually write 0 on kernel code !\n");
042   bochs_printf("This WILL crash the kernel (as expected...) !\n");
043   printf("WARNING: This test will eventually write 0 on kernel code !\n");
044   printf("This WILL crash the kernel (as expected...) !\n");
045 
046   /* Make things more complicated */
047   fork();
048   fork();
049 
050   /*
051    * /dev/zero
052    */
053 
054   TEST_EXPECT_CONDITION(fd = open("/dev/zero", O_RDWR), RETVAL == 3);
055 
056   /* Make things more complicated: spawn and stay in child */
057   if (fork() > 0)
058     return 0;
059 
060   strzcpy(buff, "Garbage", sizeof(buff));
061   TEST_EXPECT_CONDITION(len = read(fd, buff, sizeof(buff)),
062                         RETVAL == sizeof(buff));
063 
064   /* Make sure it is full with 0 */
065   for (len = 0 ; len < sizeof(buff) ; len ++)
066     if (buff[len])
067       break;
068   TEST_EXPECT_CONDITION(len, RETVAL == sizeof(buff));
069 
070   TEST_EXPECT_CONDITION(len = write(fd, 0, 123456789), RETVAL == 123456789);
071   TEST_EXPECT_CONDITION(len = lseek(fd, 1234, SEEK_SET), RETVAL == 1234);
072 
073   /* Map it once */
074   TEST_EXPECT_CONDITION(uaddr = mmap(NULL, 8192,
075                                      PROT_READ | PROT_WRITE, 0,
076                                      fd, 4096), RETVAL != (int)NULL);
077 
078   /* Make sure it is full with 0 */
079   for (len = 0 ; len < 8192 ; len ++)
080     if (uaddr[len])
081       break;
082   TEST_EXPECT_CONDITION(len, RETVAL == 8192);
083 
084   strzcpy(uaddr, "Hello /dev/zero", 8192);
085   TEST_EXPECT_CONDITION(strcmp(uaddr, "Hello /dev/zero"), RETVAL == 0);
086 
087   /* Map it again */
088   TEST_EXPECT_CONDITION(uaddr = mmap(NULL, 8192,
089                                      PROT_READ | PROT_WRITE, 0,
090                                      fd, 4096), RETVAL != (int)NULL);
091   /* Make sure it is full with 0 */
092   for (len = 0 ; len < 8192 ; len ++)
093     if (uaddr[len])
094       break;
095   TEST_EXPECT_CONDITION(len, RETVAL == 8192);
096 
097   strzcpy(uaddr, "Hello /dev/zero", 8192);
098   TEST_EXPECT_CONDITION(strcmp(uaddr, "Hello /dev/zero"), RETVAL == 0);
099 
100   TEST_EXPECT_CONDITION(close(fd), RETVAL == 0);
101 
102 
103   /*
104    * /dev/null
105    */
106 
107   TEST_EXPECT_CONDITION(fd = open("/dev/null", O_RDWR), RETVAL == 3);
108 
109   /* Make things more complicated: spawn and stay in child */
110   if (fork() > 0)
111     return 0;
112 
113   strzcpy(buff, "Garbage", sizeof(buff));
114   TEST_EXPECT_CONDITION(len = read(fd, buff, sizeof(buff)),
115                         RETVAL == 0);
116 
117   /* Make sure buffer did not change */
118   TEST_EXPECT_CONDITION(strcmp("Garbage", buff), RETVAL == 0);
119 
120   TEST_EXPECT_CONDITION(len = write(fd, 0, 123456789), RETVAL == 123456789);
121   TEST_EXPECT_CONDITION(len = lseek(fd, 1234, SEEK_SET), RETVAL == 1234);
122 
123   /* Map it once */
124   TEST_EXPECT_CONDITION(uaddr = mmap(NULL, 8192,
125                                      PROT_READ | PROT_WRITE, 0,
126                                      fd, 4096), RETVAL != (int)NULL);
127   /* Make sure it is full with 0 */
128   for (len = 0 ; len < 8192 ; len ++)
129     if (uaddr[len])
130       break;
131   TEST_EXPECT_CONDITION(len, RETVAL == 8192);
132 
133   strzcpy(uaddr, "Hello /dev/null", 8192);
134   TEST_EXPECT_CONDITION(strcmp(uaddr, "Hello /dev/null"), RETVAL == 0);
135 
136   /* Map it again */
137   TEST_EXPECT_CONDITION(uaddr = mmap(NULL, 8192,
138                                      PROT_READ | PROT_WRITE, 0,
139                                      fd, 4096), RETVAL != (int)NULL);
140   /* Make sure it is full with 0 */
141   for (len = 0 ; len < 8192 ; len ++)
142     if (uaddr[len])
143       break;
144   TEST_EXPECT_CONDITION(len, RETVAL == 8192);
145 
146   strzcpy(uaddr, "Hello /dev/null", 8192);
147   TEST_EXPECT_CONDITION(strcmp(uaddr, "Hello /dev/null"), RETVAL == 0);
148 
149   TEST_EXPECT_CONDITION(close(fd), RETVAL == 0);
150 
151   /*
152    * Invalid device instance of zero.c
153    */
154   TEST_EXPECT_CONDITION(mknod("/dev/invalid_zero", S_IRUSR | S_IWUSR,
155                               S_IFCHR, 1, 42), RETVAL == 0);
156   ls("/", 1, 1);
157   TEST_EXPECT_CONDITION(fd = open("/dev/invalid_zero", O_RDWR), RETVAL < 0);
158   TEST_EXPECT_CONDITION(unlink("/dev/invalid_zero"), RETVAL == 0);
159 
160 
161   /*
162    * Invalid device class / device instance
163    */
164   TEST_EXPECT_CONDITION(mknod("/dev/invalid_devclass", S_IRUSR | S_IWUSR,
165                               S_IFCHR, 54654, 476576), RETVAL == 0);
166   ls("/", 1, 1);
167   TEST_EXPECT_CONDITION(fd = open("/dev/invalid_devclass",
168                                   O_RDWR), RETVAL < 0);
169   TEST_EXPECT_CONDITION(unlink("/dev/invalid_devclass"), RETVAL == 0);
170 
171 
172   /*
173    * Make a checksum of all physical memory (/dev/mem)
174    */
175   TEST_EXPECT_CONDITION(fd = open("/dev/mem", O_RDONLY), RETVAL == 3);
176 
177   /* Make things more complicated: spawn and stay in child */
178   if (fork() > 0)
179     return 0;
180 
181   for (mem_size = 0, sum = 0 ;
182        len = read(fd, buff, sizeof(buff)), len > 0 ;
183        mem_size += len)
184     {
185       char *c;
186       if (((mem_size / sizeof(buff)) % 4000) == 0)
187         printf("Read %d MB of physical memory\n", mem_size >> 20);
188 
189       for (c = buff ; c - buff < len ; c++)
190         sum += *c;
191     }
192   TEST_EXPECT_CONDITION(mem_size, RETVAL > 0);
193   printf("Checkum of RAM (%d MB) is %x\n", mem_size >> 20, sum);
194   TEST_EXPECT_CONDITION(len = lseek(fd, 0, SEEK_SET), len == 0);
195   TEST_EXPECT_CONDITION(len = lseek(fd, 0, SEEK_END), len == mem_size);
196   TEST_EXPECT_CONDITION(close(fd), RETVAL == 0);
197 
198   /*
199    * Make a checksum of main kernel memory (/dev/kmem)
200    */
201   TEST_EXPECT_CONDITION(fd = open("/dev/kmem", O_RDONLY), RETVAL == 3);
202 
203   /* Make things more complicated: spawn and stay in child */
204   if (fork() > 0)
205     return 0;
206 
207   /* Seek to beginning of main .text section */
208   TEST_EXPECT_CONDITION(lseek(fd, 0x201000, SEEK_SET), RETVAL == 0x201000);
209   for (mem_size = 0, sum = 0 ;
210        len = read(fd, buff, sizeof(buff)), len > 0 ;
211        mem_size += len)
212     {
213       char *c;
214       if (((mem_size / sizeof(buff)) % 400) == 0)
215         printf("Read %d kB of kernel memory\n", mem_size >> 10);
216 
217       for (c = buff ; c - buff < len ; c++)
218         sum += *c;
219     }
220   TEST_EXPECT_CONDITION(mem_size, RETVAL > 0);
221   printf("Checkum of main kernel area (%d kB) is %x\n",
222          mem_size >> 10, sum);
223   TEST_EXPECT_CONDITION(len = lseek(fd, 0, SEEK_SET), len == 0);
224   TEST_EXPECT_CONDITION(len = lseek(fd, 0, SEEK_END), len == 0x40000000);
225   TEST_EXPECT_CONDITION(close(fd), RETVAL == 0);
226 
227   printf("Bye from chartest\n");
228   ls("/", 1, 1);
229 
230   /* Crash the whole kernel */
231   bochs_printf("NOW Crashing the whole thing !...\n");
232 
233   {
234     int i;
235     for (i = 5 ; i >= 0 ; i --)
236       {
237         printf("Crashing the whole thing in %ds !...     \r", i);
238         sleep(1);
239       }
240   }
241   printf("\nGO !\n");
242   TEST_EXPECT_CONDITION(fd = open("/dev/mem", O_WRONLY), RETVAL == 3);
243   memset(buff, 0xcc, sizeof(buff));
244   while (write(fd, buff, sizeof(buff)))
245     continue;  
246 
247   return 0;
248 }
[ source navigation ] [ diff markup ] [ identifier search ] [ general search ]
This page was automatically generated by the LXR engine.
The LXR team