static n_string object_file_read_string(n_file * file)
{
n_string return_string = 0L;
n_string_block block_string = {0};
n_int location = 0;
if (file->data[file->location] != '"') // TODO: Replace with smart char handling
{
(void)SHOW_ERROR("json not string as expected");
return return_string;
}
tracking_string_quote = 1;
file->location ++;
do{
CHECK_FILE_SIZE("end of json file reach unexpectedly");
if(file->data[file->location] != '"')
{
block_string[location] = (char)file->data[file->location];
location++;
file->location++;
}
}while (file->data[file->location] != '"');
if (location == 0)
{
(void)SHOW_ERROR("blank string in json file");
return 0L;
}
tracking_string_quote = 0;
file->location++;
CHECK_FILE_SIZE("end of json file reach unexpectedly");
return_string = io_string_copy(block_string);
return return_string;
}
errno_t sockaddr_unix2int( i4sockaddr *internal, const struct sockaddr *name, socklen_t namelen )
{
struct sockaddr_in *iname = (struct sockaddr_in *)name;
if( namelen < (int)sizeof(struct sockaddr_in) )
{
SHOW_ERROR( 1, "namelen < %d", namelen );
return EINVAL;
}
if( iname->sin_len < sizeof(struct sockaddr_in) )
{
SHOW_ERROR( 1, "sin_len < %d", iname->sin_len );
return EINVAL;
}
if( iname->sin_family != PF_INET )
{
SHOW_ERROR( 1, "not inet addr, pf = %d", iname->sin_family );
return EINVAL;
}
internal->port = ntohs(iname->sin_port);
NETADDR_TO_IPV4(internal->addr) = ntohl(iname->sin_addr.s_addr);
SHOW_FLOW( 8, "port %d, ip %s", internal->port, inet_itoa(htonl(NETADDR_TO_IPV4(internal->addr))) );
return 0;
}
n_int network_open(n_string ip, n_byte2 port, n_c_int * network_connection)
{
struct sockaddr_in addr; /* Local address */
/* Create socket for incoming connections */
if ((*network_connection = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
{
return SHOW_ERROR("Failed to set up socket");
}
/* Construct local address structure */
io_erase((n_byte *)&addr, sizeof(addr));
addr.sin_family = AF_INET; /* Internet address family */
if (ip)
{
addr.sin_addr.s_addr = inet_addr(ip); /* Server IP address */
}
else
{
addr.sin_addr.s_addr = htonl(INADDR_ANY); /* Any incoming interface */
}
addr.sin_port = htons(port); /* Local port */
/* Bind to the local address */
if (bind(*network_connection, (struct sockaddr *) &addr, sizeof(addr)) < 0)
{
return SHOW_ERROR("Failed to set up bind");
}
return 0;
}
// Cancel the process number obtained from
// the top of the stack
int32_t threadKill(ContextType *context,int32_t value)
{
UNUSED(value);
int32_t nth;
// Try to get the thread number
if (PstackPop(context,&nth)) return 0;
// Check number range
if ((nth<1)||(nth>MAX_THREADS))
{
if (SHOW_ERROR(context))
runtimeErrorMessage(context,"Invalid thread number");
return 0;
}
// Check if this thread is active
if (FThreads[nth-1].status==FTS_NONE)
{
if (SHOW_ERROR(context))
consoleErrorMessage(context,"This thread is not running");
return 0;
}
// Set abort bit
(FThreads[nth-1].context.Flags)|=CFLAG_ABORT;
// Show info if enabled
if (SHOW_INFO(context))
consolePrintf("Thread [%d] set to abort%s",nth,BREAK);
return 0;
}
ssize_t usys_recvfrom(int *err, uuprocess_t *u, int fd, void *buf, size_t buflen, int flags,
struct sockaddr *from, socklen_t *fromlen)
{
if( u == 0 )
{
*err = ENOTSOCK; // TODO correct?
return -1;
}
CHECK_FD(fd);
struct uufile *f = GETF(fd);
struct uusocket *us = f->impl;
if( *fromlen < (int)sizeof(struct sockaddr_in) )
{
*err = EINVAL;
return -1;
}
if( ! (f->flags & UU_FILE_FLAG_NET))
{
*err = ENOTSOCK;
return -1;
}
if( flags )
SHOW_ERROR( 0, "I don't know this flag %d", flags );
i4sockaddr tmp_addr;
//struct sockaddr_in *sfrom = (struct sockaddr_in *)from;
// FIXME TODO ERR allways times out in 5 sec
int len = udp_recvfrom( us->prot_data, buf, buflen, &tmp_addr, SOCK_FLAG_TIMEOUT, 5000000L );
if( len < 0 )
{
SHOW_ERROR( 7, "ret = %d", len );
*err = -len;
goto ret;
}
SHOW_FLOW( 8, "flags %x", flags );
/*
SHOW_FLOW( 7, "port %d, ip %s", tmp_addr.port, inet_itoa(htonl(NETADDR_TO_IPV4(tmp_addr.addr))) );
sfrom->sin_port = htons(tmp_addr.port);
sfrom->sin_addr.s_addr = htonl(NETADDR_TO_IPV4(tmp_addr.addr));
sfrom->sin_family = PF_INET;
sfrom->sin_len = sizeof(struct sockaddr_in);
*fromlen = sfrom->sin_len;
*/
errno_t rc = sockaddr_int2unix( from, fromlen, &tmp_addr );
if( rc )
*fromlen = 0;
ret:
return *err ? -1 : len;
}
static errno_t threads_test()
{
hal_cond_init(&c, "threadTest");
hal_mutex_init(&m, "threadTest");
hal_sem_init(&s, "threadTest");
int i = 40;
n_t_empty = i;
while(i-- > 0)
phantom_create_thread( t_empty, "Empty", 0 );
pressEnter("will create thread");
phantom_create_thread( thread1, "__T1__", 0 );
phantom_create_thread( thread1, "__T2__", 0 );
//phantom_create_thread( thread1, "__T3__" );
//phantom_create_thread( t_wait, "__TW__" );
int tid = hal_start_kernel_thread_arg( t_wait, "__TW__" );
i = 40;
while(i-- > 0)
{
if(TEST_CHATTY) pressEnter("will yield");
YIELD();
if(TEST_CHATTY) printf("!! back in main\n");
}
t_kill_thread( tid );
hal_sleep_msec( 30 );
thread_stop_request = 1;
hal_sleep_msec( 10 );
thread_activity_counter = 0;
hal_sleep_msec( 1000 );
if( thread_activity_counter )
{
SHOW_ERROR0( 0, "Can't stop thread" );
return -1;
}
while(n_t_empty > 0)
{
SHOW_FLOW( 0, "wait for %d threads", n_t_empty );
hal_sleep_msec(500);
}
if(p._ah.refCount != 1)
{
SHOW_ERROR( 0, "p._ah.refCount = %d", p._ah.refCount );
test_fail_msg( -1, "refcount" );
}
else
SHOW_ERROR( 0, "p._ah.refCount = %d, SUCCESS", p._ah.refCount );
return 0;
}
static n_int object_file_read_number(n_file * file, n_int * with_error)
{
n_int return_number = 0;
n_string_block block_string = {0};
n_int location = 0;
n_byte read_char = file->data[file->location];
n_int char_okay = (ASCII_NUMBER(read_char) || (read_char == '-'));
*with_error = 1;
if (!char_okay)
{
(void)SHOW_ERROR("first character not number or minus");
return 0;
}
CHECK_FILE_SIZE("end of json file reach unexpectedly for number");
block_string[location] = (char)read_char;
file->location++;
location++;
do{
read_char = file->data[file->location];
char_okay = ASCII_NUMBER(read_char);
CHECK_FILE_SIZE("end of json file reach unexpectedly for number");
if(char_okay)
{
block_string[location] = (char)read_char;
location++;
file->location++;
}
}while (char_okay);
{
n_int actual_value = 1;
n_int decimal_divisor = 1;
n_int error_number = io_number((n_string)block_string, &actual_value, &decimal_divisor);
if (error_number == -1)
{
return 0;
}
if (decimal_divisor != 0)
{
(void)SHOW_ERROR("decimal number in json file");
return 0;
}
return_number = actual_value;
}
*with_error = 0;
return return_number;
}
static errno_t
bootprecv( struct bootp_state *bstate, void *udp_sock, struct bootp *bp, size_t len, size_t *retlen )
{
SHOW_FLOW0( 3, "bootp_recv");
sockaddr dest_addr;
dest_addr.port = IPPORT_BOOTPS; // dest port
dest_addr.addr.len = 4;
dest_addr.addr.type = ADDR_TYPE_IP;
// INADDR_BROADCAST
//NETADDR_TO_IPV4(dest_addr.addr) = IPV4_DOTADDR_TO_ADDR(0xFF, 0xFF, 0xFF, 0xFF);
NETADDR_TO_IPV4(dest_addr.addr) = IPV4_DOTADDR_TO_ADDR(0, 0, 0, 0);
int n = udp_recvfrom(udp_sock, bp, len, &dest_addr, SOCK_FLAG_TIMEOUT, 2000000l);
if( 0 >= n )
{
SHOW_ERROR( 0, "UDP recv err = %d", n);
return ETIMEDOUT; // TODO errno
}
if (n == -1 || n < (int)(sizeof(struct bootp) - BOOTP_VENDSIZE))
goto bad;
SHOW_FLOW( 3, "bootprecv: recv %d bytes", n);
if (bp->bp_xid != htonl(xid)) {
SHOW_ERROR( 1, "bootprecv: expected xid 0x%x, got 0x%x",
xid, ntohl(bp->bp_xid));
goto bad;
}
SHOW_FLOW0( 3, "bootprecv: got one!");
/* Suck out vendor info */
if (bcmp(vm_rfc1048, bp->bp_vend, sizeof(vm_rfc1048)) == 0) {
if(vend_rfc1048(bstate, bp->bp_vend, sizeof(bp->bp_vend)) != 0)
goto bad;
}
#ifdef BOOTP_VEND_CMU
else if (bcmp(vm_cmu, bp->bp_vend, sizeof(vm_cmu)) == 0)
vend_cmu(bstate,bp->bp_vend);
#endif
else
SHOW_ERROR( 0, "bootprecv: unknown vendor 0x%lx", (long)bp->bp_vend);
if(retlen) *retlen = n;
return 0;
bad:
//errno = 0;
return EINVAL;
}
static void trfs_recv_thread(void *arg)
{
(void) arg;
u_int8_t buf[TRFS_MAX_PKT];
t_current_set_name("TRFS Recv");
while(connect_trfs())
{
SHOW_ERROR0( 1, "Unable to connect" );
hal_sleep_msec(20000);
//return;
}
while(1)
{
int rc;
if( ( rc = trfs_recv( &buf, TRFS_MAX_PKT)) <= 0 )
{
SHOW_ERROR( 1, "recv err %d", rc );
again:
hal_sleep_msec( 100 ); // Against tight loop
continue;
}
if( rc < (int)sizeof(trfs_pkt_t) )
{
SHOW_ERROR( 1, "recv pkt size %d < required %d", rc, sizeof(trfs_pkt_t) );
goto again;
}
trfs_pkt_t *rq = (trfs_pkt_t *)buf;
SHOW_FLOW( 6, "got pkt type %d", rq->type );
if(rq->sessionId != sessionId)
{
trfs_reset_session(rq->sessionId);
if(rq->type != PKT_T_Error)
continue;
}
switch(rq->type)
{
case PKT_T_Error: recvError(rq); break;
case PKT_T_ReadReply: recvReadReply(rq); break;
case PKT_T_FindReply: recvFindReply(rq); break;
default:
SHOW_ERROR( 0, "TRFS: unknown packet type %d", rq->type);
}
}
}
static void reopen_stdioe(uuprocess_t *u, const char *fname)
{
int err;
usys_close( &err, u, 0 );
usys_close( &err, u, 1 );
usys_close( &err, u, 2 );
if( usys_open( &err, u, fname, O_RDONLY, 0 ) != 0 )
SHOW_ERROR( 0, "can't open %s for stdin, %d", fname, err );
if( usys_open( &err, u, fname, O_WRONLY, 0 ) != 1 )
SHOW_ERROR( 0, "can't open %s for stdout, %d", fname, err );
if( usys_open( &err, u, fname, O_WRONLY, 0 ) != 2 )
SHOW_ERROR( 0, "can't open %s for stderr, %d", fname, err );
}
bool
create_temp_sg(scsi_ccb *ccb)
{
physical_entry *temp_sg;
status_t res;
SHOW_FLOW(3, "ccb=%p, data=%p, data_length=%" B_PRIu32, ccb, ccb->data,
ccb->data_length);
ccb->sg_list = temp_sg = (physical_entry*)locked_pool->alloc(temp_sg_pool);
if (temp_sg == NULL) {
SHOW_ERROR0(2, "cannot allocate memory for IO request!");
return false;
}
res = lock_memory(ccb->data, ccb->data_length, B_DMA_IO
| ((ccb->flags & SCSI_DIR_MASK) == SCSI_DIR_IN ? B_READ_DEVICE : 0));
if (res != B_OK) {
SHOW_ERROR(2, "cannot lock memory for IO request (%s)", strerror(res));
goto err;
}
if (fill_temp_sg(ccb))
// this is the success path
return true;
unlock_memory(ccb->data, ccb->data_length, B_DMA_IO
| ((ccb->flags & SCSI_DIR_MASK) == SCSI_DIR_IN ? B_READ_DEVICE : 0));
err:
locked_pool->free(temp_sg_pool, temp_sg);
return false;
}
static errno_t rm_mount( const char* name, int flags )
{
(void) flags;
if( *name == '/' ) name++;
errno_t rc = unlink_dir_name( &root_root, name );
if( rc )
{
SHOW_ERROR( 1, "can't unlink %s", name );
return rc;
}
hal_mutex_lock ( &mm );
int i;
for( i = 0; i < FS_MAX_MOUNT; i++ )
{
// unused
if( mount[i].fs == 0 )
continue;
if( 0 == strcmp( mount[i].path, name ) )
{
mount[i].fs = 0;
hal_mutex_unlock ( &mm );
return 0;
}
}
hal_mutex_unlock ( &mm );
return ENOENT;
}
static void * object_write_primitive(n_file * file, n_array * primitive)
{
switch (object_type(primitive))
{
case OBJECT_NUMBER:
{
n_int * int_data = (n_int *)&primitive->data;
io_writenumber(file, int_data[0],1,0);
}
break;
case OBJECT_STRING:
io_write(file, "\"", 0);
io_write(file, primitive->data, 0);
io_write(file, "\"", 0);
break;
case OBJECT_OBJECT:
object_top_object(file, (n_object *)primitive->data);
break;
case OBJECT_ARRAY:
object_top_array(file, (n_array *)primitive->data);
break;
default:
(void)SHOW_ERROR("Object kind not found");
return 0L;
}
if (primitive->next)
{
io_write(file, ",", 0);
}
return primitive->next;
}
ssize_t usys_sendmsg(int *err, uuprocess_t *u, int fd, const struct msghdr *msg, int flags)
{
(void) msg;
if( u == 0 )
{
*err = ENOTSOCK; // TODO correct?
return -1;
}
CHECK_FD(fd);
struct uufile *f = GETF(fd);
int len = 0;
struct uusocket *us = f->impl;
(void) us;
// TODO implement me
if( ! (f->flags & UU_FILE_FLAG_NET))
{
*err = ENOTSOCK;
return -1;
}
if( flags )
SHOW_ERROR( 0, "I don't know this flag %d", flags );
*err = ENOSYS;
return *err ? -1 : len;
}
static bool
scsi_alloc_dma_buffer_sg_orig(dma_buffer *buffer, size_t size)
{
// free old list first
scsi_free_dma_buffer_sg_orig(buffer);
size = (size * sizeof(physical_entry) + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1);
buffer->sg_orig = create_area("S/G to original data",
(void **)&buffer->sg_list_orig,
B_ANY_KERNEL_ADDRESS, size,
B_NO_LOCK, 0);
if (buffer->sg_orig < 0) {
SHOW_ERROR(2, "Cannot S/G list buffer to original data of %" B_PRIuSIZE
" bytes", size);
return false;
}
buffer->sg_count_max_orig = size / sizeof(physical_entry);
SHOW_INFO(3, "Got up to %" B_PRIuSIZE " S/G entries to original data",
buffer->sg_count_max_orig);
return true;
}
errno_t cd_read_file( cdfs_t *impl, iso_dir_entry *e, u_int32_t start_sector, size_t nsect, void *buf )
{
//phantom_disk_partition_t *p = impl->p;
SHOW_FLOW( 4, "CDFS file @ sect %d, sz %d", e->dataStartSector[0], e->dataLength[0] );
int file_start_sect = e->dataStartSector[0];
size_t file_size = e->dataLength[0];
size_t file_sectors = CD_BYTES_TO_SECTORS(file_size);
if( start_sector + nsect > file_sectors )
nsect = file_sectors - start_sector;
if( nsect <= 0 )
return EINVAL;
// Reasonable limit?
if( nsect > 1024 ) return EINVAL;
int sect = file_start_sect+start_sector;
SHOW_FLOW( 9, "CDFS file read @ sect %d, nsect %d", sect, nsect );
errno_t err = cd_read_sectors( impl, buf, sect, nsect );
if( err )
{
SHOW_ERROR( 1, "CDFS file sect read err %d", err );
return err;
}
return 0;
}
void recvError(trfs_pkt_t *rq)
{
SHOW_ERROR( 0, "error %d received, '%.*s'",
rq->error.errorId,
rq->error.textLen,
rq->error.text
);
}
void Parent::textbox_add(int id){
get_element(tex,gui::Textbox,gui::GUI_TYPE::TEXTBOX,id);
if (tex.parent_id != -1){
SHOW_ERROR("BasicGUI: Textbox with ID "+to_string(id)+" already has a parent with ID "+to_string(tex.parent_id)+"! Parenting not done!\n");
}
child_elements.push_back(id);
tex.parent_id = element_id;
}
errno_t lookup_fs(phantom_disk_partition_t *p)
{
char pname[128];
partGetName( p, pname, sizeof(pname) );
SHOW_INFO( 0, "Look for filesystems on partition %s", pname );
unsigned int i;
for( i = 0; i < sizeof(fs_drivers)/sizeof(fs_probe_t); i++ )
{
fs_probe_t *fp = &fs_drivers[i];
SHOW_INFO( 0, "probe %s fs on %s", fp->name, pname );
errno_t ret = fp->probe_f( p );
if( ret ) continue;
SHOW_INFO( 0, "%s file sysem found on partition %s", fp->name, pname );
if(!fp->use_f)
{
SHOW_ERROR( 0, "%s file sysem is not implemented yet", fp->name );
continue;
}
#if FS_START_THREAD
// BUG HACK - activate phantom fs syncronously, or else we will die attempting to use it
if(fp->use_f == fs_use_phantom)
fp->use_f( p );
else
hal_start_kernel_thread_arg( (void (*)(void *))fp->use_f, p );
#else
ret = fp->use_f( p );
if( ret )
{
SHOW_ERROR( 0, "%s file sysem driver rejected partition %s", fp->name, pname );
continue;
}
SHOW_INFO( 0, "%s file sysem driver occupies partition %s", fp->name, pname );
#endif
return 0;
}
return EINVAL;
}
errno_t cn_url_do_operation( int op_no, struct data_area_4_connection *c, struct data_area_4_thread *t, pvm_object_t o )
{
(void) t;
(void) c;
(void) o;
SHOW_ERROR( 1, "no op %d", op_no );
return EINVAL;
}
static status_t createGARTBuffer( GART_info *gart, size_t size )
{
physical_entry map[1];
void *unaligned_addr, *aligned_phys;
SHOW_FLOW0( 3, "" );
gart->buffer.size = size = (size + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1);
// we allocate an contiguous area having twice the size
// to be able to find an aligned, contiguous range within it;
// the graphics card doesn't care, but the CPU cannot
// make an arbitrary area WC'ed, at least elder ones
// question: is this necessary for a PCI GART because of bus snooping?
gart->buffer.unaligned_area = create_area( "Radeon PCI GART buffer",
&unaligned_addr, B_ANY_KERNEL_ADDRESS,
2 * size, B_CONTIGUOUS/*B_FULL_LOCK*/, B_READ_AREA | B_WRITE_AREA | B_USER_CLONEABLE_AREA );
// TODO: Physical aligning can be done without waste using the
// private create_area_etc().
if (gart->buffer.unaligned_area < 0) {
SHOW_ERROR( 1, "cannot create PCI GART buffer (%s)",
strerror( gart->buffer.unaligned_area ));
return gart->buffer.unaligned_area;
}
get_memory_map( unaligned_addr, B_PAGE_SIZE, map, 1 );
aligned_phys =
(void **)((map[0].address + size - 1) & ~(size - 1));
SHOW_FLOW( 3, "aligned_phys=%p", aligned_phys );
gart->buffer.area = map_physical_memory( "Radeon aligned PCI GART buffer",
(addr_t)aligned_phys,
size, B_ANY_KERNEL_BLOCK_ADDRESS | B_MTR_WC,
B_READ_AREA | B_WRITE_AREA, &gart->buffer.ptr );
if( gart->buffer.area < 0 ) {
SHOW_ERROR0( 3, "cannot map buffer with WC" );
gart->buffer.area = map_physical_memory( "Radeon aligned PCI GART buffer",
(addr_t)aligned_phys,
size, B_ANY_KERNEL_BLOCK_ADDRESS,
B_READ_AREA | B_WRITE_AREA, &gart->buffer.ptr );
}
if( gart->buffer.area < 0 ) {
SHOW_ERROR0( 1, "cannot map GART buffer" );
delete_area( gart->buffer.unaligned_area );
gart->buffer.unaligned_area = -1;
return gart->buffer.area;
}
memset( gart->buffer.ptr, 0, size );
return B_OK;
}
errno_t cache_set_writeback( cache_t *c, writeback_f_t *func, void *opaque )
{
if(c->writeback_f)
SHOW_ERROR( 3, "Reset wback f for %p", c );
c->writeback_f = func;
c->writeback_a = opaque;
return 0;
}
BOOL CAuthTest::Test_UnblockPIN()
{
SHOW_PROCESS("UnblockPIN");
if (NULL == g_hApp)
{
printf("OPen application first!\n");
return FALSE;
}
char szSoPIN[256] = {0};
printf("Input administrator's PIN\n");
fflush(stdin);
gets(szSoPIN);
char szNewUserPIN[256] = {0};
printf("Input new user's PIN\n");
fflush(stdin);
gets(szNewUserPIN);
ULONG ulRetryCount = 0;
ULONG ulReval = 0;
do
{
ulReval = SKF_UnblockPIN(g_hApp, (LPSTR)szSoPIN, (LPSTR)szNewUserPIN, &ulRetryCount);
SHOW_ERROR(ulReval);
if (SAR_PIN_INCORRECT == ulReval)
{
printf("Wrong PIN!\n");
break;
}
if (SAR_PIN_INVALID == ulReval)
{
printf("Invalid PIN!\n");
break;
}
if (SAR_PIN_LEN_RANGE == ulReval)
{
printf("Wrong PIN Length!\n");
break;
}
if (SAR_PIN_LOCKED == ulReval)
{
printf("Your PIN has been locked!\n");
break;
}
} while (0);
return (SAR_OK == ulReval);
}
ssize_t usys_sendto(int *err, uuprocess_t *u, int fd, const void *buf, size_t buflen, int flags, const struct sockaddr *to, socklen_t tolen)
{
if( u == 0 )
{
*err = ENOTSOCK; // TODO correct?
return -1;
}
CHECK_FD(fd);
struct uufile *f = GETF(fd);
struct uusocket *us = f->impl;
(void) us;
if( tolen < (int)sizeof(struct sockaddr_in) )
{
*err = EINVAL;
return -1;
}
if( ! (f->flags & UU_FILE_FLAG_NET))
{
*err = ENOTSOCK;
return -1;
}
if( flags )
SHOW_ERROR( 0, "I don't know this flag %d", flags );
/*
struct sockaddr_in *sto = (struct sockaddr_in *)to;
if( sto->sin_family != PF_INET )
SHOW_ERROR0( 0, "not inet addr?");
*/
i4sockaddr tmp_addr;
errno_t rc = sockaddr_unix2int( &tmp_addr, to, tolen );
if( rc )
{
*err = rc;
return -1;
}
//tmp_addr.port = ntohs(sto->sin_port);
//NETADDR_TO_IPV4(tmp_addr.addr) = ntohl(sto->sin_addr.s_addr);
SHOW_FLOW( 8, "flags %x", flags );
//SHOW_FLOW( 7, "port %d, ip %s", tmp_addr.port, inet_itoa(htonl(NETADDR_TO_IPV4(tmp_addr.addr))) );
int ret = udp_sendto( us->prot_data, buf, buflen, &tmp_addr);
if( ret < 0 )
*err = -ret;
return *err ? -1 : ret;
}
void phantom_thread_sleep_worker( struct data_area_4_thread *thda )
{
if(phantom_virtual_machine_stop_request)
{
SHOW_FLOW0( 5, "VM thread will die now");
hal_exit_kernel_thread();
}
SHOW_FLOW0( 5, "VM thread will sleep for sleep");
hal_mutex_lock( &interlock_mutex );
phantom_virtual_machine_threads_stopped++;
hal_cond_broadcast( &phantom_snap_wait_4_vm_enter );
//SHOW_FLOW0( 5, "VM thread reported sleep, will wait now");
if( thda->spin_to_unlock )
{
VM_SPIN_UNLOCK( (*thda->spin_to_unlock) );
thda->spin_to_unlock = 0;
}
else
{
if(thda->sleep_flag)
SHOW_ERROR(0, "Warn: vm th (da %x) sleep, no spin unlock requested", thda);
}
//while(thda->sleep_flag) hal_cond_wait( &(thda->wakeup_cond), &interlock_mutex );
while(thda->sleep_flag)
{
SHOW_ERROR(0, "Warn: old vm sleep used, th (da %x)", thda);
hal_cond_wait( &vm_thread_wakeup_cond, &interlock_mutex );
}
// TODO if snap is active someone still can wake us up - resleep for snap then!
//SHOW_FLOW0( 5, "VM thread awaken, will report wakeup");
phantom_virtual_machine_threads_stopped--;
hal_mutex_unlock( &interlock_mutex );
SHOW_FLOW0( 5, "VM thread awaken");
}
void sendRequest(trfs_queue_t *qe)
{
if( qe->type == TRFS_QEL_TYPE_READ )
sendReadRq(qe);
else
if( qe->type == TRFS_QEL_TYPE_WRITE )
sendWriteRq(qe);
else
SHOW_ERROR( 0, "unknown req type %d", qe->type );
}
int LoggerSingleton::LogWrite(const std::string& level, const std::string& module, const std::string& format, va_list ap)
{
Switch::Tool::ErrorInfo err;
if (Switch::Tool::Logger::LogWrite(err, level, module, format, ap) != 0)
{
SHOW_ERROR(err);
return -1;
}
return 0;
}
static void __cfree(int tobe, int ln)
{
int real = nfree();
if( tobe == real )
return;
SHOW_ERROR( 0, "free is %d, must be %d, diff = %d @line %d", real, tobe, real-tobe, ln );
test_fail_msg( EINVAL, "free count is wrong" );
}
errno_t cd_scan_dir( cdfs_t *impl, iso_dir_entry *e, const char *path_to_find, iso_dir_entry *found_entry )
{
//phantom_disk_partition_t *p = impl->p;
SHOW_FLOW( 7, "CDFS dir @ sect %d, sz %d, look for '%s'", e->dataStartSector[0], e->dataLength[0], path_to_find );
int sect = e->dataStartSector[0];
int left = e->dataLength[0];
const char *name_to_find;
const char *path_rest;
size_t namelen = 1;
const char *slash = index( path_to_find, '/' );
if( slash == 0 )
{
name_to_find = path_to_find;
path_rest = 0;
}
else
{
namelen = slash-path_to_find;
}
char name[namelen+1];
if( slash )
{
strlcpy( name, path_to_find, namelen+1 );
name_to_find = name;
path_rest = slash+1;
}
SHOW_FLOW( 8, "name = '%s', rest = '%s'", name_to_find, path_rest );
char buf[CD_SECT_SIZE];
while( left > 0 )
{
errno_t err = cd_read_sectors( impl, buf, sect++, 1 );
left -= CD_SECT_SIZE;
if( err )
SHOW_ERROR( 0, "CDFS dir sect read err %d != 2048, not supported", err );
else
{
err = cd_scan_dir_sect( impl, buf, name_to_find, path_rest, found_entry );
if( 0 == err ) return err;
}
}
return ENOENT;
}
static errno_t trfs_send(void *pkt, int pktsize)
{
if(trfs_failed || !phantom_tcpip_active)
return ENOTCONN;
if(debug_level_flow >= 11) hexdump( pkt, pktsize, "TRFS send pkt", 0 );
SHOW_FLOW0( 1, "sending" );
int rc;
if( 0 == (rc = udp_sendto(trfs_socket, pkt, pktsize, &trfs_addr)) )
return 0;
if(rc == ERR_NET_NO_ROUTE)
{
SHOW_ERROR( 0, "No route", rc);
return EHOSTUNREACH;
}
else
SHOW_ERROR( 0, "can't send, rc = %d", rc);
return EIO;
}
