Changeset 605


Ignore:
Timestamp:
Mar 1, 2004, 9:08:35 AM (21 years ago)
Author:
Gary Byers
Message:

Use AREA_LOCK when accessing all_areas, unless we're early in bootstrapping.
Change the API, such as it is. Need to ensure that readers/GC obey locking,
as well.

Location:
trunk/ccl/lisp-kernel
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/ccl/lisp-kernel/area.h

    r557 r605  
    8282
    8383area *new_area(BytePtr, BytePtr, area_code);
    84 void add_area(area *);
    85 area *remove_area(area *);
     84void add_area(area *, TCR *);
     85void add_area_holding_area_lock(area *);
     86void condemn_area(area *, TCR *);
     87void condemn_area_holding_area_lock(area *);
    8688area *area_containing(BytePtr);
    8789area *stack_area_containing(BytePtr);

  • trunk/ccl/lisp-kernel/gc.c

    r557 r605  
    3131#include "gc.h"
    3232#include "area.h"
     33#include "Threads.h"
    3334#include <stddef.h>
    3435#include <stdlib.h>
    … …  
    7879*/
    7980
    80 void
    81 add_area(area *new_area)
     81/*
     82  If we already own the area_lock (or during iniitalization), it's safe
     83  to add an area.
     84*/
     85
     86
     87void
     88add_area_holding_area_lock(area *new_area)
    8289{
    8390  area *that = all_areas;
    … …  
    93100  add_area_before(new_area, that);
    94101}
     102
     103/*
     104  In general, we need to own the area lock before adding an area.
     105*/
     106void
     107add_area(area *new_area, TCR *tcr)
     108{
     109  LOCK(lisp_global(AREA_LOCK),tcr);
     110  add_area_holding_area_lock(new_area);
     111  LOCK(lisp_global(AREA_LOCK),tcr);
     112} 
    95113
    96114/*
    … …  
    684702
    685703void
    686 condemn_area(area *a)
     704condemn_area_holding_area_lock(area *a)
    687705{
    688706  void free_stack(void *);
    … …  
    705723}
    706724
     725void
     726condemn_area(area *a, TCR *tcr)
     727{
     728  LOCK(lisp_global(AREA_LOCK),tcr);
     729  condemn_area_holding_area_lock(a);
     730  LOCK(lisp_global(AREA_LOCK),tcr);
     731}
    707732
    708733/*
    … …  
    713738  */
    714739void
    715 condemn_area_chain(area *a)
     740condemn_area_chain(area *a, TCR *tcr)
    716741{
    717742  area *older;
     743
     744  LOCK(lisp_global(AREA_LOCK),tcr);
     745
    718746  for (; a->younger; a = a->younger) ;
    719747  for (;a;) {
    720748    older = a->older;
    721     condemn_area(a);
     749    condemn_area_holding_area_lock(a);
    722750    a = older;
    723751  }
     752  UNLOCK(lisp_global(AREA_LOCK),tcr);
    724753}
    725754
    … …  
    18781907        switch (flag) {
    18791908        case xmacptr_flag_recursive_lock:
    1880           destroy_recursive_lock(ptr);
     1909          destroy_recursive_lock((RECURSIVE_LOCK)ptr);
    18811910          break;
    18821911

  • trunk/ccl/lisp-kernel/image.c

    r6 r605  
    711711        make_dynamic_heap_executable(a->low, a->active);
    712712      case AREA_READONLY:
    713         add_area(a);
     713        add_area_holding_area_lock(a);
    714714        break;
    715715      }

  • trunk/ccl/lisp-kernel/imports.s

    r6 r605  
    3636        defimport(allocate)
    3737        defimport(deallocate)
    38         defimport(allocate_tstack)
    39         defimport(allocate_vstack)
    40         defimport(register_cstack)
     38        defimport(allocate_tstack_holding_area_lock)
     39        defimport(allocate_vstack_holding_area_lock)
     40        defimport(register_cstack_holding_area_lock)
    4141        defimport(condemn_area_chain)
    4242        defimport(metering_control)

  • trunk/ccl/lisp-kernel/lisp_globals.h

    r557 r605  
    3131#define RET1VALN (-9)           /* magic multiple-values return address */
    3232#define TCR_KEY (-10)           /* tsd key for per-thread tcr */
    33 #define bad_GC_LOCK (-11)       /* rwlock for GC */
     33#define AREA_LOCK (-11)       /* all_areas lock */
    3434#define EXCEPTION_LOCK (-12)    /* serialize exception handling */
    3535#define GO_TAG_COUNTER (-13)

  • trunk/ccl/lisp-kernel/pmcl-kernel.c

    r557 r605  
    177177}
    178178
    179 /* This'll allocate a tstack or a vstack, but the thread
    180    mangler won't let us allocate or reliably protect
    181    a control stack.
     179/*
     180  This should only called by something that owns the area_lock, or
     181  by the initial thread before other threads exist.
    182182*/
    183183area *
    … …  
    212212    a->softprot = soft_area;
    213213    a->hardprot = hard_area;
    214     add_area(a);
     214    add_area_holding_area_lock(a);
    215215  }
    216216  return a;
    217217}
    218218
     219/*
     220  Also assumes ownership of the area_lock
     221*/
    219222area*
    220 register_cstack(BytePtr bottom, unsigned size)
     223register_cstack_holding_area_lock(BytePtr bottom, unsigned size)
    221224{
    222225  BytePtr lowlimit = (BytePtr) (((((unsigned)bottom)-size)+4095)&~4095);
    … …  
    225228  a->hardlimit = lowlimit+CSTACK_HARDPROT;
    226229  a->softlimit = a->hardlimit+CSTACK_SOFTPROT;
    227   add_area(a);
     230  add_area_holding_area_lock(a);
    228231  return a;
    229232}
    230233 
     234
    231235area*
    232 allocate_vstack(unsigned usable)
     236allocate_vstack_holding_area_lock(unsigned usable)
    233237{
    234238  return allocate_lisp_stack_area(AREA_VSTACK,
    … …  
    242246
    243247area *
    244 allocate_tstack(unsigned usable)
     248allocate_tstack_holding_area_lock(unsigned usable)
    245249{
    246250  return allocate_lisp_stack_area(AREA_TSTACK,
    … …  
    272276  }
    273277}
    274 
    275 
    276 
    277278
    278279
    … …  
    644645  a = new_area(start, end, AREA_DYNAMIC);
    645646  a->active = start+initsize;
    646   add_area(a);
     647  add_area_holding_area_lock(a);
    647648  a->markbits = reserved_area->markbits;
    648649  reserved_area->markbits = NULL;
    … …  
    11581159  program_name = argv[0];
    11591160  if ((argc == 2) && (*argv[1] != '-')) {
    1160 #ifdef DARWIN
    1161     extern int NXArgc;
    1162     NXArgc = 1;
    1163 #endif
    11641161    image_name = argv[1];
    11651162    argv[1] = NULL;
    … …  
    11811178  create_reserved_area(reserved_area_size);
    11821179  set_nil(load_image(image_name));
     1180  lisp_global(AREA_LOCK) = ptr_to_lispobj(area_lock);
     1181
    11831182  lisp_global(SUBPRIMS_BASE) = (LispObj)(1<<20);
    11841183  lisp_global(RET1VALN) = (LispObj)&ret1valn;
    … …  
    12261225    g2_area = new_area(lowptr, lowptr, AREA_STATIC);
    12271226    tenured_area = new_area(lowptr, lowptr, AREA_STATIC);
    1228     add_area(tenured_area);
    1229     add_area(g2_area);
    1230     add_area(g1_area);
     1227    add_area_holding_area_lock(tenured_area);
     1228    add_area_holding_area_lock(g2_area);
     1229    add_area_holding_area_lock(g1_area);
    12311230
    12321231    g1_area->code = AREA_DYNAMIC;

  • trunk/ccl/lisp-kernel/thread_manager.c

    r571 r605  
    406406}
    407407
    408  
     408
     409/*
     410  Caller must hold the area_lock.
     411*/
    409412TCR *
    410413new_tcr(unsigned vstack_size, unsigned tstack_size)
    411414{
    412   extern area* allocate_vstack(unsigned), *allocate_tstack(unsigned);
     415  extern area
     416    *allocate_vstack_holding_area_lock(unsigned),
     417    *allocate_tstack_holding_tcr(unsigned);
    413418  area *a;
    414419  TCR *tcr = calloc(1, sizeof(TCR));
    … …  
    420425  tcr->reset_completion = new_semaphore(0);
    421426  tcr->activate = new_semaphore(0);
    422   a = allocate_vstack(vstack_size);
     427  a = allocate_vstack_holding_area_lock(vstack_size);
    423428  tcr->vs_area = a;
    424429  tcr->save_vsp = (LispObj *) a->active; 
    425   a = allocate_tstack(tstack_size);
     430  a = allocate_tstack_holding_area_lock(tstack_size);
    426431  tcr->ts_area = a;
    427432  tcr->save_tsp = (LispObj *) a->active;
    … …  
    458463    darwin_exception_cleanup(tcr);
    459464#endif
    460  
     465    LOCK(lisp_global(AREA_LOCK),tcr);
    461466    vs = tcr->vs_area;
    462467    tcr->vs_area = NULL;
    … …  
    466471    tcr->cs_area = NULL;
    467472    if (vs) {
    468       condemn_area(vs);
     473      condemn_area_holding_area_lock(vs);
    469474    }
    470475    if (ts) {
    471       condemn_area(ts);
     476      condemn_area_holding_area_lock(ts);
    472477    }
    473478    if (cs) {
    474       condemn_area(cs);
     479      condemn_area_holding_area_lock(cs);
    475480    }
    476481    destroy_semaphore(&tcr->suspend);
    … …  
    479484    destroy_semaphore(&tcr->activate);
    480485    tcr->osid = 0;
     486    UNLOCK(lisp_global(AREA_LOCK),tcr);
    481487  } else {
    482488    tsd_set(lisp_global(TCR_KEY), tcr);
    … …  
    500506thread_init_tcr(TCR *tcr, void *stack_base, unsigned stack_size)
    501507{
    502   area *a, *register_cstack(BytePtr, unsigned);
     508  area *a, *register_cstack_holding_area_lock(BytePtr, unsigned);
    503509
    504510  tcr->osid = current_thread_osid();
    505511  tcr->native_thread_id = current_native_thread_id();
    506   a = register_cstack((BytePtr)stack_base, stack_size);
     512  LOCK(lisp_global(AREA_LOCK),tcr);
     513  a = register_cstack_holding_area_lock((BytePtr)stack_base, stack_size);
     514  UNLOCK(lisp_global(AREA_LOCK),tcr);
    507515  tcr->cs_area = a;
    508516  if (!(tcr->flags & (1<<TCR_FLAG_BIT_FOREIGN))) {
    … …  
    548556create_stack(int size)
    549557{
    550   Ptr p = (Ptr) mmap(NULL,
     558  Ptr p;
     559  size=align_to_power_of_2(size, 12);
     560  p = (Ptr) mmap(NULL,
    551561                     (size_t)size,
    552562                     PROT_READ | PROT_WRITE | PROT_EXEC,
    … …  
    619629{
    620630  thread_activation activation;
     631  TCR *current = get_tcr(false);
     632
     633  LOCK(lisp_global(AREA_LOCK),current);
    621634  activation.tcr = new_tcr(value_stack_size, temp_stack_size);
     635  UNLOCK(lisp_global(AREA_LOCK),current);
    622636  activation.created = new_semaphore(0);
    623637  create_system_thread(control_stack_size +(CSTACK_HARDPROT+CSTACK_SOFTPROT),
Note: See TracChangeset for help on using the changeset viewer.