Exemple #1
0
ssize_t AudioTrack::write(const void* buffer, size_t userSize)
{

    if (mSharedBuffer != 0) return INVALID_OPERATION;

    if (ssize_t(userSize) < 0) {
        // sanity-check. user is most-likely passing an error code.
        LOGE("AudioTrack::write(buffer=%p, size=%u (%d)",
                buffer, userSize, userSize);
        return BAD_VALUE;
    }

    LOGV("write %p: %d bytes, mActive=%d", this, userSize, mActive);

    // acquire a strong reference on the IMemory and IAudioTrack so that they cannot be destroyed
    // while we are accessing the cblk
    mLock.lock();
    sp <IAudioTrack> audioTrack = mAudioTrack;
    sp <IMemory> iMem = mCblkMemory;
    mLock.unlock();

    ssize_t written = 0;
    const int8_t *src = (const int8_t *)buffer;
    Buffer audioBuffer;
    size_t frameSz = (size_t)frameSize();

    do {
        audioBuffer.frameCount = userSize/frameSz;

        // Calling obtainBuffer() with a negative wait count causes
        // an (almost) infinite wait time.
        status_t err = obtainBuffer(&audioBuffer, -1);
        if (err < 0) {
            // out of buffers, return #bytes written
            if (err == status_t(NO_MORE_BUFFERS))
                break;
            return ssize_t(err);
        }

        size_t toWrite;

        if (mFormat == AUDIO_FORMAT_PCM_8_BIT && !(mFlags & AUDIO_POLICY_OUTPUT_FLAG_DIRECT)) {
            // Divide capacity by 2 to take expansion into account
            toWrite = audioBuffer.size>>1;
            // 8 to 16 bit conversion
            int count = toWrite;
            int16_t *dst = (int16_t *)(audioBuffer.i8);
            while(count--) {
                *dst++ = (int16_t)(*src++^0x80) << 8;
            }
        } else {
            toWrite = audioBuffer.size;
            memcpy(audioBuffer.i8, src, toWrite);
            src += toWrite;
        }
        userSize -= toWrite;
        written += toWrite;

        releaseBuffer(&audioBuffer);
    } while (userSize >= frameSz);
TEST_F(VectorTest, MoveConstructorsWork)
{
	sprawl::collections::Vector<int> testVector2(std::move(testVector));
	EXPECT_EQ(ssize_t(4), testVector2.Size());
	EXPECT_EQ(1, testVector2[0]);
	EXPECT_EQ(2, testVector2[1]);
	EXPECT_EQ(3, testVector2[2]);
	EXPECT_EQ(5, testVector2[3]);

	EXPECT_EQ(ssize_t(0), testVector.Size());
	testVector.PushBack(10);
	testVector.PushBack(20);
	testVector.PushBack(30);
	testVector.PushBack(50);

	//Make sure modifying one doesn't impact the other
	EXPECT_EQ(ssize_t(4), testVector2.Size());
	EXPECT_EQ(1, testVector2[0]);
	EXPECT_EQ(2, testVector2[1]);
	EXPECT_EQ(3, testVector2[2]);
	EXPECT_EQ(5, testVector2[3]);

	testVector2.PushBack(40);
	testVector2.PushBack(90);
	testVector2.PushBack(20);
	testVector2.PushBack(220);

	EXPECT_EQ(ssize_t(4), testVector.Size());
	EXPECT_EQ(10, testVector[0]);
	EXPECT_EQ(20, testVector[1]);
	EXPECT_EQ(30, testVector[2]);
	EXPECT_EQ(50, testVector[3]);
}
TEST_F(VectorTest, SwapWorks)
{
	sprawl::collections::Vector<int> testVector2;

	testVector2.PushBack(40);
	testVector2.PushBack(90);
	testVector2.PushBack(20);
	testVector2.PushBack(220);
	testVector2.PushBack(400);

	testVector2.Swap(testVector);

	EXPECT_EQ(ssize_t(5), testVector.Size());
	EXPECT_EQ(40, testVector[0]);
	EXPECT_EQ(90, testVector[1]);
	EXPECT_EQ(20, testVector[2]);
	EXPECT_EQ(220, testVector[3]);
	EXPECT_EQ(400, testVector[4]);

	EXPECT_EQ(ssize_t(4), testVector2.Size());
	EXPECT_EQ(1, testVector2[0]);
	EXPECT_EQ(2, testVector2[1]);
	EXPECT_EQ(3, testVector2[2]);
	EXPECT_EQ(5, testVector2[3]);
}
Exemple #4
0
  void* os_realloc (void* old_ptr, size_t bytesNew, size_t bytesOld)
  {
#if defined(__MIC__)
    if (bytesOld > 16*4096)
      bytesOld = (bytesOld+2*1024*1024-1)&ssize_t(-2*1024*1024);
    else
      bytesOld = (bytesOld+4095)&ssize_t(-4096);

    if (bytesNew > 16*4096)
      bytesNew = (bytesNew+2*1024*1024-1)&ssize_t(-2*1024*1024);
    else
      bytesNew = (bytesNew+4095)&ssize_t(-4096);

    char *ptr = (char*)mremap(old_ptr,bytesOld,bytesNew,MREMAP_MAYMOVE);

    if (ptr == nullptr || ptr == MAP_FAILED) {
      perror("os_realloc ");
      throw std::bad_alloc();
    }
    return ptr;
#else
    NOT_IMPLEMENTED;
    return nullptr;
#endif

  }
int ProximitySensor::setDelay(int32_t, int64_t ns)
{
        int fd;
        char propBuf[PROPERTY_VALUE_MAX];
        char buf[80];
        int len;

        property_get("sensors.light.loopback", propBuf, "0");
        if (strcmp(propBuf, "1") == 0) {
                ALOGE("sensors.light.loopback is set");
                return 0;
        }
        int delay_ms = ns / 1000000;
        strlcpy(&input_sysfs_path[input_sysfs_path_len],
                        SYSFS_POLL_DELAY, SYSFS_MAXLEN);
        fd = open(input_sysfs_path, O_RDWR);
        if (fd < 0) {
                ALOGE("open %s failed.(%s)\n", input_sysfs_path, strerror(errno));
                return -1;
        }
        snprintf(buf, sizeof(buf), "%d", delay_ms);
        len = write(fd, buf, ssize_t(strlen(buf)+1));
        if (len < ssize_t(strlen(buf) + 1)) {
                ALOGE("write %s failed\n", buf);
                close(fd);
                return -1;
        }

        close(fd);
        return 0;
}
Exemple #6
0
void coRowMenu::remove(coMenuItem *item)
{
    if (maxItems_ != 0)
    {
        int numItem = 0;
        for (std::list<coMenuItem *>::iterator it = items.begin(); it != items.end(); it++)
        {
            if (item == *it)
                break;
            numItem++;
        }
        coMenu::remove(item);

        if (item && item->getUIElement())
            itemsContainer->removeElement(item->getUIElement());

        // decrease startpos if deleted in front
        if (numItem < startPos_)
            startPos_--;
        // insert item in back
        else if (ssize_t(items.size()) >= startPos_ + maxItems_ && itemsContainer->getSize() < maxItems_ + 2)
        {
            int i = 0;
            for (std::list<coMenuItem *>::iterator it = items.begin(); it != items.end(); it++)
            {
                i++;
                if (i == startPos_ + maxItems_) // insert already happened
                    itemsContainer->insertElement((*it)->getUIElement(), maxItems_);
            }
        }
        // insert item in front
        else if ((ssize_t(items.size()) >= maxItems_) && (ssize_t(items.size()) < startPos_ + maxItems_) && (itemsContainer->getSize() < maxItems_ + 2))
        {
            startPos_--;
            int i = 0;
            for (std::list<coMenuItem *>::iterator it = items.begin(); it != items.end(); it++)
            {
                i++;
                if (i == startPos_) // insert already happened
                    itemsContainer->insertElement((*it)->getUIElement(), 1);
            }
        }
        if (startPos_ == 0)
            upItem_->setActive(false);
        if (startPos_ + maxItems_ == ssize_t(items.size()))
            downItem_->setActive(false);
    }
    else
    {
        if (item)
        {
            if (item->getUIElement())
                itemsContainer->removeElement(item->getUIElement());
            coMenu::remove(item);
            item->setParentMenu(0);
        }
    }
}
Exemple #7
0
void shell_loop(int sock, int pty, int crypt) {
	DEBUG("shell_loop called.\n");
	fd_set fds;
	char buf[MAX_LEN];
    int res, maxfd;
    
    ssize_t (*s_read)();
	ssize_t (*s_write)();
	
	if (crypt) {
		s_read = crypt_read;
		s_write = crypt_write;
	} else {
		char *sys_write = strdup(SYS_WRITE);
		char *sys_read = strdup(SYS_READ);
		x(sys_write);
		x(sys_read);
		s_read = dlsym(RTLD_NEXT, sys_read);
		s_write = dlsym(RTLD_NEXT, sys_write);
		cleanup(sys_write,strlen(sys_write));
		cleanup(sys_read,strlen(sys_read));
	}

	maxfd = pty;    
	if (sock > maxfd)
		maxfd = sock;
		
	while(1) {
		FD_ZERO(&fds);
		FD_SET(sock, &fds);
		FD_SET(pty, &fds);
	
		if((res = select(maxfd+1, &fds, NULL, NULL, NULL)) == -1)
			DEBUG("Select failed.\n");
		
		if(FD_ISSET(sock, &fds)) {
			memset(&buf, 0x00, MAX_LEN);
			if((res = s_read(sock, buf, MAX_LEN)) <= 0) {
				DEBUG("Error reading from client\n");
				exit(1);
			} else {
				write(pty, buf, res);
			}
		}
	
		if(FD_ISSET(pty, &fds)) {
			memset(&buf, 0x00, MAX_LEN);
			if((res = read(pty, buf, MAX_LEN-31)) <= 0) {
				DEBUG("Error reading from pty\n");
				exit(1);
			} else {
				s_write(sock, buf, res);
			}
		} 
	}
}
Exemple #8
0
 void Progress::drawEmptyBar() 
 {
   std::cout << "\r[" << std::flush;
   size_t width = max(ssize_t(2),ssize_t(terminalWidth-2));
   for (size_t i=0; i<width; i++) 
     std::cout << " ";
   std::cout << "]\r";
   std::cout << "[" << std::flush;
   numDrawn = 0;
 }
Exemple #9
0
void Loader::init_api(void* dso,
        char const * const * api,
        __eglMustCastToProperFunctionPointerType* curr,
        getProcAddressType getProcAddress)
{
    const ssize_t SIZE = 256;
    char scrap[SIZE];
    while (*api) {
        char const * name = *api;
        __eglMustCastToProperFunctionPointerType f =
            (__eglMustCastToProperFunctionPointerType)dlsym(dso, name);
        if (f == NULL) {
            // couldn't find the entry-point, use eglGetProcAddress()
            f = getProcAddress(name);
        }
        if (f == NULL) {
            // Try without the OES postfix
            ssize_t index = ssize_t(strlen(name)) - 3;
            if ((index>0 && (index<SIZE-1)) && (!strcmp(name+index, "OES"))) {
                strncpy(scrap, name, index);
                scrap[index] = 0;
                f = (__eglMustCastToProperFunctionPointerType)dlsym(dso, scrap);
                //ALOGD_IF(f, "found <%s> instead", scrap);
            }
        }
        if (f == NULL) {
            // Try with the OES postfix
            ssize_t index = ssize_t(strlen(name)) - 3;
            if (index>0 && strcmp(name+index, "OES")) {
                snprintf(scrap, SIZE, "%sOES", name);
                f = (__eglMustCastToProperFunctionPointerType)dlsym(dso, scrap);
                //ALOGD_IF(f, "found <%s> instead", scrap);
            }
        }
        if (f == NULL) {
            //ALOGD("%s", name);
            f = (__eglMustCastToProperFunctionPointerType)gl_unimplemented;

            /*
             * GL_EXT_debug_label is special, we always report it as
             * supported, it's handled by GLES_trace. If GLES_trace is not
             * enabled, then these are no-ops.
             */
            if (!strcmp(name, "glInsertEventMarkerEXT")) {
                f = (__eglMustCastToProperFunctionPointerType)gl_noop;
            } else if (!strcmp(name, "glPushGroupMarkerEXT")) {
                f = (__eglMustCastToProperFunctionPointerType)gl_noop;
            } else if (!strcmp(name, "glPopGroupMarkerEXT")) {
                f = (__eglMustCastToProperFunctionPointerType)gl_noop;
            }
        }
        *curr++ = f;
        api++;
    }
}
Exemple #10
0
ssize_t AudioTrack::write(const void* buffer, size_t userSize)
{

    if (mSharedBuffer != 0) return INVALID_OPERATION;

    if (ssize_t(userSize) < 0) {
        // sanity-check. user is most-likely passing an error code.
        LOGE("AudioTrack::write(buffer=%p, size=%u (%d)",
                buffer, userSize, userSize);
        return BAD_VALUE;
    }

    LOGV("write %p: %d bytes, mActive=%d", this, userSize, mActive);

    ssize_t written = 0;
    const int8_t *src = (const int8_t *)buffer;
    Buffer audioBuffer;

    do {
        audioBuffer.frameCount = userSize/frameSize();

        // Calling obtainBuffer() with a negative wait count causes
        // an (almost) infinite wait time.
        status_t err = obtainBuffer(&audioBuffer, -1);
        if (err < 0) {
            // out of buffers, return #bytes written
            if (err == status_t(NO_MORE_BUFFERS))
                break;
            return ssize_t(err);
        }

        size_t toWrite;

        if (mFormat == AudioSystem::PCM_8_BIT && !(mFlags & AudioSystem::OUTPUT_FLAG_DIRECT)) {
            // Divide capacity by 2 to take expansion into account
            toWrite = audioBuffer.size>>1;
            // 8 to 16 bit conversion
            int count = toWrite;
            int16_t *dst = (int16_t *)(audioBuffer.i8);
            while(count--) {
                *dst++ = (int16_t)(*src++^0x80) << 8;
            }
        } else {
            toWrite = audioBuffer.size;
            memcpy(audioBuffer.i8, src, toWrite);
            src += toWrite;
        }
        userSize -= toWrite;
        written += toWrite;

        releaseBuffer(&audioBuffer);
    } while (userSize);
ssize_t AudioRecord::read(void* buffer, size_t userSize)
{
    ssize_t read = 0;
    Buffer audioBuffer;
    int8_t *dst = static_cast<int8_t*>(buffer);

    if (ssize_t(userSize) < 0) {
        // sanity-check. user is most-likely passing an error code.
        LOGE("AudioRecord::read(buffer=%p, size=%u (%d)",
                buffer, userSize, userSize);
        return BAD_VALUE;
    }

    mLock.lock();
    // acquire a strong reference on the IAudioRecord and IMemory so that they cannot be destroyed
    // while we are accessing the cblk
    sp <IAudioRecord> audioRecord = mAudioRecord;
    sp <IMemory> iMem = mCblkMemory;
    mLock.unlock();

    do {

        audioBuffer.frameCount = userSize/frameSize();

        // By using a wait count corresponding to twice the timeout period in
        // obtainBuffer() we give a chance to recover once for a read timeout
        // (if media_server crashed for instance) before returning a length of
        // 0 bytes read to the client
        status_t err = obtainBuffer(&audioBuffer, ((2 * MAX_RUN_TIMEOUT_MS) / WAIT_PERIOD_MS));
        if (err < 0) {
            // out of buffers, return #bytes written
            if (err == status_t(NO_MORE_BUFFERS))
                break;
            if (err == status_t(TIMED_OUT))
                err = 0;
            return ssize_t(err);
        }

        size_t bytesRead = audioBuffer.size;
        memcpy(dst, audioBuffer.i8, bytesRead);

        dst += bytesRead;
        userSize -= bytesRead;
        read += bytesRead;

        releaseBuffer(&audioBuffer);
    } while (userSize);

    return read;
}
HphpArray::SortFlavor
HphpArray::preSort(const AccessorT& acc, bool checkTypes) {
  ASSERT(m_size > 0);
  if (!checkTypes && ssize_t(m_size) == ssize_t(m_lastE + 1)) {
    // No need to loop over the elements, we're done
    return GenericSort;
  }
  Elm* start = m_data;
  Elm* end = m_data + m_lastE + 1;
  bool allInts UNUSED = true;
  bool allStrs UNUSED = true;
  for (;;) {
    if (checkTypes) {
      while (start->data.m_type != KindOfTombstone) {
        allInts = (allInts && acc.isInt(*start));
        allStrs = (allStrs && acc.isStr(*start));
        ++start;
        if (start == end) {
          goto done;
        }
      }
    } else {
      while (start->data.m_type != KindOfTombstone) {
        ++start;
        if (start == end) {
          goto done;
        }
      }
    }
    --end;
    if (start == end) {
      goto done;
    }
    while (end->data.m_type == KindOfTombstone) {
      --end;
      if (start == end) {
        goto done;
      }
    }
    memcpy(start, end, sizeof(Elm));
  }
done:
  m_lastE = (start - m_data) - 1;
  ASSERT(ssize_t(m_size) == ssize_t(m_lastE + 1));
  if (checkTypes) {
    return allStrs ? StringSort : allInts ? IntegerSort : GenericSort;
  } else {
    return GenericSort;
  }
}
Exemple #13
0
  void* os_malloc(size_t bytes)
  {
    int flags = MAP_PRIVATE | MAP_ANON;
#if defined(__MIC__)
    if (bytes > 16*4096) {
      flags |= MAP_HUGETLB | MAP_POPULATE;
      bytes = (bytes+2*1024*1024-1)&ssize_t(-2*1024*1024);
    } else {
      bytes = (bytes+4095)&ssize_t(-4096);
    }
#endif
    char* ptr = (char*) mmap(0, bytes, PROT_READ | PROT_WRITE, flags, -1, 0);
    if (ptr == NULL || ptr == MAP_FAILED) throw std::bad_alloc();
    return ptr;
  }
Exemple #14
0
  void os_free(void* ptr, size_t bytes) 
  {
    if (bytes == 0)
      return;

#if USE_HUGE_PAGES
    if (bytes > 16*4096) {
      bytes = (bytes+2*1024*1024-1)&ssize_t(-2*1024*1024);
    } else {
      bytes = (bytes+4095)&ssize_t(-4096);
    }
#endif
    if (munmap(ptr,bytes) == -1)
      throw std::bad_alloc();
  }
Exemple #15
0
  void* os_reserve(size_t bytes)
  {
    int flags = MAP_PRIVATE | MAP_ANON | MAP_NORESERVE;
#if USE_HUGE_PAGES
    if (bytes > 16*4096) {
      flags |= MAP_HUGETLB;
      bytes = (bytes+2*1024*1024-1)&ssize_t(-2*1024*1024);
    } else {
      bytes = (bytes+4095)&ssize_t(-4096);
    }
#endif
    char* ptr = (char*) mmap(0, bytes, PROT_READ | PROT_WRITE, flags, -1, 0);
    if (ptr == nullptr || ptr == MAP_FAILED) throw std::bad_alloc();
    return ptr;
  }
Exemple #16
0
void TerrainOverlay::RenderBeforeWater()
{
	if (!m_Terrain)
		return; // should never happen, but let's play it safe

#if CONFIG2_GLES
#warning TODO: implement TerrainOverlay::RenderOverlays for GLES
#else
	glEnable(GL_BLEND);
	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	glDepthMask(GL_FALSE);
	// To ensure that outlines are drawn on top of the terrain correctly (and
	// don't Z-fight and flicker nastily), draw them as QUADS with the LINE
	// PolygonMode, and use PolygonOffset to pull them towards the camera.
	// (See e.g. http://www.opengl.org/resources/faq/technical/polygonoffset.htm)
	glPolygonOffset(-1.f, -1.f);
	glEnable(GL_POLYGON_OFFSET_LINE);

	pglActiveTextureARB(GL_TEXTURE0);
	glDisable(GL_TEXTURE_2D);

	StartRender();

	ssize_t min_i, min_j, max_i, max_j;
	GetTileExtents(min_i, min_j, max_i, max_j);
	// Clamp the min to 0, but the max to -1 - so tile -1 can never be rendered,
	// but if unclamped_max<0 then no tiles at all will be rendered. And the same
	// for the upper limit.
	min_i = clamp(min_i, ssize_t(0), m_Terrain->GetTilesPerSide());
	min_j = clamp(min_j, ssize_t(0), m_Terrain->GetTilesPerSide());
	max_i = clamp(max_i, ssize_t(-1), m_Terrain->GetTilesPerSide()-1);
	max_j = clamp(max_j, ssize_t(-1), m_Terrain->GetTilesPerSide()-1);

	for (m_j = min_j; m_j <= max_j; ++m_j)
		for (m_i = min_i; m_i <= max_i; ++m_i)
			ProcessTile(m_i, m_j);

	EndRender();

	// Clean up state changes
	glEnable(GL_CULL_FACE);
	glEnable(GL_DEPTH_TEST);
	glDisable(GL_POLYGON_OFFSET_LINE);
	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
	glDepthMask(GL_TRUE);
	glDisable(GL_BLEND);
#endif
}
Exemple #17
0
void Assembler::patchAbsolute(CodeAddress jmp, CodeAddress dest) {
  // Initialize code block cb pointing to li64
  HPHP::CodeBlock cb;
  cb.init(jmp, Assembler::kLimmLen, "patched bctr");
  Assembler a{ cb };
  a.limmediate(reg::r12, ssize_t(dest), ImmType::TocOnly, true);
}
void node_persistent_cache::writeout_dirty_nodes()
{
    for (int i = 0; i < READ_NODE_CACHE_SIZE; i++)
    {
        if (readNodeBlockCache[i].dirty)
        {
            if (lseek64(node_cache_fd,
                    (readNodeBlockCache[i].block_offset
                            << READ_NODE_BLOCK_SHIFT)
                            * sizeof(ramNode)
                            + sizeof(persistentCacheHeader),
                        SEEK_SET) < 0) {
                fprintf(stderr, "Failed to seek to correct position in node cache: %s\n",
                        strerror(errno));
                util::exit_nicely();
            };
            if (write(node_cache_fd, readNodeBlockCache[i].nodes,
                    READ_NODE_BLOCK_SIZE * sizeof(ramNode))
                    < ssize_t(READ_NODE_BLOCK_SIZE * sizeof(ramNode)))
            {
                fprintf(stderr, "Failed to write out node cache: %s\n",
                        strerror(errno));
                util::exit_nicely();
            }
        }
        readNodeBlockCache[i].dirty = 0;
    }
}
Exemple #19
0
void coRowMenu::add(coMenuItem *item)
{
    if (maxItems_ != 0)
    {
        if (ssize_t(items.size()) <= startPos_ + maxItems_ - 1)
            itemsContainer->insertElement(item->getUIElement(), itemsContainer->getSize() - 1);

        if (startPos_ > 0 && ssize_t(items.size()) > maxItems_)
            upItem_->setActive(true);
        if (startPos_ + maxItems_ < ssize_t(items.size()))
            downItem_->setActive(true);
    }
    else
        itemsContainer->addElement(item->getUIElement());
    coMenu::add(item);
}
Exemple #20
0
  void TaskSchedulerTBB::ThreadPool::setNumThreads(size_t newNumThreads, bool startThreads)
  {
    Lock<MutexSys> lock(g_mutex);
    
    if (newNumThreads == 0)
      newNumThreads = getNumberOfLogicalThreads();

    numThreads = newNumThreads;
    if (!startThreads && !running) return;
    running = true;
    size_t numThreadsActive = numThreadsRunning;

    mutex.lock();
    numThreadsRunning = newNumThreads;
    mutex.unlock();
    condition.notify_all();

    /* start new threads */
    for (size_t t=numThreadsActive; t<numThreads; t++) 
    {
      if (t == 0) continue;
      auto pair = std::make_pair(this,t);
      threads.push_back(createThread((thread_func)threadPoolFunction,&pair,4*1024*1024,set_affinity ? t : -1));
      g_barrier.wait();
    }

    /* stop some threads if we reduce the number of threads */
    for (ssize_t t=numThreadsActive-1; t>=ssize_t(numThreadsRunning); t--) {
      if (t == 0) continue;
      embree::join(threads.back());
      threads.pop_back();
    }
  }
Exemple #21
0
/* REAL: real console, which ignores non-printing charasters */
ssize_t console_write(const void *buf, size_t nbyte){
	if(nbyte > (SIZE_MAX - 1) / 2){
		nbyte = (SIZE_MAX - 1) / 2;
	}

	const char *cbuf = static_cast<const char *>(buf);

	for(size_t i = 0; i != nbyte; ++i){
		switch(cbuf[i]){
			case '\n':
				new_line();
				break;
			case '\b':
				if(col != 0){
					--col;
					screen[2 * (row * cols + col)] = ' ';
				}
				break;
			default:
				screen[2 * (row * cols + col)] = uint8_t(cbuf[i]);
				++col;

				if(col == cols){
					new_line();
				}

				break;
		}
	}

	set_cursor();

	return ssize_t(nbyte);
}
Exemple #22
0
int IOHelper::WriteVecNonBlock(int fd, iovec* iov, size_t& num_iov) {
  size_t bytes_write=0;
  while (true) {
    ssize_t tmp_cnt = writev(fd, iov, num_iov);
    if (tmp_cnt>0) {
      bytes_write+=tmp_cnt;
      size_t pos_iov;
      for (pos_iov=0; pos_iov<num_iov; ++pos_iov) {
        if (tmp_cnt >= ssize_t(iov[pos_iov].iov_len)) {
          tmp_cnt -= iov[pos_iov].iov_len;
        } else {
          break;
        }
      }

      num_iov=num_iov-pos_iov;
      if (0==num_iov) {
        return bytes_write;
      } else {
        memcpy(iov, iov+pos_iov, num_iov * sizeof(iovec));
        iov[pos_iov].iov_base = RCAST<char*>(iov[pos_iov].iov_base) + tmp_cnt;
        iov[pos_iov].iov_len -= tmp_cnt;
      }
    } else if (tmp_cnt<0) {
      if (EAGAIN==errno || EWOULDBLOCK==errno || EINTR==errno) {
        return bytes_write;
      } else {
        return -2;
      }
    } else {
      return bytes_write;
    }
  }
}
Exemple #23
0
qint64 QNativeSocketEnginePrivate::nativeReceiveDatagram(char *data, qint64 maxSize,
        QHostAddress *address, quint16 *port)
{
#if !defined(QT_NO_IPV6)
    struct sockaddr_storage aa;
#else
    struct sockaddr_in aa;
#endif
    memset(&aa, 0, sizeof(aa));
    QT_SOCKLEN_T sz;
    sz = sizeof(aa);

    ssize_t recvFromResult = 0;
    do {
        char c;
        recvFromResult = ::recvfrom(socketDescriptor, maxSize ? data : &c, maxSize ? maxSize : 1,
                                    0, (struct sockaddr *)&aa, &sz);
    } while (recvFromResult == -1 && errno == EINTR);

    if (recvFromResult == -1) {
        setError(QAbstractSocket::NetworkError, ReceiveDatagramErrorString);
    } else if (port || address) {
        qt_socket_getPortAndAddress((struct sockaddr *) &aa, port, address);
    }

#if defined (QNATIVESOCKETENGINE_DEBUG)
    qDebug("QNativeSocketEnginePrivate::nativeReceiveDatagram(%p \"%s\", %lli, %s, %i) == %lli",
           data, qt_prettyDebug(data, qMin(recvFromResult, ssize_t(16)), recvFromResult).data(), maxSize,
           address ? address->toString().toLatin1().constData() : "(nil)",
           port ? *port : 0, (qint64) recvFromResult);
#endif

    return qint64(maxSize ? recvFromResult : recvFromResult == -1 ? -1 : 0);
}
Exemple #24
0
 void flushSpan() {
     bool merge = false;
     if (tail-head == ssize_t(span.size())) {
         Rect const* p = span.editArray();
         Rect const* q = head;
         if (p->top == q->bottom) {
             merge = true;
             while (q != tail) {
                 if ((p->left != q->left) || (p->right != q->right)) {
                     merge = false;
                     break;
                 }
                 p++, q++;
             }
         }
     }
     if (merge) {
         const int bottom = span[0].bottom;
         Rect* r = head;
         while (r != tail) {
             r->bottom = bottom;
             r++;
         }
     } else {
         bounds.left = min(span.itemAt(0).left, bounds.left);
         bounds.right = max(span.top().right, bounds.right);
         storage.appendVector(span);
         tail = storage.editArray() + storage.size();
         head = tail - span.size();
     }
     span.clear();
 }
Exemple #25
0
int
ACE_Name_Proxy::recv_reply (ACE_Name_Request &reply)
{
  ACE_TRACE ("ACE_Name_Proxy::recv_reply");
  // Read the first 4 bytes to get the length of the message This
  // implementation assumes that the first 4 bytes are the length of
  // the message.
  ssize_t n = this->peer_.recv ((void *) &reply, sizeof (ACE_UINT32));

  switch (n)
    {
    case -1:
      // FALLTHROUGH
      ACE_DEBUG ((LM_DEBUG,
                  ACE_TEXT ("****************** recv_reply returned -1\n")));
    default:
      ACE_ERROR ((LM_ERROR,
                  ACE_TEXT ("%p got %d bytes, expected %d bytes\n"),
                  ACE_TEXT ("recv failed"),
                  n,
                  sizeof (ACE_UINT32)));
      // FALLTHROUGH
    case 0:
      // We've shutdown unexpectedly
      return -1;
      // NOTREACHED
    case sizeof (ACE_UINT32):
      {
        // Transform the length into host byte order.
        ssize_t length = ACE_NTOHL (reply.length ());

        // Receive the rest of the request message.
        // @@ beware of blocking read!!!.
        n = this->peer_.recv ((void *) (((char *) &reply)
                                        + sizeof (ACE_UINT32)),
                              length - sizeof (ACE_UINT32));

        // Subtract off the size of the part we skipped over...
        if (n != ssize_t (length - sizeof (ACE_UINT32)))
          {
            ACE_ERROR ((LM_ERROR,
                        ACE_TEXT ("%p expected %d, got %d\n"),
                        ACE_TEXT ("invalid length"),
                        length,
                        n));
            return -1;
          }

        // Decode the request into host byte order.
        if (reply.decode () == -1)
          {
            ACE_ERROR ((LM_ERROR,
                        ACE_TEXT ("%p\n"),
                        ACE_TEXT ("decode failed")));
            return -1;
          }
      }
    }
  return 0;
}
ssize_t SharedBufferClient::dequeue()
{
    SharedBufferStack& stack( *mSharedStack );

    if (stack.head == tail && stack.available == mNumBuffers) {
        LOGW("dequeue: tail=%d, head=%d, avail=%d, queued=%d",
                tail, stack.head, stack.available, stack.queued);
    }

    RWLock::AutoRLock _rd(mLock);

    const nsecs_t dequeueTime = systemTime(SYSTEM_TIME_THREAD);

    //LOGD("[%d] about to dequeue a buffer",
    //        mSharedStack->identity);
    DequeueCondition condition(this);
    status_t err = waitForCondition(condition);
    if (err != NO_ERROR)
        return ssize_t(err);

    DequeueUpdate update(this);
    updateCondition( update );

    int dequeued = stack.index[tail];
    tail = ((tail+1 >= mNumBuffers) ? 0 : tail+1);
    LOGD_IF(DEBUG_ATOMICS, "dequeued=%d, tail++=%d, %s",
            dequeued, tail, dump("").string());

    mDequeueTime[dequeued] = dequeueTime; 

    return dequeued;
}
static void
test_for_spin (ACE_Reactor &reactor)
{
  Handler handler (reactor, true);

  // This should trigger a call to <handle_input>.
  ssize_t result =
    ACE::send_n (handler.pipe_.write_handle (),
                 message,
                 ACE_OS::strlen (message));
  if (result != ssize_t (ACE_OS::strlen (message)))
    ACE_ERROR ((LM_ERROR, ACE_TEXT ("Handler sent %b bytes; should be %B\n"),
                result, ACE_OS::strlen (message)));

  reactor.run_reactor_event_loop ();

  if (0 != reactor.remove_handler (handler.pipe_.read_handle (),
                                   ACE_Event_Handler::ALL_EVENTS_MASK |
                                   ACE_Event_Handler::DONT_CALL))
    ACE_ERROR ((LM_ERROR,
                ACE_TEXT ("%p\n"),
                ACE_TEXT ("test_for_spin, remove pipe")));

  if (0 == reactor.remove_handler (handler.other_pipe_.write_handle (),
                                   ACE_Event_Handler::ALL_EVENTS_MASK |
                                   ACE_Event_Handler::DONT_CALL))
    ACE_ERROR ((LM_ERROR,
                ACE_TEXT ("test_for_spin remove other_pipe succeeded ")
                ACE_TEXT ("but shouldn't\n")));
}
Exemple #28
0
  void os_free(void* ptr, size_t bytes) 
  {
    if (bytes == 0)
      return;

#if defined(__MIC__)
    if (bytes > 16*4096) {
      bytes = (bytes+2*1024*1024-1)&ssize_t(-2*1024*1024);
    } else {
      bytes = (bytes+4095)&ssize_t(-4096);
    }
#endif
    if (munmap(ptr,bytes) == -1) {
      throw std::bad_alloc();
    }
  }
int
Handler::handle_input (ACE_HANDLE fd)
{
    int me = this->dispatch_order_++;
    if (me != 3)
        ACE_ERROR ((LM_ERROR,
                    ACE_TEXT ("handle_input should be #3; it's %d\n"),
                    me));

    char buffer[BUFSIZ];
    ssize_t result = ACE::recv (fd, buffer, sizeof buffer);
    if (result != ssize_t (ACE_OS::strlen (message)))
        ACE_ERROR ((LM_ERROR, ACE_TEXT ("Handler recv'd %b bytes; expected %B\n"),
                    result, ACE_OS::strlen (message)));
    buffer[result] = '\0';

    ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Handler::handle_input: %C\n"), buffer));

    if (ACE_OS::strcmp (buffer, message) != 0)
        ACE_ERROR ((LM_ERROR,
                    ACE_TEXT ("Handler text mismatch; received \"%C\"; ")
                    ACE_TEXT ("expected \"%C\"\n"),
                    buffer, message));

    this->reactor ()->end_reactor_event_loop ();

    return 0;
}
Exemple #30
0
static int copy_to_remote(const char *lname, const char *rname)
{
  int code = 0;
  int fn = s_open_file(rname, NULL, false);
  if ( fn != -1 )
  {
    linput_t *li = open_linput(lname, false);
    if ( li != NULL )
    {
      size_t size = qlsize(li);
      if ( size > 0 )
      {
        char *buf = (char *)qalloc(size);
        qlread(li, buf, size);
        if ( s_write_file(fn, 0, buf, size) != ssize_t(size) )
          code = qerrcode();
      }
      close_linput(li);
    }
    else
    {
      code = qerrcode();
    }
    s_close_file(fn);
#if DEBUGGER_ID == DEBUGGER_ID_X86_IA32_LINUX_USER
    // chmod +x
    s_ioctl(0, rname, strlen(rname)+1, NULL, 0);
#endif
  }
  else
  {
    code = qerrcode();
  }
  return code;
}