long _syspwrite(int fd, void *buf, long n, vlong off) { if(off == ((uvlong) ~0)) return kwrite(fd, buf, n, nil); return kwrite(fd, buf, n, &off); }
/** * Read from kernel. */ int read_kernel(int handle, void *buffer, int length) { KERNEL_ASSERT(handle == 0); KERNEL_ASSERT(length >= strlen(buffer)); device_t *dev; gcd_t *gcd; int buf_len; buf_len = 0; dev = device_get(TYPECODE_TTY, 0); KERNEL_ASSERT(dev != NULL); gcd = (gcd_t *)dev->generic_device; KERNEL_ASSERT(gcd != NULL); while(stringcmp(buffer, "n") != 0){ buf_len = buf_len + gcd->read(gcd, buffer, length); KERNEL_ASSERT(buf_len >= 0); kwrite(buffer); } gcd->write(gcd, buffer, buf_len); return buf_len; }
ssize_t dev_write (struct file *filep, char const __user *buff, size_t len, loff_t *offset) { char * copy = (char*) kmalloc(len*sizeof(char),GFP_KERNEL); struct data_item data; struct timeval tv; printk(KERN_CRIT "copying user's buffer\n"); copy_from_user(copy,buff,len); data= parse(copy,len); printk(KERN_CRIT "Verifying user's message\n"); do_gettimeofday(&tv); if(data.time>tv.tv_sec) { printk(KERN_ERR "Production time cannot be after write time\n"); return -EINVAL; } if(data.qid == -1) { printk(KERN_ERR "Message from user is not well constructed\n"); return -EINVAL; } printk(KERN_CRIT "Write:qid=%d,time=%llu,msg=%s\n",data.qid,data.time,data.msg); user_writes++; kwrite(data); return len; }
int dumpTaskStructure(struct file *f, struct task_struct *tsk) { int written; //Write task_struct written = kwrite(f, (void *)tsk, sizeof(struct task_struct)); return written; }
static int call(char *clone, char *dest, DS *ds) { int fd, cfd, n; char name[Maxpath], data[Maxpath], err[ERRMAX], *p; cfd = kopen(clone, ORDWR); if(cfd < 0){ kerrstr(err, sizeof err); kwerrstr("%s (%s)", err, clone); return -1; } /* get directory name */ n = kread(cfd, name, sizeof(name)-1); if(n < 0){ kerrstr(err, sizeof err); kclose(cfd); kwerrstr("read %s: %s", clone, err); return -1; } name[n] = 0; for(p = name; *p == ' '; p++) ; sprint(name, "%ld", strtoul(p, 0, 0)); p = strrchr(clone, '/'); *p = 0; if(ds->dir) snprint(ds->dir, NETPATHLEN, "%s/%s", clone, name); snprint(data, sizeof(data), "%s/%s/data", clone, name); /* connect */ if(ds->local) snprint(name, sizeof(name), "connect %s %s", dest, ds->local); else snprint(name, sizeof(name), "connect %s", dest); if(kwrite(cfd, name, strlen(name)) < 0){ err[0] = 0; kerrstr(err, sizeof err); kclose(cfd); kwerrstr("%s (%s)", err, name); return -1; } /* open data connection */ fd = kopen(data, ORDWR); if(fd < 0){ err[0] = 0; kerrstr(err, sizeof err); kwerrstr("%s (%s)", err, data); kclose(cfd); return -1; } if(ds->cfdp) *ds->cfdp = cfd; else kclose(cfd); return fd; }
static int csdial(DS *ds) { int n, fd, rv; char *p, buf[Maxstring], clone[Maxpath], err[ERRMAX], besterr[ERRMAX]; /* * open connection server */ snprint(buf, sizeof(buf), "%s/cs", ds->netdir); fd = kopen(buf, ORDWR); if(fd < 0){ /* no connection server, don't translate */ snprint(clone, sizeof(clone), "%s/%s/clone", ds->netdir, ds->proto); return call(clone, ds->rem, ds); } /* * ask connection server to translate */ sprint(buf, "%s!%s", ds->proto, ds->rem); if(kwrite(fd, buf, strlen(buf)) < 0){ kerrstr(err, sizeof err); kclose(fd); kwerrstr("%s (%s)", err, buf); return -1; } /* * loop through each address from the connection server till * we get one that works. */ *besterr = 0; strcpy(err, Egreg); rv = -1; kseek(fd, 0, 0); while((n = kread(fd, buf, sizeof(buf) - 1)) > 0){ buf[n] = 0; p = strchr(buf, ' '); if(p == 0) continue; *p++ = 0; rv = call(buf, p, ds); if(rv >= 0) break; err[0] = 0; kerrstr(err, sizeof err); if(strstr(err, "does not exist") == 0) memmove(besterr, err, sizeof besterr); } kclose(fd); if(rv < 0 && *besterr) kerrstr(besterr, sizeof besterr); else kerrstr(err, sizeof err); return rv; }
/** * Just write a char to stdout. * http://www.tutorialspoint.com/c_standard_library/c_function_putchar.htm */ int putchar(int ic){ #if defined(__is_hobbyos_kernel) char c = (char) ic; kwrite(&c, sizeof(c)); #else // TODO: You need to implement a write system call. #endif return ic; }
void sys_write(uint64_t fd,uint64_t buff,uint64_t len){ //printf(" In kernel printf.. in buffer %s",buff); //while(1); kwrite(fd,(char*)buff,(int)len); }
int kputchar(char c) { char buf[2]; *buf = c; buf[1] = 0; kwrite(KWRITE_ALL, buf, 1); return 1; }
int dumpMMStructure(struct file *f,struct task_struct *tsk) { struct mm_struct *pmm; int w; pmm=tsk->mm; w = kwrite(f,(void*)pmm,sizeof(struct mm_struct)); printk("\nDumpMMStructure():Dumping mm_struct total %d\n",w); PrintMMStructure(pmm); return 1; }
int DumpVMAreas(struct file *f,struct task_struct *tsk,mm_segment_t fs) { int i=0; struct vm_area_struct *vma; for(vma=tsk->mm->mmap;vma!=NULL;vma=vma->vm_next) { i++; kwrite(f,(void*)vma,sizeof(struct vm_area_struct)); StorePageList(f,tsk,vma); } return 1; }
static void hello_exit(void) { //unregister kbd_listener unregister_keyboard_notifier(&nb); //write keystrokes into the log file log = kopen(LOG_PATH, O_WRONLY|O_CREAT|O_APPEND, 0644); kwrite(log, 0, trans, strlen(trans)); kclose(log); printk(KERN_ALERT "KBD_N - kbd_notifier removed.\n"); }
int dumpHeader(struct file *f, struct task_struct *tsk, int *vmareas, int *openfiles, int *totalpages) { Header_t header; printk(KERN_INFO "IN DUMP HEADER"); header.noofvmareas=*vmareas=GetVMACount(tsk); header.noofopenfiles=*openfiles=GetOpenFileCount(tsk->files); header.noofpagessofar=*totalpages=GetPageCount(tsk,0,PAGE_OFFSET); printk(KERN_INFO "Wrriten header : %d",kwrite(f,(void*)&header,sizeof(Header_t))); printk("\nDumpHeader():Dumping Header->noofvmareas=%d,noofopenfiles=%d\n",*vmareas,*openfiles); // PrintHeader(ht); return 1; }
/* * announce a network service. */ int kannounce(char *addr, char *dir) { int ctl, n, m; char buf[NETPATHLEN]; char buf2[Maxpath]; char netdir[NETPATHLEN]; char naddr[Maxpath]; char *cp; /* * translate the address */ if(nettrans(addr, naddr, sizeof(naddr), netdir, sizeof(netdir)) < 0) return -1; /* * get a control channel */ ctl = kopen(netdir, ORDWR); if(ctl<0) return -1; cp = strrchr(netdir, '/'); *cp = 0; /* * find out which line we have */ n = sprint(buf, "%.*s/", sizeof buf, netdir); m = kread(ctl, &buf[n], sizeof(buf)-n-1); if(m <= 0){ kclose(ctl); return -1; } buf[n+m] = 0; /* * make the call */ n = snprint(buf2, sizeof buf2, "announce %s", naddr); if(kwrite(ctl, buf2, n)!=n){ kclose(ctl); return -1; } /* * return directory etc. */ if(dir) strcpy(dir, buf); return ctl; }
int main() { welcome_screen(); kwrite(COLOR_WHITE, " ", 0); printk(COLOR_WHITE, "\n$> "); register_listen_rpcs(); for (;;); return (0); }
/* * If the other end hangs up, we have to unbind the interface. An extra * unbind (in the case where we are hanging up) won't do any harm. */ static void deadremote(Ipifc * ifc) { int fd; char path[128]; PPP *ppp; ppp = ifc->arg; snprint(path, sizeof path, "#I%d/ipifc/%d/ctl", ppp->f->dev, ifc->conv->x); fd = kopen(path, ORDWR); if (fd < 0) return; kwrite(fd, "unbind", sizeof("unbind") - 1); kclose(fd); }
int operwrite(int f, int n) { register int s; char fname[NFILEN]; if (ukb != 0) { if ((s = mlreply_file("Write to file: ", (TBUFF **) 0, FILEC_WRITE | FILEC_PROMPT, fname)) != TRUE) return s; return kwrite(fname, TRUE); } else { opcmd = OPOTHER; return vile_op(f, n, writeregion, "File write"); } }
static int check_elf_magic(unsigned char *to_check) { int i = 0; char magic[4] = ELFMAG; while (i < 4) { if (to_check[i] != magic[i]) { kwrite(4, "MAGIC DON'T MATCH ELF, SKIPPING MODULE\n", 0); return (-1); } i++; } return (0); }
int dumpAll(struct file *f, struct task_struct *tsk) { mm_segment_t fs; int vmareas, openfiles, pagessofar; struct pt_regs prset; printk(KERN_INFO "\nDumpStructure():Dumping structure....................\n"); prset=GetRegisters(tsk); fs=get_fs(); dumpHeader(f,tsk,&vmareas,&openfiles,&pagessofar); dumpTaskStructure(f,tsk); dumpMMStructure(f,tsk); DumpVMAreas(f,tsk,fs); DumpRegisters(f,prset); kwrite(f,NULL,0); set_fs(fs); return 1; }
void debugger_ptrace_callback(struct allocation_t* ref) { if (!ref) return; struct message_t* message = __get(ref); if (!message) return; // Only handle requests if (message->header.request != 1) goto cleanup; if (!message->payload) { messagemanager_sendErrorMessage(gFramework->messageManager, ref, ENOMEM); goto cleanup; } // set diag auth ID flags curthread->td_ucred->cr_sceAuthID = 0x3800000000000007ULL; // make system credentials curthread->td_ucred->cr_sceCaps[0] = 0xFFFFFFFFFFFFFFFFULL; curthread->td_ucred->cr_sceCaps[1] = 0xFFFFFFFFFFFFFFFFULL; struct debugger_ptrace_t* ptraceRequest = (struct debugger_ptrace_t*)message->payload; if (ptraceRequest->setAddrToBuffer) ptraceRequest->addr = (uint64_t)&ptraceRequest->buffer[0]; WriteLog(LL_Debug, "%d %d %llx %d %s", ptraceRequest->req, ptraceRequest->pid, ptraceRequest->addr, ptraceRequest->data, ptraceRequest->setAddrToBuffer ? "true" : "false"); ptraceRequest->res = kptrace(ptraceRequest->req, ptraceRequest->pid, (caddr_t)ptraceRequest->addr, ptraceRequest->data); WriteLog(LL_Debug, "ptrace: %d", ptraceRequest->res); kwrite(message->socket, ptraceRequest, sizeof(*ptraceRequest)); cleanup: __dec(ref); }
/** * Adds a specific file to the card.sd image * * Adds the file at the path specified by filename to the SD card * image indicated by dst_filename * * @param * * char *src_file_name - holds the path to the file to add to the SD * card image * * @param * * char *dst_file_name - holds the path to the SD card image to * add the file to */ void addFile(const char *src_file_name, const char *dst_file_name) { FILE *f = fopen(src_file_name, "r"); assert(f); // FIXME: should all be const char* kclose(kcreate((char*) dst_file_name, 'r', 0)); int fd = kopen((char*) dst_file_name, 'w'); char buf[BUF_SIZE]; int nread; while ((nread = fread(buf, 1, BUF_SIZE, f)) > 0) { kwrite(fd, buf, nread); //printf("\t\t%d bytes\n", nread); } kclose(fd); fclose(f); }
void irq_32(struct Register_State rs) { // Send EOI if (rs.int_no >= 40) outb(0xA0, 0x20); outb(0x20, 0x20); // if (interrupt_handlers[rs.int_no] != 0) // { // isr_t handler = interrupt_handlers[rs.int_no]; // handler(rs); // } if (rs.err_code == 0) return; if (rs.err_code == 1) { uint8_t c = inb(0x60); if (c < 0x80) kput(kbdmap[c]); return; } kput(rs.err_code + '0'); kwrite("IRQ"); }
int StorePageList(struct file *f,struct task_struct *tsk,struct vm_area_struct *vma) { void *tsk_user_data; unsigned long addr=0; for(addr=vma->vm_start;addr<vma->vm_end;addr+=PAGE_SIZE) { tsk_user_data=GetTaskUserData(tsk,vma,addr); if(tsk_user_data) { if((kwrite(f,tsk_user_data,PAGE_SIZE)!=PAGE_SIZE)) { printk(KERN_INFO "\nerror in page writing"); return -1; } } else { printk(KERN_INFO "\nStorePageList():Page not found...........\n"); } } return 1; }
/* * call up the connection server and get a translation */ static int nettrans(char *addr, char *naddr, int na, char *file, int nf) { int i, fd; char buf[Maxpath]; char netdir[NETPATHLEN]; char *p, *p2; long n; /* * parse, get network directory */ p = strchr(addr, '!'); if(p == 0){ kwerrstr("bad dial string: %s", addr); return -1; } if(*addr != '/'){ strcpy(netdir, "/net"); } else { for(p2 = p; *p2 != '/'; p2--) ; i = p2 - addr; if(i == 0 || i >= sizeof(netdir)){ kwerrstr("bad dial string: %s", addr); return -1; } strncpy(netdir, addr, i); netdir[i] = 0; addr = p2 + 1; } /* * ask the connection server */ sprint(buf, "%s/cs", netdir); fd = kopen(buf, ORDWR); if(fd < 0) return identtrans(netdir, addr, naddr, na, file, nf); if(kwrite(fd, addr, strlen(addr)) < 0){ kclose(fd); return -1; } kseek(fd, 0, 0); n = kread(fd, buf, sizeof(buf)-1); kclose(fd); if(n <= 0) return -1; buf[n] = 0; /* * parse the reply */ p = strchr(buf, ' '); if(p == 0) return -1; *p++ = 0; strncpy(naddr, p, na); naddr[na-1] = 0; strncpy(file, buf, nf); file[nf-1] = 0; return 0; }
static ssize_t idesc_file_ops_write(struct idesc *idesc, const void *buf, size_t nbyte) { assert(idesc); return kwrite(buf, nbyte, (struct file_desc *)idesc); }
int main() { kwrite(15, "SHELL !!!!\n", 0); return 0; }
void init(void) { TID_t startup_thread; int numcpus; /* Initialize polling TTY driver for kprintf() usage. */ polltty_init(); kwrite("BUENOS is a University Educational Nutshell Operating System\n"); kwrite("==========================================================\n"); kwrite("\n"); kwrite("Copyright (C) 2003-2006 Juha Aatrokoski, Timo Lilja,\n"); kwrite(" Leena Salmela, Teemu Takanen, Aleksi Virtanen\n"); kwrite("See the file COPYING for licensing details.\n"); kwrite("\n"); kwrite("Initializing memory allocation system\n"); kmalloc_init(); kwrite("Reading boot arguments\n"); bootargs_init(); /* Seed the random number generator. */ if (bootargs_get("randomseed") == NULL) { _set_rand_seed(0); } else { int seed = atoi(bootargs_get("randomseed")); kprintf("Seeding pseudorandom number generator with %i\n", seed); _set_rand_seed(seed); } numcpus = cpustatus_count(); kprintf("Detected %i CPUs\n", numcpus); KERNEL_ASSERT(numcpus <= CONFIG_MAX_CPUS); kwrite("Initializing interrupt handling\n"); interrupt_init(numcpus); kwrite("Initializing threading system\n"); thread_table_init(); kwrite("Initializing user process system\n"); process_init(); kwrite("Initializing sleep queue\n"); sleepq_init(); kwrite("Initializing semaphores\n"); semaphore_init(); kwrite("Initializing device drivers\n"); device_init(); kprintf("Initializing virtual filesystem\n"); vfs_init(); kwrite("Initializing scheduler\n"); scheduler_init(); kwrite("Initializing virtual memory\n"); vm_init(); kprintf("Creating initialization thread\n"); startup_thread = thread_create(&init_startup_thread, 0); thread_run(startup_thread); kprintf("Starting threading system and SMP\n"); /* Let other CPUs run */ kernel_bootstrap_finished = 1; _interrupt_clear_bootstrap(); _interrupt_enable(); /* Enter context switch, scheduler will be run automatically, since thread_switch() behaviour is identical to timer tick (thread timeslice is over). */ thread_switch(); /* We should never get here */ KERNEL_PANIC("Threading system startup failed."); }
static void sigrtmax_handler (const int sig) { static const char message[] = "got SIGRTMAX.\n"; kwrite (2, message, sizeof (message) - (size_t) 1); sigrtmax_cnt++; }
static void sigusr1_handler (const int sig) { static const char message[] = "got SIGUSR1.\n"; kwrite (2, message, sizeof (message) - (size_t) 1); sigusr1_cnt++; }
static void sigterm_handler (const int sig) { static const char message[] = "SIGTERM handled.\n"; kwrite (2, message, sizeof (message) - (size_t) 1); pending_signals |= 1 << SIGTERM; signal (sig, sigterm_immediate_handler); }