void TEightTrack::Close() { int i; mem_check(); fclose(fpPhysFile); if (pCache) { FREE (pCache); pCache = 0; } for (i=0; i<numTracks; i++) { if(aTracks[i].pSegmentArray) { FREE (aTracks[i].pSegmentArray); } } numSectors = 0; numTracks = 0; numSegments = 0; segmentsToRead = 0; memset (aTracks, 0, sizeof(aTracks)); mem_check(); }
static void heap_malloc_init() { rt_uint8_t *ptr1, *ptr2, *ptr3, *ptr4, *ptr5; ptr1 = rt_malloc(1); ptr2 = rt_malloc(13); ptr3 = rt_malloc(31); ptr4 = rt_malloc(127); ptr5 = rt_malloc(0); memset(ptr1, 1, 1); memset(ptr2, 2, 13); memset(ptr3, 3, 31); memset(ptr4, 4, 127); if (mem_check(ptr1, 1, 1) != RT_FALSE) goto _failed; if (mem_check(ptr2, 2, 13) != RT_FALSE) goto _failed; if (mem_check(ptr3, 3, 31) != RT_FALSE) goto _failed; if (mem_check(ptr4, 4, 127) != RT_FALSE) goto _failed; rt_free(ptr4); rt_free(ptr3); rt_free(ptr3); rt_free(ptr1); if (ptr5 != RT_NULL) { rt_free(ptr5); } tc_done(TC_STAT_PASSED); _failed: tc_done(TC_STAT_FAILED); }
Bool symbol_is_valid(const Symbol* sym) { if (sym == NULL || !SID_ok(sym, SYMBOL_SID)) return FALSE; mem_check(sym); mem_check(sym->entry); return TRUE; }
//Set a decimal variable void set_var_decimal(Variable *varArry, int arrySpot){ String value = (String)malloc(ARRAYLENGHT * sizeof(char)); int flag; //Check if memory allocated properly. mem_check(value); do{ //User interaction printf("%s", "\n\nGive the variables value (Decimal):"); fgets(value, ARRAYLENGHT, stdin); //Check for valid lenght flag = false; if (value[strlen(value) - 1] == '\n' && strlen(value) > 1) value[strcspn(value, "\n")] = 0; //Drop the \n from the input else{ flag = true; printf("%s", "\n\nInvalid lenght. It must be between 1 and 255 characters!\n\n"); if (strlen(value) > 1) clear_stdin(); //Clear stdin from extra input } //Check if user entered a decimal if (!isdecimal(value) || flag) printf("%s", "\n\nThe value you gave is not a decimal!\n\n"); } while (!isdecimal(value)); //Copy the decimal to our array and free the buffer strcpy(varArry[arrySpot].value, value); free(value); }
void set_var_bool(Variable *varArry, int arrySpot){ String value = (String)malloc(ARRAYLENGHT * sizeof(char)); int flag; //Check if memory allocated properly. mem_check(value); do{ printf("%s", "\n\nGive the variables value (true/false):"); fgets(value, ARRAYLENGHT, stdin); //Check for valid lenght flag = false; if (value[strlen(value) - 1] == '\n' && strlen(value) > 1){ value[strcspn(value, "\n")] = 0; //Drop the \n from the input if (!isbool(value)) printf("%s", "\n\nThe value you gave is not a bool!\n\n"); } else{ flag = true; printf("%s", "\n\nInvalid lenght. It must be between 1 and 255 characters!\n\n"); if (strlen(value) > 1) clear_stdin(); //Clear stdin from extra input } } while (!isbool(value)); //Copy the value to the array and free memory strcpy(varArry[arrySpot].value, value); free(value); }
/** Deallocate BIP data structure. */ void bip_exit(BIP* bip) { assert(bip_is_valid(bip)); mem_check(bip); free(bip); }
Bool define_is_valid(const Define* def) { if (def == NULL || !SID_ok(def, DEFINE_SID)) return FALSE; mem_check(def); return TRUE; }
void bin_test(struct bin_info *p) { int b; for(b=0; b<p->bins; b++) { if(mem_check(p->m[b].ptr, p->m[b].size)) { printf("memory corrupt!\n"); abort(); } } }
/* =========================================================== mem_alloc =========================================================== Allocates a MAB of the specified size and returns a pointer to this MAB. The allocation algorithm employed is a first-fit policy. Uses the global variable 'memory' as the head of the MAB list. ----------------------------------------------------------- size: The size of the MAB being requested. ----------------------------------------------------------- return value: A pointer to the requested MAB. NULL if no such MAB could be found. ----------------------------------------------------------- */ MAB *mem_alloc(unsigned int size) { MAB *m = NULL; /* the requested MAB - null if none found */ if (size > 0) { /* try to allocate memory */ if ((m = mem_check(size)) && mem_split(m, size)) { m->allocated = true; } } /* return the (un)allocated memory */ return m; }
void mem_init(void) { if (!cpu_onboot()) // only do once, on the boot CPU return; // Determine how much base (<640K) and extended (>1MB) memory // is available in the system (in bytes), // by reading the PC's BIOS-managed nonvolatile RAM (NVRAM). // The NVRAM tells us how many kilobytes there are. // Since the count is 16 bits, this gives us up to 64MB of RAM; // additional RAM beyond that would have to be detected another way. size_t basemem = ROUNDDOWN(nvram_read16(NVRAM_BASELO)*1024, PAGESIZE); size_t extmem = ROUNDDOWN(nvram_read16(NVRAM_EXTLO)*1024, PAGESIZE); warn("Assuming we have 1GB of memory!"); extmem = 1024*1024*1024 - MEM_EXT; // assume 1GB total memory // The maximum physical address is the top of extended memory. mem_max = MEM_EXT + extmem; // Compute the total number of physical pages (including I/O holes) mem_npage = mem_max / PAGESIZE; cprintf("Physical memory: %dK available, ", (int)(mem_max/1024)); cprintf("base = %dK, extended = %dK\n", (int)(basemem/1024), (int)(extmem/1024)); spinlock_init(&_freelist_lock); pageinfo *mem_pageinfo = (pageinfo*)ROUNDUP((uint32_t)end, (uint32_t)sizeof(pageinfo)); memset(mem_pageinfo, 0, sizeof(pageinfo)*mem_npage); pageinfo **freetail = &mem_freelist; int i; // Pages 0 and 1 are reserved. for (i = 2; i < mem_npage; i++) { // All of base memory otherwise is free after the kernel // and the pageinfo table all memory should be free if(i < basemem/4096 || i >= (uint32_t)(ROUNDUP(&mem_pageinfo[mem_npage],4096))/4096) { // A free page has no references to it. mem_pageinfo[i].refcount = 0; // Add the page to the end of the free list. *freetail = &mem_pageinfo[i]; freetail = &mem_pageinfo[i].free_next; } } *freetail = NULL; // null-terminate the freelist // Check to make sure the page allocator seems to work correctly. mem_check(); }
void bin_test(void) { int b, i; for(b=0; b<n_blocks; b++) { mutex_lock(&blocks[b].mutex); for(i=0; i<BINS_PER_BLOCK; i++) { if(mem_check(blocks[b].b[i].ptr, blocks[b].b[i].size)) { printf("memory corrupt!\n"); exit(1); } } mutex_unlock(&blocks[b].mutex); } }
static void _init(JxTuiEvent *in_event) { /* configuration */ g_edit_globals.max_line_size = EDIT_LIMIT_MAX_LINE_SIZE; /* loading a document */ g_edit_globals.doc = edit_doc_open("/Users/josh/Desktop/test.txt"); /* editor setup */ edit_view_create(); /* debugging */ doc_debug(g_edit_globals.doc); mem_check(); }
int ipv6_flowlabel_opt(struct sock *sk, char __user *optval, int optlen) { int uninitialized_var(err); struct net *net = sock_net(sk); struct ipv6_pinfo *np = inet6_sk(sk); struct in6_flowlabel_req freq; struct ipv6_fl_socklist *sfl1=NULL; struct ipv6_fl_socklist *sfl, **sflp; struct ip6_flowlabel *fl, *fl1 = NULL; if (optlen < sizeof(freq)) return -EINVAL; if (copy_from_user(&freq, optval, sizeof(freq))) return -EFAULT; switch (freq.flr_action) { case IPV6_FL_A_PUT: write_lock_bh(&ip6_sk_fl_lock); for (sflp = &np->ipv6_fl_list; (sfl=*sflp)!=NULL; sflp = &sfl->next) { if (sfl->fl->label == freq.flr_label) { if (freq.flr_label == (np->flow_label&IPV6_FLOWLABEL_MASK)) np->flow_label &= ~IPV6_FLOWLABEL_MASK; *sflp = sfl->next; write_unlock_bh(&ip6_sk_fl_lock); fl_release(sfl->fl); kfree(sfl); return 0; } } write_unlock_bh(&ip6_sk_fl_lock); return -ESRCH; case IPV6_FL_A_RENEW: read_lock_bh(&ip6_sk_fl_lock); for (sfl = np->ipv6_fl_list; sfl; sfl = sfl->next) { if (sfl->fl->label == freq.flr_label) { err = fl6_renew(sfl->fl, freq.flr_linger, freq.flr_expires); read_unlock_bh(&ip6_sk_fl_lock); return err; } } read_unlock_bh(&ip6_sk_fl_lock); if (freq.flr_share == IPV6_FL_S_NONE && capable(CAP_NET_ADMIN)) { fl = fl_lookup(net, freq.flr_label); if (fl) { err = fl6_renew(fl, freq.flr_linger, freq.flr_expires); fl_release(fl); return err; } } return -ESRCH; case IPV6_FL_A_GET: if (freq.flr_label & ~IPV6_FLOWLABEL_MASK) return -EINVAL; fl = fl_create(net, sk, &freq, optval, optlen, &err); if (fl == NULL) return err; sfl1 = kmalloc(sizeof(*sfl1), GFP_KERNEL); if (freq.flr_label) { err = -EEXIST; read_lock_bh(&ip6_sk_fl_lock); for (sfl = np->ipv6_fl_list; sfl; sfl = sfl->next) { if (sfl->fl->label == freq.flr_label) { if (freq.flr_flags&IPV6_FL_F_EXCL) { read_unlock_bh(&ip6_sk_fl_lock); goto done; } fl1 = sfl->fl; atomic_inc(&fl1->users); break; } } read_unlock_bh(&ip6_sk_fl_lock); if (fl1 == NULL) fl1 = fl_lookup(net, freq.flr_label); if (fl1) { recheck: err = -EEXIST; if (freq.flr_flags&IPV6_FL_F_EXCL) goto release; err = -EPERM; if (fl1->share == IPV6_FL_S_EXCL || fl1->share != fl->share || fl1->owner != fl->owner) goto release; err = -EINVAL; if (!ipv6_addr_equal(&fl1->dst, &fl->dst) || ipv6_opt_cmp(fl1->opt, fl->opt)) goto release; err = -ENOMEM; if (sfl1 == NULL) goto release; if (fl->linger > fl1->linger) fl1->linger = fl->linger; if ((long)(fl->expires - fl1->expires) > 0) fl1->expires = fl->expires; fl_link(np, sfl1, fl1); fl_free(fl); return 0; release: fl_release(fl1); goto done; } } err = -ENOENT; if (!(freq.flr_flags&IPV6_FL_F_CREATE)) goto done; err = -ENOMEM; if (sfl1 == NULL || (err = mem_check(sk)) != 0) goto done; fl1 = fl_intern(net, fl, freq.flr_label); if (fl1 != NULL) goto recheck; if (!freq.flr_label) { if (copy_to_user(&((struct in6_flowlabel_req __user *) optval)->flr_label, &fl->label, sizeof(fl->label))) { /* Intentionally ignore fault. */ } } fl_link(np, sfl1, fl); return 0; default: return -EINVAL; } done: fl_free(fl); kfree(sfl1); return err; }
void mem_init(void) { if (!cpu_onboot()) // only do once, on the boot CPU return; // Determine how much base (<640K) and extended (>1MB) memory // is available in the system (in bytes), // by reading the PC's BIOS-managed nonvolatile RAM (NVRAM). // The NVRAM tells us how many kilobytes there are. // Since the count is 16 bits, this gives us up to 64MB of RAM; // additional RAM beyond that would have to be detected another way. size_t basemem = ROUNDDOWN(nvram_read16(NVRAM_BASELO)*1024, PAGESIZE); size_t extmem = ROUNDDOWN(nvram_read16(NVRAM_EXTLO)*1024, PAGESIZE); warn("Assuming we have 1GB of memory!"); extmem = 1024*1024*1024 - MEM_EXT; // assume 1GB total memory // The maximum physical address is the top of extended memory. mem_max = MEM_EXT + extmem; // Compute the total number of physical pages (including I/O holes) mem_npage = mem_max / PAGESIZE; cprintf("Physical memory: %dK available, ", (int)(mem_max/1024)); cprintf("base = %dK, extended = %dK\n", (int)(basemem/1024), (int)(extmem/1024)); // Insert code here to: // (1) allocate physical memory for the mem_pageinfo array, // making it big enough to hold mem_npage entries. // (2) add all pageinfo structs in the array representing // available memory that is not in use for other purposes. // // For step (2), here is some incomplete/incorrect example code // that simply marks all mem_npage pages as free. // Which memory is actually free? // 1) Reserve page 0 for the real-mode IDT and BIOS structures // (do not allow this page to be used for anything else). // 2) Reserve page 1 for the AP bootstrap code (boot/bootother.S). // 3) Mark the rest of base memory as free. // 4) Then comes the IO hole [MEM_IO, MEM_EXT). // Mark it as in-use so that it can never be allocated. // 5) Then extended memory [MEM_EXT, ...). // Some of it is in use, some is free. // Which pages hold the kernel and the pageinfo array? // Hint: the linker places the kernel (see start and end above), // but YOU decide where to place the pageinfo array. // Change the code to reflect this. pageinfo **freetail = &mem_freelist; int i; for (i = 0; i < mem_npage; i++) { // A free page has no references to it. mem_pageinfo[i].refcount = 0; // Add the page to the end of the free list. *freetail = &mem_pageinfo[i]; freetail = &mem_pageinfo[i].free_next; } *freetail = NULL; // null-terminate the freelist // ...and remove this when you're ready. panic("mem_init() not implemented"); // Check to make sure the page allocator seems to work correctly. mem_check(); }
//Create new variable menu. int create_var_menu(Variable *varArry, int *arrySize, int arrySpot){ String type = (String)malloc(ARRAYLENGHT * sizeof (char)); String name = (String)malloc(ARRAYLENGHT * sizeof (char)); int flag; //Check if memory allocated properly. mem_check(type); mem_check(name); //Get the variable's type do{ //User interaction. printf("%s", "\n\nGive the variable's type. Valid types are Integer, Decimal, String and Bool. To go back type <:"); fgets(type, ARRAYLENGHT, stdin); flag = false; if (type[strlen(type) - 1] == '\n' && strlen(type) > 1){ type[strcspn(type, "\n")] = 0; //Drop the \n from fgets input strtolower(type); //Convert the string to lowercase for ease of use. //Check for back input if (!strcmp(type, "<")){ return false; } //Check for valid input. if (strcmp(type, "integer") && strcmp(type, "decimal") && strcmp(type, "string") && strcmp(type, "bool")){ printf("%s", "\n\nInvalid type!\n\n"); } } else{ flag = true; printf("%s", "\n\nInvalid lenght. It must be between 1 and 255 characters!\n\n"); if (strlen(type) > 1) clear_stdin(); //Clear stdin from extra input } } while (strcmp(type, "integer") && strcmp(type, "decimal") && strcmp(type, "string") && strcmp(type, "bool") || flag); //Loop until user decides to cooperate. //Get the variable's name. do{ //User interaction. printf("%s", "\n\nGive a name for the variable. The max lenght is 255 characters. It can't contain whitespaces or symbols, except underscores (_):"); fgets(name, ARRAYLENGHT, stdin); flag = false; //Check for valid lenght if (name[strlen(name) - 1] == '\n' && strlen(name) > 2){ name[strcspn(name, "\n")] = 0; //Drop the \n from fgets input. //Check for valid input if (strpbrk(name, " !@#$%^&*()-+=\\|[]{};\':\",./<>?") != NULL){ printf("%s", "\n\nInvalid name!\n\n"); } else if (var_exist(varArry, name, *arrySize)){ printf("%s", "\n\nA variable with that name already exists!\n\n"); } } else{ flag = true; printf("%s", "\n\nInvalid lenght. It must be between 1 and 255 characters!\n\n"); if (strlen(name) > 1) clear_stdin(); //Clear stdin from extra input } } while (flag || strpbrk(name, " `~!@#$%^&*()-+=\\|[]{};\':\",./<>?") != NULL || var_exist(varArry, name, *arrySize)); //Loop until valid. //Copy the name and the type in the variables struct array. strcpy(varArry[arrySpot].type, type); strcpy(varArry[arrySpot].name, name); //Free the memory we don't need anymore. free(name); free(type); //Run the function corresponding to the entered type. if (!strcmp(varArry[arrySpot].type, "integer")){ set_var_int(varArry, arrySpot); } else if (!strcmp(varArry[arrySpot].type, "decimal")){ set_var_decimal(varArry, arrySpot); } else if (!strcmp(varArry[arrySpot].type, "string")){ //Loop until the lenght is correct. do{ //User interaction. For strings we don't need any valid input checks. printf("%s", "\n\nGive the variables value (String, 255 characters max):"); fgets(varArry[arrySpot].value, ARRAYLENGHT, stdin); flag = false; if (varArry[arrySpot].value[strlen(varArry[arrySpot].value) - 1] == '\n') varArry[arrySpot].value[strcspn(varArry[arrySpot].value, "\n")] = 0; //Drop the \n from fgets input. else{ flag = true; printf("%s", "\n\nInvalid lenght. It must be between 1 and 255 characters!\n\n"); clear_stdin(); //Clear stdin from extra input } } while (flag); } else{ set_var_bool(varArry, arrySpot); } return true; }
void createProcess(struct Process* process, EntryPoint entryPoint, struct Process* parent, char* args, int terminal, int kernel) { process->pid = ++pid; process->kernel = !!kernel; process->terminal = terminal; process->active = 0; process->parent = parent; process->firstChild = NULL; process->cycles = 0; process->curr_cycles = 0; process->prev_cycles = 0; process->timeStart = _time(NULL); process->uid = 0; process->gid = 0; if (parent != NULL) { process->uid = parent->uid; process->gid = parent->gid; } process->prev = NULL; if (parent == NULL) { process->ppid = 0; process->next = NULL; process->cwd = kalloc(2 * sizeof(char)); strcpy(process->cwd, "/"); } else { process->ppid = parent->pid; process->next = parent->firstChild; if (parent->firstChild) { parent->firstChild->prev = process; } parent->firstChild = process; process->cwd = kalloc(strlen(parent->cwd) + 1); strcpy(process->cwd, parent->cwd); } process->entryPoint = entryPoint; if (args == NULL) { process->args[0] = 0; } else { int i; for (i = 0; *(args + i) && i < ARGV_SIZE - 1; i++) { process->args[i] = args[i]; } process->args[i] = 0; } process->schedule.priority = 2; process->schedule.status = StatusReady; process->schedule.inWait = 0; process->schedule.ioWait = 0; process->schedule.done = 0; for (size_t i = 0; i < MAX_OPEN_FILES; i++) { if (parent && parent->fdTable[i].inode) { fs_dup(&process->fdTable[i], parent->fdTable[i]); } else { process->fdTable[i].inode = NULL; } } { process->mm.pagesInKernelStack = KERNEL_STACK_PAGES; struct Pages* mem = reserve_pages(process, process->mm.pagesInKernelStack); assert(mem != NULL); process->mm.esp0 = (char*)mem->start + PAGE_SIZE * process->mm.pagesInKernelStack; process->mm.kernelStack = process->mm.esp0; } if (kernel) { process->mm.pagesInHeap = 0; process->mm.mallocContext = NULL; } else { process->mm.pagesInHeap = 256; struct Pages* mem = reserve_pages(process, process->mm.pagesInHeap); assert(mem != NULL); process->mm.mallocContext = mm_create_context(mem->start, process->mm.pagesInHeap * PAGE_SIZE); mem_check(); } if (!kernel) { process->mm.pagesInStack = 16; struct Pages* mem = reserve_pages(process, process->mm.pagesInStack); assert(mem != NULL); process->mm.esp = (char*)mem->start + PAGE_SIZE * process->mm.pagesInStack; } else { process->mm.pagesInStack = 0; process->mm.esp = NULL; } setup_page_directory(process, kernel); if (!kernel) { struct Pages* ungetPage = reserve_pages(process, 1); assert(ungetPage != NULL); mm_pagination_map(process, (unsigned int)ungetPage->start, (unsigned int)STACK_TOP_MAPPING, 1, 1, 1); FILE* files; for (int i = 0; i < 3; i++) { files = ungetPage->start + i * sizeof(FILE); files->fd = i; files->flag = 0; files->unget = 0; } } int codeSegment, dataSegment; if (kernel) { codeSegment = KERNEL_CODE_SEGMENT; dataSegment = KERNEL_DATA_SEGMENT; char* esp0 = (char*) process->mm.esp0 - ARGV_SIZE; for (size_t i = 0; i < ARGV_SIZE; i++) { esp0[i] = process->args[i]; } process->mm.esp0 = esp0; push((unsigned int**) &process->mm.esp0, (unsigned int) process->mm.esp0); push((unsigned int**) &process->mm.esp0, (unsigned int) exit); push((unsigned int**) &process->mm.esp0, 0x202); } else { codeSegment = USER_CODE_SEGMENT; dataSegment = USER_DATA_SEGMENT; char* esp = (char*) process->mm.esp - ARGV_SIZE; for (size_t i = 0; i < ARGV_SIZE; i++) { esp[i] = process->args[i]; } process->mm.esp = esp; push((unsigned int**) &process->mm.esp, STACK_TOP_MAPPING - ARGV_SIZE); push((unsigned int**) &process->mm.esp, (unsigned int) exit); push((unsigned int**) &process->mm.esp0, dataSegment); push((unsigned int**) &process->mm.esp0, STACK_TOP_MAPPING - 2 * sizeof(int) - ARGV_SIZE); push((unsigned int**) &process->mm.esp0, 0x3202); } push((unsigned int**) &process->mm.esp0, codeSegment); push((unsigned int**) &process->mm.esp0, (unsigned int) entryPoint); push((unsigned int**) &process->mm.esp0, dataSegment); push((unsigned int**) &process->mm.esp0, dataSegment); push((unsigned int**) &process->mm.esp0, dataSegment); push((unsigned int**) &process->mm.esp0, dataSegment); push((unsigned int**) &process->mm.esp0, (unsigned int) _interruptEnd); push((unsigned int**) &process->mm.esp0, (unsigned int) signalPIC); push((unsigned int**) &process->mm.esp0, 0); }
void jpeg_decode (byte *data, int size, byte *dest, int line_bytes, int bpp, int max_width, int max_height) { struct jpeg_decompress_struct cinfo; JSAMPARRAY buffer;/* Output row buffer */ jpeg_source_info source; int tile_bytes; struct my_error_mgr jerr; jpeg_create_decompress(&cinfo); cinfo.err = jpeg_std_error(&jerr.mgr); cinfo.src = &source.pub; // source.max = max; // source.chunk = chunk; source.data = data; source.size = size; source.done = FALSE; // source.pos = pos; source.pub.init_source = init_source; source.pub.fill_input_buffer = fill_input_buffer; source.pub.skip_input_data = skip_input_data; source.pub.resync_to_restart = jpeg_resync_to_restart;/* use default method */ source.pub.term_source = term_source; source.pub.bytes_in_buffer = 0; /* forces fill_input_buffer on first read */ source.pub.next_input_byte = NULL;/* until buffer loaded */ cinfo.err = jpeg_std_error(&jerr.mgr); jerr.err = 0; jerr.mgr.error_exit = my_error_exit; if (!setjmp(jerr.setjmp_buffer)) { jpeg_read_header(&cinfo, TRUE); jpeg_start_decompress(&cinfo); /* Make a one-row-high sample array that will go away when done with image */ tile_bytes = cinfo.output_width * cinfo.output_components; buffer = (*cinfo.mem->alloc_sarray) ((j_common_ptr) &cinfo, JPOOL_IMAGE, tile_bytes, 1); // printf ("width = %d, tile_bytes = %d, line_bytes = %d\n", // cinfo.output_width, tile_bytes, line_bytes); while (cinfo.output_scanline < cinfo.output_height && cinfo.output_scanline < max_height) { jpeg_read_scanlines(&cinfo, buffer, 1); if (cinfo.output_components == 3 && bpp == 32) { byte *in; u_int32_t *out; int i; mem_check (); in = (byte *)buffer [0]; i = cinfo.output_width; if (max_width != -1 && i > max_width) i = max_width; for (out = (u_int32_t *)dest; i != 0; i--, in += 3) *out++ = in [2] | (in [1] << 8) | (in [0] << 16); mem_check (); } else memcpy (dest, buffer[0], tile_bytes); dest += line_bytes; } // debug1 (("width = %d, tile_bytes = %d, line_bytes = %d, decoded %d lines\n", // cinfo.output_width, tile_bytes, line_bytes, cinfo.output_height)); jpeg_finish_decompress(&cinfo); } jpeg_destroy_decompress(&cinfo); if (jerr.err) printf ("error = %d\n", jerr.err); }
int main(int argc, char * argv[]) { int policy; /* replacement policy */ int current; /* current page accessed */ FILE * fp; /* The file containing the page accesses */ FILE * rp; /* output file */ char filename[30]={""}; const char * extension[] ={".fifo", ".lru", "new"}; float num_accesses = 0.0; /* total number of page accesses */ float page_faults = 0.0; unsigned victim = 0; /* page to be replaced */ /* Getting and checking the input from the command line */ if(argc != 4) { printf("usage: pager policy size filename\n"); exit(1); } policy = atoi(argv[1]); mem_size = atoi(argv[2]); if( policy < 0 || policy > 2) { printf("policy must be 0, 1, or 2\n"); exit(1); } if(mem_size <= 0 ) { printf("Size must be a positive integer.\n"); exit(1); } /* Allocate and initialize the memory */ mem = (int *)calloc(mem_size, sizeof(int)); if(!mem) { printf("Cannot allocate mem\n"); exit(1); } /* open the memory access file */ fp = fopen(argv[3], "r"); if(!fp) { printf("Cannot open file %s\n", argv[3]); exit(1); } /* Create the output file */ strcat(filename, argv[3]); strcat(filename,extension[policy]); rp = fopen(filename, "w"); if(!rp) { printf("Cannot create file %s\n", filename); exit(1); } /* The main loop of the program */ fscanf(fp,"%d", ¤t); while(!feof(fp)) { num_accesses++; if(mem_check(current) == PAGEMISS) page_faults++; switch(policy) { case 0: if( IsFull()) { victim = fifo(); mem[victim] = current; } else insert(current); break; case 1: if( IsFull()) { victim = lru(); mem[victim] = current; } else insert(current); break; case 2: if( IsFull()) { victim = own(); mem[victim] = current; } else insert(current); break; default: printf("Unknown policy ... Exiting\n"); exit(1); }/* end switch-case */ print_mem(rp); fscanf(fp,"%d", ¤t); }/* end while */ fprintf(rp,"percentage of page faults = %f", page_faults/num_accesses); /* wrap-up */ fclose(fp); fclose(rp); free(mem); return 1; }
int ipv6_flowlabel_opt(struct sock *sk, char __user *optval, int optlen) { int uninitialized_var(err); struct net *net = sock_net(sk); struct ipv6_pinfo *np = inet6_sk(sk); struct in6_flowlabel_req freq; struct ipv6_fl_socklist *sfl1 = NULL; struct ipv6_fl_socklist *sfl; struct ipv6_fl_socklist __rcu **sflp; struct ip6_flowlabel *fl, *fl1 = NULL; if (optlen < sizeof(freq)) return -EINVAL; if (copy_from_user(&freq, optval, sizeof(freq))) return -EFAULT; switch (freq.flr_action) { case IPV6_FL_A_PUT: if (freq.flr_flags & IPV6_FL_F_REFLECT) { if (sk->sk_protocol != IPPROTO_TCP) return -ENOPROTOOPT; if (!np->repflow) return -ESRCH; np->flow_label = 0; np->repflow = 0; return 0; } spin_lock_bh(&ip6_sk_fl_lock); for (sflp = &np->ipv6_fl_list; (sfl = rcu_dereference(*sflp)) != NULL; sflp = &sfl->next) { if (sfl->fl->label == freq.flr_label) { if (freq.flr_label == (np->flow_label&IPV6_FLOWLABEL_MASK)) np->flow_label &= ~IPV6_FLOWLABEL_MASK; *sflp = rcu_dereference(sfl->next); spin_unlock_bh(&ip6_sk_fl_lock); fl_release(sfl->fl); kfree_rcu(sfl, rcu); return 0; } } spin_unlock_bh(&ip6_sk_fl_lock); return -ESRCH; case IPV6_FL_A_RENEW: rcu_read_lock_bh(); for_each_sk_fl_rcu(np, sfl) { if (sfl->fl->label == freq.flr_label) { err = fl6_renew(sfl->fl, freq.flr_linger, freq.flr_expires); rcu_read_unlock_bh(); return err; } } rcu_read_unlock_bh(); if (freq.flr_share == IPV6_FL_S_NONE && ns_capable(net->user_ns, CAP_NET_ADMIN)) { fl = fl_lookup(net, freq.flr_label); if (fl) { err = fl6_renew(fl, freq.flr_linger, freq.flr_expires); fl_release(fl); return err; } } return -ESRCH; case IPV6_FL_A_GET: if (freq.flr_flags & IPV6_FL_F_REFLECT) { struct net *net = sock_net(sk); if (net->ipv6.sysctl.flowlabel_consistency) { net_info_ratelimited("Can not set IPV6_FL_F_REFLECT if flowlabel_consistency sysctl is enable\n"); return -EPERM; } if (sk->sk_protocol != IPPROTO_TCP) return -ENOPROTOOPT; np->repflow = 1; return 0; } if (freq.flr_label & ~IPV6_FLOWLABEL_MASK) return -EINVAL; fl = fl_create(net, sk, &freq, optval, optlen, &err); if (!fl) return err; sfl1 = kmalloc(sizeof(*sfl1), GFP_KERNEL); if (freq.flr_label) { err = -EEXIST; rcu_read_lock_bh(); for_each_sk_fl_rcu(np, sfl) { if (sfl->fl->label == freq.flr_label) { if (freq.flr_flags&IPV6_FL_F_EXCL) { rcu_read_unlock_bh(); goto done; } fl1 = sfl->fl; atomic_inc(&fl1->users); break; } } rcu_read_unlock_bh(); if (!fl1) fl1 = fl_lookup(net, freq.flr_label); if (fl1) { recheck: err = -EEXIST; if (freq.flr_flags&IPV6_FL_F_EXCL) goto release; err = -EPERM; if (fl1->share == IPV6_FL_S_EXCL || fl1->share != fl->share || ((fl1->share == IPV6_FL_S_PROCESS) && (fl1->owner.pid == fl->owner.pid)) || ((fl1->share == IPV6_FL_S_USER) && uid_eq(fl1->owner.uid, fl->owner.uid))) goto release; err = -ENOMEM; if (!sfl1) goto release; if (fl->linger > fl1->linger) fl1->linger = fl->linger; if ((long)(fl->expires - fl1->expires) > 0) fl1->expires = fl->expires; fl_link(np, sfl1, fl1); fl_free(fl); return 0; release: fl_release(fl1); goto done; } } err = -ENOENT; if (!(freq.flr_flags&IPV6_FL_F_CREATE)) goto done; err = -ENOMEM; if (!sfl1) goto done; err = mem_check(sk); if (err != 0) goto done; fl1 = fl_intern(net, fl, freq.flr_label); if (fl1) goto recheck; if (!freq.flr_label) { if (copy_to_user(&((struct in6_flowlabel_req __user *) optval)->flr_label, &fl->label, sizeof(fl->label))) { /* Intentionally ignore fault. */ } } fl_link(np, sfl1, fl); return 0; default: return -EINVAL; }