int init_iothread(/*out*/iothread_t* iothr) { int err; thread_t* old_thread = iothr->thread; thread_t* thread; // DESIGN-TASK::: // TODO: implement thread pool / one thread per io device ! // - move thread into thread pool // - remove old_thread and iothr->thread = 0 assignment ! after thread pool creation // - use iothread pool iothr->thread = 0; if (! PROCESS_testerrortimer(&s_iothread_errtimer, &err)) { err = newgeneric_thread(&thread, &ioop_worker_thread, iothr); } if (err) goto ONERR; // set out iothr->request_stop = 0; init_iolist(&iothr->iolist); write_atomicint(&iothr->thread, thread); // start worker resume_thread(thread); return 0; ONERR: iothr->thread = old_thread; TRACEEXIT_ERRLOG(err); return err; }
int init_filereader(/*out*/filereader_t * frd, const char * filepath, const struct directory_t * relative_to/*0 => current working dir*/) { int err; size_t bufsize = sizebuffer_filereader(); initvariables_filereader(frd); err = initfile_filereader(&frd->file, &frd->filesize, filepath, relative_to); if (err) goto ONERR; if (castPoff_size(frd->filesize) <= bufsize) { err = initsinglebuffer_filereader(frd->page, (size_t)frd->filesize); if (err) goto ONERR; } else { err = initdoublebuffer_filereader(frd->page, bufsize); if (err) goto ONERR; } return 0; ONERR: (void) free_filereader(frd); TRACEEXIT_ERRLOG(err); return err; }
int initPid_eglconfig(/*out*/eglconfig_t * eglconf, struct opengl_display_t * egldisp, const uint32_t id) { int err; EGLint egl_attrib_list[] = { EGL_CONFIG_ID, (int32_t) id, EGL_NONE }; EGLint num_config; EGLConfig eglconfig[1]; EGLBoolean isOK = eglChooseConfig( egldisp, egl_attrib_list, eglconfig, lengthof(eglconfig), &num_config); if (!isOK) { err = EINVAL; goto ONERR; } if (0 == num_config) { return ESRCH; } *eglconf = eglconfig[0]; return 0; ONERR: TRACEEXIT_ERRLOG(err); return err; }
int switchpermanent_syslogin(syslogin_t* syslogin, sys_userid_t uid) { int err; VALIDATE_INPARAM_TEST(uid != sys_userid_FREE, ONERR, ); err = switchuser(syslogin, uid); if (err) goto ONERR; err = setreuid(uid, uid); if (err) { err = errno; TRACESYSCALL_ERRLOG("setreuid(uid,uid)", err); PRINTUINT32_ERRLOG(uid); goto ONERR; } // syslogin->currentuser // set in switchuser syslogin->realuser = uid; syslogin->privilegeduser = uid; return 0; ONERR: TRACEEXIT_ERRLOG(err); return err; }
int init_eglconfig(/*out*/eglconfig_t * eglconf, opengl_display_t * egldisp, const int32_t config_attributes[]) { int err; EGLint egl_attrib_list[2*gconfig__NROF]; err = convertConfigListToEGL_eglconfig(&egl_attrib_list, config_attributes); if (err) goto ONERR; EGLint num_config; EGLConfig eglconfig; EGLBoolean isOK = eglChooseConfig( egldisp, egl_attrib_list, &eglconfig, 1, &num_config); if (!isOK) { err = EINVAL; goto ONERR; } if (!num_config) { return ESRCH; } *eglconf = eglconfig; return 0; ONERR: TRACEEXIT_ERRLOG(err); return err; }
void errorstring_x11display(const x11display_t * x11disp, int x11_errcode, char * buffer, uint8_t buffer_size) { int err ; int x11_err ; if (!buffer_size) { err = EINVAL ; PRINTUINT8_ERRLOG(buffer_size) ; goto ONERR; } x11_err = XGetErrorText(x11disp->sys_display, x11_errcode, buffer, buffer_size) ; if (x11_err) { err = EINVAL ; TRACESYSCALL_ERRLOG("XGetErrorText", err) ; PRINTINT_ERRLOG(x11_err) ; goto ONERR; } buffer[buffer_size-1] = 0 ; return ; ONERR: if (buffer_size) { snprintf(buffer, buffer_size, "%d", x11_errcode) ; buffer[buffer_size-1] = 0 ; } TRACEEXIT_ERRLOG(err); return ; }
int configid_eglconfig(eglconfig_t eglconf, struct opengl_display_t * egldisp, /*out*/uint32_t * id) { int err; GETVALUE(eglconf, egldisp, EGL_CONFIG_ID, (int32_t*)id); return 0; ONERR: TRACEEXIT_ERRLOG(err); return err; }
int visualconfigid_eglconfig(eglconfig_t eglconf, struct opengl_display_t * egldisp, /*out*/int32_t * visualid) { int err; GETVALUE(eglconf, egldisp, EGL_NATIVE_VISUAL_ID, visualid); return 0; ONERR: TRACEEXIT_ERRLOG(err); return err; }
int init2_x11display(/*out*/x11display_t * x11disp, const char * display_server_name, bool isInitExtension) { int err ; err = initprivate_x11display(x11disp, display_server_name, isInitExtension); if (err) goto ONERR; return 0; ONERR: TRACEEXIT_ERRLOG(err); return err; }
int switchtorealuser_syslogin(syslogin_t* syslogin) { int err; err = switchuser(syslogin, syslogin->realuser); if (err) goto ONERR; return 0; ONERR: TRACEEXIT_ERRLOG(err); return err; }
int removeobject_x11display(x11display_t * x11disp, uint32_t objectid) { int err ; err = remove_x11windowmap(x11disp->idmap, objectid) ; if (err) goto ONERR; return 0 ; ONERR: TRACEEXIT_ERRLOG(err); return err ; }
int init_x11display(/*out*/x11display_t * x11disp, const char * display_server_name) { int err ; err = initprivate_x11display(x11disp, display_server_name, true); if (err) goto ONERR; return 0 ; ONERR: TRACEEXIT_ERRLOG(err); return err ; }
int set_x11videomode(const x11videomode_t * xvidmode, x11screen_t * x11screen) { int err ; XRRScreenConfiguration * screen_config = 0 ; if (!isextxrandr_x11display(display_x11screen(x11screen))) { err = ENOSYS ; goto ONERR; } Display * sys_display = display_x11screen(x11screen)->sys_display ; screen_config = XRRGetScreenInfo(sys_display, RootWindow(sys_display, number_x11screen(x11screen))) ; if (!screen_config) { err = ENOSYS ; goto ONERR; } Rotation current_rotation ; uint16_t current_size = XRRConfigCurrentConfiguration(screen_config, ¤t_rotation) ; int sizes_count ; XRRScreenSize * sizes = XRRConfigSizes(screen_config, &sizes_count) ; if ( !sizes || (current_size >= sizes_count)) { err = EOVERFLOW ; goto ONERR; } if ( xvidmode->modeid > sizes_count || xvidmode->width_in_pixel != (uint32_t) sizes[xvidmode->modeid].width || xvidmode->height_in_pixel != (uint32_t) sizes[xvidmode->modeid].height) { err = EINVAL ; goto ONERR; } if (XRRSetScreenConfig( sys_display, screen_config, RootWindow(sys_display, number_x11screen(x11screen)), xvidmode->modeid, current_rotation, CurrentTime)) { err = EOPNOTSUPP ; goto ONERR; } XRRFreeScreenConfigInfo(screen_config) ; return 0 ; ONERR: if (screen_config) { XRRFreeScreenConfigInfo(screen_config) ; } TRACEEXIT_ERRLOG(err); return err ; }
int insertobject_x11display(x11display_t * x11disp, struct x11window_t * object, uint32_t objectid) { int err ; VALIDATE_INPARAM_TEST(object != 0, ONERR, ); err = insert_x11windowmap(x11disp->idmap, objectid, object); if (err) goto ONERR; return 0 ; ONERR: TRACEEXIT_ERRLOG(err); return err ; }
int initfiltered_eglconfig(/*out*/eglconfig_t * eglconf, struct opengl_display_t * egldisp, const int32_t config_attributes[], eglconfig_filter_f filter, void * user) { int err; EGLint egl_attrib_list[2*gconfig__NROF]; EGLConfig * eglconfig = 0; memblock_t mblock; err = convertConfigListToEGL_eglconfig(&egl_attrib_list, config_attributes); if (err) goto ONERR; EGLint num_config; EGLBoolean isOK = eglChooseConfig( egldisp, egl_attrib_list, 0, 0, &num_config); if (!isOK) { err = EINVAL; goto ONERR; } // TODO: implement tempstack_memory_allocator // allocate memory from tempstack instead of real stack err = ALLOC_ERR_MM(&s_eglconfig_errtimer, sizeof(EGLConfig) * (unsigned)num_config, &mblock); if (err) goto ONERR; eglconfig = (EGLConfig *) mblock.addr; isOK = eglChooseConfig( egldisp, egl_attrib_list, eglconfig, num_config, &num_config); if (!isOK) { err = EINVAL; goto ONERR; } EGLint i; for (i = 0; i < num_config; ++i) { EGLint visualid; isOK = eglGetConfigAttrib( egldisp, eglconfig[i], EGL_NATIVE_VISUAL_ID, &visualid); if (filter(eglconfig[i], visualid, user)) { // set out param *eglconf = eglconfig[i]; break; } } (void) FREE_ERR_MM(&s_eglconfig_errtimer, &mblock); if (i == num_config) return ESRCH; return 0; ONERR: if (eglconfig) (void) FREE_MM(&mblock); TRACEEXIT_ERRLOG(err); return err; }
static int initprivate_x11display(/*out*/x11display_t * x11disp, const char * display_server_name, bool isInitExtension) { int err ; x11display_t newdisp = x11display_FREE; memblock_t mblock; if (!display_server_name) { display_server_name = getenv("DISPLAY") ; if (!display_server_name) { err = EINVAL; TRACE_NOARG_ERRLOG(log_flags_NONE, X11_DISPLAY_NOT_SET); goto ONERR; } } // create new x11_display err = ALLOC_MM(sizeof(x11windowmap_t), &mblock); if (err) goto ONERR; newdisp.idmap = (x11windowmap_t*) mblock.addr; memset(newdisp.idmap->entries, 0, sizeof(newdisp.idmap->entries)); newdisp.sys_display = XOpenDisplay(display_server_name); if (!newdisp.sys_display) { err = ECONNREFUSED; TRACE_ERRLOG(log_flags_NONE, X11_NO_CONNECTION, display_server_name); goto ONERR; } #define SETATOM(NAME) newdisp.atoms.NAME = XInternAtom(newdisp.sys_display, #NAME, False); \ static_assert(sizeof(newdisp.atoms.NAME) == sizeof(uint32_t), "same type") SETATOM(WM_PROTOCOLS); SETATOM(WM_DELETE_WINDOW); SETATOM(_NET_FRAME_EXTENTS); SETATOM(_NET_WM_WINDOW_OPACITY); #undef SETATOM if (isInitExtension) { err = queryextensions_x11display(&newdisp); if (err) goto ONERR; } *x11disp = newdisp; return 0; ONERR: free_x11display(&newdisp); TRACEEXIT_ERRLOG(err); return err; }
int readnext_filereader(filereader_t * frd, /*out*/struct memstream_ro_t * buffer) { int err; if (frd->ioerror) { // never logged twice return frd->ioerror; } off_t unreadsize = frd->filesize - frd->fileoffset; if (0 == unreadsize) { // ENODATA is not logged return ENODATA; } if (! frd->nrfreebuffer) { err = ENOBUFS; goto ONERR; } uint8_t * bufferaddr = frd->page[frd->nextindex].addr; size_t buffersize = frd->page[frd->nextindex].size; if (castPoff_size(unreadsize) < buffersize) { buffersize = (size_t) unreadsize; } if (! frd->unreadsize) { err = readall_iochannel(frd->file, buffersize, bufferaddr, -1); if (err) { frd->ioerror = err; goto ONERR; } frd->unreadsize = buffersize; } frd->unreadsize -= buffersize; frd->nextindex = ! frd->nextindex; -- frd->nrfreebuffer; frd->fileoffset += (off_t) buffersize; // set out param init_memstream(buffer, bufferaddr, bufferaddr + buffersize); return 0; ONERR: TRACEEXIT_ERRLOG(err); return err; }
int replaceobject_x11display(x11display_t * x11disp, struct x11window_t * object, uint32_t objectid) { int err ; x11windowmap_entry_t * found_node; err = find_x11windowmap(x11disp->idmap, objectid, &found_node) ; if (err) goto ONERR; found_node->object = object; return 0 ; ONERR: TRACEEXIT_ERRLOG(err); return err ; }
int init_module(/*out*/module_t * mod, const char * modulename) { int err; directory_t * dir = 0; vmpage_t module_page = vmpage_FREE; size_t code_size; err = new_directory(&dir, module_DIRECTORY, 0); if (err) goto ONERR; { off_t file_size; err = filesize_directory(dir, modulename, &file_size); if (err) goto ONERR; if (file_size < 0 || (OFF_MAX > SIZE_MAX && file_size >= SIZE_MAX)) { err = ENOMEM; goto ONERR; } code_size = (size_t) file_size; } err = init2_vmpage(&module_page, code_size, accessmode_RDWR); if (err) goto ONERR; { wbuffer_t wbuf = wbuffer_INIT_STATIC(code_size, module_page.addr); err = load_file(modulename, &wbuf, dir); if (err) goto ONERR; } err = protect_vmpage(&module_page, accessmode_RDEX); if (err) goto ONERR; err = delete_directory(&dir); if (err) goto ONERR; *cast_vmpage(mod, page_) = module_page; mod->code_size = code_size; return 0; ONERR: free_vmpage(&module_page); delete_directory(&dir); TRACEEXIT_ERRLOG(err); return err; }
int init_pipe(/*out*/pipe_t* pipe) { int err; static_assert(1 + &pipe->read == &pipe->write, "Arrayzugriff möglich"); if (/*Fehler?*/ pipe2(&pipe->read, O_NONBLOCK|O_CLOEXEC)) { err = errno; goto ONERR; } return 0; ONERR: TRACEEXIT_ERRLOG(err); return err; }
int init_logbuffer(/*out*/logbuffer_t * logbuf, size_t buffer_size, uint8_t buffer_addr[buffer_size], sys_iochannel_t io) { int err; VALIDATE_INPARAM_TEST(buffer_size > log_config_MINSIZE, ONERR,); logbuf->addr = buffer_addr; logbuf->size = buffer_size; logbuf->logsize = 0; logbuf->io = io; logbuf->addr[0] = 0; return 0; ONERR: TRACEEXIT_ERRLOG(err); return err; }
int configid_eglpbuffer(const eglpbuffer_t eglpbuf, struct opengl_display_t * egldisp, /*out*/uint32_t * configid) { int err; EGLint value; static_assert(sizeof(EGLint) <= sizeof(uint32_t), "attribute type can be converted to returned type"); if (!eglQuerySurface(egldisp, eglpbuf, EGL_CONFIG_ID, &value)) { goto ONERR; } *configid = (uint32_t) value; return 0; ONERR: err = convert2errno_egl(eglGetError()); TRACEEXIT_ERRLOG(err); return err; }
int tryfindobject_x11display(x11display_t * x11disp, /*out*/struct x11window_t ** object, uint32_t objectid) { int err ; x11windowmap_entry_t * found_node ; err = find_x11windowmap(x11disp->idmap, objectid, &found_node) ; if (err) goto ONERR; if (object) { *object = found_node->object ; } return 0 ; ONERR: if (err != ESRCH) { TRACEEXIT_ERRLOG(err); } return err ; }
int initcurrent_x11videomode(/*out*/x11videomode_t * current_xvidmode, x11screen_t * x11screen) { int err ; XRRScreenConfiguration * screen_config = 0 ; if (!isextxrandr_x11display(display_x11screen(x11screen))) { err = ENOSYS ; goto ONERR; } Display * sys_display = display_x11screen(x11screen)->sys_display ; screen_config = XRRGetScreenInfo(sys_display, RootWindow(sys_display, number_x11screen(x11screen))) ; if (!screen_config) { err = ENOSYS ; goto ONERR; } Rotation current_rotation ; uint16_t current_size = XRRConfigCurrentConfiguration(screen_config, ¤t_rotation) ; int sizes_count ; XRRScreenSize * sizes = XRRConfigSizes(screen_config, &sizes_count) ; if ( !sizes || (current_size >= sizes_count)) { err = EOVERFLOW ; goto ONERR; } current_xvidmode->modeid = current_size ; current_xvidmode->width_in_pixel = (uint32_t) sizes[current_size].width ; current_xvidmode->height_in_pixel = (uint32_t) sizes[current_size].height ; XRRFreeScreenConfigInfo(screen_config) ; return 0 ; ONERR: if (screen_config) { XRRFreeScreenConfigInfo(screen_config) ; } TRACEEXIT_ERRLOG(err); return err ; }
int size_eglpbuffer(const eglpbuffer_t eglpbuf, struct opengl_display_t * egldisp, /*out*/uint32_t * width, /*out*/uint32_t * height) { int err; EGLint attr_value; static_assert(sizeof(EGLint) <= sizeof(uint32_t), "attribute type can be converted to returned type"); if (!eglQuerySurface(egldisp, eglpbuf, EGL_WIDTH, &attr_value)) { goto ONERR; } *width = (uint32_t) attr_value; if (!eglQuerySurface(egldisp, eglpbuf, EGL_HEIGHT, &attr_value)) { goto ONERR; } *height = (uint32_t) attr_value; return 0; ONERR: err = convert2errno_egl(eglGetError()); TRACEEXIT_ERRLOG(err); return err; }
int init_eglwindow(/*out*/eglwindow_t * eglwin, egldisplay_t egldisp, eglconfig_t eglconf, struct sys_window_t * syswin) { int err; VALIDATE_INPARAM_TEST(syswin != 0, ONERR, ); EGLint attrib[] = { EGL_NONE }; EGLSurface window = eglCreateWindowSurface(egldisp, eglconf, (EGLNativeWindowType) syswin, attrib); if (EGL_NO_SURFACE == window) { err = convert2errno_egl(eglGetError()); goto ONERR; } *eglwin = window; return 0; ONERR: TRACEEXIT_ERRLOG(err); return err; }
int init_syslogin(/*out*/syslogin_t* syslogin) { int err; sys_userid_t uid; sys_userid_t euid; uid = getuid(); euid = geteuid(); err = switchuser(syslogin, uid); if (err) goto ONERR; // syslogin->currentuser // already set in switchuser syslogin->realuser = uid; syslogin->privilegeduser = euid; return 0; ONERR: TRACEEXIT_ERRLOG(err); return err; }
int maxpbuffer_eglconfig(eglconfig_t eglconf, struct opengl_display_t * egldisp, /*out*/uint32_t * maxwidth, /*out*/uint32_t * maxheight, /*out*/uint32_t * maxpixels) { int err; if (maxwidth) { GETVALUE(eglconf, egldisp, EGL_MAX_PBUFFER_WIDTH, (int32_t*)maxwidth); } if (maxheight) { GETVALUE(eglconf, egldisp, EGL_MAX_PBUFFER_HEIGHT, (int32_t*)maxheight); } if (maxpixels) { GETVALUE(eglconf, egldisp, EGL_MAX_PBUFFER_PIXELS, (int32_t*)maxpixels); } return 0; ONERR: TRACEEXIT_ERRLOG(err); return err; }
int init_systimer(/*out*/systimer_t* timer, sysclock_e clock_type) { int err ; clockid_t clockid = convertclockid(clock_type) ; int fd ; fd = timerfd_create(clockid, TFD_NONBLOCK|TFD_CLOEXEC) ; if (-1 == fd) { err = errno ; TRACESYSCALL_ERRLOG("timerfd_create", err) ; PRINTINT_ERRLOG(clock_type) ; goto ONERR; } else { *timer = fd ; } return 0 ; ONERR: TRACEEXIT_ERRLOG(err); return err ; }
int init_eglpbuffer(/*out*/eglpbuffer_t * eglpbuf, struct opengl_display_t * egldisp, struct opengl_config_t * eglconf, uint32_t width, uint32_t height) { int err; EGLint attr[] = { EGL_HEIGHT, height > INT32_MAX ? INT32_MAX : (int32_t)height, EGL_WIDTH, width > INT32_MAX ? INT32_MAX : (int32_t)width, EGL_NONE }; EGLSurface surface = eglCreatePbufferSurface(egldisp, eglconf, attr); if (EGL_NO_SURFACE == surface) { goto ONERR; } *eglpbuf = surface; return 0; ONERR: err = convert2errno_egl(eglGetError()); TRACEEXIT_ERRLOG(err); return err; }