/* Render a character. */ static int x_render_char(gx_xfont * xf, gx_xglyph xg, gx_device * dev, int xo, int yo, gx_color_index color, int required) { x_xfont *xxf = (x_xfont *) xf; char chr = (char)xg; gs_point wxy; gs_int_rect bbox; int x, y, w, h; int code; if (dev->dname == gs_x11_device.dname && !((gx_device_X *)dev)->is_buffered) { gx_device_X *xdev = (gx_device_X *)dev; code = (*xf->common.procs->char_metrics) (xf, xg, 0, &wxy, &bbox); if (code < 0) return code; /* Buffer text for more efficient X interaction. */ if (xdev->text.item_count == MAX_TEXT_ITEMS || xdev->text.char_count == MAX_TEXT_CHARS || (IN_TEXT(xdev) && (yo != xdev->text.origin.y || color != xdev->fore_color || xxf->font->fid != xdev->fid)) ) { DRAW_TEXT(xdev); xdev->text.item_count = xdev->text.char_count = 0; } if (xdev->text.item_count == 0) { X_SET_FILL_STYLE(xdev, FillSolid); X_SET_FORE_COLOR(xdev, color); X_SET_FUNCTION(xdev, GXcopy); xdev->text.origin.x = xdev->text.x = xo; xdev->text.origin.y = yo; xdev->text.items[0].font = xdev->fid = xxf->font->fid; } /* * The following is wrong for rotated text, but it doesn't matter, * because the next call of x_render_char will have a different Y. */ { int index = xdev->text.item_count; XTextItem *item = &xdev->text.items[index]; char *pchar = &xdev->text.chars[xdev->text.char_count++]; int delta = xo - xdev->text.x; *pchar = chr; if (index > 0 && delta == 0) { /* Continue the same item. */ item[-1].nchars++; } else { /* Start a new item. */ item->chars = pchar; item->nchars = 1; item->delta = delta; if (index > 0) item->font = None; xdev->text.item_count++; } xdev->text.x = xo + wxy.x; } if (xdev->bpixmap != (Pixmap) 0) { x = xo + bbox.p.x; y = yo + bbox.p.y; w = bbox.q.x - bbox.p.x; h = bbox.q.y - bbox.p.y; fit_fill(dev, x, y, w, h); x_update_add(xdev, x, y, w, h); } return 0; } else if (!required) return -1; /* too hard */ else { /* Display on an intermediate bitmap, then copy the bits. */ gx_device_X *xdev = xxf->xdev; int wbm, raster; int i; XImage *xim; Pixmap xpm; GC fgc; byte *bits; dev_proc_copy_mono((*copy_mono)) = dev_proc(dev, copy_mono); code = (*xf->common.procs->char_metrics) (xf, xg, 0, &wxy, &bbox); if (code < 0) return code; w = bbox.q.x - bbox.p.x; h = bbox.q.y - bbox.p.y; wbm = ROUND_UP(w, align_bitmap_mod * 8); raster = wbm >> 3; bits = (byte *) gs_malloc(xdev->memory, h, raster, "x_render_char"); if (bits == 0) return gs_error_limitcheck; xpm = XCreatePixmap(xdev->dpy, xdev->win, w, h, 1); fgc = XCreateGC(xdev->dpy, xpm, None, NULL); XSetForeground(xdev->dpy, fgc, 0); XFillRectangle(xdev->dpy, xpm, fgc, 0, 0, w, h); XSetForeground(xdev->dpy, fgc, 1); XSetFont(xdev->dpy, fgc, xxf->font->fid); XDrawString(xdev->dpy, xpm, fgc, -bbox.p.x, -bbox.p.y, &chr, 1); xim = XGetImage(xdev->dpy, xpm, 0, 0, w, h, 1, ZPixmap); i = 0; for (y = 0; y < h; y++) { char b = 0; for (x = 0; x < wbm; x++) { b = b << 1; if (x < w) b += XGetPixel(xim, x, y); if ((x & 7) == 7) bits[i++] = b; } } code = (*copy_mono) (dev, bits, 0, raster, gx_no_bitmap_id, xo + bbox.p.x, yo + bbox.p.y, w, h, gx_no_color_index, color); gs_free(xdev->memory, (char *)bits, h, raster, "x_render_char"); XFreePixmap(xdev->dpy, xpm); XFreeGC(xdev->dpy, fgc); XDestroyImage(xim); return (code < 0 ? code : 0); } }
void op_x86_res_calc( int blockIdx, float *ind_arg0, int *ind_arg0_maps, float *ind_arg1, int *ind_arg1_maps, float *ind_arg2, int *ind_arg2_maps, float *ind_arg3, int *ind_arg3_maps, short *arg0_maps, short *arg1_maps, short *arg2_maps, short *arg3_maps, short *arg4_maps, short *arg5_maps, short *arg6_maps, short *arg7_maps, int *ind_arg_sizes, int *ind_arg_offs, int block_offset, int *blkmap, int *offset, int *nelems, int *ncolors, int *colors) { float arg6_l[4]; float arg7_l[4]; int *ind_arg0_map, ind_arg0_size; int *ind_arg1_map, ind_arg1_size; int *ind_arg2_map, ind_arg2_size; int *ind_arg3_map, ind_arg3_size; float *ind_arg0_s; float *ind_arg1_s; float *ind_arg2_s; float *ind_arg3_s; int nelems2, ncolor; int nelem, offset_b; char shared[64000]; if (0==0) { // get sizes and shift pointers and direct-mapped data int blockId = blkmap[blockIdx + block_offset]; nelem = nelems[blockId]; offset_b = offset[blockId]; nelems2 = nelem; ncolor = ncolors[blockId]; ind_arg0_size = ind_arg_sizes[0+blockId*4]; ind_arg1_size = ind_arg_sizes[1+blockId*4]; ind_arg2_size = ind_arg_sizes[2+blockId*4]; ind_arg3_size = ind_arg_sizes[3+blockId*4]; ind_arg0_map = ind_arg0_maps + ind_arg_offs[0+blockId*4]; ind_arg1_map = ind_arg1_maps + ind_arg_offs[1+blockId*4]; ind_arg2_map = ind_arg2_maps + ind_arg_offs[2+blockId*4]; ind_arg3_map = ind_arg3_maps + ind_arg_offs[3+blockId*4]; // set shared memory pointers int nbytes = 0; ind_arg0_s = (float *) &shared[nbytes]; nbytes += ROUND_UP(ind_arg0_size*sizeof(float)*2); ind_arg1_s = (float *) &shared[nbytes]; nbytes += ROUND_UP(ind_arg1_size*sizeof(float)*4); ind_arg2_s = (float *) &shared[nbytes]; nbytes += ROUND_UP(ind_arg2_size*sizeof(float)*1); ind_arg3_s = (float *) &shared[nbytes]; } __syncthreads(); // make sure all of above completed // copy indirect datasets into shared memory or zero increment for (int n=0; n<ind_arg0_size; n++) for (int d=0; d<2; d++) ind_arg0_s[d+n*2] = ind_arg0[d+ind_arg0_map[n]*2]; for (int n=0; n<ind_arg1_size; n++) for (int d=0; d<4; d++) ind_arg1_s[d+n*4] = ind_arg1[d+ind_arg1_map[n]*4]; for (int n=0; n<ind_arg2_size; n++) for (int d=0; d<1; d++) ind_arg2_s[d+n*1] = ind_arg2[d+ind_arg2_map[n]*1]; for (int n=0; n<ind_arg3_size; n++) for (int d=0; d<4; d++) ind_arg3_s[d+n*4] = ZERO_float; __syncthreads(); // process set elements for (int n=0; n<nelems2; n++) { int col2 = -1; if (n<nelem) { // initialise local variables for (int d=0; d<4; d++) arg6_l[d] = ZERO_float; for (int d=0; d<4; d++) arg7_l[d] = ZERO_float; // user-supplied kernel call res_calc( ind_arg0_s+arg0_maps[n+offset_b]*2, ind_arg0_s+arg1_maps[n+offset_b]*2, ind_arg1_s+arg2_maps[n+offset_b]*4, ind_arg1_s+arg3_maps[n+offset_b]*4, ind_arg2_s+arg4_maps[n+offset_b]*1, ind_arg2_s+arg5_maps[n+offset_b]*1, arg6_l, arg7_l ); col2 = colors[n+offset_b]; } // store local variables int arg6_map = arg6_maps[n+offset_b]; int arg7_map = arg7_maps[n+offset_b]; for (int col=0; col<ncolor; col++) { if (col2==col) { for (int d=0; d<4; d++) ind_arg3_s[d+arg6_map*4] += arg6_l[d]; for (int d=0; d<4; d++) ind_arg3_s[d+arg7_map*4] += arg7_l[d]; } __syncthreads(); } } // apply pointered write/increment for (int n=0; n<ind_arg3_size; n++) for (int d=0; d<4; d++) ind_arg3[d+ind_arg3_map[n]*4] += ind_arg3_s[d+n*4]; }
// host stub function void ops_par_loop_update_halo_kernel3_minus_2_a(char const *name, ops_block block, int dim, int* range, ops_arg arg0, ops_arg arg1, ops_arg arg2) { ops_arg args[3] = { arg0, arg1, arg2}; ops_timing_realloc(94,"update_halo_kernel3_minus_2_a"); OPS_kernels[94].count++; //compute locally allocated range for the sub-block int start[3]; int end[3]; #ifdef OPS_MPI sub_block_list sb = OPS_sub_block_list[block->index]; if (!sb->owned) return; for ( int n=0; n<3; n++ ){ start[n] = sb->decomp_disp[n];end[n] = sb->decomp_disp[n]+sb->decomp_size[n]; if (start[n] >= range[2*n]) { start[n] = 0; } else { start[n] = range[2*n] - start[n]; } if (sb->id_m[n]==MPI_PROC_NULL && range[2*n] < 0) start[n] = range[2*n]; if (end[n] >= range[2*n+1]) { end[n] = range[2*n+1] - sb->decomp_disp[n]; } else { end[n] = sb->decomp_size[n]; } if (sb->id_p[n]==MPI_PROC_NULL && (range[2*n+1] > sb->decomp_disp[n]+sb->decomp_size[n])) end[n] += (range[2*n+1]-sb->decomp_disp[n]-sb->decomp_size[n]); } #else //OPS_MPI for ( int n=0; n<3; n++ ){ start[n] = range[2*n];end[n] = range[2*n+1]; } #endif //OPS_MPI int x_size = MAX(0,end[0]-start[0]); int y_size = MAX(0,end[1]-start[1]); int z_size = MAX(0,end[2]-start[2]); int xdim0 = args[0].dat->size[0]*args[0].dat->dim; int ydim0 = args[0].dat->size[1]; int xdim1 = args[1].dat->size[0]*args[1].dat->dim; int ydim1 = args[1].dat->size[1]; //build opencl kernel if not already built buildOpenCLKernels_update_halo_kernel3_minus_2_a( xdim0,ydim0,xdim1,ydim1); //Timing double t1,t2,c1,c2; ops_timers_core(&c2,&t2); //set up OpenCL thread blocks size_t globalWorkSize[3] = {((x_size-1)/OPS_block_size_x+ 1)*OPS_block_size_x, ((y_size-1)/OPS_block_size_y + 1)*OPS_block_size_y, MAX(1,end[2]-start[2])}; size_t localWorkSize[3] = {OPS_block_size_x,OPS_block_size_y,1}; int *arg2h = (int *)arg2.data; int consts_bytes = 0; consts_bytes += ROUND_UP(NUM_FIELDS*sizeof(int)); reallocConstArrays(consts_bytes); consts_bytes = 0; arg2.data = OPS_consts_h + consts_bytes; arg2.data_d = OPS_consts_d + consts_bytes; for (int d=0; d<NUM_FIELDS; d++) ((int *)arg2.data)[d] = arg2h[d]; consts_bytes += ROUND_UP(NUM_FIELDS*sizeof(int)); mvConstArraysToDevice(consts_bytes); int dat0 = args[0].dat->elem_size; int dat1 = args[1].dat->elem_size; //set up initial pointers int d_m[OPS_MAX_DIM]; #ifdef OPS_MPI for (int d = 0; d < dim; d++) d_m[d] = args[0].dat->d_m[d] + OPS_sub_dat_list[args[0].dat->index]->d_im[d]; #else //OPS_MPI for (int d = 0; d < dim; d++) d_m[d] = args[0].dat->d_m[d]; #endif //OPS_MPI int base0 = 1 * (start[0] * args[0].stencil->stride[0] - args[0].dat->base[0] - d_m[0]); base0 = base0 + args[0].dat->size[0] * (start[1] * args[0].stencil->stride[1] - args[0].dat->base[1] - d_m[1]); base0 = base0 + args[0].dat->size[0] * args[0].dat->size[1] * (start[2] * args[0].stencil->stride[2] - args[0].dat->base[2] - d_m[2]); #ifdef OPS_MPI for (int d = 0; d < dim; d++) d_m[d] = args[1].dat->d_m[d] + OPS_sub_dat_list[args[1].dat->index]->d_im[d]; #else //OPS_MPI for (int d = 0; d < dim; d++) d_m[d] = args[1].dat->d_m[d]; #endif //OPS_MPI int base1 = 1 * (start[0] * args[1].stencil->stride[0] - args[1].dat->base[0] - d_m[0]); base1 = base1 + args[1].dat->size[0] * (start[1] * args[1].stencil->stride[1] - args[1].dat->base[1] - d_m[1]); base1 = base1 + args[1].dat->size[0] * args[1].dat->size[1] * (start[2] * args[1].stencil->stride[2] - args[1].dat->base[2] - d_m[2]); ops_H_D_exchanges_device(args, 3); ops_halo_exchanges(args,3,range); ops_H_D_exchanges_device(args, 3); ops_timers_core(&c1,&t1); OPS_kernels[94].mpi_time += t1-t2; clSafeCall( clSetKernelArg(OPS_opencl_core.kernel[94], 0, sizeof(cl_mem), (void*) &arg0.data_d )); clSafeCall( clSetKernelArg(OPS_opencl_core.kernel[94], 1, sizeof(cl_mem), (void*) &arg1.data_d )); clSafeCall( clSetKernelArg(OPS_opencl_core.kernel[94], 2, sizeof(cl_mem), (void*) &arg2.data_d )); clSafeCall( clSetKernelArg(OPS_opencl_core.kernel[94], 3, sizeof(cl_int), (void*) &base0 )); clSafeCall( clSetKernelArg(OPS_opencl_core.kernel[94], 4, sizeof(cl_int), (void*) &base1 )); clSafeCall( clSetKernelArg(OPS_opencl_core.kernel[94], 5, sizeof(cl_int), (void*) &x_size )); clSafeCall( clSetKernelArg(OPS_opencl_core.kernel[94], 6, sizeof(cl_int), (void*) &y_size )); clSafeCall( clSetKernelArg(OPS_opencl_core.kernel[94], 7, sizeof(cl_int), (void*) &z_size )); //call/enque opencl kernel wrapper function clSafeCall( clEnqueueNDRangeKernel(OPS_opencl_core.command_queue, OPS_opencl_core.kernel[94], 3, NULL, globalWorkSize, localWorkSize, 0, NULL, NULL) ); if (OPS_diags>1) { clSafeCall( clFinish(OPS_opencl_core.command_queue) ); } ops_set_dirtybit_device(args, 3); ops_set_halo_dirtybit3(&args[0],range); ops_set_halo_dirtybit3(&args[1],range); //Update kernel record ops_timers_core(&c2,&t2); OPS_kernels[94].time += t2-t1; OPS_kernels[94].transfer += ops_compute_transfer(dim, range, &arg0); OPS_kernels[94].transfer += ops_compute_transfer(dim, range, &arg1); }
NTSTATUS RtlpCreateStack( IN HANDLE Process, IN SIZE_T MaximumStackSize OPTIONAL, IN SIZE_T CommittedStackSize OPTIONAL, IN ULONG ZeroBits OPTIONAL, OUT PINITIAL_TEB InitialTeb ) { NTSTATUS Status; PCH Stack; SYSTEM_BASIC_INFORMATION SysInfo; BOOLEAN GuardPage; SIZE_T RegionSize; ULONG OldProtect; Status = ZwQuerySystemInformation( SystemBasicInformation, (PVOID)&SysInfo, sizeof( SysInfo ), NULL ); if ( !NT_SUCCESS( Status ) ) { return( Status ); } // // if stack is in the current process, then default to // the parameters from the image // if ( Process == NtCurrentProcess() ) { PPEB Peb; PIMAGE_NT_HEADERS NtHeaders; Peb = NtCurrentPeb(); NtHeaders = RtlImageNtHeader(Peb->ImageBaseAddress); if (!NtHeaders) { return STATUS_INVALID_IMAGE_FORMAT; } if (!MaximumStackSize) { MaximumStackSize = NtHeaders->OptionalHeader.SizeOfStackReserve; } if (!CommittedStackSize) { CommittedStackSize = NtHeaders->OptionalHeader.SizeOfStackCommit; } } else { if (!CommittedStackSize) { CommittedStackSize = SysInfo.PageSize; } if (!MaximumStackSize) { MaximumStackSize = SysInfo.AllocationGranularity; } } // // Enforce a minimal stack commit if there is a PEB setting // for this. // if ( CommittedStackSize >= MaximumStackSize ) { MaximumStackSize = ROUND_UP(CommittedStackSize, (1024*1024)); } CommittedStackSize = ROUND_UP( CommittedStackSize, SysInfo.PageSize ); MaximumStackSize = ROUND_UP( MaximumStackSize, SysInfo.AllocationGranularity ); Stack = NULL; Status = ZwAllocateVirtualMemory( Process, (PVOID *)&Stack, ZeroBits, &MaximumStackSize, MEM_RESERVE, PAGE_READWRITE ); if ( !NT_SUCCESS( Status ) ) { #if DBG DbgPrint( "NTRTL: RtlpCreateStack( %lx ) failed. Stack Reservation Status == %X\n", Process, Status ); #endif // DBG return( Status ); } InitialTeb->OldInitialTeb.OldStackBase = NULL; InitialTeb->OldInitialTeb.OldStackLimit = NULL; InitialTeb->StackAllocationBase = Stack; InitialTeb->StackBase = Stack + MaximumStackSize; Stack += MaximumStackSize - CommittedStackSize; if (MaximumStackSize > CommittedStackSize) { Stack -= SysInfo.PageSize; CommittedStackSize += SysInfo.PageSize; GuardPage = TRUE; } else { GuardPage = FALSE; } Status = ZwAllocateVirtualMemory( Process, (PVOID *)&Stack, 0, &CommittedStackSize, MEM_COMMIT, PAGE_READWRITE ); InitialTeb->StackLimit = Stack; if ( !NT_SUCCESS( Status ) ) { #if DBG DbgPrint( "NTRTL: RtlpCreateStack( %lx ) failed. Stack Commit Status == %X\n", Process, Status ); #endif // DBG return( Status ); } // // if we have space, create a guard page. // if (GuardPage) { RegionSize = SysInfo.PageSize; Status = ZwProtectVirtualMemory( Process, (PVOID *)&Stack, &RegionSize, PAGE_GUARD | PAGE_READWRITE, &OldProtect); if ( !NT_SUCCESS( Status ) ) { #if DBG DbgPrint( "NTRTL: RtlpCreateStack( %lx ) failed. Guard Page Creation Status == %X\n", Process, Status ); #endif // DBG return( Status ); } InitialTeb->StackLimit = (PVOID)((PUCHAR)InitialTeb->StackLimit + RegionSize); } return( STATUS_SUCCESS ); }
static int reiserfs_symlink(struct inode *parent_dir, struct dentry *dentry, const char *symname) { int retval; struct inode *inode; char *name; int item_len; struct reiserfs_transaction_handle th; struct reiserfs_security_handle security; int mode = S_IFLNK | S_IRWXUGO; /* We need blocks for transaction + (user+group)*(quotas for new inode + update of quota for directory owner) */ int jbegin_count = JOURNAL_PER_BALANCE_CNT * 3 + 2 * (REISERFS_QUOTA_INIT_BLOCKS(parent_dir->i_sb) + REISERFS_QUOTA_TRANS_BLOCKS(parent_dir->i_sb)); if (!(inode = new_inode(parent_dir->i_sb))) { return -ENOMEM; } new_inode_init(inode, parent_dir, mode); retval = reiserfs_security_init(parent_dir, inode, &security); if (retval < 0) { drop_new_inode(inode); return retval; } jbegin_count += retval; reiserfs_write_lock(parent_dir->i_sb); item_len = ROUND_UP(strlen(symname)); if (item_len > MAX_DIRECT_ITEM_LEN(parent_dir->i_sb->s_blocksize)) { retval = -ENAMETOOLONG; drop_new_inode(inode); goto out_failed; } name = kmalloc(item_len, GFP_NOFS); if (!name) { drop_new_inode(inode); retval = -ENOMEM; goto out_failed; } memcpy(name, symname, strlen(symname)); padd_item(name, item_len, strlen(symname)); retval = journal_begin(&th, parent_dir->i_sb, jbegin_count); if (retval) { drop_new_inode(inode); kfree(name); goto out_failed; } retval = reiserfs_new_inode(&th, parent_dir, mode, name, strlen(symname), dentry, inode, &security); kfree(name); if (retval) { /* reiserfs_new_inode iputs for us */ goto out_failed; } reiserfs_update_inode_transaction(inode); reiserfs_update_inode_transaction(parent_dir); inode->i_op = &reiserfs_symlink_inode_operations; inode->i_mapping->a_ops = &reiserfs_address_space_operations; // must be sure this inode is written with this transaction // //reiserfs_update_sd (&th, inode, READ_BLOCKS); retval = reiserfs_add_entry(&th, parent_dir, dentry->d_name.name, dentry->d_name.len, inode, 1 /*visible */ ); if (retval) { int err; inode->i_nlink--; reiserfs_update_sd(&th, inode); err = journal_end(&th, parent_dir->i_sb, jbegin_count); if (err) retval = err; unlock_new_inode(inode); iput(inode); goto out_failed; } d_instantiate(dentry, inode); unlock_new_inode(inode); retval = journal_end(&th, parent_dir->i_sb, jbegin_count); out_failed: reiserfs_write_unlock(parent_dir->i_sb); return retval; }
size_t ofl_structs_table_properties_pack(struct ofl_table_feature_prop_header * src, struct ofp_table_feature_prop_header *dst, uint8_t *data, struct ofl_exp *exp){ dst->type = htons(src->type); switch (src->type){ case OFPTFPT_INSTRUCTIONS: case OFPTFPT_INSTRUCTIONS_MISS:{ int i; struct ofl_table_feature_prop_instructions *sp = (struct ofl_table_feature_prop_instructions*) src; struct ofp_table_feature_prop_instructions *dp = (struct ofp_table_feature_prop_instructions*) dst; uint8_t *ptr; dp->length = htons(sp->header.length); ptr = (uint8_t*) data + (sizeof(struct ofp_table_feature_prop_header)); for(i = 0; i < sp->ids_num; i++){ if(sp->instruction_ids[i].type == OFPIT_EXPERIMENTER){ struct ofp_instruction inst; inst.type = sp->instruction_ids[i].type; if (exp == NULL || exp->inst == NULL || exp->inst->unpack == NULL) { OFL_LOG_WARN(LOG_MODULE, "Received EXPERIMENTER instruction, but no callback was given."); return ofl_error(OFPET_BAD_INSTRUCTION, OFPBIC_UNSUP_INST); } inst.len = ROUND_UP(sizeof(struct ofp_instruction) + exp->inst->ofp_len(&sp->instruction_ids[i]),8); memcpy(ptr, &inst, sizeof(struct ofp_instruction) - 4); ptr += sizeof(struct ofp_instruction) - 4; } else { struct ofp_instruction inst; inst.type = htons(sp->instruction_ids[i].type); inst.len = htons(sizeof(struct ofp_instruction) - 4); memcpy(ptr, &inst, sizeof(struct ofp_instruction) - 4); ptr += sizeof(struct ofp_instruction) - 4; } } memset(ptr, 0x0, ROUND_UP(sp->header.length,8) - sp->header.length); return ROUND_UP(ntohs(dp->length),8); } case OFPTFPT_NEXT_TABLES: case OFPTFPT_NEXT_TABLES_MISS:{ int i; uint8_t *ptr; struct ofl_table_feature_prop_next_tables *sp = (struct ofl_table_feature_prop_next_tables*) src; struct ofp_table_feature_prop_next_tables *dp = (struct ofp_table_feature_prop_next_tables*) dst; dp->length = htons(sp->header.length); ptr = data + (sizeof(struct ofp_table_feature_prop_header)); for(i = 0; i < sp->table_num; i++){ memcpy(ptr, &sp->next_table_ids[i], sizeof(uint8_t)); ptr += sizeof(uint8_t); } memset(ptr, 0x0, ROUND_UP(sp->header.length,8)-sp->header.length); return ROUND_UP(ntohs(dp->length),8); } case OFPTFPT_WRITE_ACTIONS: case OFPTFPT_WRITE_ACTIONS_MISS: case OFPTFPT_APPLY_ACTIONS: case OFPTFPT_APPLY_ACTIONS_MISS:{ int i; uint8_t *ptr; struct ofl_table_feature_prop_actions *sp = (struct ofl_table_feature_prop_actions*) src; struct ofp_table_feature_prop_actions *dp = (struct ofp_table_feature_prop_actions*) dst; dp->length = htons(sp->header.length); ptr = data + (sizeof(struct ofp_table_feature_prop_header)); for(i = 0; i < sp->actions_num; i++){ if(sp->action_ids[i].type == OFPAT_EXPERIMENTER){ memcpy(ptr, &sp->action_ids[i], sizeof(struct ofp_action_header)); ptr += sizeof(struct ofp_action_header); } else { struct ofp_action_header action; action.type = htons(sp->action_ids[i].type); action.len = htons(sp->action_ids[i].len); memcpy(ptr, &action, sizeof(struct ofp_action_header) -4); ptr += sizeof(struct ofp_action_header) -4; } } memset(ptr, 0x0, ROUND_UP(sp->header.length,8)- sp->header.length); return ROUND_UP(ntohs(dp->length),8); } case OFPTFPT_MATCH: case OFPTFPT_WILDCARDS: case OFPTFPT_WRITE_SETFIELD: case OFPTFPT_WRITE_SETFIELD_MISS: case OFPTFPT_APPLY_SETFIELD: case OFPTFPT_APPLY_SETFIELD_MISS:{ int i; struct ofl_table_feature_prop_oxm *sp = (struct ofl_table_feature_prop_oxm*) src; struct ofp_table_feature_prop_oxm *dp = (struct ofp_table_feature_prop_oxm*) dst; dp->length = htons(sp->header.length); data += sizeof(struct ofp_table_feature_prop_header); for(i = 0; i < sp->oxm_num; i++){ uint32_t header = htonl(sp->oxm_ids[i]); memcpy(data, &header, sizeof(uint32_t)); data += sizeof(uint32_t); } memset(data, 0x0, ROUND_UP(sp->header.length,8)- sp->header.length); return ROUND_UP(ntohs(dp->length),8); } case OFPTFPT_EXPERIMENTER: case OFPTFPT_EXPERIMENTER_MISS:{ } default: return 0; } }
// host stub function void ops_par_loop_update_halo_kernel2_zvel_minus_2_back( char const *name, ops_block block, int dim, int *range, ops_arg arg0, ops_arg arg1, ops_arg arg2) { // Timing double t1, t2, c1, c2; ops_arg args[3] = {arg0, arg1, arg2}; #ifdef CHECKPOINTING if (!ops_checkpointing_before(args, 3, range, 57)) return; #endif if (OPS_diags > 1) { ops_timing_realloc(57, "update_halo_kernel2_zvel_minus_2_back"); OPS_kernels[57].count++; ops_timers_core(&c1, &t1); } // compute localy allocated range for the sub-block int start[3]; int end[3]; #ifdef OPS_MPI sub_block_list sb = OPS_sub_block_list[block->index]; #endif // OPS_MPI int arg_idx[3]; int arg_idx_base[3]; #ifdef OPS_MPI if (compute_ranges(args, 3, block, range, start, end, arg_idx) < 0) return; #else // OPS_MPI for (int n = 0; n < 3; n++) { start[n] = range[2 * n]; end[n] = range[2 * n + 1]; arg_idx[n] = start[n]; } #endif for (int n = 0; n < 3; n++) { arg_idx_base[n] = arg_idx[n]; } int dat0 = args[0].dat->elem_size; int dat1 = args[1].dat->elem_size; int *arg2h = (int *)arg2.data; // Upload large globals #ifdef OPS_GPU int consts_bytes = 0; consts_bytes += ROUND_UP(NUM_FIELDS * sizeof(int)); reallocConstArrays(consts_bytes); consts_bytes = 0; args[2].data = OPS_consts_h + consts_bytes; args[2].data_d = OPS_consts_d + consts_bytes; for (int d = 0; d < NUM_FIELDS; d++) ((int *)args[2].data)[d] = arg2h[d]; consts_bytes += ROUND_UP(NUM_FIELDS * sizeof(int)); mvConstArraysToDevice(consts_bytes); #endif // OPS_GPU // set up initial pointers int base0 = args[0].dat->base_offset + (OPS_soa ? args[0].dat->type_size : args[0].dat->elem_size) * start[0] * args[0].stencil->stride[0]; base0 = base0 + (OPS_soa ? args[0].dat->type_size : args[0].dat->elem_size) * args[0].dat->size[0] * start[1] * args[0].stencil->stride[1]; base0 = base0 + (OPS_soa ? args[0].dat->type_size : args[0].dat->elem_size) * args[0].dat->size[0] * args[0].dat->size[1] * start[2] * args[0].stencil->stride[2]; #ifdef OPS_GPU double *p_a0 = (double *)((char *)args[0].data_d + base0); #else double *p_a0 = (double *)((char *)args[0].data + base0); #endif int base1 = args[1].dat->base_offset + (OPS_soa ? args[1].dat->type_size : args[1].dat->elem_size) * start[0] * args[1].stencil->stride[0]; base1 = base1 + (OPS_soa ? args[1].dat->type_size : args[1].dat->elem_size) * args[1].dat->size[0] * start[1] * args[1].stencil->stride[1]; base1 = base1 + (OPS_soa ? args[1].dat->type_size : args[1].dat->elem_size) * args[1].dat->size[0] * args[1].dat->size[1] * start[2] * args[1].stencil->stride[2]; #ifdef OPS_GPU double *p_a1 = (double *)((char *)args[1].data_d + base1); #else double *p_a1 = (double *)((char *)args[1].data + base1); #endif #ifdef OPS_GPU int *p_a2 = (int *)args[2].data_d; #else int *p_a2 = arg2h; #endif int x_size = MAX(0, end[0] - start[0]); int y_size = MAX(0, end[1] - start[1]); int z_size = MAX(0, end[2] - start[2]); // initialize global variable with the dimension of dats xdim0 = args[0].dat->size[0]; ydim0 = args[0].dat->size[1]; xdim1 = args[1].dat->size[0]; ydim1 = args[1].dat->size[1]; if (xdim0 != xdim0_update_halo_kernel2_zvel_minus_2_back_h || ydim0 != ydim0_update_halo_kernel2_zvel_minus_2_back_h || xdim1 != xdim1_update_halo_kernel2_zvel_minus_2_back_h || ydim1 != ydim1_update_halo_kernel2_zvel_minus_2_back_h) { xdim0_update_halo_kernel2_zvel_minus_2_back = xdim0; xdim0_update_halo_kernel2_zvel_minus_2_back_h = xdim0; ydim0_update_halo_kernel2_zvel_minus_2_back = ydim0; ydim0_update_halo_kernel2_zvel_minus_2_back_h = ydim0; xdim1_update_halo_kernel2_zvel_minus_2_back = xdim1; xdim1_update_halo_kernel2_zvel_minus_2_back_h = xdim1; ydim1_update_halo_kernel2_zvel_minus_2_back = ydim1; ydim1_update_halo_kernel2_zvel_minus_2_back_h = ydim1; } // Halo Exchanges #ifdef OPS_GPU ops_H_D_exchanges_device(args, 3); #else ops_H_D_exchanges_host(args, 3); #endif ops_halo_exchanges(args, 3, range); #ifdef OPS_GPU ops_H_D_exchanges_device(args, 3); #else ops_H_D_exchanges_host(args, 3); #endif if (OPS_diags > 1) { ops_timers_core(&c2, &t2); OPS_kernels[57].mpi_time += t2 - t1; } update_halo_kernel2_zvel_minus_2_back_c_wrapper(p_a0, p_a1, p_a2, x_size, y_size, z_size); if (OPS_diags > 1) { ops_timers_core(&c1, &t1); OPS_kernels[57].time += t1 - t2; } #ifdef OPS_GPU ops_set_dirtybit_device(args, 3); #else ops_set_dirtybit_host(args, 3); #endif ops_set_halo_dirtybit3(&args[0], range); ops_set_halo_dirtybit3(&args[1], range); if (OPS_diags > 1) { // Update kernel record ops_timers_core(&c2, &t2); OPS_kernels[57].mpi_time += t2 - t1; OPS_kernels[57].transfer += ops_compute_transfer(dim, start, end, &arg0); OPS_kernels[57].transfer += ops_compute_transfer(dim, start, end, &arg1); } }
BOOT_CODE pptr_t alloc_region(uint32_t size_bits) { unsigned int i; unsigned int reg_index = 0; /* gcc cannot work out that this will not be used uninitialized */ region_t reg = REG_EMPTY; region_t rem_small = REG_EMPTY; region_t rem_large = REG_EMPTY; region_t new_reg; region_t new_rem_small; region_t new_rem_large; /* Search for a freemem region that will be the best fit for an allocation. We favour allocations * that are aligned to either end of the region. If an allocation must split a region we favour * an unbalanced split. In both cases we attempt to use the smallest region possible. In general * this means we aim to make the size of the smallest remaining region smaller (ideally zero) * followed by making the size of the largest remaining region smaller */ for (i = 0; i < MAX_NUM_FREEMEM_REG; i++) { /* Determine whether placing the region at the start or the end will create a bigger left over region */ if (ROUND_UP(ndks_boot.freemem[i].start, size_bits) - ndks_boot.freemem[i].start < ndks_boot.freemem[i].end - ROUND_DOWN(ndks_boot.freemem[i].end, size_bits)) { new_reg.start = ROUND_UP(ndks_boot.freemem[i].start, size_bits); new_reg.end = new_reg.start + BIT(size_bits); } else { new_reg.end = ROUND_DOWN(ndks_boot.freemem[i].end, size_bits); new_reg.start = new_reg.end - BIT(size_bits); } if (new_reg.end > new_reg.start && new_reg.start >= ndks_boot.freemem[i].start && new_reg.end <= ndks_boot.freemem[i].end) { if (new_reg.start - ndks_boot.freemem[i].start < ndks_boot.freemem[i].end - new_reg.end) { new_rem_small.start = ndks_boot.freemem[i].start; new_rem_small.end = new_reg.start; new_rem_large.start = new_reg.end; new_rem_large.end = ndks_boot.freemem[i].end; } else { new_rem_large.start = ndks_boot.freemem[i].start; new_rem_large.end = new_reg.start; new_rem_small.start = new_reg.end; new_rem_small.end = ndks_boot.freemem[i].end; } if ( is_reg_empty(reg) || (reg_size(new_rem_small) < reg_size(rem_small)) || (reg_size(new_rem_small) == reg_size(rem_small) && reg_size(new_rem_large) < reg_size(rem_large)) ) { reg = new_reg; rem_small = new_rem_small; rem_large = new_rem_large; reg_index = i; } } } if (is_reg_empty(reg)) { printf("Kernel init failing: not enough memory\n"); return 0; } /* Remove the region in question */ ndks_boot.freemem[reg_index] = REG_EMPTY; /* Add the remaining regions in largest to smallest order */ insert_region(rem_large); if (!insert_region(rem_small)) { printf("alloc_region(): wasted 0x%x bytes due to alignment, try to increase MAX_NUM_FREEMEM_REG\n", (unsigned int)(rem_small.end - rem_small.start)); } return reg.start; }
* * Clearly, this structure is only needed if the CPU has an MMU! * * The following are not the smallest areas that could be allocated for a * working system. If the amount of memory used by the page tables is * critical, they could be reduced. */ PHYS_MEM_DESC sysPhysMemDesc [] = { /* DRAM - Always the first entry */ { DDR_MCORE_ADDR, /* virtual address */ DDR_MCORE_ADDR, /* physical address */ ROUND_UP (DDR_MCORE_SIZE, PAGE_SIZE), MMU_ATTR_VALID_MSK | MMU_ATTR_PROT_MSK | MMU_ATTR_WRITEALLOCATE_MSK, #ifdef _WRS_CONFIG_SMP /* needs to be shared */ MMU_ATTR_VALID | MMU_ATTR_SUP_RWX | MMU_ATTR_WRITEALLOCATE_SHARED #else MMU_ATTR_VALID | MMU_ATTR_SUP_RWX | MMU_ATTR_WRITEALLOCATE #endif /* _WRS_CONFIG_SMP */ }, /**************************************GU memmap begin**************************/ {/*GU reserved mem 1xxx*/ DDR_GU_ADDR, /* virtual address */ DDR_GU_ADDR, /* physical address */ ROUND_UP (ECS_BBPHAC_BASE_ADDR - DDR_GU_ADDR, PAGE_SIZE), MMU_ATTR_VALID_MSK | MMU_ATTR_PROT_MSK | MMU_ATTR_NORMAL_NONCACHEABLE_MSK, MMU_ATTR_VALID | MMU_ATTR_SUP_RWX | MMU_ATTR_NORMAL_NONCACHEABLE },
// host stub function void ops_par_loop_update_halo_kernel1_fr2(char const *name, ops_block block, int dim, int *range, ops_arg arg0, ops_arg arg1, ops_arg arg2, ops_arg arg3, ops_arg arg4, ops_arg arg5, ops_arg arg6, ops_arg arg7) { // Timing double t1, t2, c1, c2; ops_arg args[8] = {arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7}; #ifdef CHECKPOINTING if (!ops_checkpointing_before(args, 8, range, 22)) return; #endif if (OPS_diags > 1) { ops_timing_realloc(22, "update_halo_kernel1_fr2"); OPS_kernels[22].count++; ops_timers_core(&c1, &t1); } // compute locally allocated range for the sub-block int start[3]; int end[3]; #ifdef OPS_MPI sub_block_list sb = OPS_sub_block_list[block->index]; if (!sb->owned) return; for (int n = 0; n < 3; n++) { start[n] = sb->decomp_disp[n]; end[n] = sb->decomp_disp[n] + sb->decomp_size[n]; if (start[n] >= range[2 * n]) { start[n] = 0; } else { start[n] = range[2 * n] - start[n]; } if (sb->id_m[n] == MPI_PROC_NULL && range[2 * n] < 0) start[n] = range[2 * n]; if (end[n] >= range[2 * n + 1]) { end[n] = range[2 * n + 1] - sb->decomp_disp[n]; } else { end[n] = sb->decomp_size[n]; } if (sb->id_p[n] == MPI_PROC_NULL && (range[2 * n + 1] > sb->decomp_disp[n] + sb->decomp_size[n])) end[n] += (range[2 * n + 1] - sb->decomp_disp[n] - sb->decomp_size[n]); } #else for (int n = 0; n < 3; n++) { start[n] = range[2 * n]; end[n] = range[2 * n + 1]; } #endif int x_size = MAX(0, end[0] - start[0]); int y_size = MAX(0, end[1] - start[1]); int z_size = MAX(0, end[2] - start[2]); int xdim0 = args[0].dat->size[0]; int ydim0 = args[0].dat->size[1]; int xdim1 = args[1].dat->size[0]; int ydim1 = args[1].dat->size[1]; int xdim2 = args[2].dat->size[0]; int ydim2 = args[2].dat->size[1]; int xdim3 = args[3].dat->size[0]; int ydim3 = args[3].dat->size[1]; int xdim4 = args[4].dat->size[0]; int ydim4 = args[4].dat->size[1]; int xdim5 = args[5].dat->size[0]; int ydim5 = args[5].dat->size[1]; int xdim6 = args[6].dat->size[0]; int ydim6 = args[6].dat->size[1]; // build opencl kernel if not already built buildOpenCLKernels_update_halo_kernel1_fr2(xdim0, ydim0, xdim1, ydim1, xdim2, ydim2, xdim3, ydim3, xdim4, ydim4, xdim5, ydim5, xdim6, ydim6); // set up OpenCL thread blocks size_t globalWorkSize[3] = { ((x_size - 1) / OPS_block_size_x + 1) * OPS_block_size_x, ((y_size - 1) / OPS_block_size_y + 1) * OPS_block_size_y, ((z_size - 1) / OPS_block_size_z + 1) * OPS_block_size_z}; size_t localWorkSize[3] = {OPS_block_size_x, OPS_block_size_y, OPS_block_size_z}; int *arg7h = (int *)arg7.data; int consts_bytes = 0; consts_bytes += ROUND_UP(NUM_FIELDS * sizeof(int)); reallocConstArrays(consts_bytes); consts_bytes = 0; arg7.data = OPS_consts_h + consts_bytes; arg7.data_d = OPS_consts_d + consts_bytes; for (int d = 0; d < NUM_FIELDS; d++) ((int *)arg7.data)[d] = arg7h[d]; consts_bytes += ROUND_UP(NUM_FIELDS * sizeof(int)); mvConstArraysToDevice(consts_bytes); // set up initial pointers int d_m[OPS_MAX_DIM]; #ifdef OPS_MPI for (int d = 0; d < dim; d++) d_m[d] = args[0].dat->d_m[d] + OPS_sub_dat_list[args[0].dat->index]->d_im[d]; #else for (int d = 0; d < dim; d++) d_m[d] = args[0].dat->d_m[d]; #endif int base0 = 1 * 1 * (start[0] * args[0].stencil->stride[0] - args[0].dat->base[0] - d_m[0]); base0 = base0 + args[0].dat->size[0] * 1 * (start[1] * args[0].stencil->stride[1] - args[0].dat->base[1] - d_m[1]); base0 = base0 + args[0].dat->size[0] * 1 * args[0].dat->size[1] * 1 * (start[2] * args[0].stencil->stride[2] - args[0].dat->base[2] - d_m[2]); #ifdef OPS_MPI for (int d = 0; d < dim; d++) d_m[d] = args[1].dat->d_m[d] + OPS_sub_dat_list[args[1].dat->index]->d_im[d]; #else for (int d = 0; d < dim; d++) d_m[d] = args[1].dat->d_m[d]; #endif int base1 = 1 * 1 * (start[0] * args[1].stencil->stride[0] - args[1].dat->base[0] - d_m[0]); base1 = base1 + args[1].dat->size[0] * 1 * (start[1] * args[1].stencil->stride[1] - args[1].dat->base[1] - d_m[1]); base1 = base1 + args[1].dat->size[0] * 1 * args[1].dat->size[1] * 1 * (start[2] * args[1].stencil->stride[2] - args[1].dat->base[2] - d_m[2]); #ifdef OPS_MPI for (int d = 0; d < dim; d++) d_m[d] = args[2].dat->d_m[d] + OPS_sub_dat_list[args[2].dat->index]->d_im[d]; #else for (int d = 0; d < dim; d++) d_m[d] = args[2].dat->d_m[d]; #endif int base2 = 1 * 1 * (start[0] * args[2].stencil->stride[0] - args[2].dat->base[0] - d_m[0]); base2 = base2 + args[2].dat->size[0] * 1 * (start[1] * args[2].stencil->stride[1] - args[2].dat->base[1] - d_m[1]); base2 = base2 + args[2].dat->size[0] * 1 * args[2].dat->size[1] * 1 * (start[2] * args[2].stencil->stride[2] - args[2].dat->base[2] - d_m[2]); #ifdef OPS_MPI for (int d = 0; d < dim; d++) d_m[d] = args[3].dat->d_m[d] + OPS_sub_dat_list[args[3].dat->index]->d_im[d]; #else for (int d = 0; d < dim; d++) d_m[d] = args[3].dat->d_m[d]; #endif int base3 = 1 * 1 * (start[0] * args[3].stencil->stride[0] - args[3].dat->base[0] - d_m[0]); base3 = base3 + args[3].dat->size[0] * 1 * (start[1] * args[3].stencil->stride[1] - args[3].dat->base[1] - d_m[1]); base3 = base3 + args[3].dat->size[0] * 1 * args[3].dat->size[1] * 1 * (start[2] * args[3].stencil->stride[2] - args[3].dat->base[2] - d_m[2]); #ifdef OPS_MPI for (int d = 0; d < dim; d++) d_m[d] = args[4].dat->d_m[d] + OPS_sub_dat_list[args[4].dat->index]->d_im[d]; #else for (int d = 0; d < dim; d++) d_m[d] = args[4].dat->d_m[d]; #endif int base4 = 1 * 1 * (start[0] * args[4].stencil->stride[0] - args[4].dat->base[0] - d_m[0]); base4 = base4 + args[4].dat->size[0] * 1 * (start[1] * args[4].stencil->stride[1] - args[4].dat->base[1] - d_m[1]); base4 = base4 + args[4].dat->size[0] * 1 * args[4].dat->size[1] * 1 * (start[2] * args[4].stencil->stride[2] - args[4].dat->base[2] - d_m[2]); #ifdef OPS_MPI for (int d = 0; d < dim; d++) d_m[d] = args[5].dat->d_m[d] + OPS_sub_dat_list[args[5].dat->index]->d_im[d]; #else for (int d = 0; d < dim; d++) d_m[d] = args[5].dat->d_m[d]; #endif int base5 = 1 * 1 * (start[0] * args[5].stencil->stride[0] - args[5].dat->base[0] - d_m[0]); base5 = base5 + args[5].dat->size[0] * 1 * (start[1] * args[5].stencil->stride[1] - args[5].dat->base[1] - d_m[1]); base5 = base5 + args[5].dat->size[0] * 1 * args[5].dat->size[1] * 1 * (start[2] * args[5].stencil->stride[2] - args[5].dat->base[2] - d_m[2]); #ifdef OPS_MPI for (int d = 0; d < dim; d++) d_m[d] = args[6].dat->d_m[d] + OPS_sub_dat_list[args[6].dat->index]->d_im[d]; #else for (int d = 0; d < dim; d++) d_m[d] = args[6].dat->d_m[d]; #endif int base6 = 1 * 1 * (start[0] * args[6].stencil->stride[0] - args[6].dat->base[0] - d_m[0]); base6 = base6 + args[6].dat->size[0] * 1 * (start[1] * args[6].stencil->stride[1] - args[6].dat->base[1] - d_m[1]); base6 = base6 + args[6].dat->size[0] * 1 * args[6].dat->size[1] * 1 * (start[2] * args[6].stencil->stride[2] - args[6].dat->base[2] - d_m[2]); ops_H_D_exchanges_device(args, 8); ops_halo_exchanges(args, 8, range); ops_H_D_exchanges_device(args, 8); if (OPS_diags > 1) { ops_timers_core(&c2, &t2); OPS_kernels[22].mpi_time += t2 - t1; } if (globalWorkSize[0] > 0 && globalWorkSize[1] > 0 && globalWorkSize[2] > 0) { clSafeCall(clSetKernelArg(OPS_opencl_core.kernel[22], 0, sizeof(cl_mem), (void *)&arg0.data_d)); clSafeCall(clSetKernelArg(OPS_opencl_core.kernel[22], 1, sizeof(cl_mem), (void *)&arg1.data_d)); clSafeCall(clSetKernelArg(OPS_opencl_core.kernel[22], 2, sizeof(cl_mem), (void *)&arg2.data_d)); clSafeCall(clSetKernelArg(OPS_opencl_core.kernel[22], 3, sizeof(cl_mem), (void *)&arg3.data_d)); clSafeCall(clSetKernelArg(OPS_opencl_core.kernel[22], 4, sizeof(cl_mem), (void *)&arg4.data_d)); clSafeCall(clSetKernelArg(OPS_opencl_core.kernel[22], 5, sizeof(cl_mem), (void *)&arg5.data_d)); clSafeCall(clSetKernelArg(OPS_opencl_core.kernel[22], 6, sizeof(cl_mem), (void *)&arg6.data_d)); clSafeCall(clSetKernelArg(OPS_opencl_core.kernel[22], 7, sizeof(cl_mem), (void *)&arg7.data_d)); clSafeCall(clSetKernelArg(OPS_opencl_core.kernel[22], 8, sizeof(cl_int), (void *)&base0)); clSafeCall(clSetKernelArg(OPS_opencl_core.kernel[22], 9, sizeof(cl_int), (void *)&base1)); clSafeCall(clSetKernelArg(OPS_opencl_core.kernel[22], 10, sizeof(cl_int), (void *)&base2)); clSafeCall(clSetKernelArg(OPS_opencl_core.kernel[22], 11, sizeof(cl_int), (void *)&base3)); clSafeCall(clSetKernelArg(OPS_opencl_core.kernel[22], 12, sizeof(cl_int), (void *)&base4)); clSafeCall(clSetKernelArg(OPS_opencl_core.kernel[22], 13, sizeof(cl_int), (void *)&base5)); clSafeCall(clSetKernelArg(OPS_opencl_core.kernel[22], 14, sizeof(cl_int), (void *)&base6)); clSafeCall(clSetKernelArg(OPS_opencl_core.kernel[22], 15, sizeof(cl_int), (void *)&x_size)); clSafeCall(clSetKernelArg(OPS_opencl_core.kernel[22], 16, sizeof(cl_int), (void *)&y_size)); clSafeCall(clSetKernelArg(OPS_opencl_core.kernel[22], 17, sizeof(cl_int), (void *)&z_size)); // call/enque opencl kernel wrapper function clSafeCall(clEnqueueNDRangeKernel( OPS_opencl_core.command_queue, OPS_opencl_core.kernel[22], 3, NULL, globalWorkSize, localWorkSize, 0, NULL, NULL)); } if (OPS_diags > 1) { clSafeCall(clFinish(OPS_opencl_core.command_queue)); } if (OPS_diags > 1) { ops_timers_core(&c1, &t1); OPS_kernels[22].time += t1 - t2; } ops_set_dirtybit_device(args, 8); ops_set_halo_dirtybit3(&args[0], range); ops_set_halo_dirtybit3(&args[1], range); ops_set_halo_dirtybit3(&args[2], range); ops_set_halo_dirtybit3(&args[3], range); ops_set_halo_dirtybit3(&args[4], range); ops_set_halo_dirtybit3(&args[5], range); ops_set_halo_dirtybit3(&args[6], range); if (OPS_diags > 1) { // Update kernel record ops_timers_core(&c2, &t2); OPS_kernels[22].mpi_time += t2 - t1; OPS_kernels[22].transfer += ops_compute_transfer(dim, start, end, &arg0); OPS_kernels[22].transfer += ops_compute_transfer(dim, start, end, &arg1); OPS_kernels[22].transfer += ops_compute_transfer(dim, start, end, &arg2); OPS_kernels[22].transfer += ops_compute_transfer(dim, start, end, &arg3); OPS_kernels[22].transfer += ops_compute_transfer(dim, start, end, &arg4); OPS_kernels[22].transfer += ops_compute_transfer(dim, start, end, &arg5); OPS_kernels[22].transfer += ops_compute_transfer(dim, start, end, &arg6); } }
/* Build a pyramid. * * width/height is the size of this layer, real_* the subsection of the layer * which is real pixels (as opposed to background). */ static Layer * pyramid_build( VipsForeignSaveDz *dz, Layer *above, int width, int height, VipsRect *real_pixels ) { VipsForeignSave *save = VIPS_FOREIGN_SAVE( dz ); Layer *layer = VIPS_NEW( dz, Layer ); VipsRect strip; int limit; layer->dz = dz; layer->width = width; layer->height = height; layer->tiles_across = ROUND_UP( width, dz->tile_size ) / dz->tile_size; layer->tiles_down = ROUND_UP( height, dz->tile_size ) / dz->tile_size; layer->real_pixels = *real_pixels; layer->image = NULL; layer->strip = NULL; layer->copy = NULL; if( !above ) /* Top of pyramid. */ layer->sub = 1; else layer->sub = above->sub * 2; layer->below = NULL; layer->above = above; /* We round the image size up to an even number to make x2 shrink * easy. */ layer->image = vips_image_new(); if( vips_image_pipelinev( layer->image, VIPS_DEMAND_STYLE_ANY, save->ready, NULL ) ) { layer_free( layer ); return( NULL ); } layer->image->Xsize = width + (width & 1); layer->image->Ysize = height + (height & 1); layer->strip = vips_region_new( layer->image ); layer->copy = vips_region_new( layer->image ); /* The regions will get used in the bg thread callback, so make sure * we don't own them. */ vips__region_no_ownership( layer->strip ); vips__region_no_ownership( layer->copy ); /* Build a line of tiles here. Normally strips are height + 2 * * overlap, but the first row is missing the top edge. * * Expand the strip if necessary to make sure we have an even * number of lines. */ layer->y = 0; layer->write_y = 0; strip.left = 0; strip.top = 0; strip.width = layer->image->Xsize; strip.height = dz->tile_size + dz->overlap; if( (strip.height & 1) == 1 ) strip.height += 1; if( vips_region_buffer( layer->strip, &strip ) ) { layer_free( layer ); return( NULL ); } switch( dz->depth ) { case VIPS_FOREIGN_DZ_DEPTH_ONEPIXEL: limit = 1; break; case VIPS_FOREIGN_DZ_DEPTH_ONETILE: limit = dz->tile_size; break; case VIPS_FOREIGN_DZ_DEPTH_ONE: limit = VIPS_MAX( width, height ); break; default: g_assert( 0 ); limit = dz->tile_size; break; } if( width > limit || height > limit ) { /* Round up, so eg. a 5 pixel wide image becomes 3 a layer * down. * * For the rect, round left/top down, round bottom/right up, * so we get all possible pixels. */ VipsRect halfrect; halfrect.left = real_pixels->left / 2; halfrect.top = real_pixels->top / 2; halfrect.width = (VIPS_RECT_RIGHT( real_pixels ) + 1) / 2 - halfrect.left; halfrect.height = (VIPS_RECT_BOTTOM( real_pixels ) + 1) / 2 - halfrect.top; if( !(layer->below = pyramid_build( dz, layer, (width + 1) / 2, (height + 1) / 2, &halfrect )) ) { layer_free( layer ); return( NULL ); } layer->n = layer->below->n + 1; } else layer->n = 0; #ifdef DEBUG printf( "pyramid_build:\n" ); printf( "\tn = %d\n", layer->n ); printf( "\twidth = %d, height = %d\n", width, height ); printf( "\tXsize = %d, Ysize = %d\n", layer->image->Xsize, layer->image->Ysize ); printf( "\treal_pixels.left = %d, real_pixels.top = %d\n", real_pixels->left, real_pixels->top ); printf( "\treal_pixels.width = %d, real_pixels.height = %d\n", real_pixels->width, real_pixels->height ); #endif return( layer ); }
/** * Create initial (temporary) page tables. * * We use 1MB (ARM_L1_SECTION_BYTES) pages (sections) with a single-level table. * This allows 1MB*4k (ARM_L1_MAX_ENTRIES) = 4G per pagetable. * * Hardware details can be found in: * ARM Architecture Reference Manual, ARMv7-A and ARMv7-R edition * B3: Virtual Memory System Architecture (VMSA) */ void paging_init(void) { /** * Make sure our page tables are correctly aligned in memory */ assert(ROUND_UP((lpaddr_t)l1_low, ARM_L1_ALIGN) == (lpaddr_t)l1_low); assert(ROUND_UP((lpaddr_t)l1_high, ARM_L1_ALIGN) == (lpaddr_t)l1_high); /** * On ARMv7-A, physical RAM (PHYS_MEMORY_START) is the same with the * offset of mapped physical memory within virtual address space * (PHYS_MEMORY_START). */ STATIC_ASSERT(MEMORY_OFFSET == PHYS_MEMORY_START, ""); /** * Zero the page tables: this has the effect of marking every PTE * as invalid. */ memset(&l1_low, 0, sizeof(l1_low)); memset(&l1_high, 0, sizeof(l1_high)); memset(&l2_vec, 0, sizeof(l2_vec)); /** * Now we lay out the kernel's virtual address space. * * 00000000-7FFFFFFFF: 1-1 mappings (hardware we have not mapped * into high kernel space yet) * 80000000-BFFFFFFFF: 1-1 mappings (this is 1GB of RAM) * C0000000-FEFFFFFFF: On-demand mappings of hardware devices, * allocated descending from DEVICE_OFFSET. * FF000000-FFEFFFFFF: Unallocated. * FFF00000-FFFFFFFFF: L2 table, containing: * FFF00000-FFFEFFFF: Unallocated * FFFF0000-FFFFFFFF: Exception vectors */ lvaddr_t base = 0; size_t i; for (i=0, base = 0; i < ARM_L1_MAX_ENTRIES/2; i++) { map_kernel_section_lo(base, make_dev_section(base)); base += ARM_L1_SECTION_BYTES; } for (i=0, base = MEMORY_OFFSET; i < ARM_L1_MAX_ENTRIES/4; i++) { map_kernel_section_hi(base, make_ram_section(base)); base += ARM_L1_SECTION_BYTES; } /* Map the exception vectors. */ map_vectors(); /** * TTBCR: Translation Table Base Control register. * TTBCR.N is bits[2:0] * In a TLB miss TTBCR.N determines whether TTBR0 or TTBR1 is used as the * base address for the translation table walk in memory: * N == 0 -> always use TTBR0 * N > 0 -> if VA[31:32-N] > 0 use TTBR1 else use TTBR0 * * TTBR0 is typically used for processes-specific addresses * TTBR1 is typically used for OS addresses that do not change on context * switch * * set TTBCR.N = 1 to use TTBR1 for VAs >= MEMORY_OFFSET (=2GB) */ assert(mmu_enabled == false); cp15_invalidate_i_and_d_caches_fast(); cp15_invalidate_tlb(); cp15_write_ttbr1((lpaddr_t)l1_high); cp15_write_ttbr0((lpaddr_t)l1_low); #define TTBCR_N 1 uint32_t ttbcr = cp15_read_ttbcr(); ttbcr = (ttbcr & ~7) | TTBCR_N; cp15_write_ttbcr(ttbcr); STATIC_ASSERT(1UL<<(32-TTBCR_N) == MEMORY_OFFSET, ""); #undef TTBCR_N cp15_enable_mmu(); cp15_enable_alignment(); cp15_invalidate_i_and_d_caches_fast(); cp15_invalidate_tlb(); mmu_enabled = true; }
/* * Prepare a transaction2 request structure */ static int smb_setup_trans2request(struct smb_request *req) { struct smb_sb_info *server = req->rq_server; int mparam, mdata; static unsigned char padding[4]; /* I know the following is very ugly, but I want to build the smb packet as efficiently as possible. */ const int smb_parameters = 15; const int header = SMB_HEADER_LEN + 2 * smb_parameters + 2; const int oparam = ROUND_UP(header + 3); const int odata = ROUND_UP(oparam + req->rq_lparm); const int bcc = (req->rq_data ? odata + req->rq_ldata : oparam + req->rq_lparm) - header; if ((bcc + oparam) > server->opt.max_xmit) return -ENOMEM; smb_setup_header(req, SMBtrans2, smb_parameters, bcc); /* * max parameters + max data + max setup == bufsize to make NT4 happy * and not abort the transfer or split into multiple responses. It also * makes smbfs happy as handling packets larger than the buffer size * is extra work. * * OS/2 is probably going to hate me for this ... */ mparam = SMB_TRANS2_MAX_PARAM; mdata = req->rq_bufsize - mparam; mdata = server->opt.max_xmit - mparam - 100; if (mdata < 1024) { mdata = 1024; mparam = 20; } #if 0 /* NT/win2k has ~4k max_xmit, so with this we request more than it wants to return as one SMB. Useful for testing the fragmented trans2 handling. */ mdata = 8192; #endif WSET(req->rq_header, smb_tpscnt, req->rq_lparm); WSET(req->rq_header, smb_tdscnt, req->rq_ldata); WSET(req->rq_header, smb_mprcnt, mparam); WSET(req->rq_header, smb_mdrcnt, mdata); WSET(req->rq_header, smb_msrcnt, 0); /* max setup always 0 ? */ WSET(req->rq_header, smb_flags, 0); DSET(req->rq_header, smb_timeout, 0); WSET(req->rq_header, smb_pscnt, req->rq_lparm); WSET(req->rq_header, smb_psoff, oparam - 4); WSET(req->rq_header, smb_dscnt, req->rq_ldata); WSET(req->rq_header, smb_dsoff, req->rq_data ? odata - 4 : 0); *(req->rq_header + smb_suwcnt) = 0x01; /* setup count */ *(req->rq_header + smb_suwcnt + 1) = 0x00; /* reserved */ WSET(req->rq_header, smb_setup0, req->rq_trans2_command); req->rq_iovlen = 2; req->rq_iov[0].iov_base = (void *) req->rq_header; req->rq_iov[0].iov_len = oparam; req->rq_iov[1].iov_base = (req->rq_parm==NULL) ? padding : req->rq_parm; req->rq_iov[1].iov_len = req->rq_lparm; req->rq_slen = oparam + req->rq_lparm; if (req->rq_data) { req->rq_iovlen += 2; req->rq_iov[2].iov_base = padding; req->rq_iov[2].iov_len = odata - oparam - req->rq_lparm; req->rq_iov[3].iov_base = req->rq_data; req->rq_iov[3].iov_len = req->rq_ldata; req->rq_slen = odata + req->rq_ldata; } /* always a data part for trans2 replies */ req->rq_setup_read = smb_setup_bcc; return 0; }
static void virtex_init(MachineState *machine) { ram_addr_t ram_size = machine->ram_size; const char *kernel_filename = machine->kernel_filename; const char *kernel_cmdline = machine->kernel_cmdline; hwaddr initrd_base = 0; int initrd_size = 0; MemoryRegion *address_space_mem = get_system_memory(); DeviceState *dev; PowerPCCPU *cpu; CPUPPCState *env; hwaddr ram_base = 0; DriveInfo *dinfo; MemoryRegion *phys_ram = g_new(MemoryRegion, 1); qemu_irq irq[32], *cpu_irq; int kernel_size; int i; /* init CPUs */ if (machine->cpu_model == NULL) { machine->cpu_model = "440-Xilinx"; } cpu = ppc440_init_xilinx(&ram_size, 1, machine->cpu_model, 400000000); env = &cpu->env; qemu_register_reset(main_cpu_reset, cpu); memory_region_allocate_system_memory(phys_ram, NULL, "ram", ram_size); memory_region_add_subregion(address_space_mem, ram_base, phys_ram); dinfo = drive_get(IF_PFLASH, 0, 0); pflash_cfi01_register(PFLASH_BASEADDR, NULL, "virtex.flash", FLASH_SIZE, dinfo ? blk_by_legacy_dinfo(dinfo) : NULL, (64 * 1024), FLASH_SIZE >> 16, 1, 0x89, 0x18, 0x0000, 0x0, 1); cpu_irq = (qemu_irq *) &env->irq_inputs[PPC40x_INPUT_INT]; dev = qdev_create(NULL, "xlnx.xps-intc"); qdev_prop_set_uint32(dev, "kind-of-intr", 0); qdev_init_nofail(dev); sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, INTC_BASEADDR); sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0, cpu_irq[0]); for (i = 0; i < 32; i++) { irq[i] = qdev_get_gpio_in(dev, i); } serial_mm_init(address_space_mem, UART16550_BASEADDR, 2, irq[UART16550_IRQ], 115200, serial_hds[0], DEVICE_LITTLE_ENDIAN); /* 2 timers at irq 2 @ 62 Mhz. */ dev = qdev_create(NULL, "xlnx.xps-timer"); qdev_prop_set_uint32(dev, "one-timer-only", 0); qdev_prop_set_uint32(dev, "clock-frequency", 62 * 1000000); qdev_init_nofail(dev); sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, TIMER_BASEADDR); sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0, irq[TIMER_IRQ]); if (kernel_filename) { uint64_t entry, low, high; hwaddr boot_offset; /* Boots a kernel elf binary. */ kernel_size = load_elf(kernel_filename, NULL, NULL, &entry, &low, &high, 1, ELF_MACHINE, 0); boot_info.bootstrap_pc = entry & 0x00ffffff; if (kernel_size < 0) { boot_offset = 0x1200000; /* If we failed loading ELF's try a raw image. */ kernel_size = load_image_targphys(kernel_filename, boot_offset, ram_size); boot_info.bootstrap_pc = boot_offset; high = boot_info.bootstrap_pc + kernel_size + 8192; } boot_info.ima_size = kernel_size; /* Load initrd. */ if (machine->initrd_filename) { initrd_base = high = ROUND_UP(high, 4); initrd_size = load_image_targphys(machine->initrd_filename, high, ram_size - high); if (initrd_size < 0) { error_report("couldn't load ram disk '%s'", machine->initrd_filename); exit(1); } high = ROUND_UP(high + initrd_size, 4); } /* Provide a device-tree. */ boot_info.fdt = high + (8192 * 2); boot_info.fdt &= ~8191; xilinx_load_device_tree(boot_info.fdt, ram_size, initrd_base, initrd_size, kernel_cmdline); } env->load_info = &boot_info; }
void _new_thread(struct k_thread *thread, k_thread_stack_t *stack, size_t stackSize, k_thread_entry_t pEntry, void *p1, void *p2, void *p3, int priority, unsigned int options) { char *pStack = K_THREAD_STACK_BUFFER(stack); /* Align stack end to maximum alignment requirement. */ char *stackEnd = (char *)ROUND_DOWN(pStack + stackSize, 16); #if XCHAL_CP_NUM > 0 u32_t *cpSA; char *cpStack; #endif _new_thread_init(thread, pStack, stackSize, priority, options); #ifdef CONFIG_DEBUG printk("\nstackPtr = %p, stackSize = %d\n", pStack, stackSize); printk("stackEnd = %p\n", stackEnd); #endif #if XCHAL_CP_NUM > 0 /* Ensure CP state descriptor is correctly initialized */ cpStack = thread->arch.preempCoprocReg.cpStack; /* short hand alias */ memset(cpStack, 0, XT_CP_ASA); /* Set to zero to avoid bad surprises */ /* Coprocessor's stack is allocated just after the k_thread */ cpSA = (u32_t *)(thread->arch.preempCoprocReg.cpStack + XT_CP_ASA); /* Coprocessor's save area alignment is at leat 16 bytes */ *cpSA = ROUND_UP(cpSA + 1, (XCHAL_TOTAL_SA_ALIGN < 16 ? 16 : XCHAL_TOTAL_SA_ALIGN)); #ifdef CONFIG_DEBUG printk("cpStack = %p\n", thread->arch.preempCoprocReg.cpStack); printk("cpAsa = %p\n", *(void **)(thread->arch.preempCoprocReg.cpStack + XT_CP_ASA)); #endif #endif /* Thread's first frame alignment is granted as both operands are * aligned */ XtExcFrame *pInitCtx = (XtExcFrame *)(stackEnd - (XT_XTRA_SIZE - XT_CP_SIZE)); #ifdef CONFIG_DEBUG printk("pInitCtx = %p\n", pInitCtx); #endif /* Explicitly initialize certain saved registers */ /* task entrypoint */ pInitCtx->pc = (u32_t)_thread_entry; /* physical top of stack frame */ pInitCtx->a1 = (u32_t)pInitCtx + XT_STK_FRMSZ; /* user exception exit dispatcher */ pInitCtx->exit = (u32_t)_xt_user_exit; /* Set initial PS to int level 0, EXCM disabled, user mode. * Also set entry point argument arg. */ #ifdef __XTENSA_CALL0_ABI__ pInitCtx->a2 = (u32_t)pEntry; pInitCtx->a3 = (u32_t)p1; pInitCtx->a4 = (u32_t)p2; pInitCtx->a5 = (u32_t)p3; pInitCtx->ps = PS_UM | PS_EXCM; #else /* For windowed ABI set also WOE and CALLINC * (pretend task is 'call4') */ pInitCtx->a6 = (u32_t)pEntry; pInitCtx->a7 = (u32_t)p1; pInitCtx->a8 = (u32_t)p2; pInitCtx->a9 = (u32_t)p3; pInitCtx->ps = PS_UM | PS_EXCM | PS_WOE | PS_CALLINC(1); #endif thread->callee_saved.topOfStack = pInitCtx; thread->arch.flags = 0; /* initial values in all other registers/k_thread entries are * irrelevant */ }
// this is the start point of execution at 0xBFC4A000 // // it loads the IOPBTCONF module list from rom0 and compiles a // list of modules and their addresses. // // this list is then passed to loadcore as it is executed in order // to then load the rest of the modules // // args: total size of IOP ram in MegaBytes // bootinfo flags // string containing the reboot image filepath // ? doesnt seem to be used void _start(int ramMBSize, int bootInfo, char* udnlString, int unk) { ROMFS ri; void *(*sysmem_entry)(u32 iopmemsize); void (*loadcore_entry)(BOOT_PARAMS *init); int i; ROMDIR_INFO romdir_info; ROMFILE_INFO romfile_info; char conf_filename[10]; int ram_byte_size, num_lines; u32 module_load_addr; u32** modules_ptr; char* file_data_ptr, *file_data_end; void* psysmemstart; BOOT_PARAMS* boot_params; if( ramMBSize <= 2 ) ram_byte_size = 2; else ram_byte_size = ramMBSize; ram_byte_size <<= 20; // compile module list to send to loadcore boot_params = (BOOT_PARAMS*)0x30000; // random address, has to be clear before loadcore call boot_params->ramMBSize = ramMBSize; boot_params->bootInfo = bootInfo; boot_params->udnlString = NULL; boot_params->moduleAddrs = (u32**)((u32)boot_params + sizeof(BOOT_PARAMS)); // right after // if a undl string is specified, get a copy of it and store a pointer to it if(udnlString) { boot_params->udnlString = (char*)boot_params->moduleAddrs; kstrcpy(boot_params->udnlString, udnlString); boot_params->moduleAddrs = (u32**)((u32)boot_params->udnlString + ROUND_UP(kstrlen(udnlString) + 8, 4)); } // find the romdir table in the rom if( searchRomDir((u32*)0xBFC00000, (u32*)0xBFC10000, &romdir_info) == NULL ) { __printf("IOPBOOT: failed to find start of rom!\n"); // error - cant find romdir! while(1) *(u8*)0x80000000 = 0; } // find the bootconf file in the romdir table kstrcpy(conf_filename, "IOPBTCONF"); conf_filename[8] = '0' + bootInfo; if( !searchFileInRom(&romdir_info, conf_filename, &romfile_info) ) { kstrcpy(conf_filename, "IOPBTCONF"); if( !searchFileInRom(&romdir_info, conf_filename, &romfile_info) ) { __printf("IOPBTCONF file not found!\n"); // error - cant find conf file! while(1) *(u8*)0x80000000 = 1; } } // count the number of lines in conf file file_data_ptr = (char*)romfile_info.fileData; file_data_end = (char*)romfile_info.fileData + romfile_info.entry->fileSize; { num_lines = 0; while( file_data_ptr < file_data_end ) { // loop until a "newline" charcter is found while(file_data_ptr < file_data_end) { if(*file_data_ptr++ < ' ') break; } // loop until a "non-newline" charcter is found while(file_data_ptr < file_data_end) { if(*file_data_ptr++ >= ' ') break; } num_lines++; } num_lines++; } // get the addresses of each module { module_load_addr = 0; boot_params->numConfLines = num_lines-1; modules_ptr = boot_params->moduleAddrs; char* file_data_ptr = (char*)romfile_info.fileData; while( file_data_ptr < file_data_end ) { if(*file_data_ptr == '@') { file_data_ptr++; module_load_addr = getHexNumber(&file_data_ptr); } else if(*file_data_ptr == '!') { if( file_data_ptr[1] == 'a' && file_data_ptr[2] == 'd' && file_data_ptr[3] == 'd' && file_data_ptr[4] == 'r' && file_data_ptr[5] == ' ' ) { file_data_ptr += 6; *modules_ptr++ = (u32*)(getHexNumber(&file_data_ptr) * 4 + 1); *modules_ptr++ = 0; } } else if(*file_data_ptr != '#') { // 'file_data_ptr' should be pointing to a filename // this finds the address of that file in the rom ROMFILE_INFO module_fileinfo; char strmodule[16]; for(i = 0; i < 16; ++i) { if( file_data_ptr[i] < ' ' ) break; strmodule[i] = file_data_ptr[i]; } strmodule[i] = 0; if( searchFileInRom(&romdir_info, strmodule, &module_fileinfo) == NULL ) { __printf("IOPBOOT: failed to find %s module\n", strmodule); return; } //__printf("mod: %s:%x\n", strmodule, module_fileinfo.fileData); *modules_ptr++ = (u32*)module_fileinfo.fileData; *modules_ptr = 0; // don't increment } // loop until a "newline" charcter is found while(file_data_ptr < file_data_end) { if(*file_data_ptr++ < ' ') break; } // loop until a "non-newline" charcter is found while(file_data_ptr < file_data_end) { if(*file_data_ptr >= ' ') break; file_data_ptr++; } } } if( searchFileInRom(&romdir_info, "IOPBOOT", &romfile_info) == NULL ) { __printf("loadElfFile: failed to find IOPBOOT module\n"); return; } // load sysmem module to memory and execute it if( searchFileInRom(&romdir_info, "SYSMEM", &romfile_info) == NULL ) { __printf("loadElfFile: failed to find SYSMEM module\n"); return; } sysmem_entry = (void *(*)(u32))loadElfFile(&romfile_info, module_load_addr); if( sysmem_entry == 0 ) return; psysmemstart = sysmem_entry(ram_byte_size); //FlushIcache(); if( psysmemstart == 0 ) { __printf("IOPBOOT: sysmem failed\n"); return; } __printf("SYSMEM success, start addr: %x, alloc start: %x\n", module_load_addr, psysmemstart); if( searchFileInRom(&romdir_info, "LOADCORE", &romfile_info) == NULL ) { __printf("loadElfFile: failed to find SYSMEM module\n"); return; } loadcore_entry = (void (*)())loadElfFile(&romfile_info, (u32)psysmemstart); if( loadcore_entry == 0 ) return; boot_params->firstModuleAddr = (u32)module_load_addr + 0x30; // skip elf? if(0x1FC10000 < ram_byte_size) { boot_params->pos = 0x1FC00000; boot_params->size = 0x10100; } else { boot_params->pos = 0; boot_params->size = 0; } __printf("executing LOADCORE entry at %p\n", loadcore_entry); loadcore_entry(boot_params); __printf("iopboot error\n"); // error - loadcore shouldnt ever return while(1) *(u8*)0x80000000 = 2; }
void op_x86_res_calc( int blockIdx, double *ind_arg0, double *ind_arg1, double *ind_arg2, int *ind_map, short *arg_map, double *arg8, int *ind_arg_sizes, int *ind_arg_offs, int block_offset, int *blkmap, int *offset, int *nelems, int *ncolors, int *colors, int set_size) { double arg9_l[1]; double arg10_l[1]; double arg11_l[1]; double arg12_l[1]; double *arg0_vec[4]; double *arg1_vec[4]; double *arg2_vec[4] = { arg9_l, arg10_l, arg11_l, arg12_l }; int *ind_arg0_map, ind_arg0_size; int *ind_arg1_map, ind_arg1_size; int *ind_arg2_map, ind_arg2_size; double *ind_arg0_s; double *ind_arg1_s; double *ind_arg2_s; int nelem, offset_b; char shared[128000]; if (0==0) { // get sizes and shift pointers and direct-mapped data int blockId = blkmap[blockIdx + block_offset]; nelem = nelems[blockId]; offset_b = offset[blockId]; ind_arg0_size = ind_arg_sizes[0+blockId*3]; ind_arg1_size = ind_arg_sizes[1+blockId*3]; ind_arg2_size = ind_arg_sizes[2+blockId*3]; ind_arg0_map = &ind_map[0*set_size] + ind_arg_offs[0+blockId*3]; ind_arg1_map = &ind_map[4*set_size] + ind_arg_offs[1+blockId*3]; ind_arg2_map = &ind_map[8*set_size] + ind_arg_offs[2+blockId*3]; // set shared memory pointers int nbytes = 0; ind_arg0_s = (double *) &shared[nbytes]; nbytes += ROUND_UP(ind_arg0_size*sizeof(double)*2); ind_arg1_s = (double *) &shared[nbytes]; nbytes += ROUND_UP(ind_arg1_size*sizeof(double)*1); ind_arg2_s = (double *) &shared[nbytes]; } // copy indirect datasets into shared memory or zero increment for (int n=0; n<ind_arg0_size; n++) for (int d=0; d<2; d++) ind_arg0_s[d+n*2] = ind_arg0[d+ind_arg0_map[n]*2]; for (int n=0; n<ind_arg1_size; n++) for (int d=0; d<1; d++) ind_arg1_s[d+n*1] = ind_arg1[d+ind_arg1_map[n]*1]; for (int n=0; n<ind_arg2_size; n++) for (int d=0; d<1; d++) ind_arg2_s[d+n*1] = ZERO_double; // process set elements for (int n=0; n<nelem; n++) { // initialise local variables for (int d=0; d<1; d++) arg9_l[d] = ZERO_double; for (int d=0; d<1; d++) arg10_l[d] = ZERO_double; for (int d=0; d<1; d++) arg11_l[d] = ZERO_double; for (int d=0; d<1; d++) arg12_l[d] = ZERO_double; arg0_vec[0] = ind_arg0_s+arg_map[0*set_size+n+offset_b]*2; arg0_vec[1] = ind_arg0_s+arg_map[1*set_size+n+offset_b]*2; arg0_vec[2] = ind_arg0_s+arg_map[2*set_size+n+offset_b]*2; arg0_vec[3] = ind_arg0_s+arg_map[3*set_size+n+offset_b]*2; arg1_vec[0] = ind_arg1_s+arg_map[4*set_size+n+offset_b]*1; arg1_vec[1] = ind_arg1_s+arg_map[5*set_size+n+offset_b]*1; arg1_vec[2] = ind_arg1_s+arg_map[6*set_size+n+offset_b]*1; arg1_vec[3] = ind_arg1_s+arg_map[7*set_size+n+offset_b]*1; // user-supplied kernel call res_calc( arg0_vec, arg1_vec, arg8+(n+offset_b)*16, arg2_vec); // store local variables int arg9_map = arg_map[8*set_size+n+offset_b]; int arg10_map = arg_map[9*set_size+n+offset_b]; int arg11_map = arg_map[10*set_size+n+offset_b]; int arg12_map = arg_map[11*set_size+n+offset_b]; for (int d=0; d<1; d++) ind_arg2_s[d+arg9_map*1] += arg9_l[d]; for (int d=0; d<1; d++) ind_arg2_s[d+arg10_map*1] += arg10_l[d]; for (int d=0; d<1; d++) ind_arg2_s[d+arg11_map*1] += arg11_l[d]; for (int d=0; d<1; d++) ind_arg2_s[d+arg12_map*1] += arg12_l[d]; } // apply pointered write/increment for (int n=0; n<ind_arg2_size; n++) for (int d=0; d<1; d++) ind_arg2[d+ind_arg2_map[n]*1] += ind_arg2_s[d+n*1]; }
int main ( int argc, char ** argv ) { int init_address=-1; int max_align = 0; unsigned long curr_size = 0; bfd *obj_bfd = NULL; bfd_error_type myerr; unsigned u = 0, v = 0; asymbol **q = NULL; asection *s = NULL; static struct bfd_link_callbacks link_callbacks; static struct bfd_link_order link_order; void *current = NULL; void *cfd_self = NULL; void *cfd_start = NULL; int cfd_size = 0; void *the_start = NULL; void *start_address = NULL; void *m = NULL; fprintf ( stderr, "In BFD fast load test. Reloc_howto_type size %d\n", sizeof ( rhtt ) ); if ( argc < 3 ) { fprintf ( stderr, "Need an executable (eg raw_gcl.exe) and an object file as arguments.\n" ); } else { memset ( &link_info, 0, sizeof (link_info) ); memset ( &link_order, 0, sizeof (link_order) ); memset ( &link_callbacks, 0, sizeof (link_callbacks) ); fprintf ( stderr, "BUILDING EXECUTABLE SYMBOL TABLE FOR %s \n", argv[1] ); build_symbol_table_bfd ( argv[1] ); link_callbacks.add_archive_element=madd_archive_element; link_callbacks.multiple_definition=mmultiple_definition; link_callbacks.multiple_common=mmultiple_common; link_callbacks.add_to_set=madd_to_set; link_callbacks.constructor=mconstructor; link_callbacks.warning=mwarning; link_callbacks.undefined_symbol=mundefined_symbol; link_callbacks.reloc_overflow=mreloc_overflow; link_callbacks.reloc_dangerous=mreloc_dangerous; link_callbacks.unattached_reloc=munattached_reloc; link_callbacks.notice = mnotice; link_info.callbacks = &link_callbacks; link_order.type = bfd_indirect_link_order; fprintf ( stderr, "OPENING OBJECT FILE %s\n", argv[2] ); if ( ! ( obj_bfd = bfd_openr ( argv[2], 0 ) ) ) { fprintf ( stderr, "Cannot open bfd.\n" ); } if ( ( myerr = bfd_get_error () ) && myerr != 3 ) { fprintf ( stderr, "Unknown bfd error code on openr %s %d\n.", argv[2], myerr ); } fflush ( stderr ); if ( ! bfd_check_format ( obj_bfd, bfd_object ) ) { fprintf ( stderr, "Unknown bfd format %s.\n", argv[2] ); } if ( ( myerr = bfd_get_error () ) && myerr != 3 ) { fprintf ( stderr, "Unknown bfd error code on check_format %s\n", argv[2] ); } bfd_set_error(0); current = NULL; fprintf ( stderr, "CALCULATING CURRENT, MAX_ALIGN and ALLOCATING \n\n" ); for ( s= obj_bfd->sections;s;s=s->next) { s->owner = obj_bfd; s->output_section = ( s->flags & SEC_ALLOC) ? s : obj_bfd->sections; s->output_offset=0; if (!(s->flags & SEC_ALLOC)) continue; if (max_align<s->alignment_power) max_align=s->alignment_power; current=round_up(current,1<<s->alignment_power); current+=s->_raw_size; fprintf ( stderr, "Section %s: owner = %x, output_offset = %x, " "output_section = %x (%s)\n", s->name, s->owner, s->output_offset, s->output_section, s->output_section->name ); } fprintf ( stderr, "1\n"); curr_size=(unsigned long)current; max_align=1<<max_align; cfd_self = 0; cfd_start = 0; cfd_size = curr_size + (max_align > sizeof(char *) ? max_align :0); cfd_start = (void *) malloc ( cfd_size ); the_start = start_address = cfd_start; fprintf ( stderr, "ALLOCATED %d bytes \n\n", cfd_size ); fprintf ( stderr, "max_align = %d, current = %d, cfd_self = %x, " "cfd_size = %x, cfd_start = %x\n", max_align, current, cfd_self, cfd_size, cfd_start ); start_address = ROUND_UP ( start_address, max_align ); cfd_size = cfd_size - ( start_address - the_start ); cfd_start = (void *) start_address; fprintf ( stderr, "max_align = %d, current = %d, cfd_self = %x, " "cfd_size = %x, cfd_start = %x\n", max_align, current, cfd_self, cfd_size, cfd_start ); memset ( cfd_start, 0, cfd_size ); for ( m = start_address, s = obj_bfd->sections; s; s=s->next ) { if (!(s->flags & SEC_ALLOC)) continue; m=round_up(m,1<<s->alignment_power); s->output_section->vma=(unsigned long)m; m+=s->_raw_size; fprintf ( stderr, "Section address %x\n", s ); fprintf ( stderr, "m loop Section %s: owner = %x, output_offset = %x, " "output_section = %x (%s), vma = %x, m = %x\n", s->name, s->owner, s->output_offset, s->output_section, s->output_section->name, s->output_section->vma, m ); } fprintf ( stderr, "\n\nDOING SOMETHING WITH THE HASHED SYMBOLS\n\n" ); if ((u=bfd_get_symtab_upper_bound(obj_bfd))<0) fprintf ( stderr, "Cannot get symtab uppoer bound.\n" ); q = (asymbol **) alloca ( u ); if ( ( v = bfd_canonicalize_symtab ( obj_bfd, q ) ) < 0 ) fprintf ( stderr, "cannot canonicalize symtab.\n" ); fprintf ( stderr, "u = %d, v = %d\n", u, v ); for (u=0;u<v;u++) { struct bfd_link_hash_entry *h; fprintf ( stderr, "u loop q[%d]->name = %s\n", u, q[u]->name ); if (!strncmp("init_",q[u]->name,5)) { init_address=q[u]->value; continue; } if (!(h=bfd_link_hash_lookup(link_info.hash,q[u]->name, MY_BFD_FALSE, MY_BFD_FALSE, MY_BFD_TRUE))) continue; if (h->type!=bfd_link_hash_defined) fprintf ( stderr, "Undefined symbol.\n" ); if (h->u.def.section) { q[u]->value=h->u.def.value+h->u.def.section->vma; q[u]->flags|=BSF_WEAK; } else fprintf ( stderr, "Symbol without section.\n" ); } fprintf ( stderr, "\n\nDOING RELOCATIONS\n\n", cfd_size ); fflush ( stderr ); for ( s = obj_bfd->sections; s; s = s->next ) { fprintf ( stderr, "s->name %s, s->flags = %x\n", s->name, s->flags ); if ( ! ( s->flags & SEC_LOAD ) ) continue; link_order.u.indirect.section=s; fprintf ( stderr, "About to get reloc section contents\n" ); fprintf ( stderr, "obj_bfd = %x, section %s, s->output_section = %x, q = %x\n", obj_bfd, s->name, s->output_section, q); fflush ( stderr ); if (!bfd_get_relocated_section_contents(obj_bfd, &link_info,&link_order, (void *)(unsigned long)s->output_section->vma,0,q)) fprintf ( stderr, "Cannot get relocated section contents\n"); } bfd_close ( obj_bfd ); printf("start address -T %x \n", cfd_start); } }
size_t ofl_structs_flow_stats_ofp_len(struct ofl_flow_stats *stats, struct ofl_exp *exp) { return ROUND_UP((sizeof(struct ofp_flow_stats) - 4) + stats->match->length,8) + ofl_structs_instructions_ofp_total_len(stats->instructions, stats->instructions_num, exp); }
/* ======================================================================== Routine Description: Construct the Key Data field of EAPoL message Arguments: pAd Pointer to our adapter Elem Message body Return Value: None Note: ======================================================================== */ VOID ConstructEapolKeyData( IN PRTMP_ADAPTER pAd, IN UCHAR AuthMode, IN UCHAR WepStatus, IN UCHAR GroupKeyWepStatus, IN UCHAR MsgType, IN UCHAR DefaultKeyIdx, IN BOOLEAN bWPA2Capable, IN UCHAR *PTK, IN UCHAR *GTK, IN UCHAR *RSNIE, IN UCHAR RSNIE_LEN, OUT PEAPOL_PACKET pMsg) { UCHAR *mpool, *Key_Data, *Rc4GTK; UCHAR ekey[(LEN_KEY_DESC_IV+LEN_EAP_EK)]; UCHAR data_offset; if (MsgType == EAPOL_PAIR_MSG_1 || MsgType == EAPOL_PAIR_MSG_4 || MsgType == EAPOL_GROUP_MSG_2) return; // allocate memory pool os_alloc_mem(pAd, (PUCHAR *)&mpool, 1500); if (mpool == NULL) return; /* Rc4GTK Len = 512 */ Rc4GTK = (UCHAR *) ROUND_UP(mpool, 4); /* Key_Data Len = 512 */ Key_Data = (UCHAR *) ROUND_UP(Rc4GTK + 512, 4); NdisZeroMemory(Key_Data, 512); pMsg->KeyDesc.KeyDataLen[1] = 0; data_offset = 0; // Encapsulate RSNIE in pairwise_msg2 & pairwise_msg3 if (RSNIE_LEN && ((MsgType == EAPOL_PAIR_MSG_2) || (MsgType == EAPOL_PAIR_MSG_3))) { if (bWPA2Capable) Key_Data[data_offset + 0] = IE_WPA2; else Key_Data[data_offset + 0] = IE_WPA; Key_Data[data_offset + 1] = RSNIE_LEN; NdisMoveMemory(&Key_Data[data_offset + 2], RSNIE, RSNIE_LEN); data_offset += (2 + RSNIE_LEN); } // Encapsulate KDE format in pairwise_msg3_WPA2 & group_msg1_WPA2 if (bWPA2Capable && ((MsgType == EAPOL_PAIR_MSG_3) || (MsgType == EAPOL_GROUP_MSG_1))) { // Key Data Encapsulation (KDE) format - 802.11i-2004 Figure-43w and Table-20h Key_Data[data_offset + 0] = 0xDD; if (GroupKeyWepStatus == Ndis802_11Encryption3Enabled) { Key_Data[data_offset + 1] = 0x16;// 4+2+16(OUI+DataType+DataField) } else { Key_Data[data_offset + 1] = 0x26;// 4+2+32(OUI+DataType+DataField) } Key_Data[data_offset + 2] = 0x00; Key_Data[data_offset + 3] = 0x0F; Key_Data[data_offset + 4] = 0xAC; Key_Data[data_offset + 5] = 0x01; // GTK KDE format - 802.11i-2004 Figure-43x Key_Data[data_offset + 6] = (DefaultKeyIdx & 0x03); Key_Data[data_offset + 7] = 0x00; // Reserved Byte data_offset += 8; } // Encapsulate GTK and encrypt the key-data field with KEK. // Only for pairwise_msg3_WPA2 and group_msg1 if ((MsgType == EAPOL_PAIR_MSG_3 && bWPA2Capable) || (MsgType == EAPOL_GROUP_MSG_1)) { // Fill in GTK if (GroupKeyWepStatus == Ndis802_11Encryption3Enabled) { NdisMoveMemory(&Key_Data[data_offset], GTK, LEN_AES_KEY); data_offset += LEN_AES_KEY; } else { NdisMoveMemory(&Key_Data[data_offset], GTK, TKIP_GTK_LENGTH); data_offset += TKIP_GTK_LENGTH; } // Still dont know why, but if not append will occur "GTK not include in MSG3" // Patch for compatibility between zero config and funk if (MsgType == EAPOL_PAIR_MSG_3 && bWPA2Capable) { if (GroupKeyWepStatus == Ndis802_11Encryption3Enabled) { Key_Data[data_offset + 0] = 0xDD; Key_Data[data_offset + 1] = 0; data_offset += 2; } else { Key_Data[data_offset + 0] = 0xDD; Key_Data[data_offset + 1] = 0; Key_Data[data_offset + 2] = 0; Key_Data[data_offset + 3] = 0; Key_Data[data_offset + 4] = 0; Key_Data[data_offset + 5] = 0; data_offset += 6; } } // Encrypt the data material in key data field if (WepStatus == Ndis802_11Encryption3Enabled) { AES_GTK_KEY_WRAP(&PTK[16], Key_Data, data_offset, Rc4GTK); // AES wrap function will grow 8 bytes in length data_offset += 8; } else { // PREPARE Encrypted "Key DATA" field. (Encrypt GTK with RC4, usinf PTK[16]->[31] as Key, IV-field as IV) // put TxTsc in Key RSC field pAd->PrivateInfo.FCSCRC32 = PPPINITFCS32; //Init crc32. // ekey is the contanetion of IV-field, and PTK[16]->PTK[31] NdisMoveMemory(ekey, pMsg->KeyDesc.KeyIv, LEN_KEY_DESC_IV); NdisMoveMemory(&ekey[LEN_KEY_DESC_IV], &PTK[16], LEN_EAP_EK); ARCFOUR_INIT(&pAd->PrivateInfo.WEPCONTEXT, ekey, sizeof(ekey)); //INIT SBOX, KEYLEN+3(IV) pAd->PrivateInfo.FCSCRC32 = RTMP_CALC_FCS32(pAd->PrivateInfo.FCSCRC32, Key_Data, data_offset); WPAARCFOUR_ENCRYPT(&pAd->PrivateInfo.WEPCONTEXT, Rc4GTK, Key_Data, data_offset); } NdisMoveMemory(pMsg->KeyDesc.KeyData, Rc4GTK, data_offset); } else { NdisMoveMemory(pMsg->KeyDesc.KeyData, Key_Data, data_offset); } // set key data length field and total length pMsg->KeyDesc.KeyDataLen[1] = data_offset; pMsg->Body_Len[1] += data_offset; os_free_mem(pAd, mpool); }
NTSTATUS RtlCreateProcessParameters( OUT PRTL_USER_PROCESS_PARAMETERS *pProcessParameters, IN PUNICODE_STRING ImagePathName, IN PUNICODE_STRING DllPath OPTIONAL, IN PUNICODE_STRING CurrentDirectory OPTIONAL, IN PUNICODE_STRING CommandLine OPTIONAL, IN PVOID Environment OPTIONAL, IN PUNICODE_STRING WindowTitle OPTIONAL, IN PUNICODE_STRING DesktopInfo OPTIONAL, IN PUNICODE_STRING ShellInfo OPTIONAL, IN PUNICODE_STRING RuntimeData OPTIONAL ) /*++ Routine Description: This function formats NT style RTL_USER_PROCESS_PARAMETERS record. The record is self-contained in a single block of memory allocated by this function. The allocation method is opaque and thus the record must be freed by calling the RtlDestroyProcessParameters function. The process parameters record is created in a de-normalized form, thus making it suitable for passing to the RtlCreateUserProcess function. It is expected that the caller will fill in additional fields in the process parameters record after this function returns, but prior to calling RtlCreateUserProcess. Arguments: pProcessParameters - Pointer to a variable that will receive the address of the process parameter structure created by this routine. The memory for the structure is allocated in an opaque manner and must be freed by calling RtlDestroyProcessParameters. ImagePathName - Required parameter that is the fully qualified NT path name of the image file that will be used to create the process that will received these parameters. DllPath - An optional parameter that is an NT String variable pointing to the search path the NT Loader is to use in the target process when searching for Dll modules. If not specified, then the Dll search path is filled in from the current process's Dll search path. CurrentDirectory - An optional parameter that is an NT String variable pointing to the default directory string for the target process. If not specified, then the current directory string is filled in from the current process's current directory string. CommandLine - An optional parameter that is an NT String variable that will be passed to the target process as its command line. If not specified, then the command line passed to the target process will be a null string. Environment - An optional parameter that is an opaque pointer to an environment variable block of the type created by RtlCreateEnvironment routine. If not specified, then the target process will receive a copy of the calling process's environment variable block. WindowTitle - An optional parameter that is an NT String variable that points to the title string the target process is to use for its main window. If not specified, then a null string will be passed to the target process as its default window title. DesktopInfo - An optional parameter that is an NT String variable that contains uninterpreted data that is passed as is to the target process. If not specified, the target process will receive a pointer to an empty string. ShellInfo - An optional parameter that is an NT String variable that contains uninterpreted data that is passed as is to the target process. If not specified, the target process will receive a pointer to an empty string. RuntimeData - An optional parameter that is an NT String variable that contains uninterpreted data that is passed as is to the target process. If not specified, the target process will receive a pointer to an empty string. Return Value: STATUS_SUCCESS - The process parameters is De-Normalized and contains entries for each of the specified argument and variable strings. STATUS_BUFFER_TOO_SMALL - The specified process parameters buffer is too small to contain the argument and environment strings. The value of ProcessParameters->Length is modified to contain the buffer size needed to contain the argument and variable strings. --*/ { PRTL_USER_PROCESS_PARAMETERS p; NTSTATUS Status; ULONG ByteCount; PWSTR pDst; PPEB Peb; PRTL_USER_PROCESS_PARAMETERS ProcessParameters; HANDLE CurDirHandle; BOOLEAN PebLockAcquired = FALSE; // // Acquire the Peb Lock for the duration while we copy information out // of it. // Peb = NtCurrentPeb(); ProcessParameters = Peb->ProcessParameters; Status = STATUS_SUCCESS; p = NULL; CurDirHandle = NULL; try { // // Validate input parameters // #define VALIDATE_STRING_PARAMETER(_x) \ do { \ ASSERT(ARGUMENT_PRESENT((_x))); \ if (!ARGUMENT_PRESENT((_x))) { \ Status = STATUS_INVALID_PARAMETER; \ leave; \ } \ if (ARGUMENT_PRESENT((_x))) { \ ASSERT((_x)->MaximumLength >= (_x)->Length); \ ASSERT(((_x)->Length == 0) || ((_x)->Buffer != NULL)); \ if (((_x)->MaximumLength < (_x)->Length) || \ (((_x)->Length != 0) && ((_x)->Buffer == NULL))) { \ Status = STATUS_INVALID_PARAMETER; \ leave; \ } \ } \ } while (0) #define VALIDATE_OPTIONAL_STRING_PARAMETER(_x) \ do { \ if (ARGUMENT_PRESENT((_x))) { \ ASSERT((_x)->MaximumLength >= (_x)->Length); \ ASSERT(((_x)->Length == 0) || ((_x)->Buffer != NULL)); \ if (((_x)->MaximumLength < (_x)->Length) || \ (((_x)->Length != 0) && ((_x)->Buffer == NULL))) { \ Status = STATUS_INVALID_PARAMETER; \ leave; \ } \ } \ } while (0) VALIDATE_STRING_PARAMETER (ImagePathName); VALIDATE_OPTIONAL_STRING_PARAMETER (DllPath); VALIDATE_OPTIONAL_STRING_PARAMETER (CurrentDirectory); VALIDATE_OPTIONAL_STRING_PARAMETER (CommandLine); VALIDATE_OPTIONAL_STRING_PARAMETER (WindowTitle); VALIDATE_OPTIONAL_STRING_PARAMETER (DesktopInfo); VALIDATE_OPTIONAL_STRING_PARAMETER (ShellInfo); VALIDATE_OPTIONAL_STRING_PARAMETER (RuntimeData); #undef VALIDATE_STRING_PARAMETER #undef VALIDATE_OPTIONAL_STRING_PARAMETER if (!ARGUMENT_PRESENT (CommandLine)) { CommandLine = ImagePathName; } if (!ARGUMENT_PRESENT (WindowTitle)) { WindowTitle = (PUNICODE_STRING)&NullString; } if (!ARGUMENT_PRESENT (DesktopInfo)) { DesktopInfo = (PUNICODE_STRING)&NullString; } if (!ARGUMENT_PRESENT (ShellInfo)) { ShellInfo = (PUNICODE_STRING)&NullString; } if (!ARGUMENT_PRESENT (RuntimeData)) { RuntimeData = (PUNICODE_STRING)&NullString; } // // Determine size need to contain the process parameter record // structure and all of the strings it will point to. Each string // will be aligned on a ULONG byte boundary. // We do the ones we can outside of the peb lock. // ByteCount = sizeof (*ProcessParameters); ByteCount += ROUND_UP (DOS_MAX_PATH_LENGTH*2, sizeof( ULONG ) ); ByteCount += ROUND_UP (ImagePathName->Length + sizeof(UNICODE_NULL), sizeof( ULONG ) ); ByteCount += ROUND_UP (CommandLine->Length + sizeof(UNICODE_NULL), sizeof( ULONG ) ); ByteCount += ROUND_UP (WindowTitle->MaximumLength, sizeof( ULONG ) ); ByteCount += ROUND_UP (DesktopInfo->MaximumLength, sizeof( ULONG ) ); ByteCount += ROUND_UP (ShellInfo->MaximumLength, sizeof( ULONG ) ); ByteCount += ROUND_UP (RuntimeData->MaximumLength, sizeof( ULONG ) ); PebLockAcquired = TRUE; RtlAcquirePebLock (); // // For optional pointer parameters, default them to point to their // corresponding field in the current process's process parameter // structure or to a null string. // if (!ARGUMENT_PRESENT (DllPath)) { DllPath = &ProcessParameters->DllPath; } if (!ARGUMENT_PRESENT (CurrentDirectory)) { if (ProcessParameters->CurrentDirectory.Handle) { CurDirHandle = (HANDLE)((ULONG_PTR)ProcessParameters->CurrentDirectory.Handle & ~OBJ_HANDLE_TAGBITS); CurDirHandle = (HANDLE)((ULONG_PTR)CurDirHandle | RTL_USER_PROC_CURDIR_INHERIT); } CurrentDirectory = &ProcessParameters->CurrentDirectory.DosPath; } else { ASSERT(CurrentDirectory->MaximumLength >= CurrentDirectory->Length); ASSERT((CurrentDirectory->Length == 0) || (CurrentDirectory->Buffer != NULL)); if (ProcessParameters->CurrentDirectory.Handle) { CurDirHandle = (HANDLE)((ULONG_PTR)ProcessParameters->CurrentDirectory.Handle & ~OBJ_HANDLE_TAGBITS); CurDirHandle = (HANDLE)((ULONG_PTR)CurDirHandle | RTL_USER_PROC_CURDIR_CLOSE); } } if (!ARGUMENT_PRESENT (Environment)) { Environment = ProcessParameters->Environment; } ByteCount += ROUND_UP (DllPath->MaximumLength, sizeof( ULONG ) ); // // Allocate memory for the process parameter record. // p = RtlAllocateHeap (RtlProcessHeap (), 0, ByteCount); if (p == NULL) { Status = STATUS_INSUFFICIENT_RESOURCES; __leave; } RtlZeroMemory (p, sizeof (*p)); p->MaximumLength = ByteCount; p->Length = ByteCount; p->Flags = RTL_USER_PROC_PARAMS_NORMALIZED; p->DebugFlags = 0; p->Environment = Environment; p->CurrentDirectory.Handle = CurDirHandle; // // Inherits ^C inhibit information // p->ConsoleFlags = ProcessParameters->ConsoleFlags; pDst = (PWSTR)(p + 1); RtlpCopyProcString (&pDst, &p->CurrentDirectory.DosPath, CurrentDirectory, DOS_MAX_PATH_LENGTH*2); RtlpCopyProcString (&pDst, &p->DllPath, DllPath, 0); RtlpCopyProcString (&pDst, &p->ImagePathName, ImagePathName, ImagePathName->Length + sizeof (UNICODE_NULL)); if (CommandLine->Length == CommandLine->MaximumLength) { RtlpCopyProcString (&pDst, &p->CommandLine, CommandLine, 0); } else { RtlpCopyProcString (&pDst, &p->CommandLine, CommandLine, CommandLine->Length + sizeof (UNICODE_NULL)); } RtlpCopyProcString (&pDst, &p->WindowTitle, WindowTitle, 0); RtlpCopyProcString (&pDst, &p->DesktopInfo, DesktopInfo, 0); RtlpCopyProcString (&pDst, &p->ShellInfo, ShellInfo, 0); if (RuntimeData->Length != 0) { RtlpCopyProcString (&pDst, &p->RuntimeData, RuntimeData, 0); } *pProcessParameters = RtlDeNormalizeProcessParams (p); p = NULL; } finally { if (PebLockAcquired) { RtlReleasePebLock(); } if (AbnormalTermination ()) { Status = STATUS_ACCESS_VIOLATION; } if (p != NULL) { RtlDestroyProcessParameters (p); } } return Status; }
/* * Creates a stack for a thread or fiber */ NTSTATUS WINAPI BaseCreateStack(HANDLE hProcess, SIZE_T StackReserve, SIZE_T StackCommit, PINITIAL_TEB InitialTeb) { NTSTATUS Status; PIMAGE_NT_HEADERS Headers; ULONG_PTR Stack; ULONG PageSize, Dummy, AllocationGranularity; SIZE_T StackReserveHeader, StackCommitHeader, GuardPageSize, GuaranteedStackCommit; DPRINT("BaseCreateStack (hProcess: %p, Max: %lx, Current: %lx)\n", hProcess, StackReserve, StackCommit); /* Read page size */ PageSize = BaseStaticServerData->SysInfo.PageSize; AllocationGranularity = BaseStaticServerData->SysInfo.AllocationGranularity; /* Get the Image Headers */ Headers = RtlImageNtHeader(NtCurrentPeb()->ImageBaseAddress); if (!Headers) return STATUS_INVALID_IMAGE_FORMAT; StackCommitHeader = Headers->OptionalHeader.SizeOfStackCommit; StackReserveHeader = Headers->OptionalHeader.SizeOfStackReserve; if (!StackReserve) StackReserve = StackReserveHeader; if (!StackCommit) { StackCommit = StackCommitHeader; } else if (StackCommit >= StackReserve) { StackReserve = ROUND_UP(StackCommit, 1024 * 1024); } StackCommit = ROUND_UP(StackCommit, PageSize); StackReserve = ROUND_UP(StackReserve, AllocationGranularity); GuaranteedStackCommit = NtCurrentTeb()->GuaranteedStackBytes; if ((GuaranteedStackCommit) && (StackCommit < GuaranteedStackCommit)) { StackCommit = GuaranteedStackCommit; } if (StackCommit >= StackReserve) { StackReserve = ROUND_UP(StackCommit, 1024 * 1024); } StackCommit = ROUND_UP(StackCommit, PageSize); StackReserve = ROUND_UP(StackReserve, AllocationGranularity); /* Reserve memory for the stack */ Stack = 0; Status = NtAllocateVirtualMemory(hProcess, (PVOID*)&Stack, 0, &StackReserve, MEM_RESERVE, PAGE_READWRITE); if (!NT_SUCCESS(Status)) { DPRINT1("Failure to reserve stack: %lx\n", Status); return Status; } /* Now set up some basic Initial TEB Parameters */ InitialTeb->AllocatedStackBase = (PVOID)Stack; InitialTeb->StackBase = (PVOID)(Stack + StackReserve); InitialTeb->PreviousStackBase = NULL; InitialTeb->PreviousStackLimit = NULL; /* Update the Stack Position */ Stack += StackReserve - StackCommit; /* Allocate memory for the stack */ Status = NtAllocateVirtualMemory(hProcess, (PVOID*)&Stack, 0, &StackCommit, MEM_COMMIT, PAGE_READWRITE); if (!NT_SUCCESS(Status)) { DPRINT1("Failure to allocate stack\n"); GuardPageSize = 0; NtFreeVirtualMemory(hProcess, (PVOID*)&Stack, &GuardPageSize, MEM_RELEASE); return Status; } /* Now set the current Stack Limit */ InitialTeb->StackLimit = (PVOID)Stack; /* Create a guard page */ GuardPageSize = PageSize; Status = NtProtectVirtualMemory(hProcess, (PVOID*)&Stack, &GuardPageSize, PAGE_GUARD | PAGE_READWRITE, &Dummy); if (!NT_SUCCESS(Status)) { DPRINT1("Failure to set guard page\n"); return Status; } /* Update the Stack Limit keeping in mind the Guard Page */ InitialTeb->StackLimit = (PVOID)((ULONG_PTR)InitialTeb->StackLimit + GuardPageSize); /* We are done! */ return STATUS_SUCCESS; }
static int get_expected_segs_to_target(int inode, int target_node, int *num_segs_ortho_dir_ptr) { /* Returns the number of segments the same type as inode that will be needed * * to reach target_node (not including inode) in each direction (the same * * direction (horizontal or vertical) as inode and the orthogonal direction).*/ t_rr_type rr_type; int target_x, target_y, num_segs_same_dir, cost_index, ortho_cost_index; int no_need_to_pass_by_clb; float inv_length, ortho_inv_length, ylow, yhigh, xlow, xhigh; target_x = rr_node[target_node].xlow; target_y = rr_node[target_node].ylow; cost_index = rr_node[inode].cost_index; inv_length = rr_indexed_data[cost_index].inv_length; ortho_cost_index = rr_indexed_data[cost_index].ortho_cost_index; ortho_inv_length = rr_indexed_data[ortho_cost_index].inv_length; rr_type = rr_node[inode].type; if(rr_type == CHANX) { ylow = rr_node[inode].ylow; xhigh = rr_node[inode].xhigh; xlow = rr_node[inode].xlow; /* Count vertical (orthogonal to inode) segs first. */ if(ylow > target_y) { /* Coming from a row above target? */ *num_segs_ortho_dir_ptr = ROUND_UP((ylow - target_y + 1.) * ortho_inv_length); no_need_to_pass_by_clb = 1; } else if(ylow < target_y - 1) { /* Below the CLB bottom? */ *num_segs_ortho_dir_ptr = ROUND_UP((target_y - ylow) * ortho_inv_length); no_need_to_pass_by_clb = 1; } else { /* In a row that passes by target CLB */ *num_segs_ortho_dir_ptr = 0; no_need_to_pass_by_clb = 0; } /* Now count horizontal (same dir. as inode) segs. */ if(xlow > target_x + no_need_to_pass_by_clb) { num_segs_same_dir = ROUND_UP((xlow - no_need_to_pass_by_clb - target_x) * inv_length); } else if(xhigh < target_x - no_need_to_pass_by_clb) { num_segs_same_dir = ROUND_UP((target_x - no_need_to_pass_by_clb - xhigh) * inv_length); } else { num_segs_same_dir = 0; } } else { /* inode is a CHANY */ ylow = rr_node[inode].ylow; yhigh = rr_node[inode].yhigh; xlow = rr_node[inode].xlow; /* Count horizontal (orthogonal to inode) segs first. */ if(xlow > target_x) { /* Coming from a column right of target? */ *num_segs_ortho_dir_ptr = ROUND_UP((xlow - target_x + 1.) * ortho_inv_length); no_need_to_pass_by_clb = 1; } else if(xlow < target_x - 1) { /* Left of and not adjacent to the CLB? */ *num_segs_ortho_dir_ptr = ROUND_UP((target_x - xlow) * ortho_inv_length); no_need_to_pass_by_clb = 1; } else { /* In a column that passes by target CLB */ *num_segs_ortho_dir_ptr = 0; no_need_to_pass_by_clb = 0; } /* Now count vertical (same dir. as inode) segs. */ if(ylow > target_y + no_need_to_pass_by_clb) { num_segs_same_dir = ROUND_UP((ylow - no_need_to_pass_by_clb - target_y) * inv_length); } else if(yhigh < target_y - no_need_to_pass_by_clb) { num_segs_same_dir = ROUND_UP((target_y - no_need_to_pass_by_clb - yhigh) * inv_length); } else { num_segs_same_dir = 0; } } return (num_segs_same_dir); }
void * CacheRead( file_list * list, unsigned long pos, unsigned len ) /**************************************************************************/ /* read len bytes out of the cache. */ { unsigned bufnum; unsigned startnum; unsigned offset; unsigned amtread; char * result; char ** cache; unsigned long newpos; infilelist *file; if( list->file->flags & INSTAT_FULL_CACHE ) { if( pos + len > list->file->len ) return NULL; return (char *)list->file->cache + pos; } Multipage = FALSE; file = list->file; offset = pos % CACHE_PAGE_SIZE; amtread = CACHE_PAGE_SIZE - offset; startnum = pos / CACHE_PAGE_SIZE; bufnum = startnum; cache = file->cache; for(;;) { if( cache[bufnum] == NULL ) { // make sure page is in. _ChkAlloc( cache[bufnum], CACHE_PAGE_SIZE ); newpos = (unsigned long) bufnum * CACHE_PAGE_SIZE; if( file->currpos != newpos ) { QSeek( file->handle, newpos, file->name ); } file->currpos = newpos + CACHE_PAGE_SIZE; QRead( file->handle, cache[bufnum], CACHE_PAGE_SIZE, file->name ); } if( amtread >= len ) break; amtread += CACHE_PAGE_SIZE; // it spans pages. bufnum++; Multipage = TRUE; } if( !Multipage ) { result = cache[startnum] + offset; } else { if( len > TokSize ) { TokSize = ROUND_UP( len, SECTOR_SIZE ); _LnkReAlloc( TokBuff, TokBuff, TokSize ); } amtread = CACHE_PAGE_SIZE - offset; memcpy( TokBuff, cache[startnum] + offset, amtread ); len -= amtread; result = TokBuff + amtread; for(;;) { startnum++; if( len <= CACHE_PAGE_SIZE ) { memcpy( result, cache[startnum], len ); break; } else { memcpy( result, cache[startnum], CACHE_PAGE_SIZE ); len -= CACHE_PAGE_SIZE; result += CACHE_PAGE_SIZE; } } result = TokBuff; } return result; }
static int reiserfs_add_entry(struct reiserfs_transaction_handle *th, struct inode *dir, const char *name, int namelen, struct inode *inode, int visible) { struct cpu_key entry_key; struct reiserfs_de_head *deh; INITIALIZE_PATH(path); struct reiserfs_dir_entry de; DECLARE_BITMAP(bit_string, MAX_GENERATION_NUMBER + 1); int gen_number; char small_buf[32 + DEH_SIZE]; /* 48 bytes now and we avoid kmalloc if we create file with short name */ char *buffer; int buflen, paste_size; int retval; BUG_ON(!th->t_trans_id); /* cannot allow items to be added into a busy deleted directory */ if (!namelen) return -EINVAL; if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize)) return -ENAMETOOLONG; /* each entry has unique key. compose it */ make_cpu_key(&entry_key, dir, get_third_component(dir->i_sb, name, namelen), TYPE_DIRENTRY, 3); /* get memory for composing the entry */ buflen = DEH_SIZE + ROUND_UP(namelen); if (buflen > sizeof(small_buf)) { buffer = kmalloc(buflen, GFP_NOFS); if (!buffer) return -ENOMEM; } else buffer = small_buf; paste_size = (get_inode_sd_version(dir) == STAT_DATA_V1) ? (DEH_SIZE + namelen) : buflen; /* fill buffer : directory entry head, name[, dir objectid | , stat data | ,stat data, dir objectid ] */ deh = (struct reiserfs_de_head *)buffer; deh->deh_location = 0; /* JDM Endian safe if 0 */ put_deh_offset(deh, cpu_key_k_offset(&entry_key)); deh->deh_state = 0; /* JDM Endian safe if 0 */ /* put key (ino analog) to de */ deh->deh_dir_id = INODE_PKEY(inode)->k_dir_id; /* safe: k_dir_id is le */ deh->deh_objectid = INODE_PKEY(inode)->k_objectid; /* safe: k_objectid is le */ /* copy name */ memcpy((char *)(deh + 1), name, namelen); /* padd by 0s to the 4 byte boundary */ padd_item((char *)(deh + 1), ROUND_UP(namelen), namelen); /* entry is ready to be pasted into tree, set 'visibility' and 'stat data in entry' attributes */ mark_de_without_sd(deh); visible ? mark_de_visible(deh) : mark_de_hidden(deh); /* find the proper place for the new entry */ memset(bit_string, 0, sizeof(bit_string)); de.de_gen_number_bit_string = bit_string; retval = reiserfs_find_entry(dir, name, namelen, &path, &de); if (retval != NAME_NOT_FOUND) { if (buffer != small_buf) kfree(buffer); pathrelse(&path); if (retval == IO_ERROR) { return -EIO; } if (retval != NAME_FOUND) { reiserfs_error(dir->i_sb, "zam-7002", "reiserfs_find_entry() returned " "unexpected value (%d)", retval); } return -EEXIST; } gen_number = find_first_zero_bit(bit_string, MAX_GENERATION_NUMBER + 1); if (gen_number > MAX_GENERATION_NUMBER) { /* there is no free generation number */ reiserfs_warning(dir->i_sb, "reiserfs-7010", "Congratulations! we have got hash function " "screwed up"); if (buffer != small_buf) kfree(buffer); pathrelse(&path); return -EBUSY; } /* adjust offset of directory enrty */ put_deh_offset(deh, SET_GENERATION_NUMBER(deh_offset(deh), gen_number)); set_cpu_key_k_offset(&entry_key, deh_offset(deh)); /* update max-hash-collisions counter in reiserfs_sb_info */ PROC_INFO_MAX(th->t_super, max_hash_collisions, gen_number); if (gen_number != 0) { /* we need to re-search for the insertion point */ if (search_by_entry_key(dir->i_sb, &entry_key, &path, &de) != NAME_NOT_FOUND) { reiserfs_warning(dir->i_sb, "vs-7032", "entry with this key (%K) already " "exists", &entry_key); if (buffer != small_buf) kfree(buffer); pathrelse(&path); return -EBUSY; } } /* perform the insertion of the entry that we have prepared */ retval = reiserfs_paste_into_item(th, &path, &entry_key, dir, buffer, paste_size); if (buffer != small_buf) kfree(buffer); if (retval) { reiserfs_check_path(&path); return retval; } dir->i_size += paste_size; dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC; if (!S_ISDIR(inode->i_mode) && visible) // reiserfs_mkdir or reiserfs_rename will do that by itself reiserfs_update_sd(th, dir); reiserfs_check_path(&path); return 0; }
static int vpc_create(const char *filename, QemuOpts *opts, Error **errp) { uint8_t buf[1024]; VHDFooter *footer = (VHDFooter *) buf; char *disk_type_param; int i; uint16_t cyls = 0; uint8_t heads = 0; uint8_t secs_per_cyl = 0; int64_t total_sectors; int64_t total_size; int disk_type; int ret = -EIO; Error *local_err = NULL; BlockDriverState *bs = NULL; /* Read out options */ total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0), BDRV_SECTOR_SIZE); disk_type_param = qemu_opt_get_del(opts, BLOCK_OPT_SUBFMT); if (disk_type_param) { if (!strcmp(disk_type_param, "dynamic")) { disk_type = VHD_DYNAMIC; } else if (!strcmp(disk_type_param, "fixed")) { disk_type = VHD_FIXED; } else { ret = -EINVAL; goto out; } } else { disk_type = VHD_DYNAMIC; } ret = bdrv_create_file(filename, opts, &local_err); if (ret < 0) { error_propagate(errp, local_err); goto out; } ret = bdrv_open(&bs, filename, NULL, NULL, BDRV_O_RDWR | BDRV_O_PROTOCOL, NULL, &local_err); if (ret < 0) { error_propagate(errp, local_err); goto out; } /* * Calculate matching total_size and geometry. Increase the number of * sectors requested until we get enough (or fail). This ensures that * qemu-img convert doesn't truncate images, but rather rounds up. * * If the image size can't be represented by a spec conform CHS geometry, * we set the geometry to 65535 x 16 x 255 (CxHxS) sectors and use * the image size from the VHD footer to calculate total_sectors. */ total_sectors = MIN(VHD_MAX_GEOMETRY, total_size / BDRV_SECTOR_SIZE); for (i = 0; total_sectors > (int64_t)cyls * heads * secs_per_cyl; i++) { calculate_geometry(total_sectors + i, &cyls, &heads, &secs_per_cyl); } if ((int64_t)cyls * heads * secs_per_cyl == VHD_MAX_GEOMETRY) { total_sectors = total_size / BDRV_SECTOR_SIZE; /* Allow a maximum disk size of approximately 2 TB */ if (total_sectors > VHD_MAX_SECTORS) { ret = -EFBIG; goto out; } } else { total_sectors = (int64_t)cyls * heads * secs_per_cyl; total_size = total_sectors * BDRV_SECTOR_SIZE; } /* Prepare the Hard Disk Footer */ memset(buf, 0, 1024); memcpy(footer->creator, "conectix", 8); /* TODO Check if "qemu" creator_app is ok for VPC */ memcpy(footer->creator_app, "qemu", 4); memcpy(footer->creator_os, "Wi2k", 4); footer->features = cpu_to_be32(0x02); footer->version = cpu_to_be32(0x00010000); if (disk_type == VHD_DYNAMIC) { footer->data_offset = cpu_to_be64(HEADER_SIZE); } else { footer->data_offset = cpu_to_be64(0xFFFFFFFFFFFFFFFFULL); } footer->timestamp = cpu_to_be32(time(NULL) - VHD_TIMESTAMP_BASE); /* Version of Virtual PC 2007 */ footer->major = cpu_to_be16(0x0005); footer->minor = cpu_to_be16(0x0003); footer->orig_size = cpu_to_be64(total_size); footer->current_size = cpu_to_be64(total_size); footer->cyls = cpu_to_be16(cyls); footer->heads = heads; footer->secs_per_cyl = secs_per_cyl; footer->type = cpu_to_be32(disk_type); #if defined(CONFIG_UUID) uuid_generate(footer->uuid); #endif footer->checksum = cpu_to_be32(vpc_checksum(buf, HEADER_SIZE)); if (disk_type == VHD_DYNAMIC) { ret = create_dynamic_disk(bs, buf, total_sectors); } else { ret = create_fixed_disk(bs, buf, total_size); } out: bdrv_unref(bs); g_free(disk_type_param); return ret; }
ofl_err ofl_actions_unpack(struct ofp_action_header *src, size_t *len, struct ofl_action_header **dst, struct ofl_exp *exp) { if (*len < sizeof(struct ofp_action_header)) { OFL_LOG_WARN(LOG_MODULE, "Received action is too short (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } if (*len < ntohs(src->len)) { OFL_LOG_WARN(LOG_MODULE, "Received action has invalid length (set to %u, but only %zu received).", ntohs(src->len), *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } if ((ntohs(src->len) % 8) != 0) { OFL_LOG_WARN(LOG_MODULE, "Received action length is not a multiple of 64 bits (%u).", ntohs(src->len)); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } switch (ntohs(src->type)) { case OFPAT_OUTPUT: { struct ofp_action_output *sa; struct ofl_action_output *da; if (*len < sizeof(struct ofp_action_output)) { OFL_LOG_WARN(LOG_MODULE, "Received OUTPUT action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } sa = (struct ofp_action_output *)src; if (ntohl(sa->port) == 0 || (ntohl(sa->port) > OFPP_MAX && ntohl(sa->port) < OFPP_IN_PORT) || ntohl(sa->port) == OFPP_ANY) { if (OFL_LOG_IS_WARN_ENABLED(LOG_MODULE)) { char *ps = ofl_port_to_string(ntohl(sa->port)); OFL_LOG_WARN(LOG_MODULE, "Received OUTPUT action has invalid port (%s).", ps); free(ps); } return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_OUT_PORT); } da = (struct ofl_action_output *)malloc(sizeof(struct ofl_action_output)); da->port = ntohl(sa->port); da->max_len = ntohs(sa->max_len); *len -= sizeof(struct ofp_action_output); *dst = (struct ofl_action_header *)da; break; } case OFPAT_COPY_TTL_OUT: { //ofp_action_header length was already checked *len -= sizeof(struct ofp_action_header); *dst = (struct ofl_action_header *)malloc(sizeof(struct ofl_action_header)); break; } case OFPAT_COPY_TTL_IN: { //ofp_action_header length was already checked *len -= sizeof(struct ofp_action_header); *dst = (struct ofl_action_header *)malloc(sizeof(struct ofl_action_header)); break; } case OFPAT_XOR_ENCODE: { struct ofp_action_xor_encode *sa; struct ofl_action_xor_encode *da; if (*len < sizeof(struct ofp_action_xor_encode)) { OFL_LOG_WARN(LOG_MODULE, "Received OFPAT_XOR_ENCODE: action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } sa = (struct ofp_action_xor_encode *)src; da = (struct ofl_action_xor_encode *)malloc(sizeof(struct ofl_action_xor_encode)); da->label_a = sa->label_a; da->label_b = sa->label_b; *len -= sizeof(struct ofp_action_xor_encode); *dst = (struct ofl_action_header *)da; break; } case OFPAT_XOR_DECODE: { struct ofp_action_xor_decode *sa; struct ofl_action_xor_decode *da; if (*len < sizeof(struct ofp_action_xor_decode)) { OFL_LOG_WARN(LOG_MODULE, "Received OFPAT_XOR_DECODE: action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } sa = (struct ofp_action_xor_decode *)src; da = (struct ofl_action_xor_decode *)malloc(sizeof(struct ofl_action_xor_decode)); da->label_a = sa->label_a; da->label_b = sa->label_b; *len -= sizeof(struct ofp_action_xor_decode); *dst = (struct ofl_action_header *)da; break; } case OFPAT_SET_MPLS_LABEL_FROM_COUNTER: { struct ofp_action_set_mpls_label_from_counter *sa; struct ofl_action_set_mpls_label_from_counter *da; if (*len < sizeof(struct ofp_action_set_mpls_label_from_counter)) { OFL_LOG_WARN(LOG_MODULE, "Received OFPAT_SET_MPLS_LABEL_FROM_COUNTER::: action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } sa = (struct ofp_action_set_mpls_label_from_counter *)src; da = (struct ofl_action_set_mpls_label_from_counter *)malloc(sizeof(struct ofl_action_set_mpls_label_from_counter)); *len -= sizeof(struct ofp_action_set_mpls_label_from_counter); *dst = (struct ofl_action_header *)da; break; } case OFPAT_SET_PARITY_MPLS_LABEL: { struct ofp_action_parity_mpls_label *sa; struct ofl_action_set_parity_mpls_label *da; if (*len < sizeof(struct ofp_action_parity_mpls_label)) { OFL_LOG_WARN(LOG_MODULE, "Received OFPAT_SET_PARITY_MPLS_LABEL:: action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } sa = (struct ofp_action_parity_mpls_label *)src; da = (struct ofl_action_set_parity_mpls_label *)malloc(sizeof(struct ofl_action_set_parity_mpls_label)); *len -= sizeof(struct ofp_action_parity_mpls_label); *dst = (struct ofl_action_header *)da; break; } case OFPAT_SET_MPLS_LABEL: { struct ofp_action_mpls_label *sa; struct ofl_action_set_mpls_label *da; if (*len < sizeof(struct ofp_action_mpls_label)) { OFL_LOG_WARN(LOG_MODULE, "Received OFPAT_SET_MPLS_LABEL: action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } sa = (struct ofp_action_mpls_label *)src; da = (struct ofl_action_set_mpls_label *)malloc(sizeof(struct ofl_action_set_mpls_label)); da->mpls_label = sa->mpls_label; *len -= sizeof(struct ofp_action_mpls_label); *dst = (struct ofl_action_header *)da; break; } case OFPAT_SET_MPLS_TTL: { struct ofp_action_mpls_ttl *sa; struct ofl_action_mpls_ttl *da; if (*len < sizeof(struct ofp_action_mpls_ttl)) { OFL_LOG_WARN(LOG_MODULE, "Received SET_MPLS_TTL action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } sa = (struct ofp_action_mpls_ttl *)src; da = (struct ofl_action_mpls_ttl *)malloc(sizeof(struct ofl_action_mpls_ttl)); da->mpls_ttl = sa->mpls_ttl; *len -= sizeof(struct ofp_action_mpls_ttl); *dst = (struct ofl_action_header *)da; break; } case OFPAT_DEC_MPLS_TTL: { //ofp_action_header length was already checked *len -= sizeof(struct ofp_action_mpls_ttl); *dst = (struct ofl_action_header *)malloc(sizeof(struct ofl_action_header)); break; } case OFPAT_PUSH_VLAN: case OFPAT_PUSH_PBB: case OFPAT_PUSH_MPLS: { struct ofp_action_push *sa; struct ofl_action_push *da; if (*len < sizeof(struct ofp_action_push)) { OFL_LOG_WARN(LOG_MODULE, "Received PUSH_VLAN/MPLS/PBB action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } sa = (struct ofp_action_push *)src; if (((ntohs(src->type) == OFPAT_PUSH_VLAN) && (ntohs(sa->ethertype) != ETH_TYPE_VLAN && ntohs(sa->ethertype) != ETH_TYPE_VLAN_PBB)) || ((ntohs(src->type) == OFPAT_PUSH_MPLS) && (ntohs(sa->ethertype) != ETH_TYPE_MPLS && ntohs(sa->ethertype) != ETH_TYPE_MPLS_MCAST)) || ((ntohs(src->type) == OFPAT_PUSH_PBB) && (ntohs(sa->ethertype) != ETH_TYPE_PBB))) { OFL_LOG_WARN(LOG_MODULE, "Received PUSH_VLAN/MPLS/PBB has invalid eth type. (%u)", ntohs(sa->ethertype)); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_ARGUMENT); } da = (struct ofl_action_push *)malloc(sizeof(struct ofl_action_push)); da->ethertype = ntohs(sa->ethertype); *len -= sizeof(struct ofp_action_push); *dst = (struct ofl_action_header *)da; break; } case OFPAT_POP_VLAN: case OFPAT_POP_PBB: { //ofp_action_header length was already checked *len -= sizeof(struct ofp_action_header); *dst = (struct ofl_action_header *)malloc(sizeof(struct ofl_action_header)); break; } case OFPAT_POP_MPLS: { struct ofp_action_pop_mpls *sa; struct ofl_action_pop_mpls *da; if (*len < sizeof(struct ofp_action_pop_mpls)) { OFL_LOG_WARN(LOG_MODULE, "Received POP_MPLS action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } sa = (struct ofp_action_pop_mpls *)src; da = (struct ofl_action_pop_mpls *)malloc(sizeof(struct ofl_action_pop_mpls)); da->ethertype = ntohs(sa->ethertype); *len -= sizeof(struct ofp_action_pop_mpls); *dst = (struct ofl_action_header *)da; break; } case OFPAT_SET_QUEUE: { struct ofp_action_set_queue *sa; struct ofl_action_set_queue *da; if (*len < sizeof(struct ofp_action_set_queue)) { OFL_LOG_WARN(LOG_MODULE, "Received SET_QUEUE action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } sa = (struct ofp_action_set_queue *)src; da = (struct ofl_action_set_queue *)malloc(sizeof(struct ofl_action_set_queue)); da->queue_id = ntohl(sa->queue_id); *len -= sizeof(struct ofp_action_set_queue); *dst = (struct ofl_action_header *)da; break; } case OFPAT_GROUP: { struct ofp_action_group *sa; struct ofl_action_group *da; if (*len < sizeof(struct ofp_action_group)) { OFL_LOG_WARN(LOG_MODULE, "Received GROUP action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } sa = (struct ofp_action_group *)src; if (ntohl(sa->group_id) > OFPG_MAX) { if (OFL_LOG_IS_WARN_ENABLED(LOG_MODULE)) { char *gs = ofl_group_to_string(ntohl(sa->group_id)); OFL_LOG_WARN(LOG_MODULE, "Received GROUP action has invalid group id (%s).", gs); free(gs); } return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_OUT_GROUP); } da = (struct ofl_action_group *)malloc(sizeof(struct ofl_action_group)); da->group_id = ntohl(sa->group_id); *len -= sizeof(struct ofp_action_group); *dst = (struct ofl_action_header *)da; break; } case OFPAT_SET_NW_TTL: { struct ofp_action_nw_ttl *sa; struct ofl_action_set_nw_ttl *da; if (*len < sizeof(struct ofp_action_nw_ttl)) { OFL_LOG_WARN(LOG_MODULE, "Received SET_NW_TTL action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } sa = (struct ofp_action_nw_ttl *)src; da = (struct ofl_action_set_nw_ttl *)malloc(sizeof(struct ofl_action_set_nw_ttl)); da->nw_ttl = sa->nw_ttl; *len -= sizeof(struct ofp_action_nw_ttl); *dst = (struct ofl_action_header *)da; break; } case OFPAT_DEC_NW_TTL: { //ofp_action_header length was already checked *len -= sizeof(struct ofp_action_header); *dst = (struct ofl_action_header *)malloc(sizeof(struct ofl_action_header)); break; } case OFPAT_SET_FIELD: { struct ofp_action_set_field *sa; struct ofl_action_set_field *da; uint8_t *value; sa = (struct ofp_action_set_field*) src; da = (struct ofl_action_set_field *)malloc(sizeof(struct ofl_action_set_field)); da->field = (struct ofl_match_tlv*) malloc(sizeof(struct ofl_match_tlv)); memcpy(&da->field->header,sa->field,4); da->field->header = ntohl(da->field->header); value = (uint8_t *) src + sizeof (struct ofp_action_set_field); da->field->value = malloc(OXM_LENGTH(da->field->header)); /*TODO: need to check if other fields are valid */ if(da->field->header == OXM_OF_IN_PORT || da->field->header == OXM_OF_IN_PHY_PORT || da->field->header == OXM_OF_METADATA){ return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_SET_TYPE); } switch(OXM_LENGTH(da->field->header)){ case 1: case 6: case 16: memcpy(da->field->value , value, OXM_LENGTH(da->field->header)); break; case 2:{ uint16_t v = ntohs(*((uint16_t*) value)); memcpy(da->field->value , &v, OXM_LENGTH(da->field->header)); break; } case 4:{ uint32_t v; uint8_t field = OXM_FIELD(da->field->header); if( field != 11 && field != 12 && field != 22 && field != 23) v = htonl(*((uint32_t*) value)); else v = *((uint32_t*) value); memcpy(da->field->value , &v, OXM_LENGTH(da->field->header)); break; } case 8:{ uint64_t v = hton64(*((uint64_t*) value)); memcpy(da->field->value , &v, OXM_LENGTH(da->field->header)); break; } } *len -= ROUND_UP(ntohs(src->len),8); *dst = (struct ofl_action_header *)da; break; } case OFPAT_EXPERIMENTER: { ofl_err error; if (*len < sizeof(struct ofp_action_experimenter_header)) { OFL_LOG_WARN(LOG_MODULE, "Received EXPERIMENTER action has invalid length (%zu).", *len); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_LEN); } if (exp == NULL || exp->act == NULL || exp->act->unpack == NULL) { OFL_LOG_WARN(LOG_MODULE, "Received EXPERIMENTER action, but no callback is given."); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_EXPERIMENTER); } error = exp->act->unpack(src, len, dst); if (error) { return error; } break; } default: { OFL_LOG_WARN(LOG_MODULE, "Received unknown action type (%u).", ntohs(src->type)); return ofl_error(OFPET_BAD_ACTION, OFPBAC_BAD_TYPE); } } (*dst)->type = (enum ofp_action_type)ntohs(src->type); return 0; }
asmlinkage long sys_select(int n, fd_set __user *inp, fd_set __user *outp, fd_set __user *exp, struct timeval __user *tvp) { fd_set_bits fds; char *bits; long timeout; int ret, size, max_fdset; timeout = MAX_SCHEDULE_TIMEOUT; if (tvp) { time_t sec, usec; if ((ret = verify_area(VERIFY_READ, tvp, sizeof(*tvp))) || (ret = __get_user(sec, &tvp->tv_sec)) || (ret = __get_user(usec, &tvp->tv_usec))) goto out_nofds; ret = -EINVAL; if (sec < 0 || usec < 0) goto out_nofds; if ((unsigned long) sec < MAX_SELECT_SECONDS) { timeout = ROUND_UP(usec, 1000000/HZ); timeout += sec * (unsigned long) HZ; } } ret = -EINVAL; if (n < 0) goto out_nofds; /* max_fdset can increase, so grab it once to avoid race */ max_fdset = current->files->max_fdset; if (n > max_fdset) n = max_fdset; /* * We need 6 bitmaps (in/out/ex for both incoming and outgoing), * since we used fdset we need to allocate memory in units of * long-words. */ ret = -ENOMEM; size = FDS_BYTES(n); bits = select_bits_alloc(size); if (!bits) goto out_nofds; fds.in = (unsigned long *) bits; fds.out = (unsigned long *) (bits + size); fds.ex = (unsigned long *) (bits + 2*size); fds.res_in = (unsigned long *) (bits + 3*size); fds.res_out = (unsigned long *) (bits + 4*size); fds.res_ex = (unsigned long *) (bits + 5*size); if ((ret = get_fd_set(n, inp, fds.in)) || (ret = get_fd_set(n, outp, fds.out)) || (ret = get_fd_set(n, exp, fds.ex))) goto out; zero_fd_set(n, fds.res_in); zero_fd_set(n, fds.res_out); zero_fd_set(n, fds.res_ex); ret = do_select(n, &fds, &timeout); if (tvp && !(current->personality & STICKY_TIMEOUTS)) { time_t sec = 0, usec = 0; if (timeout) { sec = timeout / HZ; usec = timeout % HZ; usec *= (1000000/HZ); } put_user(sec, &tvp->tv_sec); put_user(usec, &tvp->tv_usec); } if (ret < 0) goto out; if (!ret) { ret = -ERESTARTNOHAND; if (signal_pending(current)) goto out; ret = 0; } if (set_fd_set(n, inp, fds.res_in) || set_fd_set(n, outp, fds.res_out) || set_fd_set(n, exp, fds.res_ex)) ret = -EFAULT; out: select_bits_free(bits, size); out_nofds: return ret; }
NTSTATUS CmpDoFileSetSize( PHHIVE Hive, ULONG FileType, ULONG FileSize, ULONG OldFileSize ) /*++ Routine Description: This routine sets the size of a file. It must not return until the size is guaranteed. It is environment specific. Must be running in the context of the cmp worker thread. Arguments: Hive - Hive we are doing I/O for FileType - which supporting file to use FileSize - 32 bit value to set the file's size to OldFileSize - old file size, in order to determine if this is a shrink; - ignored if file type is not primary, or hive doesn't use the mapped views technique Return Value: FALSE if failure TRUE if success --*/ { PCMHIVE CmHive; HANDLE FileHandle; NTSTATUS Status; FILE_END_OF_FILE_INFORMATION FileInfo; IO_STATUS_BLOCK IoStatus; BOOLEAN oldFlag; LARGE_INTEGER FileOffset; // where the mapping starts ASSERT(FIELD_OFFSET(CMHIVE, Hive) == 0); CmHive = (PCMHIVE)Hive; FileHandle = CmHive->FileHandles[FileType]; if (FileHandle == NULL) { return TRUE; } // // disable hard error popups, to avoid self deadlock on bogus devices // oldFlag = IoSetThreadHardErrorMode(FALSE); FileInfo.EndOfFile.HighPart = 0L; if( FileType == HFILE_TYPE_PRIMARY ) { FileInfo.EndOfFile.LowPart = ROUND_UP(FileSize, CM_FILE_GROW_INCREMENT); } else { FileInfo.EndOfFile.LowPart = FileSize; } ASSERT_PASSIVE_LEVEL(); Status = ZwSetInformationFile( FileHandle, &IoStatus, (PVOID)&FileInfo, sizeof(FILE_END_OF_FILE_INFORMATION), FileEndOfFileInformation ); if (NT_SUCCESS(Status)) { ASSERT(IoStatus.Status == Status); } else { // // set debugging info // CmRegistryIODebug.Action = CmpIoFileSetSize; CmRegistryIODebug.Handle = FileHandle; CmRegistryIODebug.Status = Status; #if DBG DbgPrintEx(DPFLTR_CONFIG_ID,DPFLTR_TRACE_LEVEL,"CmpFileSetSize:\tHandle=%08lx OldLength = %08lx NewLength=%08lx \n", FileHandle, OldFileSize, FileSize); #endif if( (Status == STATUS_DISK_FULL) && ExIsResourceAcquiredExclusiveLite(&CmpRegistryLock) ) { DbgPrintEx(DPFLTR_CONFIG_ID,DPFLTR_TRACE_LEVEL,"Disk is full while attempting to grow file %lx; will flush upon lock release\n",FileHandle); CmpFlushOnLockRelease = TRUE;; } } // // restore hard error popups mode // IoSetThreadHardErrorMode(oldFlag); // // purge // if( HiveWritesThroughCache(Hive,FileType) && (OldFileSize > FileSize)) { // // first we have to unmap any possible mapped views in the last 256K window // to avoid deadlock on CcWaitOnActiveCount inside CcPurgeCacheSection call below // ULONG Offset = FileSize & (~(_256K - 1)); // // we are not allowed to shrink in shared mode. // ASSERT_HIVE_WRITER_LOCK_OWNED((PCMHIVE)Hive); while( Offset < OldFileSize ) { CmpUnmapCmViewSurroundingOffset((PCMHIVE)Hive,Offset); Offset += CM_VIEW_SIZE; } // // we need to take extra precaution here and unmap the very last view too // FileOffset.HighPart = 0; FileOffset.LowPart = FileSize; // // This is a shrink; Inform cache manager of the change of the size // CcPurgeCacheSection( ((PCMHIVE)Hive)->FileObject->SectionObjectPointer, (PLARGE_INTEGER)(((ULONG_PTR)(&FileOffset)) + 1), OldFileSize - FileSize, FALSE ); // // Flush out this view to clear out the Cc dirty hints // CcFlushCache( ((PCMHIVE)Hive)->FileObject->SectionObjectPointer, (PLARGE_INTEGER)(((ULONG_PTR)(&FileOffset)) + 1),/*we are private writers*/ OldFileSize - FileSize,NULL); } return Status; }
static NTSTATUS VfatGetFileBothInformation( PVFAT_DIRENTRY_CONTEXT DirContext, PDEVICE_EXTENSION DeviceExt, PFILE_BOTH_DIR_INFORMATION pInfo, ULONG BufferLength) { if ((sizeof(FILE_BOTH_DIR_INFORMATION) + DirContext->LongNameU.Length) > BufferLength) return STATUS_BUFFER_OVERFLOW; pInfo->EaSize = 0; if (DeviceExt->Flags & VCB_IS_FATX) { pInfo->FileNameLength = DirContext->LongNameU.Length; RtlCopyMemory(pInfo->FileName, DirContext->LongNameU.Buffer, DirContext->LongNameU.Length); pInfo->NextEntryOffset = ULONG_ROUND_UP(sizeof(FILE_BOTH_DIR_INFORMATION) + DirContext->LongNameU.Length); pInfo->ShortName[0] = 0; pInfo->ShortNameLength = 0; /* pInfo->FileIndex = ; */ FsdDosDateTimeToSystemTime(DeviceExt, DirContext->DirEntry.FatX.CreationDate, DirContext->DirEntry.FatX.CreationTime, &pInfo->CreationTime); FsdDosDateTimeToSystemTime(DeviceExt, DirContext->DirEntry.FatX.AccessDate, DirContext->DirEntry.FatX.AccessTime, &pInfo->LastAccessTime); FsdDosDateTimeToSystemTime(DeviceExt, DirContext->DirEntry.FatX.UpdateDate, DirContext->DirEntry.FatX.UpdateTime, &pInfo->LastWriteTime); pInfo->ChangeTime = pInfo->LastWriteTime; if (DirContext->DirEntry.FatX.Attrib & FILE_ATTRIBUTE_DIRECTORY) { pInfo->EndOfFile.QuadPart = 0; pInfo->AllocationSize.QuadPart = 0; } else { pInfo->EndOfFile.u.HighPart = 0; pInfo->EndOfFile.u.LowPart = DirContext->DirEntry.FatX.FileSize; /* Make allocsize a rounded up multiple of BytesPerCluster */ pInfo->AllocationSize.u.HighPart = 0; pInfo->AllocationSize.u.LowPart = ROUND_UP(DirContext->DirEntry.FatX.FileSize, DeviceExt->FatInfo.BytesPerCluster); } pInfo->FileAttributes = DirContext->DirEntry.FatX.Attrib & 0x3f; } else { pInfo->FileNameLength = DirContext->LongNameU.Length; pInfo->NextEntryOffset = ULONG_ROUND_UP(sizeof(FILE_BOTH_DIR_INFORMATION) + DirContext->LongNameU.Length); RtlCopyMemory(pInfo->ShortName, DirContext->ShortNameU.Buffer, DirContext->ShortNameU.Length); pInfo->ShortNameLength = (CCHAR)DirContext->ShortNameU.Length; RtlCopyMemory(pInfo->FileName, DirContext->LongNameU.Buffer, DirContext->LongNameU.Length); /* pInfo->FileIndex = ; */ FsdDosDateTimeToSystemTime(DeviceExt, DirContext->DirEntry.Fat.CreationDate, DirContext->DirEntry.Fat.CreationTime, &pInfo->CreationTime); FsdDosDateTimeToSystemTime(DeviceExt, DirContext->DirEntry.Fat.AccessDate, 0, &pInfo->LastAccessTime); FsdDosDateTimeToSystemTime(DeviceExt, DirContext->DirEntry.Fat.UpdateDate, DirContext->DirEntry.Fat.UpdateTime, &pInfo->LastWriteTime); pInfo->ChangeTime = pInfo->LastWriteTime; if (DirContext->DirEntry.Fat.Attrib & FILE_ATTRIBUTE_DIRECTORY) { pInfo->EndOfFile.QuadPart = 0; pInfo->AllocationSize.QuadPart = 0; } else { pInfo->EndOfFile.u.HighPart = 0; pInfo->EndOfFile.u.LowPart = DirContext->DirEntry.Fat.FileSize; /* Make allocsize a rounded up multiple of BytesPerCluster */ pInfo->AllocationSize.u.HighPart = 0; pInfo->AllocationSize.u.LowPart = ROUND_UP(DirContext->DirEntry.Fat.FileSize, DeviceExt->FatInfo.BytesPerCluster); } pInfo->FileAttributes = DirContext->DirEntry.Fat.Attrib & 0x3f; } return STATUS_SUCCESS; }