int handle_bad_ioasa(struct ctx *p_ctx, __u64 data) { __u64 *p_u64; __u32 *p_u32; __u64 lba=0; sisl_ioarcb_t *rcb; rcb = (sisl_ioarcb_t *)malloc(sizeof(sisl_ioarcb_t)); fill_buf((__u64*)&p_ctx->wbuf[0][0], sizeof(p_ctx->wbuf[0])/sizeof(__u64),data); memset(&(rcb->cdb[0]), 0, sizeof(rcb->cdb)); p_u64 = (__u64*)&(rcb->cdb[2]); rcb->res_hndl = p_ctx->res_hndl; rcb->req_flags = SISL_REQ_FLAGS_RES_HNDL; rcb->req_flags |= SISL_REQ_FLAGS_HOST_WRITE; write_lba(p_u64, lba); rcb->data_ea = (__u64) &p_ctx->wbuf[0][0]; rcb->data_len = sizeof(p_ctx->wbuf[0]); rcb->cdb[0] = 0x8A; p_u32 = (__u32*)&(rcb->cdb[10]); write_32(p_u32, p_ctx->blk_len); asm volatile( "lwsync" : : ); write_64(&p_ctx->p_host_map->ioarrin,(__u64)rcb); return 0; }
void fill_send_read(struct ctx *p_ctx, __u64 vlba, __u32 flags) { __u64 *p_u64; __u32 *p_u32; __u64 plba; memset(&p_ctx->rbuf[0][0], 0, sizeof(p_ctx->rbuf[0])); memset(&p_ctx->cmd[0].rcb.cdb[0], 0, sizeof(p_ctx->cmd[0].rcb.cdb)); p_ctx->cmd[0].rcb.cdb[0] = 0x88; // read(16) p_u64 = (__u64*)&p_ctx->cmd[0].rcb.cdb[2]; if (flags & VLBA){ p_ctx->cmd[0].rcb.req_flags = SISL_REQ_FLAGS_RES_HNDL; p_ctx->cmd[0].rcb.req_flags |= SISL_REQ_FLAGS_HOST_READ; p_ctx->cmd[0].rcb.res_hndl = p_ctx->res_hndl; write_64(p_u64, vlba); // Read(16) Virtual LBA debug("send read for vlba =0x%lX\n",vlba); } else { p_ctx->cmd[0].rcb.lun_id = lun_id; p_ctx->cmd[0].rcb.port_sel = fc_port; // either FC port p_ctx->cmd[0].rcb.req_flags = SISL_REQ_FLAGS_HOST_READ; if(flags & NO_XLATE){ plba = vlba; } else { (void)mc_xlate_lba(p_ctx->mc_hndl, p_ctx->res_hndl, vlba, &plba); } write_64(p_u64, plba); // physical LBA# debug("send read for plba =0x%lX\n",plba); } p_ctx->cmd[0].rcb.data_len = sizeof(p_ctx->rbuf[0]); p_ctx->cmd[0].rcb.data_ea = (__u64) &p_ctx->rbuf[0][0]; p_u32 = (__u32*)&p_ctx->cmd[0].rcb.cdb[10]; write_32(p_u32, LBA_BLK); p_ctx->cmd[0].sa.host_use[0] = 0; // 0 means active p_ctx->cmd[0].sa.ioasc = 0; }
void fill_send_write(struct ctx *p_ctx, __u64 vlba, __u64 data, __u64 stride, __u32 flags) { __u64 *p_u64; __u32 *p_u32; __u64 plba; int i; for(i = 0 ; i < NUM_CMDS; i++) { vlba = i * stride; fill_buf((__u64*)&p_ctx->wbuf[i][0], sizeof(p_ctx->wbuf[i])/sizeof(__u64),data); memset(&p_ctx->cmd[i].rcb.cdb[0], 0, sizeof(p_ctx->cmd[i].rcb.cdb)); p_u64 = (__u64*)&p_ctx->cmd[i].rcb.cdb[2]; if(flags & VLBA){ p_ctx->cmd[i].rcb.res_hndl = p_ctx->res_hndl; p_ctx->cmd[i].rcb.req_flags = SISL_REQ_FLAGS_RES_HNDL; p_ctx->cmd[i].rcb.req_flags |= SISL_REQ_FLAGS_HOST_WRITE; write_64(p_u64, vlba); // write(16) Virtual LBA }else { p_ctx->cmd[i].rcb.lun_id = lun_id; p_ctx->cmd[i].rcb.port_sel = fc_port; // either FC port p_ctx->cmd[i].rcb.req_flags = SISL_REQ_FLAGS_HOST_WRITE; if(flags & NO_XLATE){ plba = vlba; } else { (void)mc_xlate_lba(p_ctx->mc_hndl, p_ctx->res_hndl, vlba, &plba); } write_64(p_u64, plba); // physical LBA# } p_ctx->cmd[i].rcb.data_ea = (__u64) &p_ctx->wbuf[0][0]; p_ctx->cmd[i].rcb.data_len = sizeof(p_ctx->wbuf[0]); p_ctx->cmd[i].rcb.cdb[0] = 0x8A; p_u32 = (__u32*)&p_ctx->cmd[i].rcb.cdb[10]; write_32(p_u32, LBA_BLK); p_ctx->cmd[i].sa.host_use[0] = 0; // 0 means active p_ctx->cmd[i].sa.ioasc = 0; } }
int bg_f_chunk_write_header(bg_f_io_t * io, bg_f_chunk_t * ch, bg_f_chunk_type_t type) { ch->type = type; ch->start = io->ftell_callback(io->data); if(!write_32(io, ch->type) || !write_64(io, ch->size)) return 0; return 1; }
int bg_f_chunk_write_footer(bg_f_io_t * io, bg_f_chunk_t * ch) { int64_t end_pos = io->ftell_callback(io->data); io->seek_callback(io->data, ch->start + 4, SEEK_SET); ch->size = end_pos - ch->start - 12; if(!write_64(io, ch->size)) return 0; io->seek_callback(io->data, end_pos, SEEK_SET); return 1; }
int CDECL main(int argc, char **argv) { if (argc ==1) { cerr << "Usage: makeeco eco_file" << endl; return -1; } Bitboard::init(); initOptions(argv[0]); Attacks::init(); Scoring::init(); if (!initGlobals(argv[0], false)) { cleanupGlobals(); exit(-1); } atexit(cleanupGlobals); ifstream eco_file( argv[argc-1], ios::in); if (!eco_file.good()) { cerr << "Cannot open file: " << argv[argc-1] << endl; return -1; } Board b; cout << "// This is a machine-generated file. Do not edit." << endl; cout << endl; cout << "#include \"ecodata.h\"" << endl << endl; cout << "const struct ECOData eco_codes[] =" << endl; cout << "{{" << '"' << "A00" << '"' << ", "; write_64(b.hashCode(),cout); cout << ", " << '"' << '"' << "}," << endl; int lines = 1; while (eco_file.good() && !eco_file.eof()) { string eco_line; getline(eco_file,eco_line); if (do_eco(eco_line)) { cerr << "error in ECO file, line " << lines << endl; } ++lines; } cout << "{0,0," << '"' << '"' << "}};" << endl; return 0; }
int place_bad_addresses(struct ctx *p_ctx, int action) { int cnt = NUM_CMDS; int wait_try=MAX_TRY_WAIT; int p_cmd = 0; int i; __u64 room; __u64 baddr = 0x1234; /* make memory updates visible to AFU before MMIO */ asm volatile( "lwsync" : : ); if (2 == action) { // set up bad HRRQ address write_64(&p_ctx->p_host_map->rrq_start, (__u64)0x456123); write_64(&p_ctx->p_host_map->rrq_end, (__u64)0x895e6fe); bad_address= true; } if (3 == action) { //cmd_room violation room = read_64(&p_ctx->p_host_map->cmd_room); debug("%d:placing %d cmds in 0X%"PRIX64" cmd_room...\n",pid,NUM_CMDS,room); for (i=0;i<NUM_CMDS ;i++) write_64(&p_ctx->p_host_map->ioarrin, (__u64)&p_ctx->cmd[i].rcb); bad_address= true; return 0; } while (cnt) { room = read_64(&p_ctx->p_host_map->cmd_room); if (0 == room) { usleep(MC_BLOCK_DELAY_ROOM); wait_try--; } if (0 == wait_try) { fprintf(stderr, "%d: send cmd wait over %d cmd remain\n", pid, cnt); return -1; } for (i = 0; i < room; i++) { // add a usleep here if room=0 ? // write IOARRIN if (1 == action) { //bad RCB address write_64(&p_ctx->p_host_map->ioarrin, baddr*i); bad_address= true; } else { write_64(&p_ctx->p_host_map->ioarrin, (__u64)&p_ctx->cmd[p_cmd++].rcb); } wait_try = MAX_TRY_WAIT; //each cmd give try max time if (cnt-- == 1) break; } } return 0; }
int test_mc_invalid_opcode() { int rc; struct ctx myctx; struct ctx *p_ctx = &myctx; __u64 chunks=10; __u64 actual_size=0; __u64 vlba =0; __u64 *p_u64; __u32 *p_u32; mc_stat_t l_mc_stat; pthread_t thread; if(mc_init() !=0 ) { fprintf(stderr, "mc_init failed.\n"); return -1; } debug("mc_init success.\n"); rc = ctx_init(p_ctx); if(rc != 0) { fprintf(stderr, "Context init failed, errno %d\n", errno); return -1; } pthread_create(&thread,NULL,ctx_rrq_rx, p_ctx); rc = mc_register(master_dev_path, p_ctx->ctx_hndl, (volatile __u64 *)p_ctx->p_host_map,&p_ctx->mc_hndl); if(rc != 0) { fprintf(stderr, "ctx _reg failed, ctx_hndl %d,rc %d\n",p_ctx->ctx_hndl, rc ); return -1; } rc = mc_open(p_ctx->mc_hndl,MC_RDWR, &p_ctx->res_hndl); if (rc != 0) { fprintf(stderr, "error opening res_hndl rc %d\n", rc); return -1; } rc = mc_size(p_ctx->mc_hndl, p_ctx->res_hndl,chunks, &actual_size); CHECK_RC(rc, "mc_size"); rc = mc_stat(p_ctx->mc_hndl, p_ctx->res_hndl, &l_mc_stat); CHECK_RC(rc, "mc_stat"); pid = getpid(); vlba = (actual_size * (1 << l_mc_stat.nmask))-1; fill_buf((__u64*)&p_ctx->wbuf[0][0], sizeof(p_ctx->wbuf[0])/sizeof(__u64),pid); memset(&p_ctx->cmd[0].rcb.cdb[0], 0, sizeof(p_ctx->cmd[0].rcb.cdb)); p_u64 = (__u64*)&p_ctx->cmd[0].rcb.cdb[2]; p_ctx->cmd[0].rcb.res_hndl = p_ctx->res_hndl; p_ctx->cmd[0].rcb.req_flags = SISL_REQ_FLAGS_RES_HNDL; p_ctx->cmd[0].rcb.req_flags |= SISL_REQ_FLAGS_HOST_WRITE; write_64(p_u64, vlba); // write(16) Virtual LBA p_ctx->cmd[0].rcb.data_ea = (__u64) &p_ctx->wbuf[0][0]; p_ctx->cmd[0].rcb.data_len = sizeof(p_ctx->wbuf[0]); p_ctx->cmd[0].rcb.cdb[0] = 0xFA; // invalid opcode p_u32 = (__u32*)&p_ctx->cmd[0].rcb.cdb[10]; write_32(p_u32, 8); // 8 LBAs for 4K p_ctx->cmd[0].sa.host_use[0] = 0; // 0 means active p_ctx->cmd[0].sa.ioasc = 0; send_single_cmd(p_ctx); rc = wait_single_resp(p_ctx); return rc; }
Buffer::Pointer Buffer::write(uint64_t in_value) throw(KafkaError) { write_64(&in_value); return shared_from_this(); }
extern int mp4_fragment_file(struct mp4_context_t const* mp4_context, struct bucket_t** buckets) { uint64_t filepos = 0; int result = 1; moov_t* moov = mp4_context->moov; moov_t* fmoov; struct woov_t* woov = NULL; mfra_t* mfra; if(!moov_build_index(mp4_context, mp4_context->moov)) { return 0; } // Start with the ftyp { unsigned char ftyp[28]; unsigned char* buffer = ftyp; buffer = write_32(buffer, 28); buffer = write_32(buffer, FOURCC('f', 't', 'y', 'p')); buffer = write_32(buffer, FOURCC('a', 'v', 'c', '1')); // major_brand buffer = write_32(buffer, 0); // minor_version buffer = write_32(buffer, FOURCC('i', 's', 'o', 'm')); // compatible_brands buffer = write_32(buffer, FOURCC('i', 's', 'o', '2')); buffer = write_32(buffer, FOURCC('f', 'r', 'a', 'g')); bucket_insert_tail(buckets, bucket_init_memory(ftyp, sizeof(ftyp))); filepos += sizeof(ftyp); } { uint32_t i; struct trak_weight_t{ int w; void* v; }wtrack[MAX_TRACKS]; for(i = 0; i < moov->tracks_; i++) { if(moov->traks_[i]->mdia_->hdlr_->handler_type_ == FOURCC('s', 'o', 'u', 'n')) {wtrack[i].w=1;wtrack[i].v=moov->traks_[i];} else if(moov->traks_[i]->mdia_->hdlr_->handler_type_ == FOURCC('v', 'i', 'd', 'e')) {wtrack[i].w=2;wtrack[i].v=moov->traks_[i];} else {wtrack[i].w=3;wtrack[i].v=moov->traks_[i];} } for (i = 1; i < moov->tracks_; ++i) { unsigned int j; for (j= moov->tracks_ - 1; j>=i;j--) { if(wtrack[j].w < wtrack[j-1].w) { struct trak_weight_t t = wtrack[j]; wtrack[j] = wtrack[j-1]; wtrack[j-1] = t; } } } for (i = 0; i < moov->tracks_; ++i) { moov->traks_[i] = wtrack[i].v; moov->traks_[i]->tkhd_->track_id_=i+1; } moov->mvhd_->next_track_id_=i+1; } // A fragmented MPEG4 file starts with a MOOV atom with only the mandatory // atoms fmoov = moov_init(); { unsigned int i; mvex_t* mvex = mvex_init(); fmoov->mvhd_ = mvhd_copy(moov->mvhd_); fmoov->mvhd_->duration_ = 0; fmoov->tracks_ = moov->tracks_; fmoov->mvex_ = mvex; for(i = 0; i != moov->tracks_; ++i) { unsigned int s; trak_t* trak = moov->traks_[i]; trak_t* ftrak = trak_init(); mdia_t* mdia = trak->mdia_; mdia_t* fmdia = mdia_init(); minf_t* minf = mdia->minf_; minf_t* fminf = minf_init(); stbl_t* stbl = minf->stbl_; stbl_t* fstbl = stbl_init(); fmoov->traks_[i] = ftrak; ftrak->tkhd_ = tkhd_copy(trak->tkhd_); ftrak->tkhd_->duration_ = 0; ftrak->mdia_ = fmdia; ftrak->samples_size_ = trak->samples_size_; ftrak->samples_ = (samples_t*) malloc((trak->samples_size_ + 1) * sizeof(samples_t)); memcpy(ftrak->samples_, trak->samples_, (trak->samples_size_ + 1) * sizeof(samples_t)); ftrak->smoothes_size_ = trak->smoothes_size_; ftrak->smoothes_ = (struct smooth_t*) malloc((trak->samples_size_ + 1) * sizeof(struct smooth_t)); memcpy(ftrak->smoothes_, trak->smoothes_, (trak->smoothes_size_ + 1) * sizeof(struct smooth_t)); fmdia->mdhd_ = mdhd_copy(mdia->mdhd_); // convert trak's timescale and duration fmdia->mdhd_->version_ = 1; fmdia->mdhd_->timescale_ = 10000000; fmdia->mdhd_->duration_ = 0; // trak_time_to_moov_time(fmdia->mdhd_->duration_, // fmdia->mdhd_->timescale_, mdia->mdhd_->timescale_); fmdia->hdlr_ = hdlr_copy(mdia->hdlr_); fmdia->minf_ = fminf; fminf->smhd_ = minf->smhd_ == NULL ? NULL : smhd_copy(minf->smhd_); fminf->vmhd_ = minf->vmhd_ == NULL ? NULL : vmhd_copy(minf->vmhd_); fminf->dinf_ = dinf_copy(minf->dinf_); fminf->stbl_ = fstbl; fstbl->stts_ = stts_init(); fstbl->ctts_ = ctts_init(); fstbl->stsz_ = stsz_init(); fstbl->stsc_ = stsc_init(); fstbl->stco_ = stco_init(); fstbl->stsd_ = stsd_copy(stbl->stsd_); for(s = 0; s != ftrak->samples_size_ + 1; ++s) { // SmoothStreaming uses a fixed 10000000 timescale ftrak->samples_[s].pts_ = trak_time_to_moov_time( ftrak->samples_[s].pts_, ftrak->mdia_->mdhd_->timescale_, trak->mdia_->mdhd_->timescale_); ftrak->samples_[s].cto_ = (unsigned int)(trak_time_to_moov_time( ftrak->samples_[s].cto_, ftrak->mdia_->mdhd_->timescale_, trak->mdia_->mdhd_->timescale_)); } { // update trak duration samples_t const* first = (samples_t const*)&ftrak->samples_[0]; samples_t const* last = (samples_t const*)&ftrak->samples_[ftrak->samples_size_]; ftrak->mdia_->mdhd_->duration_ = last->pts_ - first->pts_; ftrak->tkhd_->duration_ = trak_time_to_moov_time(ftrak->mdia_->mdhd_->duration_, fmoov->mvhd_->timescale_, ftrak->mdia_->mdhd_->timescale_); // update movie duration if(ftrak->tkhd_->duration_ > fmoov->mvhd_->duration_) { fmoov->mvhd_->duration_ = ftrak->tkhd_->duration_ ; } } { trex_t* trex = trex_init(); trex->track_id_ = trak->tkhd_->track_id_; trex->default_sample_description_index_ = 1; mvex->trexs_[mvex->tracks_] = trex; ++mvex->tracks_; } } { unsigned char* moov_data = mp4_context->moov_data; uint32_t moov_size = moov_write(fmoov, moov_data); bucket_insert_tail(buckets, bucket_init_memory(moov_data, moov_size)); filepos += moov_size; } } woov = woov_init(mp4_context, fmoov); mfra = mfra_init(); mfra->tracks_ = fmoov->tracks_; { unsigned int i; unsigned int tfra_entries = 0; for(i = 0; i != fmoov->tracks_; ++i) { trak_t const* trak = fmoov->traks_[i]; struct tfra_t* tfra = tfra_init(); mfra->tfras_[i] = tfra; tfra->version_ = 1; tfra->flags_ = 0; tfra->track_id_ = trak->tkhd_->track_id_; tfra->length_size_of_traf_num_ = 1; tfra->length_size_of_trun_num_ = 1; tfra->length_size_of_sample_num_ = 1; // count the number of smooth sync samples (nr of moofs) tfra->number_of_entry_ = 0; { unsigned int start; for(start = 0; start != trak->samples_size_; ++start) { { if(trak->samples_[start].is_smooth_ss_) { ++tfra->number_of_entry_; } } } } tfra->table_ = (tfra_table_t*) malloc(tfra->number_of_entry_ * sizeof(tfra_table_t)); tfra_entries += tfra->number_of_entry_; // next track } { unsigned int tfra_index = 0; trak_t const* base_trak = fmoov->traks_[0]; while(tfra_index != base_trak->smoothes_size_) { // insert moof bucket { moof_t* moof = moof_init(); bucket_t* bucket = bucket_init(BUCKET_TYPE_MEMORY); bucket_insert_tail(buckets, bucket); // create moof and write samples moof_create(mp4_context, fmoov, woov, moof, mfra, filepos, tfra_index+1, buckets, 0 /* OUTPUT_FORMAT_MP4 */); // if(options->output_format == OUTPUT_FORMAT_MP4) { unsigned int samples_count = 0; unsigned char* moof_data = NULL; unsigned int moof_size = 0; for(i = 0;i < moof->tracks_; ++i) samples_count += moof->trafs_[i]->trun_->sample_count_; moof_data = (unsigned char*)malloc(8192 + (samples_count) * 12); moof_size = moof_write(moof, moof_data); // now that we know the size of the moof atom, we know where the mdat // will start. We patch the 'data_offset' field to skip the // moof atom and the mdat header. moof->trafs_[0]->trun_->data_offset_ = moof_size + ATOM_PREAMBLE_SIZE; moof_size = moof_write(moof, moof_data); bucket->buf_ = malloc(moof_size); bucket->size_ = moof_size; memcpy(bucket->buf_, moof_data, (size_t)bucket->size_); free(moof_data); } moof_exit(moof); // advance filepos for moof and mdat atom while(*buckets != bucket) { filepos += bucket->size_; bucket = bucket->next_; } } // next fragment ++tfra_index; } } moov_exit(fmoov); { uint32_t woov_size = woov_write(mp4_context, woov, buckets); int offset = 0; offset += 28; // ftyp offset += woov_size; //woov offset += ATOM_PREAMBLE_SIZE; //mdat woov->mdat_size+=8; // header; if(woov->mdat_size > UINT32_MAX) { offset+=8; woov->mdat_size+=8; } for(i = 0; i != woov->moov->tracks_; ++i) { trak_t* trak = woov->moov->traks_[i]; stco_shift_offsets_inplace( (unsigned char*)trak->mdia_->minf_->stbl_->stco_->stco_inplace_, (int)offset); } write_32(woov_data + 8, woov_size); write_64(woov_data + 12, woov->mdat_size); bucket_insert_tail(buckets, bucket_init_memory(woov_data, sizeof(woov_data))); woov_exit(woov); } // Write the Movie Fragment Random Access (MFRA) atom { unsigned char* mfra_data = (unsigned char*)malloc(8192 + tfra_entries * 28); uint32_t mfra_size = mfra_write(mfra, mfra_data); bucket_insert_tail(buckets, bucket_init_memory(mfra_data, mfra_size)); mfra_exit(mfra); free(mfra_data); } } return result; }
int do_eco(const string &eco_line) { ColorType side = White; Board board; int movecount = 0; stringstream s(eco_line); const string &str = s.str(); string::const_iterator it = str.begin(); // Follow the opening line string token; string code; string name; int first_token = 1; while (it != str.end()) { // skip spaces while (isspace(*it) && it != str.end()) it++; if (it == str.end()) break; // extract text string text; int first = 1; int quoted = 0; while (it != str.end() && (quoted ? (*it != '"') : !isspace(*it))) { if (first && *it == '"') { quoted++; it++; first = 0; continue; } text += *it++; } if (first_token) { code = text; first_token = 0; continue; } else if (quoted) { name = text; break; } else if (text.length() == 0) { break; } // skip numbers if (isdigit(text[0])) continue; if (!isalpha(text[0])) return -1; // parse the move Move m = Notation::value(board,side,Notation::SAN_IN,text); if (IsNull(m) || !legalMove(board,StartSquare(m),DestSquare(m))) { cerr << "Illegal or invalid move: " << text << endl; return -1; } else { ++movecount; board.doMove(m); } side = OppositeColor(side); } if (code.length()) { cout << '{' << '"' << code << '"' << ", "; write_64(board.hashCode(),cout); cout << " ,"; if (name.length()) cout << '"' << name << '"'; else cout << '"' << '"'; cout << "},"; cout << endl; } return 0; }