Remove ONE_xBYTE #defines
[akaros.git] / kern / src / env.c
index 2abc57c..0623f3e 100644 (file)
@@ -44,9 +44,9 @@ int env_setup_vm(env_t *e)
        /* These need to be contiguous, so the kernel can alias them.  Note the
         * pages return with a refcnt, but it's okay to insert them since we free
         * them manually when the process is cleaned up. */
-       if (!(e->procinfo = get_cont_pages(LOG2_UP(PROCINFO_NUM_PAGES), 0)))
+       if (!(e->procinfo = kpages_alloc(PROCINFO_NUM_PAGES * PGSIZE, MEM_WAIT)))
                goto env_setup_vm_error_i;
-       if (!(e->procdata = get_cont_pages(LOG2_UP(PROCDATA_NUM_PAGES), 0)))
+       if (!(e->procdata = kpages_alloc(PROCDATA_NUM_PAGES * PGSIZE, MEM_WAIT)))
                goto env_setup_vm_error_d;
        /* Normally we would 0 the pages here.  We handle it in proc_init_proc*.
         * Do not start the process without calling those. */
@@ -82,26 +82,15 @@ int env_setup_vm(env_t *e)
        return 0;
 
 env_setup_vm_error:
-       free_cont_pages(e->procdata, LOG2_UP(PROCDATA_NUM_PAGES));
+       kpages_free(e->procdata, PROCDATA_NUM_PAGES * PGSIZE);
 env_setup_vm_error_d:
-       free_cont_pages(e->procinfo, LOG2_UP(PROCINFO_NUM_PAGES));
+       kpages_free(e->procinfo, PROCINFO_NUM_PAGES * PGSIZE);
 env_setup_vm_error_i:
-       page_decref(shared_page);
        env_user_mem_free(e, 0, UVPT);
        env_pagetable_free(e);
        return -ENOMEM;
 }
 
-#define PER_CPU_THING(type,name)\
-type SLOCKED(name##_lock) * RWPROTECT name;\
-type SLOCKED(name##_lock) *\
-(get_per_cpu_##name)()\
-{\
-       { R_PERMITTED(global(name))\
-               return &name[core_id()];\
-       }\
-}
-
 /* Frees (decrefs) all memory mapped in the given range */
 void env_user_mem_free(env_t* e, void* start, size_t len)
 {
@@ -123,3 +112,40 @@ void env_user_mem_free(env_t* e, void* start, size_t len)
        tlbflush();
 }
 
+void set_username(struct username *u, char *name)
+{
+       ERRSTACK(1);
+
+       spin_lock(&u->name_lock);
+
+       if (waserror()) {
+               spin_unlock(&u->name_lock);
+               nexterror();
+       }
+
+       __set_username(u, name);
+
+       poperror();
+       spin_unlock(&u->name_lock);
+}
+
+/*
+ * This function exists so that you can do your own locking - do not use it
+ * without locking the username's spinlock yourself.
+ */
+void __set_username(struct username *u, char *name)
+{
+       if (!name)
+               error(EINVAL, "New username is NULL");
+
+       if (strlen(name) > sizeof(u->name) - 1)
+               error(EINVAL, "New username for process more than %d chars long",
+                     sizeof(u->name) - 1);
+
+       // 'backward' copy since reads aren't protected
+       u->name[0] = 0;
+       wmb(); // ensure user.name="" before writing the rest of the new name
+       strlcpy(&u->name[1], &name[1], sizeof(u->name));
+       wmb(); // ensure new name is written before writing first byte
+       u->name[0] = name[0];
+}