void KX_BlenderMaterial::OnConstruction(int layer)
{
if (mConstructed)
// when material are reused between objects
return;
if (mMaterial->glslmat)
SetBlenderGLSLShader(layer);
// for each unique material...
int i;
for (i=0; i<mMaterial->num_enabled; i++) {
if ( mMaterial->mapping[i].mapping & USEENV ) {
if (!GLEW_ARB_texture_cube_map) {
spit("CubeMap textures not supported");
continue;
}
if (!mTextures[i].InitCubeMap(i, mMaterial->cubemap[i] ) )
spit("unable to initialize image("<<i<<") in "<<
mMaterial->matname<< ", image will not be available");
}
else {
if ( mMaterial->img[i] ) {
if ( ! mTextures[i].InitFromImage(i, mMaterial->img[i], (mMaterial->flag[i] &MIPMAP)!=0 ))
spit("unable to initialize image("<<i<<") in "<<
mMaterial->matname<< ", image will not be available");
}
}
}
mBlendFunc[0] =0;
mBlendFunc[1] =0;
mConstructed = true;
}
void Scoremiddlegoal()
{ waitForButton();
starttask(CollectD);
{
drive_Enc(63,7,4);
}
stopdrivemotors();
StopTask(CollectD);
StartTask(medgoal);
{
stopTime(1.75);//wait for arm
drive_Enc(63,8,5);//drive foward
}
StopTask(medgoal);
spit(0.75);
drive_Enc(-63,4,2);
spit(0.75);
StartTask(armDown);
{
drive_Enc(-63,15,5);
}
StopTask(armDown);
waitForButton();
StartTask(CollectD);
{
drive_Enc(70,15,5);
}
StopTask(CollectD);
}
void KX_BlenderMaterial::InitTextures()
{
// for each unique material...
int i;
for (i=0; i<BL_Texture::GetMaxUnits(); i++) {
if ( mMaterial->mapping[i].mapping & USEENV ) {
if (!GLEW_ARB_texture_cube_map) {
spit("CubeMap textures not supported");
continue;
}
if (!mTextures[i].InitCubeMap(i, mMaterial->cubemap[i] ) )
spit("unable to initialize image("<<i<<") in "<<
mMaterial->matname<< ", image will not be available");
}
/* If we're using glsl materials, the textures are handled by bf_gpu, so don't load them twice!
* However, if we're using a custom shader, then we still need to load the textures ourselves. */
else if (!mMaterial->glslmat || mShader) {
if ( mMaterial->img[i] ) {
if ( ! mTextures[i].InitFromImage(i, mMaterial->img[i], (mMaterial->flag[i] &MIPMAP)!=0 ))
spit("unable to initialize image("<<i<<") in "<<
mMaterial->matname<< ", image will not be available");
}
}
}
}
void beginpage()
{
int i;
for (i = 0; i < o_m1; i++) spit('\n');
writetitle(ohead);
for (i = 0; i < o_m2; i++) spit('\n');
line_no = 0;
}
void endpage()
{
int i;
for (i = line_no; i < TXTLEN; i++) {
spit('\n');
line_no++;
}
for (i = 0; i < o_m3; i++) spit('\n');
writetitle(ofoot);
for (i = 0; i < o_m4; i++) spit('\n');
page_no++;
}
void spits(char *s)
{
while (*s) {
spit(*s);
s++;
}
}
static ava_value main_impl(void* arg) {
unsigned argc = ((const main_data*)arg)->argc;
const char*const* argv = ((const main_data*)arg)->argv;
ava_string package_name, package_prefix, file_prefix, infile, outfile;
const char* slash;
size_t len;
const ava_pcode_global_list* pcode;
if (2 != argc)
errx(EX_USAGE, "Usage: %s <filename>", argv[0]);
slash = strchr(argv[1], '/');
if (!slash || slash == argv[1])
errx(EX_USAGE, "Bad input filename: %s", argv[1]);
package_name = ava_string_of_bytes(argv[1], slash - argv[1]);
package_prefix = ava_strcat(package_name, AVA_ASCII9_STRING(":"));
file_prefix = ava_strcat(package_name, AVA_ASCII9_STRING("/"));
infile = ava_string_of_cstring(slash + 1);
len = ava_strlen(infile);
if (len < 5 || !ava_string_equal(AVA_ASCII9_STRING(".ava"),
ava_string_slice(infile, len - 4, len)))
errx(EX_USAGE, "Bad input filename: %s", argv[1]);
outfile = ava_strcat(
ava_string_slice(infile, 0, len - 4), AVA_ASCII9_STRING(".avam"));
pcode = compile(package_prefix, file_prefix, infile);
spit(ava_strcat(file_prefix, outfile), pcode);
return ava_value_of_string(AVA_EMPTY_STRING);
}
void RAS_ListSlot::SetModified(bool mod)
{
if (mod && !(m_flag & LIST_MODIFY)) {
spit("Modifying list (" << m_list << ")");
m_flag = m_flag &~ LIST_END;
m_flag |= LIST_STREAM;
}
}
void RAS_ListSlot::RemoveList()
{
if (m_list != 0) {
spit("Releasing display list (" << m_list << ")");
glDeleteLists((GLuint)m_list, 1);
m_list =0;
}
}
void BlockMiddleGoal()
{
StartTask(medgoal);
{
drivetime(80,1.2)
}
StopTask(medgoal);
spit(20);
}
void nodeDisplay (node *gotN) {
printf("%s\n", spit(gotN));
if (gotN->type != NODE_END) {
for (int i = 0; i < gotN->optNum; i++) {
printf("%i: %s\n", i + 1, gotN->options[i]);
}
}
}
void drive_Highgoal()
{
spit(0.5);/// let the spinners roll out.
drivetime(80,1.2);
stopDrivemotors(); ;//zero-out the motors
//stopTime(1.75);//wait for arm
// drivetime(50,2);//drive foward more...
stopTime(20);//sit at the wall for three seconds.
// drive_Enc(-85,2.75,3.4);//back up and spit.
// spit(4);// spit
// drive_Enc(-100, 7,2);//back up
}
/*
* Initialize the GUI interface for the plugin
*/
void QgsSpitPlugin::initGui()
{
// Create the action for tool
spitAction = new QAction( QIcon( spitIcon ), tr( "&Import Shapefiles to PostgreSQL" ), this );
spitAction->setWhatsThis( tr( "Import shapefiles into a PostGIS-enabled PostgreSQL database. "
"The schema and field names can be customized on import" ) );
// Connect the action to the spit slot
connect( spitAction, SIGNAL( triggered() ), this, SLOT( spit() ) );
// Add the icon to the toolbar and to the plugin menu
qI->addToolBarIcon( spitAction );
qI->addPluginToMenu( tr( "&Spit" ), spitAction );
}
static char *
remote_event_locked(const char *command)
{
if (strcmp(command, "burp") == 0) {
burp();
} else if (strcmp(command, "spit") == 0) {
spit();
} else {
return strdup("Invalid command");
}
return strdup(SERVER_OK);
}
static void
take_action()
{
pthread_mutex_lock(&event_lock);
if (randomly_with_prob(BURP_PROB)) {
if (! n_consecutive_spits) {
printf("Too many burps, do a spit instead.\n");
spit();
} else {
burp();
}
} else {
if (n_consecutive_spits >= MAX_CONSECUTIVE_SPITS) {
printf("Too many spits, do a burp instead.\n");
burp();
} else {
spit();
}
}
pthread_mutex_unlock(&event_lock);
}
void writeline(int adflag, int flushflag)
{
int j;
int q;
for (j = assylen - 1; j; j--) {
if (assyline[j] == ' ')
assylen--;
else
break;
}
q = TXTLEN;
if (line_no >= q) newpage();
for (j = 0; j < assylen; j++) spit(assyline[j]);
spit('\n');
assylen = 0;
assyline[0] = 0;
line_no++;
if (flushflag==0) {
strcpy(assyline, holdword);
assylen = strlen(holdword);
*holdword = 0;
holdp = holdword;
}
}
int BL_Shader::GetUniformLocation(const char *name)
{
if ( GLEW_ARB_fragment_shader &&
GLEW_ARB_vertex_shader &&
GLEW_ARB_shader_objects
)
{
MT_assert(mShader!=0);
int location = glGetUniformLocationARB(mShader, name);
if (location == -1)
spit("Invalid uniform value: " << name << ".");
return location;
}
return -1;
}
/*
* Initialize the GUI interface for the plugin
*/
void QgsSpitPlugin::initGui()
{
delete spitAction;
// Create the action for tool
spitAction = new QAction( QIcon(), tr( "&Import Shapefiles to PostgreSQL" ), this );
spitAction->setObjectName( "spitAction" );
setCurrentTheme( "" );
spitAction->setWhatsThis( tr( "Import shapefiles into a PostGIS-enabled PostgreSQL database. "
"The schema and field names can be customized on import" ) );
// Connect the action to the spit slot
connect( spitAction, SIGNAL( triggered() ), this, SLOT( spit() ) );
// Add the icon to the toolbar and to the plugin menu
qI->addDatabaseToolBarIcon( spitAction );
qI->addPluginToDatabaseMenu( tr( "&Spit" ), spitAction );
// this is called when the icon theme is changed
connect( qI, SIGNAL( currentThemeChanged( QString ) ), this, SLOT( setCurrentTheme( QString ) ) );
}
void RAS_ListSlot::DrawList()
{
if (m_flag &LIST_STREAM || m_flag& LIST_NOCREATE) {
RemoveList();
return;
}
if (m_flag &LIST_MODIFY) {
if (m_flag &LIST_CREATE) {
if (m_list == 0) {
m_list = (unsigned int)glGenLists(1);
m_flag = m_flag &~ LIST_CREATE;
spit("Created display list (" << m_list << ")");
}
}
if (m_list != 0)
glNewList((GLuint)m_list, GL_COMPILE);
m_flag |= LIST_BEGIN;
return;
}
glCallList(m_list);
}
void blankline()
{
if (line_no >= TXTLEN) newpage();
spit('\n');
line_no++;
}
bool BL_Texture::InitCubeMap(int unit, EnvMap *cubemap)
{
if (!GLEW_ARB_texture_cube_map)
{
spit("cubemaps not supported");
mOk = false;
return mOk;
}
else if (!cubemap || cubemap->ima->ok==0)
{
mOk = false;
return mOk;
}
ImBuf *ibuf= BKE_image_get_ibuf(cubemap->ima, NULL);
if (ibuf==0)
{
cubemap->ima->ok = 0;
mOk = false;
return mOk;
}
mNeedsDeleted = 1;
mType = GL_TEXTURE_CUBE_MAP_ARB;
mTexture = 0;
mUnit = unit;
ActivateUnit(mUnit);
BL_TextureMap::iterator mapLook = g_textureManager.find(cubemap->ima->id.name);
if (mapLook != g_textureManager.end())
{
if (mapLook->second.gl_texture != 0 && mapLook->second.ref_buffer == cubemap->ima)
{
mTexture = mapLook->second.gl_texture;
glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, mTexture);
mOk = IsValid();
return mOk;
}
}
glGenTextures(1, (GLuint*)&mTexture);
glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, mTexture);
// track created units
BL_TextureObject obj;
obj.gl_texture = mTexture;
obj.ref_buffer = cubemap->ima;
g_textureManager.insert(std::pair<char*, BL_TextureObject>((char*)cubemap->ima->id.name, obj));
bool needs_split = false;
if (!cubemap->cube[0])
{
needs_split = true;
spit ("Re-Generating texture buffer");
}
if (needs_split)
my_envmap_split_ima(cubemap, ibuf);
if (!is_pow2(cubemap->cube[0]->x) || !is_pow2(cubemap->cube[0]->y))
{
spit("invalid envmap size please render with CubeRes @ power of two");
my_free_envmapdata(cubemap);
mOk = false;
return mOk;
}
#define SetCubeMapFace(face, num) \
glTexImage2D(face, 0,GL_RGBA, \
cubemap->cube[num]->x, \
cubemap->cube[num]->y, \
0, GL_RGBA, GL_UNSIGNED_BYTE, \
cubemap->cube[num]->rect)
SetCubeMapFace(GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB, 5);
SetCubeMapFace(GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB, 3);
SetCubeMapFace(GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB, 0);
SetCubeMapFace(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB, 1);
SetCubeMapFace(GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB, 2);
SetCubeMapFace(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB, 4);
glTexParameteri( GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
glTexParameteri( GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
if(GLEW_VERSION_1_2)
glTexParameteri( GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE );
if (needs_split)
my_free_envmapdata(cubemap);
glDisable(GL_TEXTURE_CUBE_MAP_ARB);
ActivateUnit(0);
mOk = IsValid();
return mOk;
}
bool BL_Shader::LinkProgram()
{
int vertlen = 0, fraglen=0, proglen=0;
int vertstatus=0, fragstatus=0, progstatus=0;
unsigned int tmpVert=0, tmpFrag=0, tmpProg=0;
int char_len=0;
char *logInf =0;
if (mError)
goto programError;
if (!vertProg || !fragProg) {
spit("Invalid GLSL sources");
return false;
}
if ( !GLEW_ARB_fragment_shader) {
spit("Fragment shaders not supported");
return false;
}
if ( !GLEW_ARB_vertex_shader) {
spit("Vertex shaders not supported");
return false;
}
// -- vertex shader ------------------
tmpVert = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
glShaderSourceARB(tmpVert, 1, (const char**)&vertProg, 0);
glCompileShaderARB(tmpVert);
glGetObjectParameterivARB(tmpVert, GL_OBJECT_INFO_LOG_LENGTH_ARB,(GLint*) &vertlen);
// print info if any
if ( vertlen > 0 && vertlen < MAX_LOG_LEN) {
logInf = (char*)MEM_mallocN(vertlen, "vert-log");
glGetInfoLogARB(tmpVert, vertlen, (GLsizei*)&char_len, logInf);
if (char_len >0) {
spit("---- Vertex Shader Error ----");
spit(logInf);
}
MEM_freeN(logInf);
logInf=0;
}
// check for compile errors
glGetObjectParameterivARB(tmpVert, GL_OBJECT_COMPILE_STATUS_ARB,(GLint*)&vertstatus);
if (!vertstatus) {
spit("---- Vertex shader failed to compile ----");
goto programError;
}
// -- fragment shader ----------------
tmpFrag = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
glShaderSourceARB(tmpFrag, 1,(const char**)&fragProg, 0);
glCompileShaderARB(tmpFrag);
glGetObjectParameterivARB(tmpFrag, GL_OBJECT_INFO_LOG_LENGTH_ARB, (GLint*) &fraglen);
if (fraglen >0 && fraglen < MAX_LOG_LEN) {
logInf = (char*)MEM_mallocN(fraglen, "frag-log");
glGetInfoLogARB(tmpFrag, fraglen,(GLsizei*) &char_len, logInf);
if (char_len >0) {
spit("---- Fragment Shader Error ----");
spit(logInf);
}
MEM_freeN(logInf);
logInf=0;
}
glGetObjectParameterivARB(tmpFrag, GL_OBJECT_COMPILE_STATUS_ARB, (GLint*) &fragstatus);
if (!fragstatus) {
spit("---- Fragment shader failed to compile ----");
goto programError;
}
// -- program ------------------------
// set compiled vert/frag shader & link
tmpProg = glCreateProgramObjectARB();
glAttachObjectARB(tmpProg, tmpVert);
glAttachObjectARB(tmpProg, tmpFrag);
glLinkProgramARB(tmpProg);
glGetObjectParameterivARB(tmpProg, GL_OBJECT_INFO_LOG_LENGTH_ARB, (GLint*) &proglen);
glGetObjectParameterivARB(tmpProg, GL_OBJECT_LINK_STATUS_ARB, (GLint*) &progstatus);
if (proglen > 0 && proglen < MAX_LOG_LEN) {
logInf = (char*)MEM_mallocN(proglen, "prog-log");
glGetInfoLogARB(tmpProg, proglen, (GLsizei*)&char_len, logInf);
if (char_len >0) {
spit("---- GLSL Program ----");
spit(logInf);
}
MEM_freeN(logInf);
logInf=0;
}
if (!progstatus) {
spit("---- GLSL program failed to link ----");
goto programError;
}
// set
mShader = tmpProg;
glDeleteObjectARB(tmpVert);
glDeleteObjectARB(tmpFrag);
mOk = 1;
mError = 0;
return true;
programError:
if (tmpVert) {
glDeleteObjectARB(tmpVert);
tmpVert=0;
}
if (tmpFrag) {
glDeleteObjectARB(tmpFrag);
tmpFrag=0;
}
if (tmpProg) {
glDeleteObjectARB(tmpProg);
tmpProg=0;
}
mOk = 0;
mUse = 0;
mError = 1;
return false;
}
int main(int argc, const char*argv[]) {
sm_set_program_name(argv[0]);
struct sm_params params;
struct sm_result result;
struct option* ops = options_allocate(100);
options_string(ops, "in", &p.file_in, "stdin", "Input file ");
options_string(ops, "out", &p.file_out, "stdout", "Output file ");
options_string(ops, "out_stats", &p.file_out_stats, "", "Output file (stats) ");
options_string(ops, "file_jj", &p.file_jj, "",
"File for journaling -- if left empty, journal not open.");
options_int(ops, "algo", &p.algo, 0, "Which algorithm to use (0:(pl)ICP 1:gpm-stripped 2:HSM) ");
options_int(ops, "debug", &p.debug, 0, "Shows debug information");
options_int(ops, "recover_from_error", &p.recover_from_error, 0, "If true, tries to recover from an ICP matching error");
p.format = 0;
/* options_int(ops, "format", &p.format, 0,
"Output format (0: log in JSON format, 1: log in Carmen format (not implemented))");*/
sm_options(¶ms, ops);
if(!options_parse_args(ops, argc, argv)) {
fprintf(stderr, "\n\nUsage:\n");
options_print_help(ops, stderr);
return -1;
}
sm_debug_write(p.debug);
/* Open input and output files */
FILE * file_in = open_file_for_reading(p.file_in);
if(!file_in) return -1;
FILE * file_out = open_file_for_writing(p.file_out);
if(!file_out) return -1;
if(strcmp(p.file_jj, "")) {
FILE * jj = open_file_for_writing(p.file_jj);
if(!jj) return -1;
jj_set_stream(jj);
}
FILE * file_out_stats = 0;
if(strcmp(p.file_out_stats, "")) {
file_out_stats = open_file_for_writing(p.file_out_stats);
if(!file_out_stats) return -1;
}
/* Read first scan */
LDP laser_ref;
if(!(laser_ref = ld_read_smart(file_in))) {
sm_error("Could not read first scan.\n");
return -1;
}
if(!ld_valid_fields(laser_ref)) {
sm_error("Invalid laser data in first scan.\n");
return -2;
}
/* For the first scan, set estimate = odometry */
copy_d(laser_ref->odometry, 3, laser_ref->estimate);
spit(laser_ref, file_out);
int count=-1;
LDP laser_sens;
while( (laser_sens = ld_read_smart(file_in)) ) {
count++;
if(!ld_valid_fields(laser_sens)) {
sm_error("Invalid laser data in (#%d in file).\n", count);
return -(count+2);
}
params.laser_ref = laser_ref;
params.laser_sens = laser_sens;
/* Set first guess as the difference in odometry */
if( any_nan(params.laser_ref->odometry,3) ||
any_nan(params.laser_sens->odometry,3) ) {
sm_error("The 'odometry' field is set to NaN so I don't know how to get an initial guess. I usually use the difference in the odometry fields to obtain the initial guess.\n");
sm_error(" laser_ref->odometry = %s \n", friendly_pose(params.laser_ref->odometry) );
sm_error(" laser_sens->odometry = %s \n", friendly_pose(params.laser_sens->odometry) );
sm_error(" I will quit it here. \n");
return -3;
}
double odometry[3];
pose_diff_d(laser_sens->odometry, laser_ref->odometry, odometry);
double ominus_laser[3], temp[3];
ominus_d(params.laser, ominus_laser);
oplus_d(ominus_laser, odometry, temp);
oplus_d(temp, params.laser, params.first_guess);
/* Do the actual work */
switch(p.algo) {
case(0):
sm_icp(¶ms, &result); break;
case(1):
sm_gpm(¶ms, &result); break;
case(2):
sm_hsm(¶ms, &result); break;
default:
sm_error("Unknown algorithm to run: %d.\n",p.algo);
return -1;
}
if(!result.valid){
if(p.recover_from_error) {
sm_info("One ICP matching failed. Because you passed -recover_from_error, I will try to recover."
" Note, however, that this might not be good in some cases. \n");
sm_info("The recover is that the displacement is set to 0. No result stats is output. \n");
/* For the first scan, set estimate = odometry */
copy_d(laser_ref->estimate, 3, laser_sens->estimate);
ld_free(laser_ref); laser_ref = laser_sens;
} else {
sm_error("One ICP matching failed. Because I process recursively, I will stop here.\n");
sm_error("Use the option -recover_from_error if you want to try to recover.\n");
ld_free(laser_ref);
return 2;
}
} else {
/* Add the result to the previous estimate */
oplus_d(laser_ref->estimate, result.x, laser_sens->estimate);
/* Write the corrected log */
spit(laser_sens, file_out);
/* Write the statistics (if required) */
if(file_out_stats) {
JO jo = result_to_json(¶ms, &result);
fputs(jo_to_string(jo), file_out_stats);
fputs("\n", file_out_stats);
jo_free(jo);
}
ld_free(laser_ref); laser_ref = laser_sens;
}
}
ld_free(laser_ref);
return 0;
}
int main(gint argc, gchar **argv) {
const gchar *self = *argv++;
if (argc < 2) {
g_message("%s command [arguments...]", self);
return 1;
}
if (g_getenv("NIX_CHROOTENV"))
g_warning("chrootenv doesn't stack!");
else
g_setenv("NIX_CHROOTENV", "", TRUE);
g_autofree gchar *prefix =
g_build_filename(g_get_tmp_dir(), "chrootenvXXXXXX", NULL);
fail_if(!g_mkdtemp_full(prefix, 0755));
pid_t cpid = fork();
if (cpid < 0)
fail("fork", errno);
else if (cpid == 0) {
uid_t uid = getuid();
gid_t gid = getgid();
if (unshare(CLONE_NEWNS | CLONE_NEWUSER) < 0) {
int unshare_errno = errno;
g_message("Requires Linux version >= 3.19 built with CONFIG_USER_NS");
if (g_file_test("/proc/sys/kernel/unprivileged_userns_clone",
G_FILE_TEST_EXISTS))
g_message("Run: sudo sysctl -w kernel.unprivileged_userns_clone=1");
fail("unshare", unshare_errno);
}
spit("/proc/self/setgroups", "deny");
spit("/proc/self/uid_map", "%d %d 1", uid, uid);
spit("/proc/self/gid_map", "%d %d 1", gid, gid);
bind("/", prefix);
fail_if(chroot(prefix));
fail_if(chdir("/"));
fail_if(execvp(*argv, argv));
}
else {
int status;
fail_if(waitpid(cpid, &status, 0) != cpid);
fail_if(nftw(prefix, nftw_remove, getdtablesize(),
FTW_DEPTH | FTW_MOUNT | FTW_PHYS));
if (WIFEXITED(status))
return WEXITSTATUS(status);
else if (WIFSIGNALED(status))
kill(getpid(), WTERMSIG(status));
return 1;
}
}
void Utils::serializeProfit(float profit, const string filename) {
spit(to_string(profit), filename);
}
int main(gint argc, gchar **argv) {
const gchar *self = *argv++;
if (argc < 2) {
g_message("%s command [arguments...]", self);
return 1;
}
g_autofree const gchar *prefix = create_tmpdir();
pid_t cpid = fork();
if (cpid < 0)
fail("fork", errno);
else if (cpid == 0) {
uid_t uid = getuid();
gid_t gid = getgid();
if (unshare(CLONE_NEWNS | CLONE_NEWUSER) < 0) {
int unshare_errno = errno;
g_message("Requires Linux version >= 3.19 built with CONFIG_USER_NS");
if (g_file_test("/proc/sys/kernel/unprivileged_userns_clone",
G_FILE_TEST_EXISTS))
g_message("Run: sudo sysctl -w kernel.unprivileged_userns_clone=1");
fail("unshare", unshare_errno);
}
spit("/proc/self/setgroups", "deny");
spit("/proc/self/uid_map", "%d %d 1", uid, uid);
spit("/proc/self/gid_map", "%d %d 1", gid, gid);
// If there is a /host directory, assume this is nested chrootenv and use it as host instead.
gboolean nested_host = g_file_test("/host", G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR);
g_autofree const gchar *host = nested_host ? "/host" : "/";
bind(host, prefix);
// Replace /host by an actual (inner) /host.
if (nested_host) {
fail_if(g_mkdir("/real-host", 0755));
fail_if(mount("/host/host", "/real-host", NULL, MS_BIND | MS_REC, NULL));
// For some reason umount("/host") returns EBUSY even immediately after
// pivot_root. We detach it at least to keep `/proc/mounts` from blowing
// up in nested cases.
fail_if(umount2("/host", MNT_DETACH));
fail_if(mount("/real-host", "/host", NULL, MS_MOVE, NULL));
fail_if(rmdir("/real-host"));
}
fail_if(chdir("/"));
fail_if(execvp(*argv, argv));
}
else {
int status;
fail_if(waitpid(cpid, &status, 0) != cpid);
fail_if(rmdir(prefix));
if (WIFEXITED(status))
return WEXITSTATUS(status);
else if (WIFSIGNALED(status))
kill(getpid(), WTERMSIG(status));
return 1;
}
}
void writetitle(char *t)
{
char d;
char *pst;
int j;
int l;
int m;
int n;
int pstlen;
d = *t;
if (d=='\0') {
spit('\n');
return;
}
pst = pgform();
pstlen= strlen(pst);
t++;
l = titlen(t, d, pstlen);
while (1) {
if (*t == 0) break;
if (*t == d) break;
if (*t == '%')
spits(pst);
else
spit(*t);
t++;
}
if (*t == '\0') {
spit('\n');
return;
}
t++;
m = titlen(t, d, pstlen);
for (j = l; j < (o_ll - m) / 2; j++) spit(' ');
while (1) {
if (*t == 0) break;
if (*t == d) break;
if (*t == '%')
spits(pst);
else
spit(*t);
t++;
}
if (*t == '\0') {
spit('\n');
return;
}
if ((o_ll - m) / 2 > l)
m = m + (o_ll - m) / 2;
else
m = m + l;
t++;
n = titlen(t, d, pstlen);
for (j = m; j < o_ll - n; j++) spit(' ');
while (1) {
if (*t == 0) break;
if (*t == d) break;
if (*t == '%')
spits(pst);
else
spit(*t);
t++;
}
spit('\n');
}
int main (int argc, char **argv) {
int i=0,j=0;
uint32_t num_tests, num_sets_per_test, num_ops_per_test, the_max_num_labels, seed;
uint8_t x=0;
uint32_t y=0,zz=0;
Dpdf *pdf=NULL;
int num_args = 6;
if (argc-1 == num_args) {
num_tests = atoi(argv[1]);
num_sets_per_test = atoi(argv[2]);
num_ops_per_test = atoi(argv[3]);
the_max_num_labels = atoi(argv[4]);
seed = atoi(argv[5]);
bv_debug = atoi(argv[6]);
}
else {
printf ("I needed %d args; you provided %d -- using defaults.\n", num_args, argc-1);
printf ("usage: bvlt num_tests num_sets_per_test num_ops_per_test max_labels seed bv_debug\n");
num_tests = 10;
num_sets_per_test = 10;
num_ops_per_test = 1000;
the_max_num_labels = 32;
seed = 1234567;
bv_debug = TRUE;
}
printf ("%d tests\n", num_tests);
printf ("%d sets per test\n", num_sets_per_test);
printf ("%d ops per test\n", num_ops_per_test);
printf ("%d max unique labels\n", the_max_num_labels);
printf ("%d random seed\n", seed);
pdf = prob_create("bvc",NUM_OPS);
prob_set(pdf,ERASE,0.05);
prob_set(pdf,IS_EMPTY,0.05);
prob_set(pdf,ADD,0.5);
prob_set(pdf,COPY,0.05);
prob_set(pdf,UNION,0.05);
prob_normalize(pdf);
printf ("dist of ops {ERASE,IS_EMPTY,ADD,COPY,UNION}\n ");
prob_spit(pdf);
srand(seed);
labelset_set_max_num_labels(the_max_num_labels);
for (i=0; i<num_tests; i++) {
if (bv_debug) printf ("test %d\n", i);
LabelSet **ls = (LabelSet **) my_malloc(sizeof(LabelSet *) * num_sets_per_test, poolid_label_set);
for (j=0; j<num_sets_per_test; j++) {
ls[j] = labelset_new();
}
for (j=0; j<num_ops_per_test; j++) {
if (bv_debug) printf ("op %d: ", j);
uint32_t l = random() % num_sets_per_test;
int d = prob_draw(pdf);
LabelSet *tls = ls[l];
switch (d) {
case ERASE:
labelset_erase(tls);
assert ((labelset_card(tls)) == 0);
if (bv_debug) {
printf ("erase set %d. ",l);
spit (l,ls);
}
break;
case IS_EMPTY:
x = labelset_is_empty(tls);
if (x)
assert ((labelset_card(tls)) == 0);
else
assert ((labelset_card(tls)) != 0);
if (bv_debug) {
printf ("is_empty set=%d: %d. ", l, x);
spit (l,ls);
}
break;
case ADD:
{
uint32_t n1 = labelset_card(tls);
uint32_t y = (random()) % the_max_num_labels;
uint8_t already_there = labelset_member(tls,y);
labelset_add(tls,y);
assert (labelset_member(tls,y));
uint32_t n2 = labelset_card(tls);
if (already_there)
assert (n1 == n2);
else
assert (n1 + 1 == n2);
if (bv_debug) {
printf ("add to set=%d, el=%d. ",l,y);
spit(l,ls);
}
break;
}
case COPY:
{
uint32_t o=0;
do {
o = random() % num_sets_per_test;
} while (o == l);
labelset_copy(tls,ls[o]);
if (bv_debug) {
printf ("copy set=%d to set=%d. ",o,l);
spit(l,ls);
}
break;
}
case UNION:
{
uint32_t o=0;
do {
o = random() % num_sets_per_test;
} while (o == l);
labelset_union(tls,ls[o]);
if (bv_debug) {
printf ("union set=%d <- set=%d. ", l,o);
spit(l,ls);
}
break;
}
default:
printf ("wtf d=%d\n", d);
abort();
break;
}
zz += x; // make sure x actually gets computed.
} // iterate over ops
// release memory
for (j=0; j<num_sets_per_test; j++) {
labelset_free(ls[j]);
}
my_free(ls, sizeof(LabelSet), poolid_label_set);
} // iterate over tests
printf ("zz=%d\n", zz); // say no to optimizers
prob_destroy(pdf);
} // main
