int sys_chdir (char *pathname)
{
register error_t err = 0;
register struct thread_s *this;
register struct task_s *task;
this = current_thread;
task = current_task;
if(!pathname)
{
this->info.errno = EINVAL;
return -1;
}
rwlock_wrlock(&task->cwd_lock);
if((err = vfs_chdir(pathname, task->vfs_cwd, &task->vfs_cwd)))
{
rwlock_unlock(&task->cwd_lock);
this->info.errno = (err < 0) ? -err : err;
return -1;
}
rwlock_unlock(&task->cwd_lock);
return 0;
}
int mm_info(mm_context *ctx, void *addr, anvil_vmm_info_t& info)
{
struct mm_mapping *pmap;
kdebug("mm_info\n");
mm_context_dump(ctx);
// Iterate thru till we find the first mapping whose start is >= addr
rwlock_wrlock(&ctx->lock);
pmap = first_mapping(ctx);
while (pmap)
{
uintptr_t pmap_end = pmap->start_addr + pmap->length;
if ((uintptr_t)addr <= pmap->start_addr)
{
info.addr = (void *)pmap->start_addr;
info.object = pmap->object;
info.len = pmap->length;
info.fd = pmap->fd;
info.prot = pmap->prot;
kdebug("mm_info found\n");
rwlock_unlock(&ctx->lock);
return 0;
}
pmap = next_mapping(ctx, pmap);
}
rwlock_unlock(&ctx->lock);
kdebug("mm_info done\n");
return -1;
}
struct phys_page *search_obj_chain(mm_context *ctx, struct mm_mapping *mapping, uintptr_t fault_addr)
{
struct mm_object *front_pobj = mapping->object;
struct mm_object *pobj = front_pobj;
struct phys_page *page;
struct phys_page *new_page;
uintptr_t fault_page = (uintptr_t)fault_addr & ~0xfff;
int prot = PM_USER | (mapping->prot & PM_WRITABLE ? PM_WRITABLE : 0);
while (pobj)
{
rwlock_wrlock(&pobj->lock);
page = first_page(pobj);
while (page)
{
if (mapping->start_addr + page->offset == fault_page)
{
switch (pobj->share_type)
{
case share_private:
// kdebug("Object is private %p\n", fault_page);
kpage_map_user((void *)fault_page, page, mm_pgtable_alloc_callback, ctx, ctx->cr3, prot);
//mm_ctx_reload(ctx);
break;
case share_shared:
// kdebug("Object is shared %p\n", fault_page);
kpage_map_user((void *)fault_page, page, mm_pgtable_alloc_callback, ctx, ctx->cr3, prot);
// mm_ctx_reload(ctx);
break;
case share_cow:
// kdebug("%d: Object is cow %p %p\n", get_core_id(), fault_addr, ctx);
/* Make a copy of the page and put it in front_pobj */
new_page = kphys_alloc(physmem_state_user);
new_page->offset = fault_page - mapping->start_addr;
front_pobj->page_list.add_head(new_page);
++front_pobj->npages;
memcpy((void *)(pagestruct_to_phys(new_page) + VADDR_PHYSMEM), (void *)(pagestruct_to_phys(page) + VADDR_PHYSMEM), __PAGESIZE);
kpage_map_user((void *)fault_page, new_page, mm_pgtable_alloc_callback, ctx, ctx->cr3, PM_WRITABLE | PM_USER);
break;
default:
;
}
rwlock_unlock(&pobj->lock);
return page;
}
/* Go to the next one */
page = next_page(pobj, page);
}
rwlock_unlock(&pobj->lock);
pobj = pobj->chain;
}
return NULL;
}
struct rpc_dplx_rec *
rpc_dplx_lookup_rec(int fd, uint32_t iflags, uint32_t *oflags)
{
struct rbtree_x_part *t;
struct rpc_dplx_rec rk, *rec = NULL;
struct opr_rbtree_node *nv;
cond_init_rpc_dplx();
rk.fd_k = fd;
t = rbtx_partition_of_scalar(&(rpc_dplx_rec_set.xt), fd);
rwlock_rdlock(&t->lock);
nv = opr_rbtree_lookup(&t->t, &rk.node_k);
/* XXX rework lock+insert case, so that new entries are inserted
* locked, and t->lock critical section is reduced */
if (! nv) {
rwlock_unlock(&t->lock);
rwlock_wrlock(&t->lock);
nv = opr_rbtree_lookup(&t->t, &rk.node_k);
if (! nv) {
rec = alloc_dplx_rec();
if (! rec) {
__warnx(TIRPC_DEBUG_FLAG_LOCK,
"%s: failed allocating rpc_dplx_rec", __func__);
goto unlock;
}
/* tell the caller */
*oflags = RPC_DPLX_LKP_OFLAG_ALLOC;
rec->fd_k = fd;
if (opr_rbtree_insert(&t->t, &rec->node_k)) {
/* cant happen */
__warnx(TIRPC_DEBUG_FLAG_LOCK,
"%s: collision inserting in locked rbtree partition",
__func__);
free_dplx_rec(rec);
}
}
}
else {
rec = opr_containerof(nv, struct rpc_dplx_rec, node_k);
*oflags = RPC_DPLX_LKP_FLAG_NONE;
}
rpc_dplx_ref(rec, (iflags & RPC_DPLX_LKP_IFLAG_LOCKREC) ?
RPC_DPLX_FLAG_LOCK :
RPC_DPLX_FLAG_NONE);
unlock:
rwlock_unlock(&t->lock);
return (rec);
}
int Thread::try_join(Thread* joiner, void **value_ptr)
{
/*
* We lock here because the joinable member might be cleared by the
* detach code
*/
rwlock_wrlock(&m_join_lock);
if (!m_joinable || m_joiner != NULL)
{
// Someone is already joining us so fail
rwlock_unlock(&m_join_lock);
kdebug("kcall_threadjoin not joinable or already joined\n");
return EINVAL;
}
if (m_state == THR_ST_ZOMBIE)
{
// We are a zombie, ready to be reaped
void *value = zombie_state_info.exit_val;
int err;
if (value_ptr && (err = joiner->kcopy_touser(value_ptr, &value, sizeof(value))) < 0)
{
return err;
}
rwlock_unlock(&m_join_lock);
die();
kdebug("kcall_threadjoin returning value\n");
return 0;
}
// We are not ready to be joined yet so block the joiner and queue him
// on our m_joiner member
//
// NOTE: Normally we don't allow threads to block other threads but this
// is a helper method executing because of a call from joiner
m_joiner = joiner;
joiner->joining_state_info.joined_to = this;
joiner->joining_state_info.value_ptr = value_ptr;
joiner->m_continuation_func = &Thread::join_cont;
// This blocks the tread that called this method i.e. joiner
sys.m_sched.block(THR_ST_JOINING);
//rwlock_unlock(&exiter->m_join_lock);
rwlock_unlock(&m_join_lock);
return 0;
}
/* TODO: don't use locks to lookup region as if address has been accessed it must be in kyesdb */
static error_t check_args(struct vmm_s *vmm, uint_t start, uint_t len, struct vm_region_s **reg)
{
error_t err;
struct vm_region_s *region;
err = 0;
rwlock_rdlock(&vmm->rwlock);
region = vmm->last_region;
if((start >= region->vm_limit) || (start < region->vm_start))
{
region = vm_region_find(vmm, start);
if((region == NULL) || (start < region->vm_start))
err = EINVAL;
}
if((err == 0) && ((start + len) >= region->vm_limit))
err = EINVAL;
rwlock_unlock(&vmm->rwlock);
*reg = region;
return 0;
}
int get_user_by_sockaddr(struct sockaddr_storage *sa, size_t sa_len,
struct curve25519_proto **proto)
{
int ret = -1;
struct sockaddr_map_entry *entry;
unsigned int hash = hash_name((char *) sa, sa_len);
errno = 0;
rwlock_rd_lock(&sockaddr_map_lock);
entry = lookup_hash(hash, &sockaddr_mapper);
while (entry && entry->sa_len == sa_len &&
memcmp(sa, entry->sa, entry->sa_len))
entry = entry->next;
if (entry && entry->sa_len == sa_len &&
!memcmp(sa, entry->sa, entry->sa_len)) {
(*proto) = entry->proto;
ret = 0;
} else {
(*proto) = NULL;
errno = ENOENT;
}
rwlock_unlock(&sockaddr_map_lock);
return ret;
}
void remove_user_by_sockaddr(struct sockaddr_storage *sa, size_t sa_len)
{
struct sockaddr_map_entry *pos;
struct sockaddr_map_entry *entry;
unsigned int hash = hash_name((char *) sa, sa_len);
entry = sockaddr_to_sockaddr_map_entry(sa, sa_len);
if (!entry)
return;
rwlock_wr_lock(&sockaddr_map_lock);
pos = remove_hash(hash, entry, entry->next, &sockaddr_mapper);
while (pos && pos->next && pos->next != entry)
pos = pos->next;
if (pos && pos->next && pos->next == entry)
pos->next = entry->next;
memset(entry->proto->enonce, 0, sizeof(entry->proto->enonce));
memset(entry->proto->dnonce, 0, sizeof(entry->proto->dnonce));
entry->proto = NULL;
entry->next = NULL;
xfree(entry->sa);
xfree(entry);
rwlock_unlock(&sockaddr_map_lock);
}
static int register_user_by_sockaddr(struct sockaddr_storage *sa,
size_t sa_len,
struct curve25519_proto *proto)
{
void **pos;
struct sockaddr_map_entry *entry;
unsigned int hash = hash_name((char *) sa, sa_len);
rwlock_wr_lock(&sockaddr_map_lock);
entry = xzmalloc(sizeof(*entry));
entry->sa = xmemdupz(sa, sa_len);
entry->sa_len = sa_len;
entry->proto = proto;
pos = insert_hash(hash, entry, &sockaddr_mapper);
if (pos) {
entry->next = (*pos);
(*pos) = entry;
}
rwlock_unlock(&sockaddr_map_lock);
return 0;
}
void
svc_run()
{
fd_set readfds, cleanfds;
struct timeval timeout;
timeout.tv_sec = 30;
timeout.tv_usec = 0;
for (;;) {
rwlock_rdlock(&svc_fd_lock);
readfds = svc_fdset;
cleanfds = svc_fdset;
rwlock_unlock(&svc_fd_lock);
switch (_select(svc_maxfd+1, &readfds, NULL, NULL, &timeout)) {
case -1:
FD_ZERO(&readfds);
if (errno == EINTR) {
continue;
}
_warn("svc_run: - select failed");
return;
case 0:
__svc_clean_idle(&cleanfds, 30, FALSE);
continue;
default:
svc_getreqset(&readfds);
}
}
}
int sys_getcwd (char *buff, size_t size)
{
register struct thread_s *this;
register struct task_s *task;
register error_t err;
struct ku_obj ku_buff;
this = current_thread;
task = current_task;
if((size < VFS_MAX_NAME_LENGTH) || (!buff))
{
err = ERANGE;
goto SYS_GETCWD_ERROR;
}
if(vmm_check_address("usr cwd buffer", task, buff, size))
{
err = EFAULT;
goto SYS_GETCWD_ERROR;
}
KU_SZ_BUFF(ku_buff, buff, size);
rwlock_rdlock(&task->cwd_lock);
err = vfs_get_path(&task->vfs_cwd, &ku_buff);
rwlock_unlock(&task->cwd_lock);
SYS_GETCWD_ERROR:
this->info.errno = err;
return (int)buff;
}
/*
* This function causes svc_run() to exit by telling it that it has no
* more work to do.
*/
void
svc_exit()
{
rwlock_wrlock(&svc_fd_lock);
FD_ZERO(&svc_fdset);
rwlock_unlock(&svc_fd_lock);
}
void trie_cleanup(void)
{
rwlock_wr_lock(&tree_lock);
ptree_free(tree);
rwlock_unlock(&tree_lock);
rwlock_destroy(&tree_lock);
}
char *
elf_rawfile (Elf *elf, size_t *ptr)
{
char *result;
if (elf == NULL)
{
/* No valid descriptor. */
__libelf_seterrno (ELF_E_INVALID_HANDLE);
error_out:
if (ptr != NULL)
*ptr = 0;
return NULL;
}
/* If the file is not mmap'ed and not previously loaded, do it now. */
if (elf->map_address == NULL && __libelf_readall (elf) == NULL)
goto error_out;
rwlock_rdlock (elf->lock);
if (ptr != NULL)
*ptr = elf->maximum_size;
result = (char *) elf->map_address + elf->start_offset;
rwlock_unlock (elf->lock);
return result;
}
void remove_user_by_socket(int fd)
{
struct sock_map_entry *pos;
struct sock_map_entry *entry = socket_to_sock_map_entry(fd);
if (!entry)
return;
rwlock_wr_lock(&sock_map_lock);
pos = remove_hash(entry->fd, entry, entry->next, &sock_mapper);
while (pos && pos->next && pos->next != entry)
pos = pos->next;
if (pos && pos->next && pos->next == entry)
pos->next = entry->next;
memset(entry->proto->enonce, 0, sizeof(entry->proto->enonce));
memset(entry->proto->dnonce, 0, sizeof(entry->proto->dnonce));
entry->proto = NULL;
entry->next = NULL;
xfree(entry);
rwlock_unlock(&sock_map_lock);
}
static void* thread_func(void* arg)
{
int i;
int sum = 0;
for (i = 0; i < 1000; i++)
{
rwlock_rdlock(&s_rwlock);
sum += s_counter;
rwlock_unlock(&s_rwlock);
rwlock_wrlock(&s_rwlock);
s_counter++;
rwlock_unlock(&s_rwlock);
}
return 0;
}
/*
* pclose --
* Pclose returns -1 if stream is not associated with a `popened' command,
* if already `pclosed', or waitpid returns an error.
*/
int
pclose(FILE *iop)
{
struct pid *cur, *last;
int pstat;
pid_t pid;
_DIAGASSERT(iop != NULL);
rwlock_wrlock(&pidlist_lock);
/* Find the appropriate file pointer. */
for (last = NULL, cur = pidlist; cur; last = cur, cur = cur->next)
if (cur->fp == iop)
break;
if (cur == NULL) {
#if defined(__minix)
rwlock_unlock(&pidlist_lock);
#else
(void)rwlock_unlock(&pidlist_lock);
#endif /* defined(__minix) */
return (-1);
}
(void)fclose(iop);
/* Remove the entry from the linked list. */
if (last == NULL)
pidlist = cur->next;
else
last->next = cur->next;
#if defined(__minix)
rwlock_unlock(&pidlist_lock);
#else
(void)rwlock_unlock(&pidlist_lock);
#endif /* defined(__minix) */
do {
pid = waitpid(cur->pid, &pstat, 0);
} while (pid == -1 && errno == EINTR);
free(cur);
return (pid == -1 ? -1 : pstat);
}
void parse_userfile_and_generate_user_store_or_die(char *homedir)
{
FILE *fp;
char path[PATH_MAX], buff[512];
int line = 1, ret, fd;
memset(path, 0, sizeof(path));
slprintf(path, sizeof(path), "%s/%s", homedir, FILE_CLIENTS);
rwlock_init(&store_lock);
rwlock_wr_lock(&store_lock);
fp = fopen(path, "r");
if (!fp)
panic("Cannot open client file!\n");
memset(buff, 0, sizeof(buff));
while (fgets(buff, sizeof(buff), fp) != NULL) {
buff[sizeof(buff) - 1] = 0;
/* A comment. Skip this line */
if (buff[0] == '#' || buff[0] == '\n') {
memset(buff, 0, sizeof(buff));
line++;
continue;
}
ret = parse_line(buff, homedir);
if (ret < 0)
panic("Cannot parse line %d from clients!\n", line);
line++;
memset(buff, 0, sizeof(buff));
}
fclose(fp);
if (store == NULL)
panic("No registered clients found!\n");
rwlock_unlock(&store_lock);
init_sock_mapper();
init_sockaddr_mapper();
/*
* Pubkey is also used as a hmac of the initial packet to check
* the integrity of the packet, so that we know if it's just random
* garbage or a 'valid' packet. Again, just for the integrity!
*/
memset(path, 0, sizeof(path));
slprintf(path, sizeof(path), "%s/%s", homedir, FILE_PUBKEY);
fd = open_or_die(path, O_RDONLY);
ret = read(fd, token, sizeof(token));
if (ret != crypto_auth_hmacsha512256_KEYBYTES)
panic("Cannot read public key!\n");
close(fd);
}
/** Create a new semaphore.
* @param name Optional name for the semaphore, for debugging purposes.
* @param count Initial count of the semaphore.
* @param security Security attributes for the ACL. If NULL, default
* attributes will be constructed which grant full access
* to the semaphore to the calling process' user.
* @param rights Access rights for the handle.
* @param handlep Where to store handle to the semaphore.
* @return Status code describing result of the operation. */
status_t kern_semaphore_create(const char *name, size_t count,
const object_security_t *security, object_rights_t rights,
handle_t *handlep)
{
object_security_t ksecurity = { -1, -1, NULL };
user_semaphore_t *sem;
status_t ret;
if(!handlep)
return STATUS_INVALID_ARG;
if(security) {
ret = object_security_from_user(&ksecurity, security, true);
if(ret != STATUS_SUCCESS)
return ret;
}
/* Construct a default ACL if required. */
if(!ksecurity.acl) {
ksecurity.acl = kmalloc(sizeof(*ksecurity.acl), MM_WAIT);
object_acl_init(ksecurity.acl);
object_acl_add_entry(ksecurity.acl, ACL_ENTRY_USER, -1, SEMAPHORE_RIGHT_USAGE);
}
sem = kmalloc(sizeof(user_semaphore_t), MM_WAIT);
sem->id = id_allocator_alloc(&semaphore_id_allocator);
if(sem->id < 0) {
kfree(sem);
object_security_destroy(&ksecurity);
return STATUS_NO_SEMAPHORES;
}
if(name) {
ret = strndup_from_user(name, SEMAPHORE_NAME_MAX, &sem->name);
if(ret != STATUS_SUCCESS) {
id_allocator_free(&semaphore_id_allocator, sem->id);
kfree(sem);
object_security_destroy(&ksecurity);
return ret;
}
} else {
sem->name = NULL;
}
object_init(&sem->obj, &semaphore_object_type, &ksecurity, NULL);
object_security_destroy(&ksecurity);
semaphore_init(&sem->sem, (sem->name) ? sem->name : "user_semaphore", count);
refcount_set(&sem->count, 1);
rwlock_write_lock(&semaphore_tree_lock);
avl_tree_insert(&semaphore_tree, &sem->tree_link, sem->id, sem);
rwlock_unlock(&semaphore_tree_lock);
ret = object_handle_create(&sem->obj, NULL, rights, NULL, 0, NULL, NULL, handlep);
if(ret != STATUS_SUCCESS)
user_semaphore_release(sem);
return ret;
}
Pe *
pe_begin(int fildes, Pe_Cmd cmd, Pe *ref)
{
Pe *retval = NULL;
if (ref != NULL) {
rwlock_rdlock(ref->lock);
} else if (fcntl(fildes, F_GETFL) == -1 && errno == EBADF) {
__libpe_seterrno(PE_E_INVALID_FILE);
return NULL;
}
switch (cmd) {
case PE_C_NULL:
break;
case PE_C_READ_MMAP_PRIVATE:
if (ref != NULL && ref->cmd != PE_C_READ_MMAP_PRIVATE) {
__libpe_seterrno(PE_E_INVALID_CMD);
break;
}
/* fall through */
case PE_C_READ:
case PE_C_READ_MMAP:
if (ref != NULL)
retval = dup_pe(fildes, cmd, ref);
else
retval = read_file(fildes, ~((size_t)0), cmd,
NULL);
break;
case PE_C_RDWR:
case PE_C_RDWR_MMAP:
if (ref != NULL) {
if (ref->cmd != PE_C_RDWR &&
ref->cmd != PE_C_RDWR_MMAP &&
ref->cmd != PE_C_WRITE &&
ref->cmd != PE_C_WRITE_MMAP) {
__libpe_seterrno(PE_E_INVALID_CMD);
retval = NULL;
}
} else {
retval = read_file(fildes, ~((size_t) 0), cmd,
NULL);
}
break;
case PE_C_WRITE:
case PE_C_WRITE_MMAP:
retval = write_file(fildes, cmd);
break;
default:
__libpe_seterrno(PE_E_INVALID_CMD);
break;
}
if (ref != NULL)
rwlock_unlock(ref->lock);
return retval;
}
int Thread::do_exit_thread(void *value)
{
/*
* Now we lock so others can't change our joiner member. Note that not
* only do joiners join us but the timer subsystem may timeout a joiner
* and remove him.
*/
deactivate();
rwlock_wrlock(&m_join_lock);
if (!m_joinable)
{
/* We cannot be joined so we die immediately */
kdebug("Thread::do_exit_thread() not joinable\n");
sys.m_sched.block(THR_ST_DEAD);
rwlock_unlock(&m_join_lock);
die();
return 0;
}
if (m_joiner != NULL)
{
/*
* Someone is waiting for us so make him ready. We don't need to
* lock him. The lock on us prevents anyone from touching the joiner
*/
kdebug("Thread::do_exit_thread() have joiner\n");
m_joiner->joining_state_info.value = value;
m_joiner->m_continuation_func = &Thread::join_cont;
sys.m_sched.add(m_joiner, 0);
sys.m_sched.block(THR_ST_DEAD);
rwlock_unlock(&m_join_lock);
die();
return 0;
}
kdebug("Thread::do_exit_thread() becoming zombie\n");
zombie_state_info.exit_val = value;
sys.m_sched.block(THR_ST_ZOMBIE);
rwlock_unlock(&m_join_lock);
return 0;
}
/**
* @brief This function is not called from anywhere and may be removed.
*/
void neue_unlock(neue_t *neue) {
if (neue) {
rwlock_unlock(&(neue->lock));
//log_pedantic("%20.li unlocking", thread_get_thread_id());
}
return;
}
static void destroy_sockaddr_mapper(void)
{
rwlock_wr_lock(&sockaddr_map_lock);
for_each_hash(&sockaddr_mapper, cleanup_batch_sockaddr_mapper);
free_hash(&sockaddr_mapper);
rwlock_unlock(&sockaddr_map_lock);
rwlock_destroy(&sockaddr_map_lock);
}
void get_serv_store_entry_by_alias(char *alias, size_t len,
char **host, char **port, int *udp)
{
struct server_store *elem;
rwlock_rd_lock(&store_lock);
elem = store;
if (!alias) {
while (elem && elem->next)
elem = elem->next;
if (elem) {
(*host) = elem->host;
(*port) = elem->port;
(*udp) = elem->udp;
selected = elem;
} else {
rwlock_unlock(&store_lock);
goto nothing;
}
} else {
while (elem) {
if (!strncmp(elem->alias, alias,
min(len, strlen(elem->alias) + 1)))
break;
elem = elem->next;
}
if (elem) {
(*host) = elem->host;
(*port) = elem->port;
(*udp) = elem->udp;
selected = elem;
} else {
rwlock_unlock(&store_lock);
goto nothing;
}
}
rwlock_unlock(&store_lock);
return;
nothing:
(*host) = NULL;
(*port) = NULL;
(*udp) = -1;
}
FILE *
popen(const char *cmd, const char *type)
{
struct pid *cur;
int pdes[2], serrno;
pid_t pid;
_DIAGASSERT(cmd != NULL);
_DIAGASSERT(type != NULL);
if ((cur = pdes_get(pdes, &type)) == NULL)
return NULL;
#ifdef _REENTRANT
(void)rwlock_rdlock(&pidlist_lock);
#endif
(void)__readlockenv();
switch (pid = vfork()) {
case -1: /* Error. */
serrno = errno;
(void)__unlockenv();
#ifdef _REENTRANT
(void)rwlock_unlock(&pidlist_lock);
#endif
pdes_error(pdes, cur);
errno = serrno;
return NULL;
/* NOTREACHED */
case 0: /* Child. */
pdes_child(pdes, type);
execl(_PATH_BSHELL, "sh", "-c", cmd, NULL);
_exit(127);
/* NOTREACHED */
}
(void)__unlockenv();
pdes_parent(pdes, cur, pid, type);
#ifdef _REENTRANT
(void)rwlock_unlock(&pidlist_lock);
#endif
return cur->fp;
}
//thread for read operations
void *threadreadlock(void *vargp)
{
printf("%s\n", "Wait for reading!");
rwlock_lockRead(&rwl); //read lock
printf("%s%d\n", "Reading... Value: ", i); //read and print value
//rwlock_getInfo(&rwl);
rwlock_unlock(&rwl); //read unlock
return NULL;
}
int sys_mkdir (char *pathname, uint_t mode)
{
register error_t err = 0;
struct task_s *task = current_task;
struct ku_obj ku_path;
KU_BUFF(ku_path, pathname);
rwlock_rdlock(&task->cwd_lock);
if((err = vfs_mkdir(&task->vfs_cwd, &ku_path, mode)))
{
current_thread->info.errno = (err < 0) ? -err : err;
rwlock_unlock(&task->cwd_lock);
return -1;
}
rwlock_unlock(&task->cwd_lock);
return 0;
}
static void init_sockaddr_mapper(void)
{
rwlock_init(&sockaddr_map_lock);
rwlock_wr_lock(&sockaddr_map_lock);
memset(&sockaddr_mapper, 0, sizeof(sockaddr_mapper));
init_hash(&sockaddr_mapper);
rwlock_unlock(&sockaddr_map_lock);
}
int sys_stat(char *pathname, struct vfs_stat_s *buff, int fd)
{
struct thread_s *this;
register error_t err = 0;
struct vfs_file_s *file;
struct vfs_node_s *node;
struct task_s *task;
this = current_thread;
task = current_task;
if((buff == NULL) || ((pathname == NULL) && (fd == -1)))
{
this->info.errno = EINVAL;
return -1;
}
if((uint_t)buff >= CONFIG_KERNEL_OFFSET)
{
this->info.errno = EPERM;
return -1;
}
if(pathname == NULL)
{
if((fd >= CONFIG_TASK_FILE_MAX_NR) || (task_fd_lookup(task,fd) == NULL))
return EBADFD;
file = task_fd_lookup(task,fd);
node = file->f_node;
err = vfs_stat(task->vfs_cwd, NULL, &node);
}
else
{
node = NULL;
rwlock_rdlock(&task->cwd_lock);
err = vfs_stat(task->vfs_cwd, pathname, &node);
rwlock_unlock(&task->cwd_lock);
}
if(err) goto SYS_STAT_ERR;
err = cpu_uspace_copy(buff, &node->n_stat, sizeof(node->n_stat));
if(err == 0)
return 0;
SYS_STAT_ERR:
if(pathname == NULL)
vfs_node_down_atomic(node);
this->info.errno = err;
return -1;
}
unsigned char *get_serv_store_entry_auth_token(void)
{
unsigned char *ret = NULL;
rwlock_rd_lock(&store_lock);
if (selected)
ret = selected->auth_token;
rwlock_unlock(&store_lock);
return ret;
}
