Date: Tue, 5 Aug 2003 19:44:51 -0400 (EDT) From: Daniel Eischen <eischen@vigrid.com> To: Mike Makonnen <mtm@identd.net> Cc: Marcel Moolenaar <marcel@xcllnt.net> Subject: Re: cvs commit: src/sys/i386/i386 sys_machdep.c Message-ID: <Pine.GSO.4.10.10308051940540.6797-100000@pcnet5.pcnet.com> In-Reply-To: <20030805231633.GA24684@kokeb.ambesa.net>
next in thread | previous in thread | raw e-mail | index | archive | help
On Tue, 5 Aug 2003, Mike Makonnen wrote:
> On Sat, Aug 02, 2003 at 02:03:39PM -0700, Marcel Moolenaar wrote:
> > On Sat, Aug 02, 2003 at 03:52:44PM -0400, Mike Makonnen wrote:
> > >
> > > As I indicated to Julian, I don't have time to do this now. I will
> > > be going off-line in a couple of weeks for I don't know how long.
> > > In the mean time I have a bunch of other stuff I have to get to.
> > > But, if someone else wants to do it I can tell you exactly
> > > what you need to do. It's relatively simple.
> >
> > Can you post the description to threads@?
> > I'll see if I can find a spare moment...
>
> When I went back over the code, to write this summary
> I found it is going to be much easier than I thought
> at first. Assuming, i386_set_ldt() returns the auto-allocated
> LDT slot we just have to load that into %gs, instead of
> the ldt_index (which points into the ldt_entries array).
>
> So, if someone can tell me what the magic number for
> auto-allocation is I can take care of this tonight. But,
> because I'll be offline soon I'll go ahead and post
> the background on how that code works just in case someone
> needs to mess with it.
>
> The pointers to pthread structures are kept in the array
> ldt_entries[MAX_THR]. Currently, MAX_THR is set to 128, but
> since we start at index NLDT the maximum number of simultaneous
> threads in an application is MAX_THR - NLDT. The global variable
> ldt_free is used to keep track of the next free index in the
> array. To facilitate this, when libthr is first initialized
> each entry in the array contains a pointer to the next free
> index. The ldt_free variable is then set to point to the first
> free entry in the array (ldt_entries[NLDT]) and the contents
> of that index (as preveiously stated) will be a pointer to
> the next free entry in the array (in this case
> ldt_entries[NLDT + 1]). When a new pthread is created, ldt_free
> is dereferenced to find the next empty entry. It is set to this
> entry and the contents of the previous entry it pointed to
> are overwritten with the address of the newly created pthread.
> When a thread exits the array index it occupied is overwritten
> by a pointer to ldt_free and ldt_free is pointed to the
> array index that held the just freed pthread.
>
> Another thing that happens when a new pthread is created is that
> we setup a segment descriptor structure which points into the
> ldt_entries entry we just setup for our newly created pthread.
> This segment descripter pointing into ldt_entries is what is
> passed into i386_set_ldt(). If the call to i386_set_ldt() succeeds
> we then load the LDT index into %gs.
>
> So, there should be no need to bump up any limits or anything
> to accomodate this change.
Code says it so much better than words. Here's a quick attempt
to show you what is needed. I took the liberty of simplifying
it a bit since with auto ldt allocation, I don't think there's
any need to have a predetermined number of slots (it also
eliminates the need to lock the entry array).
Watch out for any line wraps...
--
Dan Eischen
Index: arch/i386/i386/_setcurthread.c
===================================================================
RCS file: /opt/FreeBSD/cvs/src/lib/libthr/arch/i386/i386/_setcurthread.c,v
retrieving revision 1.10
diff -u -r1.10 _setcurthread.c
--- arch/i386/i386/_setcurthread.c 29 Jun 2003 00:12:39 -0000 1.10
+++ arch/i386/i386/_setcurthread.c 5 Aug 2003 23:36:10 -0000
@@ -39,105 +39,34 @@
#include "thr_private.h"
-#define MAXTHR 128
-
-#define LDT_INDEX(x) (((long)(x) - (long)ldt_entries) / sizeof(ldt_entries[0]))
-
-void **ldt_free = NULL;
-void *ldt_entries[MAXTHR];
-static int ldt_inited = 0;
-static spinlock_t ldt_lock = _SPINLOCK_INITIALIZER;
-
-static void ldt_init(void);
-
/* in _curthread.S */
extern void _set_gs(int);
-/*
- * Initialize the array of ldt_entries and the next free slot.
- * This routine must be called with the global ldt lock held.
- */
-static void
-ldt_init(void)
-{
- int i;
-
- ldt_free = &ldt_entries[NLDT];
-
- for (i = 0; i < MAXTHR - 1; i++)
- ldt_entries[i] = (void *)&ldt_entries[i + 1];
-
- ldt_entries[MAXTHR - 1] = NULL;
-
- ldt_inited = 1;
-}
-
void
_retire_thread(void *entry)
{
- _spinlock(&ldt_lock);
- if (ldt_free == NULL)
- *(void **)entry = NULL;
- else
- *(void **)entry = *ldt_free;
- ldt_free = entry;
- _spinunlock(&ldt_lock);
+ int ldt;
+
+ ldt = (int)entry;
+ if (ldt >= 0)
+ i386_set_ldt(ldt, NULL, 1);
}
void *
_set_curthread(ucontext_t *uc, struct pthread *thr, int *err)
{
union descriptor desc;
- void **ldt_entry;
int ldt_index;
- int error;
*err = 0;
-
- /*
- * If we are setting up the initial thread, the gs register
- * won't be setup for the current thread. In any case, we
- * don't need protection from re-entrancy at this point in
- * the life of the program.
- */
- if (thr != _thread_initial)
- _SPINLOCK(&ldt_lock);
-
- if (ldt_inited == NULL)
- ldt_init();
-
- if (ldt_free == NULL) {
- /* Concurrent thread limit reached */
- *err = curthread->error = EAGAIN;
- if (thr != _thread_initial)
- _SPINUNLOCK(&ldt_lock);
- return (NULL);
- }
-
- /*
- * Pull one off of the free list and update the free list pointer.
- */
- ldt_entry = ldt_free;
- ldt_free = (void **)*ldt_entry;
-
- if (thr != _thread_initial)
- _SPINUNLOCK(&ldt_lock);
-
- /*
- * Cache the address of the thread structure here. This is
- * what the gs register will point to.
- */
- *ldt_entry = (void *)thr;
- ldt_index = LDT_INDEX(ldt_entry);
-
bzero(&desc, sizeof(desc));
/*
* Set up the descriptor to point into the ldt table which contains
* only a pointer to the thread.
*/
- desc.sd.sd_lolimit = sizeof(*ldt_entry);
- desc.sd.sd_lobase = (unsigned int)ldt_entry & 0xFFFFFF;
+ desc.sd.sd_lolimit = sizeof(*thr);
+ desc.sd.sd_lobase = (unsigned int)thr & 0xFFFFFF;
desc.sd.sd_type = SDT_MEMRO;
desc.sd.sd_dpl = SEL_UPL;
desc.sd.sd_p = 1;
@@ -145,19 +74,19 @@
desc.sd.sd_xx = 0;
desc.sd.sd_def32 = 1;
desc.sd.sd_gran = 0;
- desc.sd.sd_hibase = (unsigned int)ldt_entry >> 24;
+ desc.sd.sd_hibase = (unsigned int)thr >> 24;
- error = i386_set_ldt(ldt_index, &desc, 1);
- if (error == -1)
- abort();
-
- /*
- * Set up our gs with the index into the ldt for this entry.
- */
- if (uc != NULL)
- uc->uc_mcontext.mc_gs = LSEL(ldt_index, SEL_UPL);
- else
- _set_gs(LSEL(ldt_index, SEL_UPL));
-
- return (ldt_entry);
+ ldt_index = i386_set_ldt(LDT_AUTO_ALLOC, &desc, 1);
+ if (ldt_index < 0)
+ *err = EAGAIN;
+ else {
+ /*
+ * Set up our gs with the ldt index.
+ */
+ if (uc != NULL)
+ uc->uc_mcontext.mc_gs = LSEL(ldt_index, SEL_UPL);
+ else
+ _set_gs(LSEL(ldt_index, SEL_UPL));
+ }
+ return ((void *)ldt_index);
}
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?Pine.GSO.4.10.10308051940540.6797-100000>