int main(int argc, char **argv)
{
GlobalInfo g;
CURLMcode rc;
(void)argc;
(void)argv;
memset(&g, 0, sizeof(GlobalInfo));
g.loop = ev_default_loop(0);
init_fifo(&g);
g.multi = curl_multi_init();
ev_timer_init(&g.timer_event, timer_cb, 0., 0.);
g.timer_event.data = &g;
g.fifo_event.data = &g;
curl_multi_setopt(g.multi, CURLMOPT_SOCKETFUNCTION, sock_cb);
curl_multi_setopt(g.multi, CURLMOPT_SOCKETDATA, &g);
curl_multi_setopt(g.multi, CURLMOPT_TIMERFUNCTION, multi_timer_cb);
curl_multi_setopt(g.multi, CURLMOPT_TIMERDATA, &g);
/* we don't call any curl_multi_socket*() function yet as we have no handles
added! */
ev_loop(g.loop, 0);
curl_multi_cleanup(g.multi);
return 0;
}
int main(int argc, char **argv)
{
GlobalInfo g;
CURLMcode rc;
(void)argc;
(void)argv;
memset(&g, 0, sizeof(GlobalInfo));
g.loop = ev_default_loop(0);
init_fifo(&g);
g.multi = curl_multi_init();
ev_timer_init(&g.timer_event, timer_cb, 0., 0.);
g.timer_event.data = &g;
g.fifo_event.data = &g;
curl_multi_setopt(g.multi, CURLMOPT_SOCKETFUNCTION, sock_cb);
curl_multi_setopt(g.multi, CURLMOPT_SOCKETDATA, &g);
curl_multi_setopt(g.multi, CURLMOPT_TIMERFUNCTION, multi_timer_cb);
curl_multi_setopt(g.multi, CURLMOPT_TIMERDATA, &g);
do
{
rc = curl_multi_socket_all(g.multi, &g.still_running);
} while ( CURLM_CALL_MULTI_PERFORM == rc );
ev_loop(g.loop, 0);
curl_multi_cleanup(g.multi);
return 0;
}
int main(int argc, char **argv)
{
GlobalInfo *g;
CURLMcode rc;
GMainLoop*gmain;
int fd;
GIOChannel* ch;
g=g_malloc0(sizeof(GlobalInfo));
fd=init_fifo();
ch=g_io_channel_unix_new(fd);
g_io_add_watch(ch,G_IO_IN,fifo_cb,g);
gmain=g_main_loop_new(NULL,FALSE);
g->multi = curl_multi_init();
curl_multi_setopt(g->multi, CURLMOPT_SOCKETFUNCTION, sock_cb);
curl_multi_setopt(g->multi, CURLMOPT_SOCKETDATA, g);
curl_multi_setopt(g->multi, CURLMOPT_TIMERFUNCTION, update_timeout_cb);
curl_multi_setopt(g->multi, CURLMOPT_TIMERDATA, g);
/* we don't call any curl_multi_socket*() function yet as we have no handles
added! */
g_main_loop_run(gmain);
curl_multi_cleanup(g->multi);
return 0;
}
void task_b_main(LAYER *layer)
{
FIFO fifo;
TIMER *timer_1s;
int i, fifobuf[128], count = 0, count0 = 0;
char s[12];
init_fifo(&fifo, 128, fifobuf, 0);
timer_1s = timer_alloc();
timer_init(timer_1s, &fifo, 100);
timer_set(timer_1s, 100);
for (;;) {
count++;
io_cli();
if (fifo_status(&fifo) == 0)
{
io_sti();
}
else
{
i = fifo_get(&fifo);
io_sti();
if (i == 100)
{
sprintf(s, "%11d", count - count0);
displayStrings_atLayer(layer, 24, 28, COL8_000000, COL8_C6C6C6, s);
count0 = count;
timer_set(timer_1s, 100);
}
}
}
}
void task_b_main(LAYER *layer_bg)
{
FIFO fifo;
TIMER *timer_display;
int i, fifobuf[128], count = 0;
char strings[20];
init_fifo(&fifo, 128, fifobuf);
timer_display = timer_alloc();
timer_init(timer_display, &fifo, 1);
timer_set(timer_display, 1);
for(;;)
{
count++;
io_cli();
if(0 == fifo_status(&fifo))
{
io_sti();
}
else
{
i = fifo_get(&fifo);
io_sti();
if(1 == i)
{
sprintf(strings, "%11d", count);
displayStrings_atLayer(layer_bg, 0, 144, COL8_FFFFFF, COL8_008484, strings);
timer_set(timer_display, 1);
}
}
}
}
int main(int argc, char **argv)
{
GlobalInfo g;
(void)argc;
(void)argv;
memset(&g, 0, sizeof(GlobalInfo));
event_init();
init_fifo(&g);
g.multi = curl_multi_init();
evtimer_set(&g.timer_event, timer_cb, &g);
/* setup the generic multi interface options we want */
curl_multi_setopt(g.multi, CURLMOPT_SOCKETFUNCTION, sock_cb);
curl_multi_setopt(g.multi, CURLMOPT_SOCKETDATA, &g);
curl_multi_setopt(g.multi, CURLMOPT_TIMERFUNCTION, multi_timer_cb);
curl_multi_setopt(g.multi, CURLMOPT_TIMERDATA, &g);
/* we don't call any curl_multi_socket*() function yet as we have no handles
added! */
event_dispatch();
curl_multi_cleanup(g.multi);
return 0;
}
int main(int argc, char **argv)
{
GlobalInfo g;
(void)argc;
(void)argv;
memset(&g, 0, sizeof(GlobalInfo));
g.evbase = event_base_new();
init_fifo(&g);
g.multi = curl_multi_init();
g.timer_event = evtimer_new(g.evbase, timer_cb, &g);
/* setup the generic multi interface options we want */
curl_multi_setopt(g.multi, CURLMOPT_SOCKETFUNCTION, sock_cb);
curl_multi_setopt(g.multi, CURLMOPT_SOCKETDATA, &g);
curl_multi_setopt(g.multi, CURLMOPT_TIMERFUNCTION, multi_timer_cb);
curl_multi_setopt(g.multi, CURLMOPT_TIMERDATA, &g);
/* we don't call any curl_multi_socket*() function yet as we have no handles
added! */
event_base_dispatch(g.evbase);
/* this, of course, won't get called since only way to stop this program is
via ctrl-C, but it is here to show how cleanup /would/ be done. */
clean_fifo(&g);
event_free(g.timer_event);
event_base_free(g.evbase);
curl_multi_cleanup(g.multi);
return 0;
}
int main(int argc, char **argv)
{
GlobalInfo *g;
CURLMcode rc;
GMainLoop*gmain;
int fd;
GIOChannel* ch;
g=g_malloc0(sizeof(GlobalInfo));
fd=init_fifo();
ch=g_io_channel_unix_new(fd);
g_io_add_watch(ch,G_IO_IN,fifo_cb,g);
gmain=g_main_loop_new(NULL,FALSE);
g->multi = curl_multi_init();
curl_multi_setopt(g->multi, CURLMOPT_SOCKETFUNCTION, sock_cb);
curl_multi_setopt(g->multi, CURLMOPT_SOCKETDATA, g);
curl_multi_setopt(g->multi, CURLMOPT_TIMERFUNCTION, update_timeout_cb);
curl_multi_setopt(g->multi, CURLMOPT_TIMERDATA, g);
do {
rc = curl_multi_socket_all(g->multi, &g->still_running);
} while (CURLM_CALL_MULTI_PERFORM == rc);
g_main_loop_run(gmain);
curl_multi_cleanup(g->multi);
return 0;
}
int elksfs_mknod(register struct inode *dir, char *name, size_t len,
int mode, int rdev)
{
struct buffer_head *bh;
register struct inode *inode;
struct elksfs_dir_entry *de;
int error;
if (!dir)
return -ENOENT;
bh = elksfs_find_entry(dir, name, len, &de);
if (bh) {
brelse(bh);
iput(dir);
return -EEXIST;
}
inode = elksfs_new_inode(dir);
if (!inode) {
iput(dir);
return -ENOSPC;
}
inode->i_uid = current->euid;
inode->i_mode = (__u16) mode;
inode->i_op = NULL;
if (S_ISREG(inode->i_mode))
inode->i_op = &elksfs_file_inode_operations;
else if (S_ISDIR(inode->i_mode)) {
inode->i_op = &elksfs_dir_inode_operations;
if (dir->i_mode & S_ISGID)
inode->i_mode |= S_ISGID;
} else if (S_ISLNK(inode->i_mode))
inode->i_op = &elksfs_symlink_inode_operations;
else if (S_ISCHR(inode->i_mode))
inode->i_op = &chrdev_inode_operations;
else if (S_ISBLK(inode->i_mode))
inode->i_op = &blkdev_inode_operations;
#ifdef NOT_YET
else if (S_ISFIFO(inode->i_mode))
init_fifo(inode);
#endif
if (S_ISBLK(mode) || S_ISCHR(mode))
inode->i_rdev = to_kdev_t(rdev);
inode->i_dirt = 1;
error = elksfs_add_entry(dir, name, len, &bh, &de);
if (error) {
inode->i_nlink--;
inode->i_dirt = 1;
iput(inode);
iput(dir);
return error;
}
de->inode = inode->i_ino;
mark_buffer_dirty(bh, 1);
brelse(bh);
iput(dir);
iput(inode);
return 0;
}
//打开新的console的函数
LAYER *open_console(LAYER_MANAGE *layer_manage, unsigned int memory_total)
{
MEMMANAGE *memmanage = (MEMMANAGE *)MEMMANAGE_ADDR;
LAYER *layer_console = layer_alloc(layer_manage);
unsigned char *buf_console = (unsigned char *)memmanage_alloc_4K(memmanage, 256 * 165);
TASK *task_console = task_alloc();
int *console_fifo = (int *)memmanage_alloc_4K(memmanage, 128 * 4);
layer_set(layer_console, buf_console, 256, 165, -1);
create_window(buf_console, 256, 165, "console", INACTIVE);
create_textbox(layer_console, 8, 28, 240, 128, COL8_000000);
task_console->console_stack = memmanage_alloc_4K(memmanage, 64 * 1024) + 64 * 1024 - 12; //由于这里要传入两个参数，所以减去了12
task_console->tss.esp = task_console->console_stack;
task_console->tss.eip = (int) &console_task; //eip指向的是运行console的函数首地址
task_console->tss.es = 1 * 8;
task_console->tss.cs = 2 * 8;
task_console->tss.ss = 1 * 8;
task_console->tss.ds = 1 * 8;
task_console->tss.fs = 1 * 8;
task_console->tss.gs = 1 * 8;
*((int *) (task_console->tss.esp + 4)) = (int) layer_console;
*((int *) (task_console->tss.esp + 8)) = memory_total;
task_run(task_console, 2, 2); /* level=2, priority=2 */
layer_console->task = task_console;
layer_console->flags |= 0x20; //flags的0x20代表当前窗口的光标ON
init_fifo(&task_console->fifo, 128, console_fifo, task_console);
return layer_console;
}
/* cnode.c */
static void coda_fill_inode(struct inode *inode, struct coda_vattr *attr)
{
CDEBUG(D_SUPER, "ino: %ld\n", inode->i_ino);
if (coda_debug & D_SUPER )
print_vattr(attr);
coda_vattr_to_iattr(inode, attr);
if (S_ISREG(inode->i_mode))
inode->i_op = &coda_file_inode_operations;
else if (S_ISDIR(inode->i_mode))
inode->i_op = &coda_dir_inode_operations;
else if (S_ISLNK(inode->i_mode))
inode->i_op = &coda_symlink_inode_operations;
else if (S_ISCHR(inode->i_mode)) {
inode->i_op = &chrdev_inode_operations;
inode->i_rdev = to_kdev_t(attr->va_rdev);
} else if (S_ISBLK(inode->i_mode)) {
inode->i_op = &blkdev_inode_operations;
inode->i_rdev = to_kdev_t(attr->va_rdev);
} else if (S_ISFIFO(inode->i_mode))
init_fifo(inode);
else if (S_ISSOCK(inode->i_mode))
inode->i_op = NULL;
else {
printk ("coda_fill_inode: what's this? i_mode = %o\n",
inode->i_mode);
inode->i_op = NULL;
}
}
/*
* Fill in inode information from the fattr.
*/
static void
nfs_fill_inode(struct inode *inode, struct nfs_fattr *fattr)
{
/*
* Check whether the mode has been set, as we only want to
* do this once. (We don't allow inodes to change types.)
*/
if (inode->i_mode == 0) {
inode->i_mode = fattr->mode;
if (S_ISREG(inode->i_mode))
inode->i_op = &nfs_file_inode_operations;
else if (S_ISDIR(inode->i_mode))
inode->i_op = &nfs_dir_inode_operations;
else if (S_ISLNK(inode->i_mode))
inode->i_op = &nfs_symlink_inode_operations;
else if (S_ISCHR(inode->i_mode)) {
inode->i_op = &chrdev_inode_operations;
inode->i_rdev = to_kdev_t(fattr->rdev);
} else if (S_ISBLK(inode->i_mode)) {
inode->i_op = &blkdev_inode_operations;
inode->i_rdev = to_kdev_t(fattr->rdev);
} else if (S_ISFIFO(inode->i_mode))
init_fifo(inode);
else
inode->i_op = NULL;
/*
* Preset the size and mtime, as there's no need
* to invalidate the caches.
*/
inode->i_size = fattr->size;
inode->i_mtime = fattr->mtime.seconds;
NFS_OLDMTIME(inode) = fattr->mtime.seconds;
}
nfs_refresh_inode(inode, fattr);
}
void nfs_refresh_inode(struct inode *inode, struct nfs_fattr *fattr)
{
int was_empty;
if (!inode || !fattr) {
printk("nfs_refresh_inode: inode or fattr is NULL\n");
return;
}
if (inode->i_ino != fattr->fileid) {
printk("nfs_refresh_inode: inode number mismatch\n");
return;
}
was_empty = (inode->i_mode == 0);
/*
* Some (broken?) NFS servers return 0 as the file type.
* We'll assume that 0 means the file type has not changed.
*/
if(!(fattr->mode & S_IFMT)){
inode->i_mode = (inode->i_mode & S_IFMT) |
(fattr->mode & ~S_IFMT);
}else{
inode->i_mode = fattr->mode;
}
inode->i_nlink = fattr->nlink;
inode->i_uid = fattr->uid;
inode->i_gid = fattr->gid;
/* Size changed from outside: invalidate caches on next read */
if (inode->i_size != fattr->size)
NFS_CACHEINV(inode);
if (NFS_OLDMTIME(inode) != fattr->mtime.seconds)
NFS_ATTRTIMEO(inode) = NFS_MINATTRTIMEO(inode);
inode->i_size = fattr->size;
if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
inode->i_rdev = to_kdev_t(fattr->rdev);
else
inode->i_rdev = 0;
inode->i_blocks = fattr->blocks;
inode->i_atime = fattr->atime.seconds;
inode->i_mtime = fattr->mtime.seconds;
inode->i_ctime = fattr->ctime.seconds;
if (S_ISREG(inode->i_mode))
inode->i_op = &nfs_file_inode_operations;
else if (S_ISDIR(inode->i_mode))
inode->i_op = &nfs_dir_inode_operations;
else if (S_ISLNK(inode->i_mode))
inode->i_op = &nfs_symlink_inode_operations;
else if (S_ISCHR(inode->i_mode))
inode->i_op = &chrdev_inode_operations;
else if (S_ISBLK(inode->i_mode))
inode->i_op = &blkdev_inode_operations;
else if (S_ISFIFO(inode->i_mode)) {
if (was_empty)
init_fifo(inode);
} else
inode->i_op = NULL;
nfs_lookup_cache_refresh(inode, fattr);
}
/*}}}*/
void A1_p() {/*{{{*/
// Procesy A1 generują kolejne liczby parzyste, jeżeli produkowana liczba
// będzie mniejsza niż największa liczba z obu buforów, i wstawiają
// wygenerowaną liczbę do tego bufora, w którym jest mniej liczb.
shm_at();
int number = 2;
while(1) {
// printf("While iteration\\n");
P(mutex);
int max1 = max(FIFO_1);
int max2 = max(FIFO_2);
int max = max1 > max2 ? max1 : max2;
V(mutex);
if ( number < max ) {
P(mutex);
if ( count(FIFO_1) < count(FIFO_2) )
put(FIFO_1, number);
else
put(FIFO_2, number);
V(mutex);
number += 2;
} else {
P(a1);
}
sleep(1);
}
}/*}}}*/
void A2_p() {/*{{{*/
// Procesy A2 generują do bufora 1 kolejne liczby nieparzyste jeżeli w
// buforze 1 jest mniej niż 30 liczb
shm_at();
int number = 1;
while(1) {
printf("A2 loop\n");
if ( *count(FIFO_1) < 30 ) {
P(mutex);
put(FIFO_1, number);
V(mutex);
number += 2;
} else {
P(a2);
}
sleep(1);
}
}/*}}}*/
void A3_p() {/*{{{*/
// Procesy A3 generują do bufora 2 kolejne liczby nieparzyste jeżeli w
// buforze 2 jest mniej niż 20 liczb
shm_at();
int number = 1;
while(1) {
// printf("A3 loop\\n");
if ( *count(FIFO_2) < 20 ) {
P(mutex);
put(FIFO_2, number);
V(mutex);
number += 2;
} else {
P(a3);
}
sleep(1);
}
}/*}}}*/
void B1_p() {/*{{{*/
// Procesy B1 zjadają liczby parzyste (z dowolnego bufora), pod warunkiem
// że dany bufor zawiera co najmniej 6 liczb.
shm_at();
while(1) {
// printf("B1 loop\\n");
if ( (*count(FIFO_1) >= 6) && (top(FIFO_1) % 2 == 0) ) {
P(mutex);
get(FIFO_1);
V(mutex);
} else
P(b1_1);
if ( (*count(FIFO_2) >= 6) && (top(FIFO_2) % 2 == 0) ) {
P(mutex);
get(FIFO_2);
V(mutex);
} else
P(b1_2);
sleep(1);
}
}/*}}}*/
void B2_p() {/*{{{*/
// Procesy B2 zjadają liczby nieparzyste (z dowolnego bufora), pod
// warunkiem że dany bufor zawiera co najmniej 7 liczb.
shm_at();
while(1) {
// printf("B2\\n");
if ( (*count(FIFO_1) >= 7) && (top(FIFO_1) % 2 != 0) ) {
P(mutex);
get(FIFO_1);
V(mutex);
} else
P(b2_1);
if ( (*count(FIFO_2) >= 7) && (top(FIFO_2) % 2 != 0) ) {
P(mutex);
get(FIFO_2);
V(mutex);
} else
P(b2_2);
sleep(1);
}
}/*}}}*/
void generate() {/*{{{*/
shm_at();
int number = 1;
while(1) {
P(mutex);
put(FIFO_1, number);
number += 1;
V(mutex);
sleep(1);
}
}/*}}}*/
void consume() {/*{{{*/
shm_at();
int number = 1;
while(1) {
P(mutex);
get(FIFO_1);
V(mutex);
sleep(1);
}
}/*}}}*/
void parent() {/*{{{*/
while (1) {
print_fifo(FIFO_1);
printf("\n");
print_fifo(FIFO_2);
printf("\n");
printf("-------------------------------\n");
printf("\n");
sleep(1);
}
}/*}}}*/
void decrease_remaining() {/*{{{*/
if ( remaining_A1 > 0 )
remaining_A1--;
else if ( remaining_A2 > 0 )
remaining_A2--;
else if ( remaining_A3 > 0 )
remaining_A3--;
else if ( remaining_B1 > 0 )
remaining_B1--;
else if ( remaining_B2 > 0 )
remaining_B2--;
}/*}}}*/
void set_gid() {/*{{{*/
if ( remaining_A1 > 0 ) {
setgid(A1);
--remaining_A1;
} else if ( remaining_A2 > 0 ) {
setgid(A2);
--remaining_A2;
} else if ( remaining_A3 > 0 ) {
setgid(A3);
--remaining_A3;
} else if ( remaining_B1 > 0 ) {
setgid(B1);
--remaining_B1;
} else if ( remaining_B2 > 0 ) {
setgid(B2);
--remaining_B2;
}
}/*}}}*/
int main(int argc, char** argv) {/*{{{*/
pid_t pid;
int i;
// Attach shm segment to process
shm_at();
// Init fifos
init_fifo();
i = 0;
for ( int i = 0; i < PCOUNT; ++i ) {
pid = fork();
if ( pid == 0 ) {
// Child
set_gid();
// printf("Child process gid: %d\\n", getgid());
int gid = getgid();
switch (gid) {
case A1:
A1_p();
break;
case A2:
A2_p();
// generate();
break;
case A3:
A3_p();
// consume();
break;
case B1:
B1_p();
break;
case B2:
B2_p();
break;
}
break;
} else {
// Used for proper group id assignment
decrease_remaining();
}
}
if ( pid != 0 )
parent();
/*
if ( (pid = fork()) == 0 ) {
// Child
setgid(A1);
printf("Child process group: %d\n", getgid());
} else {
printf("Parent process group: %d\n", getgid());
wait();
}
*/
}/*}}}*/
extern void test_cubefifo_init_fifo(void)
{
fifo_t *fifo;
fifo = init_fifo(5, 0);
CU_ASSERT(fifo != NULL);
fifo_destroy(fifo);
}
extern void test_cubefifo_empty_fifo(void)
{
fifo_t *fifo;
fifo = init_fifo(5, 0);
CU_ASSERT(empty_fifo(fifo) == 0);
fifo_destroy(fifo);
}
static int fifo_open(struct inode *inode, struct file *file)
{
char is_cons = file->f_mode & FMODE_READ;
char used = false;
struct fifo_t *f = vmalloc(sizeof(struct fifo_t));
if(f == NULL)
return -ENOMEM;
if(init_fifo(f) != 0){
vfree(f);
return -ENOMEM;
}
// Ya tenemos un nuevo fifo creado.
if(down_interruptible(&mutex_fifos))
return -EINTR;
if(inode->i_private == NULL){
inode->i_private = f;
used = true;
}
up(&mutex_fifos);
if(!used){ // Si no hemos usado el nuevo fivo (el inodo ya tenia fifo asociado)
vfree(f);
f = NULL;
}
f = (struct fifo_t*) inode->i_private;
DBGV("Pipe abierto para %s con lecotres %d, escriores %d",
(file->f_mode & FMODE_READ)? "lectura": "escritura",
f->num_cons,
f->num_prod);
// INICIO SECCIÓN CRÍTICA >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
if (down_interruptible(&f->mutex))
return -EINTR;
if (is_cons){
// Eres consumidor
f->num_cons++;
while(f->num_bloq_prod){
f->num_bloq_prod--;
up(&f->cola_prod);
}
while(!f->num_prod)
cond_wait(&f->mutex, &f->cola_cons, f->num_bloq_cons,
__InterruptHandler__ {
down(&f->mutex);
f->num_cons--;
up(&f->mutex);
}
);
}else{
int prtsrtpath(struct graph *g, int src, int dest)
{
struct enode *e;
struct vnode *v;
int i, ndx, level, curv;
int *pred;
if( (f = init_fifo(g->sz)) == NULL)
{
perror("prtsrtpath: fifo Malloc error");
return(-1);
}
if( (pred = malloc(g->sz*sizeof(int))) == NULL)
{
perror("prtsrtpath: pred value Malloc error");
return(-1);
}
//Set all preds to -1
for( i = 0; i < g->sz; i++)
pred[i] = -1;
//Set all visited to 0
for( i = 0; i < g->sz; i++)
g->vn[i].visited = 0;
curv = src;
g->vn[curv].visited = 1;
level = 1;
insert_fifo(curv, &f);
while(f->sz > 0)
{
extract_fifo(&ndx, f);
v = &(g->vn[ndx]);
level = v->visited + 1;
e = v->edge;
while( e != NULL)
{
if( !g->vn[e->vndx].visited)
{
g->vn[e->vndx].visited = level;
pred[e->vndx] = ndx;
insert_fifo(e->vndx, &f);
}
e = e->next;
}
}
free(f);
prtpred(src, dest, pred);
free(pred);
return(0);
}
int xiafs_mknod(struct inode *dir, const char *name, int len, int mode, int rdev)
{
struct inode * inode;
struct buffer_head * bh;
struct xiafs_direct * de;
if (!dir)
return -ENOENT;
bh = xiafs_find_entry(dir,name,len,&de, NULL);
if (bh) {
brelse(bh);
iput(dir);
return -EEXIST;
}
inode = xiafs_new_inode(dir);
if (!inode) {
iput(dir);
return -ENOSPC;
}
inode->i_uid = current->fsuid;
inode->i_mode = mode;
inode->i_op = NULL;
if (S_ISREG(inode->i_mode))
inode->i_op = &xiafs_file_inode_operations;
else if (S_ISDIR(inode->i_mode)) {
inode->i_op = &xiafs_dir_inode_operations;
if (dir->i_mode & S_ISGID)
inode->i_mode |= S_ISGID;
}
else if (S_ISLNK(inode->i_mode))
inode->i_op = &xiafs_symlink_inode_operations;
else if (S_ISCHR(inode->i_mode))
inode->i_op = &chrdev_inode_operations;
else if (S_ISBLK(inode->i_mode))
inode->i_op = &blkdev_inode_operations;
else if (S_ISFIFO(inode->i_mode))
init_fifo(inode);
if (S_ISBLK(mode) || S_ISCHR(mode))
inode->i_rdev = to_kdev_t(rdev);
inode->i_atime = inode->i_ctime = inode->i_atime = CURRENT_TIME;
inode->i_dirt = 1;
bh = xiafs_add_entry(dir, name, len, &de, NULL);
if (!bh) {
inode->i_nlink--;
inode->i_dirt = 1;
iput(inode);
iput(dir);
return -ENOSPC;
}
de->d_ino = inode->i_ino;
mark_buffer_dirty(bh, 1);
brelse(bh);
iput(dir);
iput(inode);
return 0;
}
int main() {
//signal(SIGCLD, SIG_IGN);
atomic_set(&ActiveConnectionAtomic, 0);
init_fifo();
fork_process(ForkNum);
net_process();
return 1;
}
int bftraversal(struct graph *g)
{
int i;
struct enode *e;
struct vnode *v;
int ndx;
int level;
if( (f = init_fifo(g->sz)) == NULL)
{
perror("bfttraversal: fifo Malloc error");
return(-1);
}
//Reset all visited fields to 0
for( i = 0; i < g->sz; i++)
g->vn[i].visited = 0;
i = 0;
printf("\n");
while(i != -1)
{
g->vn[i].visited = 1;
level = 1;
insert_fifo(i,&f);
while(f->sz > 0)
{
extract_fifo(&ndx,f);
v = &(g->vn[ndx]);
printf("%d(%d) ", v->item, v->visited);
level = v->visited + 1;
e = v->edge;
while( e != NULL)
{
if( !g->vn[e->vndx].visited)
{
g->vn[e->vndx].visited = level;
insert_fifo(e->vndx,&f);
}
e = e->next;
}
}
i = unvisited(g);
printf("\n");
}
free(f);
return(0);
}
void minix_read_inode(struct inode * inode)
{
struct buffer_head * bh;
struct minix_inode * raw_inode;
int block, ino;
ino = inode->i_ino;
inode->i_op = NULL;
inode->i_mode = 0;
if (!ino || ino >= inode->i_sb->u.minix_sb.s_ninodes) {
printk("Bad inode number on dev 0x%04x: %d is out of range\n",
inode->i_dev, ino);
return;
}
block = 2 + inode->i_sb->u.minix_sb.s_imap_blocks +
inode->i_sb->u.minix_sb.s_zmap_blocks +
(ino-1)/MINIX_INODES_PER_BLOCK;
if (!(bh=bread(inode->i_dev,block, BLOCK_SIZE))) {
printk("Major problem: unable to read inode from dev 0x%04x\n",
inode->i_dev);
return;
}
raw_inode = ((struct minix_inode *) bh->b_data) +
(ino-1)%MINIX_INODES_PER_BLOCK;
inode->i_mode = raw_inode->i_mode;
inode->i_uid = raw_inode->i_uid;
inode->i_gid = raw_inode->i_gid;
inode->i_nlink = raw_inode->i_nlinks;
inode->i_size = raw_inode->i_size;
inode->i_mtime = inode->i_atime = inode->i_ctime = raw_inode->i_time;
inode->i_blocks = inode->i_blksize = 0;
if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
inode->i_rdev = raw_inode->i_zone[0];
else for (block = 0; block < 9; block++)
inode->u.minix_i.i_data[block] = raw_inode->i_zone[block];
brelse(bh);
if (S_ISREG(inode->i_mode))
inode->i_op = &minix_file_inode_operations;
else if (S_ISDIR(inode->i_mode))
inode->i_op = &minix_dir_inode_operations;
else if (S_ISLNK(inode->i_mode))
inode->i_op = &minix_symlink_inode_operations;
else if (S_ISCHR(inode->i_mode))
inode->i_op = &chrdev_inode_operations;
else if (S_ISBLK(inode->i_mode))
inode->i_op = &blkdev_inode_operations;
else if (S_ISFIFO(inode->i_mode))
init_fifo(inode);
}
static int
updtLockphase( ushort apval )
{
int fifoIsEmpty, fifoIsRunning;
int tmp1,tmp2;
fifoIsEmpty = ( ( fifoEmpty( pTheFifoObject ) == 1 ) &&
( fifoBufWkEntries(pTheFifoObject->pFifoWordBufs) == 0L ) );
fifoIsRunning = fifoRunning( pTheFifoObject );
if (fifoIsEmpty && fifoIsRunning) {
errLogRet( LOGIT, debugInfo, "FIFO empty but running in update APBUS\n" );
return( -1 );
}
if (fifoIsEmpty)
init_fifo( NULL, 0, 0 );
fifoStuffCmd(pTheFifoObject,CL_AP_BUS_SLCT, 0x0A30); /* lk xmtr */
fifoStuffCmd(pTheFifoObject,CL_AP_BUS_WRT, 0x0A17); /* PIRB2 24-31*/
tmp1 = (int)(- (currentStatBlock.stb.AcqLockPhase * 32.0 / 45.0))&0xFF;
fifoStuffCmd(pTheFifoObject,CL_AP_BUS_INCWR,0x0A00|tmp1);/* zeroing */
fifoStuffCmd(pTheFifoObject,CL_AP_BUS_SLCT, 0x0A30); /* lk xmtr */
fifoStuffCmd(pTheFifoObject,CL_AP_BUS_WRT, 0x0A18); /* SMC2 */
fifoStuffCmd(pTheFifoObject,CL_AP_BUS_INCWR,0x0A08);
fifoStuffCmd(pTheFifoObject,CL_AP_BUS_SLCT, 0x0A30); /* lk xmtr */
fifoStuffCmd(pTheFifoObject,CL_AP_BUS_WRT, 0x0A1E); /* HOP CLK2 */
fifoStuffCmd(pTheFifoObject,CL_AP_BUS_INCWR,0x0A00); /* strobe*/
fifoStuffCmd(pTheFifoObject,CL_AP_BUS_SLCT, 0x0A30); /* lk xmtr */
fifoStuffCmd(pTheFifoObject,CL_AP_BUS_WRT, 0x0A17); /* PIRB2 24-31*/
tmp2 = (int)(apval * 32.0 / 45.0)&0xFF;
fifoStuffCmd(pTheFifoObject,CL_AP_BUS_INCWR,0x0A00|tmp2);
fifoStuffCmd(pTheFifoObject,CL_AP_BUS_SLCT, 0x0A30); /* lk xmtr */
fifoStuffCmd(pTheFifoObject,CL_AP_BUS_WRT, 0x0A1E); /* HOP CLK2*/
fifoStuffCmd(pTheFifoObject,CL_AP_BUS_INCWR,0x0A00); /* strobe */
if (fifoIsEmpty)
{ fifoStuffCmd(pTheFifoObject,HALTOP,0);
fifoStart( pTheFifoObject );
fifoWait4Stop( pTheFifoObject );
}
DPRINT3( DEBUG_APBUS, "updtLockphase: fifo empty: %d, value: %d [0x%x]\n",
fifoIsEmpty, apval, apval );
currentStatBlock.stb.AcqLockPhase = apval;
return( 0 );
}
int sysv_mknod(struct inode * dir, struct dentry * dentry, int mode, int rdev)
{
int error;
struct inode * inode;
struct buffer_head * bh;
struct sysv_dir_entry * de;
if (!dir)
return -ENOENT;
bh = sysv_find_entry(dir, dentry->d_name.name,
dentry->d_name.len, &de);
if (bh) {
brelse(bh);
return -EEXIST;
}
inode = sysv_new_inode(dir);
if (!inode)
return -ENOSPC;
inode->i_uid = current->fsuid;
inode->i_mode = mode;
inode->i_op = NULL;
if (S_ISREG(inode->i_mode))
inode->i_op = &sysv_file_inode_operations;
else if (S_ISCHR(inode->i_mode))
inode->i_op = &chrdev_inode_operations;
else if (S_ISBLK(inode->i_mode))
inode->i_op = &blkdev_inode_operations;
else if (S_ISFIFO(inode->i_mode))
init_fifo(inode);
if (S_ISBLK(mode) || S_ISCHR(mode))
inode->i_rdev = to_kdev_t(rdev);
mark_inode_dirty(inode);
error = sysv_add_entry(dir, dentry->d_name.name,
dentry->d_name.len, &bh, &de);
if (error) {
inode->i_nlink--;
mark_inode_dirty(inode);
iput(inode);
return error;
}
de->inode = inode->i_ino;
mark_buffer_dirty(bh, 1);
brelse(bh);
d_instantiate(dentry, inode);
return 0;
}
int main(int argc, char *argv[])
{
dispatch_t *dpp;
resmgr_attr_t resmgr_attr;
dispatch_context_t *ctp;
resmgr_connect_funcs_t connect_funcs;
resmgr_io_funcs_t io_funcs;
iofunc_attr_t io_attr;
printf("Start resource manager\n");
fifoHandler = init_fifo();
pthread_mutex_init(&resource_mutex, NULL);
// create dispatch.
if (!(dpp = dispatch_create()))
error("dispatch_create()");
// initialize resource manager attributes.
memset(&resmgr_attr, 0, sizeof(resmgr_attr));
resmgr_attr.nparts_max = 1;
resmgr_attr.msg_max_size = 2048;
// set standard connect and io functions.
iofunc_func_init(_RESMGR_CONNECT_NFUNCS, &connect_funcs,
_RESMGR_IO_NFUNCS, &io_funcs);
iofunc_attr_init(&io_attr, S_IFNAM | 0666, 0, 0);
io_funcs.read = io_read;
io_funcs.write = io_write;
// establish resource manager
if (resmgr_attach(dpp, &resmgr_attr, "/dev/myresource", _FTYPE_ANY, 0, &connect_funcs, &io_funcs, &io_attr) < 0)
error("resmgr_attach()");
// wait forever, handling messages.
ctp = dispatch_context_alloc(dpp);
while(1)
{
if (!(ctp = dispatch_block(ctp)))
error("dispatch_block()");
dispatch_handler(ctp);
}
exit(EXIT_SUCCESS);
}
int main(void) {
fifo_t F;
init_fifo(&F, 3, true);
put_fifo(&F, "Hello");
put_fifo(&F, "cruel");
put_fifo(&F, "world!!!!");
printf("The capacity is: %d\n",F.capacity);
printf("The size is: %d\n",F.size);
char *msg1 = get_fifo(&F);
char *msg2 = get_fifo(&F);
char *msg3 = get_fifo(&F);
printf("%s\n", msg3);
return 0;
}
//启动一个命令行窗口任务
TASK *open_console_task(LAYER *layer, unsigned int mem_total)
{
MEMMANAGE *memmanage = (MEMMANAGE *)MEMMANAGE_ADDR;
TASK *task_console = task_alloc();
int *console_fifo = (int *)memmanage_alloc_4K(memmanage, 128 * 4);
task_console->console_stack = memmanage_alloc_4K(memmanage, 64 * 1024); //由于这里要传入两个参数，所以减去了12
task_console->tss.esp = task_console->console_stack + 64 * 1024 - 12;
task_console->tss.eip = (int) &console_task; //eip指向的是运行console的函数首地址
task_console->tss.es = 1 * 8;
task_console->tss.cs = 2 * 8;
task_console->tss.ss = 1 * 8;
task_console->tss.ds = 1 * 8;
task_console->tss.fs = 1 * 8;
task_console->tss.gs = 1 * 8;
*((int *) (task_console->tss.esp + 4)) = (int) layer;
*((int *) (task_console->tss.esp + 8)) = mem_total;
task_run(task_console, 2, 2); /* level=2, priority=2 */
init_fifo(&task_console->fifo, 128, console_fifo, task_console);
return task_console;
}
void inversion_pile(lifo_t * p)
{
/*variables locales*/
fifo_t * f = NULL; /*file*/
type_t tmp; /*valeurs a afficher*/
int err; /*erreur*/
/*initialisation*/
f = (fifo_t *)malloc(sizeof(fifo_t));
err = init_fifo(f,p->t_max);
if (! err)
{
printf("Pile a inverser :\n");
afficher_lifo(p);
/*parcours de la pile*/
while (!lifo_vide(p))
{
tmp = depiler(p); /*passage des valeurs*/
enfiler(f,tmp);
}
printf("Etat de la file :\n");
afficher_fifo(f);
while (! fifo_vide(f))
{
tmp = defiler(f); /*passage des valeurs*/
empiler(p,tmp);
}
/*liberation de la file*/
free_fifo(f);
}
printf("Pile inversee :\n");
afficher_lifo(p);
}
void* controlador(void* arg) {
char* fifo_name;
int fd, ret;
pthread_t detach_thread;
info_t* request_info;
fifo_name = (char *) arg;
if ( (fd = init_fifo(fifo_name, O_RDONLY)) == -1 )
pthread_exit(NULL);
while (1) {
request_info = (info_t *) malloc(sizeof(info_t));
ret = read(fd, request_info, sizeof(*request_info));
if (ret > 0)
{
if (strcmp(request_info->vehicle_fifo_name, FINISH_STR) == 0)
break;
pthread_create(&detach_thread, NULL, arrumador, request_info);
}
else if (ret == -1)
{
perror("Error reading on controller");
free(request_info);
close(fd);
unlink_fifo(fifo_name);
return NULL;
}
}
close(fd);
unlink_fifo(fifo_name);
pthread_exit(NULL);
}
void HariMain(void)
{
/*
**最初的这部分变量没有通过内存管理来分配，它们本身属于操作系统的一部分，存在于bootpack.hrb所在的那块儿内存空间中
*/
BOOTINFO *binfo = (BOOTINFO *) ADR_BOOTINFO;
MOUSE_DECODE mouse_dec;
MEMMANAGE *memmanage = (MEMMANAGE *)MEMMANAGE_ADDR;
LAYER_MANAGE *layer_manage;
LAYER *layer_bg, *layer_mouse;
FIFO fifo_mutual; //缓冲区管理，所有中断公用的
FIFO keycmd_fifo;
TASK *task_a, *task_console[2], *task; //后面的那个task只是作为一个临时变量来用的
CONSOLE *console;
int fifobuf[128], keycmd_buf[32], *console_fifo[2]; //缓冲区
int mCursorX, mCursorY; //鼠标光标显示位置的横纵坐标
int key_shift = 0, key_ctrl = 0, key_leds = (binfo->leds >> 4) & 7, keycmd_wait = -1; //标志键盘输入到哪个窗口中
int j, x, y, last_mcursorX = -1, last_mcursorY= -1, tmp_layerX = 0; //last_mcursorX这两个变量记录的是鼠标移动之前的坐标
int new_mcursorX = 0, new_mcursorY = 0, new_layerX = 0x7fffffff, new_layerY = 0;
LAYER *layer = 0, *key_to_window; //key_to_window这个变量记录当前的键盘输入到哪个窗口中
unsigned int memory_total, i;
char buf_cursor[mCursorWidth * mCursorHeight];
unsigned char *buf_bg, *buf_console[2]; //屏幕的大背景会在init_screen的时候画出来，这里只需要一个指向它的指针即可
unsigned char strings[40];
mCursorX = binfo->scrnx / 2;
mCursorY = (binfo->scrny - 28)/ 2; //减去下方任务栏的高度
/*内存检查*/
i = memtest(0x00400000, 0xbfffffff) / (1024 * 1024); //i的单位是MB
/*内存管理*/
memmanage_init(memmanage);
memory_total = i * 1024 * 1024;
memmanage_free_4K(memmanage, 0x00001000, 0x0009e000);
memmanage_free_4K(memmanage, 0x00400000, memory_total - 0x00400000);
init_fifo(&keycmd_fifo, 32, keycmd_buf, 0);
/*初始化接收中断的缓冲区*/
init_fifo(&fifo_mutual, 128, fifobuf, 0); //初始化mouseFIFO缓冲区，现在还没任务，先指定为0
/*初始化GDT和IDT表以及PIC板的数据*/
init_GDTandIDT(); //初始化GDT和IDT表
init_pic(); //初始化PIC主从板数据，除了IRQ2禁止了全部中断
io_sti(); //开始接收中断
/*初始化PIT中断控制*/
init_PIT();
/*若要接收鼠标中断需要两个步骤，首先必须使鼠标控制电路（就是键盘控制电路的一部分）有效，然后要使鼠标本身有效*/
init_keyboard(&fifo_mutual, 256); //初始化键盘控制器电路
enable_mouse(&fifo_mutual, 512, &mouse_dec); //激活鼠标
/*开放各种中断*/
io_out8(PIC0_IMR, 0xf8); //PIC0开发IRQ(11111000)，开放IRQ0、IRQ1和IRQ2，定时器、键盘中断和从PIC板
io_out8(PIC1_IMR, 0xef); //PIC1开放IRQ(11101111)， 开放鼠标中断
/*初始化任务切换管理*/
task_a = task_init(memmanage); //这个task_a其实代表的就是这些鼠标键盘等的任务
fifo_mutual.task = task_a; //为鼠标键盘等的缓冲区指定唤醒任务为task_a
task_run(task_a, 1, 2);
/*初始化调色板，为图形界面做准备*/
init_palette(); //初始化调色板
/*初始化图层管理，并且初始化鼠标光标和背景的图层*/
layer_manage = layer_man_init(memmanage, binfo->vram, binfo->scrnx, binfo->scrny);
*((int *) 0x0fe4) = (int) layer_manage;
layer_bg = layer_alloc(layer_manage); //为背景分配图层
layer_mouse = layer_alloc(layer_manage); //为鼠标分配图层
buf_bg = (unsigned char *)memmanage_alloc_4K(memmanage, binfo->scrnx * binfo->scrny); //为背景图形的内容分配内存
/*为各个图形的图层内容进行设定*/
layer_set(layer_bg, buf_bg, binfo->scrnx, binfo->scrny, -1);
layer_set(layer_mouse, buf_cursor, 16, 16 ,99);
/*初始化整个桌面背景*/
init_screen(buf_bg, binfo->scrnx, binfo->scrny); //这个时候的init_screen不再是直接画出背景，而是在mBg内存地址中填写好背景内容
layer_slide(layer_bg, 0, 0); //把背景图层从(0,0)坐标开始画
/*初始化鼠标图标*/
init_mouse_cursor(buf_cursor, 99); //初始化鼠标光标
layer_slide(layer_mouse, mCursorX, mCursorY); //现在显示图形不需要再用displayShape函数了，直接用这个图层管理的绘图函数就行
/*执行两个命令行窗口任务*/
key_to_window = open_console(layer_manage, memory_total); //最初的时候由第一个console接收键盘输入
layer_slide(key_to_window, 8, 2);
/*设置好各个图层的高度*/
layer_switch(layer_bg, 0); //把背景图层调为最底层，高度为0
layer_switch(key_to_window, 1); //命令行窗口图层调节为第三层，高度为2
layer_switch(layer_mouse, 2); //鼠标图层调为最高层，高度为3
keywindow_on(key_to_window);
//
fifo_put(&keycmd_fifo, KEYCMD_LED);
fifo_put(&keycmd_fifo, key_leds);
*((int *) 0x0fec) = (int) &fifo_mutual;
for(;;)
{
if(fifo_status(&keycmd_fifo) > 0 && keycmd_wait < 0)
{
keycmd_wait = fifo_get(&keycmd_fifo);
wait_KBC_sendready();
io_out8(PORT_KEYDATA, keycmd_wait);
}
/*只有在从中断返回的缓冲区中读取数据的时候才需要禁止中断，因为如果这个时候来了中断而没有禁止的话，
**有可能读脏数据，即把还没有读出的数据的给抹掉或换成别的数据
*/
io_cli();
if(0 == fifo_status(&fifo_mutual)) //当前没有中断产生
{
//利用CPU空闲的时间来执行耗时的绘图工作(这样的话会造成反应很快的表象，但其实，如果中断很多，尤其是鼠标中断很多的时候，
//会把之前记录下的new_mcursorX覆盖掉，而只绘制最新的图层坐标)
if(new_mcursorX >= 0)
{
io_sti();
layer_slide(layer_mouse, new_mcursorX, new_mcursorY);
new_mcursorX = -1; //绘制完鼠标之后，就把它的坐标设置为负数，反正鼠标不会出去屏幕，为负数的时候就说明不需要重绘鼠标
}
//图层的横坐标为0x7fffffff的时候就不需要重绘了，这是作为一个标志的，它为其他值的时候就需要重绘了
else if(new_layerX != 0x7fffffff)
{
io_sti();
layer_slide(layer, new_layerX, new_layerY);
new_layerX = 0x7fffffff;
}
//如果不需要重绘鼠标和图层的话，就没有什么工作可做了，进入休眠就可以了
else
{
task_sleep(task_a); //如果没有需要处理的数据，就自己让自己休眠
/*上面的那个函数直接就跳转到另一个任务中去了，不过，因为每个人物的默认eflags都是开启中断的，
**所以不用担心，这个任务还是能被唤醒的，耳环醒后的第一个动作就是为了以防万一先开启中断
*/
io_sti(); //万一只有自己在运行的话，则无法睡眠，那么就执行hlt指令好了，这样省电嘛
}
}
else
{
i = fifo_get(&fifo_mutual);
io_sti();
//窗口被关闭的情况
if(0 != key_to_window && 0 == key_to_window->flags)
{
//如果当前画面上只剩下鼠标和背景的时候
if(1 == layer_manage->top)
{
key_to_window = 0;
}
else
{
key_to_window = layer_manage->layers_order[layer_manage->top - 1]; //当窗口被关闭的时候，自动切换成最上层的layer接收键盘输入
keywindow_on(key_to_window);
}
}
//如果是键盘中断的话，需要处理键盘发送来的中断数据
if((keyboard_offset <= i) && (i <= keyboard_offset + 255))
{
//判断shift键是否按下，然后使用不同的keytable表
if(i < 0x80 + keyboard_offset)
{
if(0 == key_shift)
{
strings[0] = key_table[i - keyboard_offset];
}
else
{
strings[0] = key_table_shift[i - keyboard_offset];
}
}
else
{
strings[0] = 0;
}
//判断Caps和Shift键的情况以确定输入大写还是小写字母
if('A' <= strings[0] && strings[0] <= 'Z')
{
//小写字母的情况
if((0 == (key_leds & 4) && 0 == key_shift) || (0 != (key_leds & 4) && 0 != key_shift))
{
strings[0] += 0x20;
}
}
//判断按下的字符是否为一般字符，0对应的字符不处理，对退格键和回车键加上了对应字符，他们对应的table表里的元素不再是0
if(strings[0] != 0 && key_to_window != 0)
{
fifo_put(&key_to_window->task->fifo, strings[0] + 256);
}
//如果按下了ctrl+d，就打开一个console
if(('D' == strings[0] || 'd' == strings[0]) && (0 != key_ctrl))
{
if(key_to_window != 0)
{
keywindow_off(key_to_window);
}
key_to_window = open_console(layer_manage, memory_total);
layer_slide(key_to_window, 300, 2);
layer_switch(key_to_window, layer_manage->top);
//自动把键盘输入切换到这个新打开的console中
keywindow_on(key_to_window);
}
//如果同时按下了ctrl+x，那么就关闭应用程序
if(('X' == strings[0] || 'x' == strings[0]) && (0 != key_ctrl) && key_to_window != 0)
{
task = key_to_window->task; //找到当前接收键盘输入的（即最前面的）图层所对应的任务
if(0 != task && task->tss.ss0 != 0)
{
console_putstring_toend(task->console, "\nTerminate program! :\n");
io_cli();
//让CPU直接跳转到console中执行，不再管应用程序，也就是所谓的停止应用程序继续运行
task->tss.eax = (int) &(task->tss.esp0);
task->tss.eip = (int) asm_end_app;
io_sti();
}
}
/*这些都是那些不能打印的特殊按键，它们对应的都是0*/
//按下“TAB键”的处理情况，切换输入窗口
if(i == keyboard_offset + 0x0f && key_to_window != 0)
{
//先让当前的窗口的光标OFF掉
keywindow_off(key_to_window);
j = key_to_window->height - 1;
if(0 == j)
{
//如果切换之后的图层是最底层的操作系统的图层，那么就切换成最上层的图层
j = layer_manage->top - 1;
}
key_to_window = layer_manage->layers_order[j];
//使切换到的窗口的光标ON
keywindow_on(key_to_window);
}
//左或右Ctrl ON
if(0x1d + keyboard_offset == i)
{
key_ctrl = 1;
}
//左或右Ctrl OFF
if(0x9d + keyboard_offset == i)
{
key_ctrl = 0;
}
//左shift ON
if(0x2a + keyboard_offset == i)
{
key_shift |= 1;
}
//右shift ON
if(0x36 + keyboard_offset == i)
{
key_shift |= 2;
}
//左shift OFF
if(0xaa + keyboard_offset == i)
{
key_shift &= ~1;
}
//左shift OFF
if(0xb6 + keyboard_offset == i)
{
key_shift &= ~2;
}
/*对各种锁定键的处理*/
//CapsLock键
if(i == keyboard_offset + 0x3a)
{
key_leds ^= 4;
fifo_put(&keycmd_fifo, KEYCMD_LED);
fifo_put(&keycmd_fifo, key_leds);
}
//NumLock键
if(i == keyboard_offset + 0x45)
{
key_leds ^= 2;
fifo_put(&keycmd_fifo, KEYCMD_LED);
fifo_put(&keycmd_fifo, key_leds);
}
//ScrollLock键
if(i == keyboard_offset + 0x46)
{
key_leds ^= 1;
fifo_put(&keycmd_fifo, KEYCMD_LED);
fifo_put(&keycmd_fifo, key_leds);
}
//键盘成功接收到数据
if(i == keyboard_offset + 0xfa)
{
keycmd_wait = -1;
}
//键盘没有成功接收到数据
if(i == keyboard_offset + 0xfe)
{
wait_KBC_sendready();
io_out8(PORT_KEYDATA, keycmd_wait);
}
}
//如果是鼠标中断的话，需要处理鼠标发送来的中断数据
else if((mouse_offset <= i) && (i <= mouse_offset + 255))
{
if(0 != mouse_decode(&mouse_dec, i - mouse_offset)) //只有返回值为1的时候才说明成功接收完成一次鼠标的中断
{
/*鼠标的移动*/
//根据mouse_dec里存储的鼠标信息画出新的鼠标图像
mCursorX += mouse_dec.x;
mCursorY += mouse_dec.y;
//不能让鼠标移出画面
if(mCursorX < 0)
{
mCursorX = 0;
}
if(mCursorY < 0)
{
mCursorY = 0;
}
if(mCursorX > binfo->scrnx - 1)
{
mCursorX = binfo->scrnx - 1;
}
if(mCursorY > binfo->scrny - 1)
{
mCursorY = binfo->scrny - 1;
}
//记录下鼠标光标的移动到的位置，等待fifo中为空的时候开始绘图
new_mcursorX = mCursorX;
new_mcursorY = mCursorY;
//按下了左键
if(0 != (mouse_dec.btn & 0x01))
{
//如果last_mcursorX小于0，说明当前不是处于窗口移动模式，那么就需要检查现在鼠标按下左键之后有没有落在某个图层的标题栏上
if(last_mcursorX < 0)
{
for(j = layer_manage->top - 1; j > 0; j--)
{
layer = layer_manage->layers_order[j];
//计算一下鼠标的坐标在不在这个图层里面
x = mCursorX - layer->x;
y = mCursorY - layer->y;
if(0 <= x && x < layer->length && 0 <= y && y <= layer->width)
{
//鼠标所在区域也不能是涂层的透明区域
if(layer->buffer[y * layer->length + x] != layer->color_luc)
{
layer_switch(layer, layer_manage->top - 1);
//如果当前的layer不是接收键盘输入的图层（即最前面的图层），那么就需要切换
if(layer != key_to_window)
{
//鼠标左击窗口所做的事情跟按下TAB键的事情差不多
keywindow_off(key_to_window);
key_to_window = layer;
keywindow_on(key_to_window);
}
//查看鼠标当前点击的区域是不是窗口的标题栏，并且不能是关闭按钮所在的区域
if(3 <= x && x < layer->length - 21 && 3 <= y && y <= 21)
{
last_mcursorX = mCursorX;
last_mcursorY = mCursorY;
tmp_layerX = layer->x; //这个tmp_layerX只是个要绘制的图层横坐标的过渡部分，真正的坐标还需要处理
new_layerY = layer->y;
}
//这个是鼠标点击到关闭按钮的情况
if(layer->length - 21 <= x && x <= layer->length - 5 && 5 <= y && y <= 19)
{
//查看该窗口是否为应用程序的窗口，如果是应用程序产生的窗口而不是console的那个黑窗口，那么这个窗口的flags有0x10
if(0 != (layer->flags & 0x10))
{
//这部分处理跟按下ctrl+x的处理基本一样
task = layer->task;
console_putstring_toend(task->console, "Break by mouse!\n");
io_cli();
task->tss.eax = (int)&(task->tss.esp0);
task->tss.eip = (int)asm_end_app;
io_sti();
}
//不是应用程序的话就是console命令行窗口产生的layer
else
{
//不能再这里的task_a中直接关闭，因为还有些console自身管理的定时器和fat等东西无法释放了
task = layer->task;
io_cli();
fifo_put(&task->fifo, 4);
io_sti();
}
}
break;
}
}
}
}
//只要last_mcursorX大于0，说明当前处于窗口移动模式，说明当前鼠标正点击着某个图层的标题栏呢
else
{
x = mCursorX - last_mcursorX;
y = mCursorY - last_mcursorY;
new_layerX = (tmp_layerX + x + 2) & ~3;
new_layerY = new_layerY + y;
last_mcursorY = mCursorY; //更新到移动后的坐标
}
}
//如果当前没有按下左键，就把last_mcursorX设置为负数，作为当前不处于窗口移动的依据
else
{
last_mcursorX = -1;
if(0x7fffffff != new_layerX)
{
layer_slide(layer, new_layerX, new_layerY); //一旦鼠标不点击这窗口移动了，就立即最后一次绘制窗口并且停止窗口的移动
new_layerX = 0x7fffffff;
}
}
}
}
//收到这个之间的数据，说明是让关闭console的
else if(768 <= i && i <= 1023)
{
close_console(layer_manage->layers + (i - 768));
}
}
}
}
