コード例 #1
0
ファイル: sgen-nursery-allocator.c プロジェクト: Sciumo/mono
void
mono_sgen_nursery_allocator_prepare_for_pinning (void)
{
	Fragment *frag;

	/*
	 * The code below starts the search from an entry in scan_starts, which might point into a nursery
	 * fragment containing random data. Clearing the nursery fragments takes a lot of time, and searching
	 * though them too, so lay arrays at each location inside a fragment where a search can start:
	 * - scan_locations[i]
	 * - start_nursery
	 * - the start of each fragment (the last_obj + last_obj case)
	 * The third encompasses the first two, since scan_locations [i] can't point inside a nursery fragment.
	 */
	for (frag = unmask (nursery_fragments); frag; frag = unmask (frag->next)) {
		MonoArray *o;

		g_assert (frag->fragment_end - frag->fragment_next >= sizeof (MonoArray));
		o = (MonoArray*)frag->fragment_next;
		memset (o, 0, sizeof (MonoArray));
		g_assert (mono_sgen_get_array_fill_vtable ());
		o->obj.vtable = mono_sgen_get_array_fill_vtable ();
		/* Mark this as not a real object */
		o->obj.synchronisation = GINT_TO_POINTER (-1);
		o->max_length = (frag->fragment_end - frag->fragment_next) - sizeof (MonoArray);
		g_assert (frag->fragment_next + mono_sgen_safe_object_get_size ((MonoObject*)o) == frag->fragment_end);
	}
}
コード例 #2
0
ファイル: sgen-nursery-allocator.c プロジェクト: Sciumo/mono
void*
mono_sgen_nursery_alloc (size_t size)
{
	Fragment *frag;
	DEBUG (4, fprintf (gc_debug_file, "Searching nursery for size: %zd\n", size));
	size = SGEN_ALIGN_UP (size);

	HEAVY_STAT (InterlockedIncrement (&stat_nursery_alloc_requests));

#ifdef NALLOC_DEBUG
	InterlockedIncrement (&alloc_count);
#endif

restart:
	for (frag = unmask (nursery_fragments); frag; frag = unmask (frag->next)) {
		HEAVY_STAT (InterlockedIncrement (&stat_alloc_iterations));

		if (size <= (frag->fragment_end - frag->fragment_next)) {
			void *p = alloc_from_fragment (frag, size);
			if (!p) {
				HEAVY_STAT (InterlockedIncrement (&stat_alloc_retries));
				goto restart;
			}
#ifdef NALLOC_DEBUG
			add_alloc_record (p, size, FIXED_ALLOC);
#endif
			return p;
		}
	}
	return NULL;
}
コード例 #3
0
void*
sgen_fragment_allocator_par_alloc (SgenFragmentAllocator *allocator, size_t size)
{
	SgenFragment *frag;

#ifdef NALLOC_DEBUG
	InterlockedIncrement (&alloc_count);
#endif

restart:
	for (frag = (SgenFragment *)unmask (allocator->alloc_head); unmask (frag); frag = (SgenFragment *)unmask (frag->next)) {
		HEAVY_STAT (++stat_alloc_iterations);

		if (size <= (size_t)(frag->fragment_end - frag->fragment_next)) {
			void *p = par_alloc_from_fragment (allocator, frag, size);
			if (!p) {
				HEAVY_STAT (++stat_alloc_retries);
				goto restart;
			}
#ifdef NALLOC_DEBUG
			add_alloc_record (p, size, FIXED_ALLOC);
#endif
			return p;
		}
	}
	return NULL;
}
コード例 #4
0
ファイル: BattleScene.cpp プロジェクト: joyfish/PlaneWar
void Battle::playActionOver(cocostudio::Armature *armature, cocostudio::MovementEventType type, const char *name) {
    if (armature == m_pReadygo) {
        if (type == COMPLETE) {
            removeChild(armature);
            m_pReadygo = NULL;
            unmask();
            BIND(BUND_ID_GLOBAL_TOUCH_MOVED, this, Battle::globalTouchMoved);
            g_pEventEngine->BundlerCall(BUND_ID_PLANE_FIRE, this, sizeof(this));
        }
    }
    
    if (armature == m_pBossIn) {
        if (type == COMPLETE) {
            removeChild(armature);
            m_pBossIn = NULL;
            unmask();
            const BossConfig * pconfig = g_pGameConfig->getBossConfig(m_pConfig->boss);
            m_pBoss = Boss::create(pconfig);
            addChild(m_pBoss, GRADE_ENEMY);
            if (m_pConfig->boss != "chisezhilang") {
                m_pBoss->setScale(g_pGameConfig->scaleEleMin);
            } else {
                m_pBoss->setScale(g_pGameConfig->scaleEleMin * 1.5);
            }
            m_pBoss->setPosition(Vec2(pconfig->pos.x * g_pGameConfig->scaleEleX, pconfig->pos.y * g_pGameConfig->scaleEleY));
            m_pBoss->setRotation(pconfig->rotate);
            ActionInterval * action = MoveBy::create(2, Vec2(0, -500 * g_pGameConfig->scaleEleY));
            m_pBoss->runAction(Sequence::create(action, CallFuncN::create(this, callfuncN_selector(Battle::playbossAi)), NULL));
        }
    }
    
    if (armature == m_pMissionVictory) {
        if (type == COMPLETE) {
            Node * icon = g_pGameConfig->getIcon(m_equip.model, m_equip.type);
            icon->setPosition(Vec2(-200, -275));
            icon->setScale(g_pGameConfig->scaleEleMin * 5);
            m_pMissionVictory->addChild(icon, GRADE_UI);
            icon->setOpacity(0);
            ActionInterval * scale = ScaleTo::create(.5f, g_pGameConfig->scaleEleMin * 1.5);
            ActionInterval * fadein = FadeIn::create(.5f);
            icon->runAction(Spawn::create(scale, fadein, NULL));
            
            UNBIND(BUND_ID_GLOBAL_TOUCH_MOVED, this, Battle::globalTouchMoved);
            
            scheduleOnce(schedule_selector(Battle::returnMission), 2.0f);
        }
    }
    
    if (armature == m_pMissionFaild) {
        if (type == COMPLETE) {
            UNBIND(BUND_ID_GLOBAL_TOUCH_MOVED, this, Battle::globalTouchMoved);
            
            scheduleOnce(schedule_selector(Battle::returnMission), 2.0f);
        }
    }
}
コード例 #5
0
ファイル: sgen-nursery-allocator.c プロジェクト: Sciumo/mono
char *
mono_sgen_nursery_alloc_get_upper_alloc_bound (void)
{
	char *p = NULL;
	Fragment *frag;

	for (frag = unmask (nursery_fragments); frag; frag = unmask (frag->next))
		p = MAX (p, frag->fragment_next);

	return MAX (p, nursery_last_pinned_end);
}
コード例 #6
0
ファイル: sgen-nursery-allocator.c プロジェクト: Sciumo/mono
gboolean
mono_sgen_can_alloc_size (size_t size)
{
	Fragment *frag;
	size = SGEN_ALIGN_UP (size);

	for (frag = unmask (nursery_fragments); frag; frag = unmask (frag->next)) {
		if ((frag->fragment_end - frag->fragment_next) >= size)
			return TRUE;
	}
	return FALSE;
}
コード例 #7
0
ファイル: sgen-nursery-allocator.c プロジェクト: Sciumo/mono
mword
mono_sgen_build_nursery_fragments (GCMemSection *nursery_section, void **start, int num_entries)
{
	char *frag_start, *frag_end;
	size_t frag_size;
	int i;

#ifdef NALLOC_DEBUG
	reset_alloc_records ();
#endif

	while (unmask (nursery_fragments)) {
		Fragment *nf = unmask (nursery_fragments);
		Fragment *next = unmask (nf->next);

		nf->next_free = fragment_freelist;
		fragment_freelist = nf;
		nursery_fragments = next;
	}
	frag_start = nursery_start;
	fragment_total = 0;
	/* clear scan starts */
	memset (nursery_section->scan_starts, 0, nursery_section->num_scan_start * sizeof (gpointer));
	for (i = 0; i < num_entries; ++i) {
		frag_end = start [i];
		/* remove the pin bit from pinned objects */
		SGEN_UNPIN_OBJECT (frag_end);
		nursery_section->scan_starts [((char*)frag_end - (char*)nursery_section->data)/SGEN_SCAN_START_SIZE] = frag_end;
		frag_size = frag_end - frag_start;
		if (frag_size)
			add_nursery_frag (frag_size, frag_start, frag_end);
		frag_size = SGEN_ALIGN_UP (mono_sgen_safe_object_get_size ((MonoObject*)start [i]));
#ifdef NALLOC_DEBUG
		add_alloc_record (start [i], frag_size, PINNING);
#endif
		frag_start = (char*)start [i] + frag_size;
	}
	nursery_last_pinned_end = frag_start;
	frag_end = nursery_end;
	frag_size = frag_end - frag_start;
	if (frag_size)
		add_nursery_frag (frag_size, frag_start, frag_end);
	if (!unmask (nursery_fragments)) {
		DEBUG (1, fprintf (gc_debug_file, "Nursery fully pinned (%d)\n", num_entries));
		for (i = 0; i < num_entries; ++i) {
			DEBUG (3, fprintf (gc_debug_file, "Bastard pinning obj %p (%s), size: %d\n", start [i], mono_sgen_safe_name (start [i]), mono_sgen_safe_object_get_size (start [i])));
		}
		
	}

	return fragment_total;
}
コード例 #8
0
void
sgen_clear_allocator_fragments (SgenFragmentAllocator *allocator)
{
	SgenFragment *frag;

	for (frag = unmask (allocator->alloc_head); frag; frag = unmask (frag->next)) {
		SGEN_LOG (4, "Clear nursery frag %p-%p", frag->fragment_next, frag->fragment_end);
		sgen_clear_range (frag->fragment_next, frag->fragment_end);
#ifdef NALLOC_DEBUG
		add_alloc_record (frag->fragment_next, frag->fragment_end - frag->fragment_next, CLEAR_NURSERY_FRAGS);
#endif
	}	
}
コード例 #9
0
ファイル: pf_print_state.c プロジェクト: ajinkya93/OpenBSD
void
print_addr(struct pf_addr_wrap *addr, sa_family_t af, int verbose)
{
	switch (addr->type) {
	case PF_ADDR_DYNIFTL:
		printf("(%s", addr->v.ifname);
		if (addr->iflags & PFI_AFLAG_NETWORK)
			printf(":network");
		if (addr->iflags & PFI_AFLAG_BROADCAST)
			printf(":broadcast");
		if (addr->iflags & PFI_AFLAG_PEER)
			printf(":peer");
		if (addr->iflags & PFI_AFLAG_NOALIAS)
			printf(":0");
		if (verbose) {
			if (addr->p.dyncnt <= 0)
				printf(":*");
			else
				printf(":%d", addr->p.dyncnt);
		}
		printf(")");
		break;
	case PF_ADDR_TABLE:
		if (verbose)
			if (addr->p.tblcnt == -1)
				printf("<%s:*>", addr->v.tblname);
			else
				printf("<%s:%d>", addr->v.tblname,
				    addr->p.tblcnt);
		else
			printf("<%s>", addr->v.tblname);
		return;
	case PF_ADDR_ADDRMASK:
		if (PF_AZERO(&addr->v.a.addr, AF_INET6) &&
		    PF_AZERO(&addr->v.a.mask, AF_INET6))
			printf("any");
		else {
			char buf[48];

			if (inet_ntop(af, &addr->v.a.addr, buf,
			    sizeof(buf)) == NULL)
				printf("?");
			else
				printf("%s", buf);
		}
		break;
	case PF_ADDR_NOROUTE:
		printf("no-route");
		return;
	default:
		printf("?");
		return;
	}
	if (! PF_AZERO(&addr->v.a.mask, af)) {
		int bits = unmask(&addr->v.a.mask, af);

		if (bits != (af == AF_INET ? 32 : 128))
			printf("/%d", bits);
	}
}
コード例 #10
0
gboolean
sgen_can_alloc_size (size_t size)
{
	SgenFragment *frag;

	if (!SGEN_CAN_ALIGN_UP (size))
		return FALSE;

	size = SGEN_ALIGN_UP (size);

	for (frag = unmask (mutator_allocator.alloc_head); frag; frag = unmask (frag->next)) {
		if ((size_t)(frag->fragment_end - frag->fragment_next) >= size)
			return TRUE;
	}
	return FALSE;
}
コード例 #11
0
ファイル: keyboard.c プロジェクト: fengye0316/RTOS
int main(int argc, char** argv) {
  register_handlers();
  sscanf(argv[0], "%d", &parent_pid);
  sscanf(argv[1], "%d", &fid);
  sscanf(argv[2], "%d", &mem_size);
#ifdef DEBUG
  printf("KBD: %d %d %d\n", parent_pid, mem_size, fid);
#endif
  mem_ptr = mmap((caddr_t)0, mem_size, PROT_READ|PROT_WRITE,
  		 MAP_SHARED, fid, (off_t)0);
  mem_buffer *buffer = (mem_buffer*) mem_ptr;
  char local_buffer[MEMBLOCK_SIZE];
  int index = 0;
  char kbd_in = '\0';
  unmask();
  while(1) { 
    kbd_in = getchar();
    putc(kbd_in, stdout);
    //echo back
    if (kbd_in != '\r' && index < MEMBLOCK_SIZE-1) {
      local_buffer[index++] = kbd_in;
    } else {
      local_buffer[index++] = '\0';
      while (buffer->flag != MEM_DONE)
        sleep(1); //1-sec polling
      strcpy(buffer->data, local_buffer);
      buffer->flag = MEM_READY;
      buffer->length = index;
      index = 0;
      kill(parent_pid, SIGUSR1);
    }
      
  }
return 0;
}
コード例 #12
0
ファイル: sgen-nursery-allocator.c プロジェクト: Sciumo/mono
/* Clear all remaining nursery fragments */
void
mono_sgen_clear_nursery_fragments (void)
{
	Fragment *frag;

	if (mono_sgen_get_nursery_clear_policy () == CLEAR_AT_TLAB_CREATION) {
		mono_sgen_clear_current_nursery_fragment ();

		for (frag = unmask (nursery_fragments); frag; frag = unmask (frag->next)) {
			DEBUG (4, fprintf (gc_debug_file, "Clear nursery frag %p-%p\n", frag->fragment_next, frag->fragment_end));
			memset (frag->fragment_next, 0, frag->fragment_end - frag->fragment_next);
#ifdef NALLOC_DEBUG
			add_alloc_record (frag->fragment_next, frag->fragment_end - frag->fragment_next, CLEAR_NURSERY_FRAGS);
#endif
		}
	}
}
コード例 #13
0
ファイル: sgen-nursery-allocator.c プロジェクト: Sciumo/mono
static void
add_fragment (char *start, char *end)
{
	Fragment *fragment;

	fragment = alloc_fragment ();
	fragment->fragment_start = start;
	fragment->fragment_next = start;
	fragment->fragment_end = end;
	fragment->next = unmask (nursery_fragments);
	nursery_fragments = fragment;
}
コード例 #14
0
ファイル: uWS.cpp プロジェクト: piyushpandey013/uWebSockets
    static inline void consumeIncompleteMessage(int length, const int headerLength, T fullPayloadLength, SocketData *socketData, char *src, frameFormat &frame, void *socket)
    {
        socketData->spillLength = 0;
        socketData->state = READ_MESSAGE;
        socketData->remainingBytes = fullPayloadLength - length + headerLength;
        socketData->mask = *(uint32_t *) &src[headerLength - 4];
        rotate_mask(4 - (length - headerLength) % 4, &socketData->mask);

        unmask(src, src, headerLength - 4, headerLength, length);
        socketData->server->fragmentCallback(socket, src, length - headerLength,
                                             socketData->opCode[socketData->opStack], socketData->fin, socketData->remainingBytes);
    }
コード例 #15
0
ファイル: pfctl_parser.c プロジェクト: rjmooney/pftest
void
print_addr(struct pf_addr *addr, struct pf_addr *mask, u_int8_t af)
{
    char buf[48];
    const char *bf;

    bf = inet_ntop(af, addr, buf, sizeof(buf));
    printf("%s", bf);
    if (mask != NULL) {
        if (!PF_AZERO(mask, af))
            printf("/%u", unmask(mask, af));
    }
}
コード例 #16
0
// Decrypt the supplied data
bool SecureDataManager::decrypt(const ByteString& encrypted, ByteString& plaintext)
{
	// Check the object logged in state
	if ((!userLoggedIn && !soLoggedIn) || (maskedKey.size() != 32))
	{
		return false;
	}

	// Do not attempt decryption of empty byte strings
	if (encrypted.size() == 0)
	{
		plaintext = ByteString("");
		return true;
	}

	AESKey theKey(256);
	ByteString unmaskedKey;

	{
		MutexLocker lock(dataMgrMutex);

		unmask(unmaskedKey);

		theKey.setKeyBits(unmaskedKey);

		remask(unmaskedKey);
	}

	// Take the IV from the input data
	ByteString IV = encrypted.substr(0, aes->getBlockSize());

	if (IV.size() != aes->getBlockSize())
	{
		ERROR_MSG("Invalid IV in encrypted data");

		return false;
	}

	ByteString finalBlock;

	if (!aes->decryptInit(&theKey, SymMode::CBC, IV) ||
	    !aes->decryptUpdate(encrypted.substr(aes->getBlockSize()), plaintext) ||
	    !aes->decryptFinal(finalBlock))
	{
		return false;
	}

	plaintext += finalBlock;

	return true;
}
コード例 #17
0
void
sgen_fragment_allocator_add (SgenFragmentAllocator *allocator, char *start, char *end)
{
	SgenFragment *fragment;

	fragment = sgen_fragment_allocator_alloc ();
	fragment->fragment_start = start;
	fragment->fragment_next = start;
	fragment->fragment_end = end;
	fragment->next_in_order = fragment->next = (SgenFragment *)unmask (allocator->region_head);

	allocator->region_head = allocator->alloc_head = fragment;
	g_assert (fragment->fragment_end > fragment->fragment_start);
}
コード例 #18
0
ファイル: singles.cpp プロジェクト: jpreiss/bitdoku
void only_in_row(Sudoku &sudoku, int row)
{
	int cols_who_contain[9];
	sudoku.digit_to_column_map(row, cols_who_contain);

	for (int num = 0; num < 9; ++num)
	{
		int cols = cols_who_contain[num];
		if (1 == num_ones(cols))
		{
			int col = unmask(cols);
			sudoku.set(row, col, mask(num));
		}
	}
}
コード例 #19
0
Smword
Irq_sender::consume()
{
  Smword old;

  do
    {
      old = _queued;
    }
  while (!mp_cas (&_queued, old, old - 1));

  if (old == 2 && hit_func == &hit_edge_irq)
    unmask();

  return old - 1;
}
コード例 #20
0
// Encrypt the supplied data
bool SecureDataManager::encrypt(const ByteString& plaintext, ByteString& encrypted)
{
	// Check the object logged in state
	if ((!userLoggedIn && !soLoggedIn) || (maskedKey.size() != 32))
	{
		return false;
	}

	AESKey theKey(256);
	ByteString unmaskedKey;

	{
		MutexLocker lock(dataMgrMutex);

		unmask(unmaskedKey);

		theKey.setKeyBits(unmaskedKey);

		remask(unmaskedKey);
	}

	// Wipe encrypted data block
	encrypted.wipe();

	// Generate random IV
	ByteString IV;

	if (!rng->generateRandom(IV, aes->getBlockSize())) return false;

	ByteString finalBlock;

	if (!aes->encryptInit(&theKey, SymMode::CBC, IV) ||
	    !aes->encryptUpdate(plaintext, encrypted) ||
	    !aes->encryptFinal(finalBlock))
	{
		return false;
	}

	encrypted += finalBlock;

	// Add IV to output data
	encrypted = IV + encrypted;

	return true;
}
コード例 #21
0
ファイル: uWS.cpp プロジェクト: piyushpandey013/uWebSockets
    static inline int consumeCompleteMessage(int &length, const int headerLength, T fullPayloadLength, SocketData *socketData, char **src, frameFormat &frame, void *socket)
    {
        unmask(*src, *src, headerLength - 4, headerLength, fullPayloadLength);
        socketData->server->fragmentCallback(socket, *src, fullPayloadLength, socketData->opCode[socketData->opStack], socketData->fin, 0);

        // did we close the socket using Socket.fail()?
        if (uv_is_closing((uv_handle_t *) socket)) {
            return 1;
        }

        if (frame.fin) {
            socketData->opStack--;
        }

        *src += fullPayloadLength + headerLength;
        length -= fullPayloadLength + headerLength;
        socketData->spillLength = 0;
        return 0;
    }
コード例 #22
0
/*!
 * This function is used to subscribe on an event.
 *
 * @param        event_sub   structure of event, it contains type of event and callback
 *
 * @return       This function returns 0 if successful.
 */
int mc13783_event_subscribe_internal(type_event_notification event_sub)
{
	notify_event *new_notify_event;
	void *pmem = kmalloc(sizeof(notify_event), GFP_KERNEL);	/*check? */

	TRACEMSG(_K_D("event subscribe\n"));

	down_interruptible(&sem_event);
	new_notify_event = notify_event_tab[event_sub.event];

	if (new_notify_event == NULL) {
		notify_event_tab[event_sub.event] = (notify_event *) pmem;
		new_notify_event = notify_event_tab[event_sub.event];
		new_notify_event->callback = NULL;
		new_notify_event->callback_p = NULL;
		new_notify_event->param = (void *)NO_PARAM;
	} else {
		while (new_notify_event->next_notify_event != NULL) {
			new_notify_event = (notify_event *)
			    new_notify_event->next_notify_event;
		}
		new_notify_event->next_notify_event = (notify_event *) pmem;
		new_notify_event = (notify_event *)
		    new_notify_event->next_notify_event;
		new_notify_event->callback = NULL;
		new_notify_event->callback_p = NULL;
		new_notify_event->param = (void *)NO_PARAM;
	}
	if (event_sub.param != (void *)NO_PARAM) {
		new_notify_event->callback_p = event_sub.callback_p;
		new_notify_event->param = event_sub.param;
	} else {
		new_notify_event->callback = event_sub.callback;
	}
	new_notify_event->next_notify_event = NULL;
	up(&sem_event);

	CHECK_ERROR(unmask(event_sub.event));

	/* test if event is not available */
	mc13783_wq_handler(NULL);
	return 0;
}
コード例 #23
0
PUBLIC
L4_msg_tag
Irq_sender::kinvoke(L4_obj_ref, L4_fpage::Rights /*rights*/, Syscall_frame *f,
                    Utcb const *utcb, Utcb *)
{
  register Context *const c_thread = ::current();
  assert_opt (c_thread);
  register Space *const c_space = c_thread->space();
  assert_opt (c_space);

  L4_msg_tag tag = f->tag();

  if (EXPECT_FALSE(tag.proto() != L4_msg_tag::Label_irq))
    return commit_result(-L4_err::EBadproto);

  if (EXPECT_FALSE(tag.words() < 1))
    return commit_result(-L4_err::EInval);

  switch ((utcb->values[0] & 0xffff))
    {
    case Op_eoi_1:
    case Op_eoi_2:
      if (_queued < 1)
	unmask();

      return no_reply();
    case Op_attach: /* ATTACH, DETACH */
      return sys_attach(tag, utcb, f, c_space);
    case Op_trigger:
      log();
      hit(0);
      return no_reply();
    default:
      return commit_result(-L4_err::EInval);
    }
}
コード例 #24
0
ファイル: rowbox.cpp プロジェクト: jpreiss/bitdoku
void row_box(Sudoku &sudoku, int row)
{
	int boxes_who_contain[9] = { 0 };
	for (int col = 0; col < 9; ++col)
	{
		int cell = sudoku(row, col);
		for (int num = 0; num < 9; ++num)
		{
			int mask_num = mask(num);
			if (cell & mask_num)
			{
				boxes_who_contain[num] |= mask(col / 3);
			}
		}	
	}

	for (int num = 0; num < 9; ++num)
	{
		int boxes = boxes_who_contain[num];
		if (1 == num_ones(boxes))
		{
			int box = unmask(boxes);

			// figure out the other two rows we need to deal with
			int row_base = (row / 3) * 3;
			int other_rows_mask = 0x7 << row_base;
			int other_row_1;
			int other_row_2;
			int other_rows = subtract(other_rows_mask, mask(row));
			lowest_two_set(other_rows, other_row_1, other_row_2);

			box_row_eliminate(sudoku, other_row_1, box, mask(num));
			box_row_eliminate(sudoku, other_row_2, box, mask(num));
		}
	}
}
コード例 #25
0
mword
sgen_build_nursery_fragments (GCMemSection *nursery_section, SgenGrayQueue *unpin_queue)
{
	char *frag_start, *frag_end;
	size_t frag_size;
	SgenFragment *frags_ranges;
	void **pin_start, **pin_entry, **pin_end;

#ifdef NALLOC_DEBUG
	reset_alloc_records ();
#endif
	/*The mutator fragments are done. We no longer need them. */
	sgen_fragment_allocator_release (&mutator_allocator);

	frag_start = sgen_nursery_start;
	fragment_total = 0;

	/* The current nursery might give us a fragment list to exclude [start, next[*/
	frags_ranges = sgen_minor_collector.build_fragments_get_exclude_head ();

	/* clear scan starts */
	memset (nursery_section->scan_starts, 0, nursery_section->num_scan_start * sizeof (gpointer));

	pin_start = pin_entry = sgen_pinning_get_entry (nursery_section->pin_queue_first_entry);
	pin_end = sgen_pinning_get_entry (nursery_section->pin_queue_last_entry);

	while (pin_entry < pin_end || frags_ranges) {
		char *addr0, *addr1;
		size_t size;

		addr0 = addr1 = sgen_nursery_end;
		if (pin_entry < pin_end)
			addr0 = (char *)*pin_entry;
		if (frags_ranges)
			addr1 = frags_ranges->fragment_start;

		if (addr0 < addr1) {
			if (unpin_queue)
				GRAY_OBJECT_ENQUEUE (unpin_queue, (GCObject*)addr0, sgen_obj_get_descriptor_safe ((GCObject*)addr0));
			else
				SGEN_UNPIN_OBJECT (addr0);
			size = SGEN_ALIGN_UP (sgen_safe_object_get_size ((GCObject*)addr0));
			CANARIFY_SIZE (size);
			sgen_set_nursery_scan_start (addr0);
			frag_end = addr0;
			++pin_entry;
		} else {
			frag_end = addr1;
			size = frags_ranges->fragment_next - addr1;
			frags_ranges = frags_ranges->next_in_order;
		}

		frag_size = frag_end - frag_start;

		if (size == 0)
			continue;

		g_assert (frag_size >= 0);
		g_assert (size > 0);
		if (frag_size && size)
			add_nursery_frag (&mutator_allocator, frag_size, frag_start, frag_end);	

		frag_size = size;
#ifdef NALLOC_DEBUG
		add_alloc_record (*pin_entry, frag_size, PINNING);
#endif
		frag_start = frag_end + frag_size;
	}

	nursery_last_pinned_end = frag_start;
	frag_end = sgen_nursery_end;
	frag_size = frag_end - frag_start;
	if (frag_size)
		add_nursery_frag (&mutator_allocator, frag_size, frag_start, frag_end);

	/* Now it's safe to release the fragments exclude list. */
	sgen_minor_collector.build_fragments_release_exclude_head ();

	/* First we reorder the fragment list to be in ascending address order. This makes H/W prefetchers happier. */
	fragment_list_reverse (&mutator_allocator);

	/*The collector might want to do something with the final nursery fragment list.*/
	sgen_minor_collector.build_fragments_finish (&mutator_allocator);

	if (!unmask (mutator_allocator.alloc_head)) {
		SGEN_LOG (1, "Nursery fully pinned");
		for (pin_entry = pin_start; pin_entry < pin_end; ++pin_entry) {
			GCObject *p = (GCObject *)*pin_entry;
			SGEN_LOG (3, "Bastard pinning obj %p (%s), size: %zd", p, sgen_client_vtable_get_name (SGEN_LOAD_VTABLE (p)), sgen_safe_object_get_size (p));
		}
	}
	return fragment_total;
}
コード例 #26
0
void*
sgen_fragment_allocator_par_range_alloc (SgenFragmentAllocator *allocator, size_t desired_size, size_t minimum_size, size_t *out_alloc_size)
{
	SgenFragment *frag, *min_frag;
	size_t current_minimum;

restart:
	min_frag = NULL;
	current_minimum = minimum_size;

#ifdef NALLOC_DEBUG
	InterlockedIncrement (&alloc_count);
#endif

	for (frag = (SgenFragment *)unmask (allocator->alloc_head); frag; frag = (SgenFragment *)unmask (frag->next)) {
		size_t frag_size = frag->fragment_end - frag->fragment_next;

		HEAVY_STAT (++stat_alloc_range_iterations);

		if (desired_size <= frag_size) {
			void *p;
			*out_alloc_size = desired_size;

			p = par_alloc_from_fragment (allocator, frag, desired_size);
			if (!p) {
				HEAVY_STAT (++stat_alloc_range_retries);
				goto restart;
			}
#ifdef NALLOC_DEBUG
			add_alloc_record (p, desired_size, RANGE_ALLOC);
#endif
			return p;
		}
		if (current_minimum <= frag_size) {
			min_frag = frag;
			current_minimum = frag_size;
		}
	}

	/* The second fragment_next read should be ordered in respect to the first code block */
	mono_memory_barrier ();

	if (min_frag) {
		void *p;
		size_t frag_size;

		frag_size = min_frag->fragment_end - min_frag->fragment_next;
		if (frag_size < minimum_size)
			goto restart;

		*out_alloc_size = frag_size;

		mono_memory_barrier ();
		p = par_alloc_from_fragment (allocator, min_frag, frag_size);

		/*XXX restarting here is quite dubious given this is already second chance allocation. */
		if (!p) {
			HEAVY_STAT (++stat_alloc_retries);
			goto restart;
		}
#ifdef NALLOC_DEBUG
		add_alloc_record (p, frag_size, RANGE_ALLOC);
#endif
		return p;
	}

	return NULL;
}
コード例 #27
0
static void*
par_alloc_from_fragment (SgenFragmentAllocator *allocator, SgenFragment *frag, size_t size)
{
	char *p = frag->fragment_next;
	char *end = p + size;

	if (end > frag->fragment_end)
		return NULL;

	/* p = frag->fragment_next must happen before */
	mono_memory_barrier ();

	if (InterlockedCompareExchangePointer ((volatile gpointer*)&frag->fragment_next, end, p) != p)
		return NULL;

	if (frag->fragment_end - end < SGEN_MAX_NURSERY_WASTE) {
		SgenFragment *next, **prev_ptr;
		
		/*
		 * Before we clean the remaining nursery, we must claim the remaining space
		 * as it could end up been used by the range allocator since it can end up
		 * allocating from this dying fragment as it doesn't respect SGEN_MAX_NURSERY_WASTE
		 * when doing second chance allocation.
		 */
		if ((sgen_get_nursery_clear_policy () == CLEAR_AT_TLAB_CREATION || sgen_get_nursery_clear_policy () == CLEAR_AT_TLAB_CREATION_DEBUG) && claim_remaining_size (frag, end)) {
			sgen_clear_range (end, frag->fragment_end);
			HEAVY_STAT (stat_wasted_bytes_trailer += frag->fragment_end - end);
#ifdef NALLOC_DEBUG
			add_alloc_record (end, frag->fragment_end - end, BLOCK_ZEROING);
#endif
		}

		prev_ptr = find_previous_pointer_fragment (allocator, frag);

		/*Use Michaels linked list remove*/

		/*prev_ptr will be null if the fragment was removed concurrently */
		while (prev_ptr) {
			next = frag->next;

			/*already deleted*/
			if (!get_mark (next)) {
				/*frag->next read must happen before the first CAS*/
				mono_memory_write_barrier ();

				/*Fail if the next node is removed concurrently and its CAS wins */
				if (InterlockedCompareExchangePointer ((volatile gpointer*)&frag->next, mask (next, 1), next) != next) {
					continue;
				}
			}

			/* The second CAS must happen after the first CAS or frag->next. */
			mono_memory_write_barrier ();

			/* Fail if the previous node was deleted and its CAS wins */
			if (InterlockedCompareExchangePointer ((volatile gpointer*)prev_ptr, unmask (next), frag) != frag) {
				prev_ptr = find_previous_pointer_fragment (allocator, frag);
				continue;
			}
			break;
		}
	}

	return p;
}
コード例 #28
0
void
print_addr(struct pf_addr_wrap *addr, sa_family_t af, int verbose)
{
	switch (addr->type) {
	case PF_ADDR_DYNIFTL:
		printf("(%s", addr->v.ifname);
		if (addr->iflags & PFI_AFLAG_NETWORK)
			printf(":network");
		if (addr->iflags & PFI_AFLAG_BROADCAST)
			printf(":broadcast");
		if (addr->iflags & PFI_AFLAG_PEER)
			printf(":peer");
		if (addr->iflags & PFI_AFLAG_NOALIAS)
			printf(":0");
		if (verbose) {
			if (addr->p.dyncnt <= 0)
				printf(":*");
			else
				printf(":%d", addr->p.dyncnt);
		}
		printf(")");
		break;
	case PF_ADDR_TABLE:
		if (verbose)
			if (addr->p.tblcnt == -1)
				printf("<%s:*>", addr->v.tblname);
			else
				printf("<%s:%d>", addr->v.tblname,
				    addr->p.tblcnt);
		else
			printf("<%s>", addr->v.tblname);
		return;
	case PF_ADDR_RANGE: {
		char buf[48];

		if (inet_ntop(af, &addr->v.a.addr, buf, sizeof(buf)) == NULL)
			printf("?");
		else
			printf("%s", buf);
		if (inet_ntop(af, &addr->v.a.mask, buf, sizeof(buf)) == NULL)
			printf(" - ?");
		else
			printf(" - %s", buf);
		break;
	}
	case PF_ADDR_ADDRMASK:
		if (PF_AZERO(&addr->v.a.addr, AF_INET6) &&
		    PF_AZERO(&addr->v.a.mask, AF_INET6))
			printf("any");
		else {
			char buf[48];

			if (inet_ntop(af, &addr->v.a.addr, buf,
			    sizeof(buf)) == NULL)
				printf("?");
			else
				printf("%s", buf);
		}
		break;
	case PF_ADDR_NOROUTE:
		printf("no-route");
		return;
	case PF_ADDR_URPFFAILED:
		printf("urpf-failed");
		return;
	case PF_ADDR_RTLABEL:
		printf("route \"%s\"", addr->v.rtlabelname);
		return;
	default:
		printf("?");
		return;
	}

	/* mask if not _both_ address and mask are zero */
	if (addr->type != PF_ADDR_RANGE &&
	    !(PF_AZERO(&addr->v.a.addr, AF_INET6) &&
	    PF_AZERO(&addr->v.a.mask, AF_INET6))) {
		int bits = unmask(&addr->v.a.mask, af);

		if (bits < (af == AF_INET ? 32 : 128))
			printf("/%d", bits);
	}
}
コード例 #29
0
// Generic function for creating an encrypted version of the key from the specified passphrase
bool SecureDataManager::pbeEncryptKey(const ByteString& passphrase, ByteString& encryptedKey)
{
	// Generate salt
	ByteString salt;

	if (!rng->generateRandom(salt, 8)) return false;

	// Derive the key using RFC4880 PBE
	AESKey* pbeKey = NULL;

	if (!RFC4880::PBEDeriveKey(passphrase, salt, &pbeKey))
	{
		return false;
	}

	// Add the salt
	encryptedKey.wipe();
	encryptedKey += salt;

	// Generate random IV
	ByteString IV;

	if (!rng->generateRandom(IV, aes->getBlockSize())) return false;

	// Add the IV
	encryptedKey += IV;

	// Encrypt the data
	ByteString block;

	if (!aes->encryptInit(pbeKey, SymMode::CBC, IV))
	{
		delete pbeKey;

		return false;
	}

	// First, add the magic
	if (!aes->encryptUpdate(magic, block))
	{
		delete pbeKey;

		return false;
	}

	encryptedKey += block;

	// Then, add the key itself
	ByteString key;

	{
		MutexLocker lock(dataMgrMutex);

		unmask(key);

		bool rv = aes->encryptUpdate(key, block);

		remask(key);

		if (!rv)
		{
			delete pbeKey;

			return false;
		}
	}

	encryptedKey += block;

	// And finalise encryption
	if (!aes->encryptFinal(block))
	{
		delete pbeKey;

		return false;
	}

	encryptedKey += block;

	delete pbeKey;

	return true;
}
コード例 #30
0
ファイル: clock.c プロジェクト: soupytwist/upepc-2014
int
main(int argc, char **argv)
{
    int clocks[MAXCLOCKS*4], lit[4];
    int P, p, K, N, n, i, *cl, *now;
    int d1, d2, d3, d4;
    int answer;
    
    i = 0;

    /* First digit can only be blank or 1 */
    for (d1 = 10; d1 != -1; d1 = (d1 == 10 ? 1 : -1)) {
        /*
         * Second digit can be 0-9 UNLESS first digit is 1,
         * in which case, it can only be 0-2.
         */
        for (d2 = (d1 == 10 ? 1 : 0); (d1 == 10 && d2 <= 9) || (d1 == 1 && d2 <= 2); d2++) {
            /* Third digit can be anything 0-5 */
            for (d3 = 0; d3 <= 5; d3++) {
                /* Fourth digit can be anything 0-9 */
                for (d4 = 0; d4 <= 9; d4++) {
                    CLOCKS[i++] = digits[d1];
                    CLOCKS[i++] = digits[d2];
                    CLOCKS[i++] = digits[d3];
                    CLOCKS[i++] = digits[d4];
                }
            }
        }
    }

    /* P: Number of data set 1 <= P <= 1000 */
    scanf("%d", &P);

    for (p = 1; p <= P; p++) {
        /* K: Data set number */
        /* N: Number of previous displays seen 1 <= N <= 10 */
        scanf("%d %d", &K, &N);

        /* Reset the lit segments we have seen */
        lit[0] = lit[1] = lit[2] = lit[3] = 0;

        /* Read in the N clock faces- last clock face is the current time */
        for (n = 0; n < N; n++) {
            cl = &clocks[n*4];
            read_clock(cl);

            /* Accumulate the lit segments */
            unmask(lit, cl);
        }

        /* Pointer to the last clock face- the current time */
        now = &clocks[(N-1)*4];
        answer = -1;

        /* Check against all possible clocks for 'now' */
        for (i = 0; i < NUMCLOCKS * 4; i += 4) {
            cl = &CLOCKS[i];

            if ((cl[0] & lit[0]) != now[0] ||
                (cl[1] & lit[1]) != now[1] || 
                (cl[2] & lit[2]) != now[2] || 
                (cl[3] & lit[3]) != now[3]) {
                continue;
            }

            if (answer == -1) {
                /* We found an answer; mark it */
                answer = i;
            } else {
                /* We found another answer; then we're not 100% certain */
                answer = -1;
                break;
            }
        }

        printf("%d ", K);
        if (answer != -1) {
            print_clock(&CLOCKS[answer]);
        } else {
            printf("?\n");
        }
    }

    return 0;
}