* grp.cc: Call gr.refresh() rather than doing isunitialized tests throughout.

(gr): Use constructor (sigh).
(pwdgrp::parse_group): Rename from parse_grp.
(pwdgrp::read_group): Rename from read_etc_group.  Just call gr.load with a
single argument.
* passwd.cc: Call pr.refresh() rather than doing isunitialized tests
throughout.
(pr): Use constructor (sigh).
(pwdgrp::parse_passwd): Rename from "parse_pwd".
(pwdgrp::read_passwd): Rename from read_etc_passwd.  Just call pr.load with a
single argument.
* pwdgrp.h (pwdgrp_state): Eliminate.
(pwdgrp): Reflect above renamings.
(pwdgrp::etc_ix): Rename from pwd_ix.
(pwdgrp::read): New element.
(pwdgrp::lock): New element.
(pwdgrp::refresh): New function.
(pwdgrp::load): Eliminate variations which take buffer arguments.
(pwdgrp::pwdgrp): New constructors.  Initialize mutex here.
* uinfo.cc (pwdgrp::load): Accommodate pwd_ix -> etc_ix renaming.
(pwdgrp::load): Set initialized state to true rather than setting state to
loaded.

winsup/cygwin/ChangeLog

@@ -1,3 +1,29 @@
+2003-01-21  Christopher Faylor  <cgf@redhat.com>
+
+	* grp.cc: Call gr.refresh() rather than doing isunitialized tests
+	throughout.
+	(gr): Use constructor (sigh).
+	(pwdgrp::parse_group): Rename from parse_grp.
+	(pwdgrp::read_group): Rename from read_etc_group.  Just call gr.load
+	with a single argument.
+	* passwd.cc: Call pr.refresh() rather than doing isunitialized tests
+	throughout.
+	(pr): Use constructor (sigh).
+	(pwdgrp::parse_passwd): Rename from "parse_pwd".
+	(pwdgrp::read_passwd): Rename from read_etc_passwd.  Just call pr.load
+	with a single argument.
+	* pwdgrp.h (pwdgrp_state): Eliminate.
+	(pwdgrp): Reflect above renamings.
+	(pwdgrp::etc_ix): Rename from pwd_ix.
+	(pwdgrp::read): New element.
+	(pwdgrp::lock): New element.
+	(pwdgrp::refresh): New function.
+	(pwdgrp::load): Eliminate variations which take buffer arguments.
+	(pwdgrp::pwdgrp): New constructors.  Initialize mutex here.
+	* uinfo.cc (pwdgrp::load): Accommodate pwd_ix -> etc_ix renaming.
+	(pwdgrp::load): Set initialized state to true rather than setting state
+	to loaded.
+
 2003-01-21  Christopher Faylor  <cgf@redhat.com>
 
         * include/cygwin/version.h: Bump DLL minor number.

winsup/cygwin/grp.cc

@@ -29,12 +29,12 @@ details. */
 /* Position in the group cache */
 #define grp_pos _reent_winsup ()->_grp_pos
 
-static pwdgrp gr;
 static __group32 *group_buf;
+static pwdgrp gr (group_buf);
 static char * NO_COPY null_ptr;
 
 bool
-pwdgrp::parse_grp (char *line)
+pwdgrp::parse_group (char *line)
 {
   char *dp = strchr (line, ':');
 
@@ -83,42 +83,18 @@ pwdgrp::parse_grp (char *line)
 # undef grp
 }
 
-class group_lock
-{
-  bool armed;
-  static NO_COPY pthread_mutex_t mutex;
-public:
-  group_lock (bool doit)
-    {
-      if (armed = doit)
-        pthread_mutex_lock (&mutex);
-    }
-  ~group_lock ()
-    {
-      if (armed)
-        pthread_mutex_unlock (&mutex);
-    }
-};
-
-pthread_mutex_t NO_COPY group_lock::mutex = (pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER;
-
 /* Cygwin internal */
 /* Read in /etc/group and save contents in the group cache */
 /* This sets group_in_memory_p to 1 so functions in this file can
    tell that /etc/group has been read in */
-static void
+void
-read_etc_group ()
+pwdgrp::read_group ()
-{
-  group_lock here (cygwin_finished_initializing);
-
-  /* if we got blocked by the mutex, then etc_group may have been processed */
-  if (gr.isinitializing ())
 {
   for (int i = 0; i < gr.curr_lines; i++)
-	if ((group_buf + i)->gr_mem != &null_ptr)
+    if ((*group_buf)[i].gr_mem != &null_ptr)
-	  free ((group_buf + i)->gr_mem);
+      free ((*group_buf)[i].gr_mem);
 
-      if (!gr.load ("/etc/group", group_buf))
+  if (!gr.load ("/etc/group"))
     debug_printf ("gr.load failed");
 
   /* Complete /etc/group in memory if needed */
@@ -144,7 +120,6 @@ read_etc_group ()
   static char NO_COPY pretty_ls[] = "????????::-1:";
   if (wincap.has_security ())
     gr.add_line (pretty_ls);
-    }
   return;
 }
 
@@ -153,8 +128,7 @@ internal_getgrsid (cygsid &sid)
 {
   char sid_string[128];
 
-  if (gr.isuninitialized ())
+  gr.refresh ();
-    read_etc_group ();
 
   if (sid.string (sid_string))
     for (int i = 0; i < gr.curr_lines; i++)
@@ -166,8 +140,7 @@ internal_getgrsid (cygsid &sid)
 struct __group32 *
 internal_getgrgid (__gid32_t gid, bool check)
 {
-  if (gr.isuninitialized () || (check && gr.isinitializing ()))
+  gr.refresh (check);
-    read_etc_group ();
 
   for (int i = 0; i < gr.curr_lines; i++)
     if (group_buf[i].gr_gid == gid)
@@ -178,8 +151,7 @@ internal_getgrgid (__gid32_t gid, bool check)
 struct __group32 *
 internal_getgrnam (const char *name, bool check)
 {
-  if (gr.isuninitialized () || (check && gr.isinitializing ()))
+  gr.refresh (check);
-    read_etc_group ();
 
   for (int i = 0; i < gr.curr_lines; i++)
     if (strcasematch (group_buf[i].gr_name, name))
@@ -242,8 +214,7 @@ endgrent ()
 extern "C" struct __group32 *
 getgrent32 ()
 {
-  if (gr.isinitializing ())
+  gr.refresh ();
-    read_etc_group ();
 
   if (grp_pos < gr.curr_lines)
     return group_buf + grp_pos++;
@@ -269,8 +240,7 @@ setgrent ()
 struct __group32 *
 internal_getgrent (int pos)
 {
-  if (gr.isuninitialized ())
+  gr.refresh ();
-    read_etc_group ();
 
   if (pos < gr.curr_lines)
     return group_buf + pos;

winsup/cygwin/passwd.cc

@@ -26,8 +26,9 @@ details. */
 /* Read /etc/passwd only once for better performance.  This is done
    on the first call that needs information from it. */
 
-static pwdgrp pr;
 passwd *passwd_buf;
+/* FIXME: This really should use a constructor, but they are slow */
+static pwdgrp pr (passwd_buf);
 
 /* Position in the passwd cache */
 #define pw_pos  _reent_winsup ()->_pw_pos
@@ -63,7 +64,7 @@ grab_int (char **p)
 
 /* Parse /etc/passwd line into passwd structure. */
 bool
-pwdgrp::parse_pwd (char *buf)
+pwdgrp::parse_passwd (char *buf)
 {
 # define res (*passwd_buf)[curr_lines]
   /* Allocate enough room for the passwd struct and all the strings
@@ -83,43 +84,14 @@ pwdgrp::parse_pwd (char *buf)
 # undef res
 }
 
-class passwd_lock
-{
-  bool armed;
-  static NO_COPY pthread_mutex_t mutex;
- public:
-  passwd_lock (bool doit)
-  {
-    if (doit)
-      pthread_mutex_lock (&mutex);
-    armed = doit;
-  }
-  ~passwd_lock ()
-  {
-    if (armed)
-      pthread_mutex_unlock (&mutex);
-  }
-};
-
-pthread_mutex_t NO_COPY passwd_lock::mutex = (pthread_mutex_t) PTHREAD_MUTEX_INITIALIZER;
-
 /* Read in /etc/passwd and save contents in the password cache.
    This sets pr to loaded or emulated so functions in this file can
    tell that /etc/passwd has been read in or will be emulated. */
-static void
+void
-read_etc_passwd ()
+pwdgrp::read_passwd ()
 {
-  /* A mutex is ok for speed here - pthreads will use critical sections not
+  if (!load ("/etc/passwd"))
-   * mutexes for non-shared mutexes in the future. Also, this function will
+    debug_printf ("load failed");
-   * at most be called once from each thread, after that the pr
-   * test will succeed */
-  passwd_lock here (cygwin_finished_initializing);
-
-  /* if we got blocked by the mutex, then etc_passwd may have been processed */
-  if (pr.isinitializing ())
-    {
-      if (!pr.load ("/etc/passwd", passwd_buf))
-	debug_printf ("pr.load failed");
 
   char strbuf[128] = "";
   bool searchentry = true;
@@ -152,7 +124,6 @@ read_etc_passwd ()
       debug_printf ("Completing /etc/passwd: %s", linebuf);
       pr.add_line (linebuf);
     }
-    }
   return;
 }
 
@@ -163,8 +134,7 @@ internal_getpwsid (cygsid &sid)
   char *ptr1, *ptr2, *endptr;
   char sid_string[128] = {0,','};
 
-  if (pr.isuninitialized ())
+  pr.refresh ();
-    read_etc_passwd ();
 
   if (sid.string (sid_string + 2))
     {
@@ -182,8 +152,7 @@ internal_getpwsid (cygsid &sid)
 struct passwd *
 internal_getpwuid (__uid32_t uid, bool check)
 {
-  if (pr.isuninitialized () || (check && pr.isinitializing ()))
+  pr.refresh (check);
-    read_etc_passwd ();
 
   for (int i = 0; i < pr.curr_lines; i++)
     if (uid == (__uid32_t) passwd_buf[i].pw_uid)
@@ -194,8 +163,7 @@ internal_getpwuid (__uid32_t uid, bool check)
 struct passwd *
 internal_getpwnam (const char *name, bool check)
 {
-  if (pr.isuninitialized () || (check && pr.isinitializing ()))
+  pr.refresh (check);
-    read_etc_passwd ();
 
   for (int i = 0; i < pr.curr_lines; i++)
     /* on Windows NT user names are case-insensitive */
@@ -316,8 +284,7 @@ getpwnam_r (const char *nam, struct passwd *pwd, char *buffer, size_t bufsize, s
 extern "C" struct passwd *
 getpwent (void)
 {
-  if (pr.isinitializing ())
+  pr.refresh ();
-    read_etc_passwd ();
 
   if (pw_pos < pr.curr_lines)
     return passwd_buf + pw_pos++;
@@ -355,8 +322,7 @@ getpass (const char * prompt)
   char *pass=_reent_winsup ()->_pass;
   struct termios ti, newti;
 
-  if (pr.isinitializing ())
+  pr.refresh ();
-    read_etc_passwd ();
 
   cygheap_fdget fhstdin (0);
 

winsup/cygwin/pwdgrp.h

@@ -21,59 +21,61 @@ extern struct __group32 *internal_getgrnam (const char *, bool = FALSE);
 extern struct __group32 *internal_getgrent (int);
 int internal_getgroups (int, __gid32_t *, cygsid * = NULL);
 
-enum pwdgrp_state {
-  uninitialized = 0,
-  initializing,
-  loaded
-};
-
 class pwdgrp
 {
-  pwdgrp_state state;
+  unsigned pwdgrp_buf_elem_size;
-  int pwd_ix;
-  path_conv pc;
-  char *buf;
-  int max_lines;
   union
   {
     passwd **passwd_buf;
     __group32 **group_buf;
     void **pwdgrp_buf;
   };
-  unsigned pwdgrp_buf_elem_size;
+  void (pwdgrp::*read) ();
   bool (pwdgrp::*parse) (char *);
+  int etc_ix;
+  path_conv pc;
+  char *buf;
+  int max_lines;
+  bool initialized;
+  CRITICAL_SECTION lock;
 
   char *gets (char*&);
-  bool parse_pwd (char *);
-  bool parse_grp (char *);
 
 public:
   int curr_lines;
 
+  bool parse_passwd (char *);
+  bool parse_group (char *);
+  void read_passwd ();
+  void read_group ();
+
   void add_line (char *);
-  bool isinitializing ()
+  void refresh (bool check = true)
   {
-    if (state <= initializing)
+    if (initialized && check && etc::file_changed (etc_ix))
-      state = initializing;
+      initialized = false;
-    else if (etc::file_changed (pwd_ix))
+    if (!initialized)
-      state = initializing;
+      {
-    return state == initializing;
+	EnterCriticalSection (&lock);
+	if (!initialized)
+	  (this->*read) ();
+	LeaveCriticalSection (&lock);
+      }
   }
-  bool isuninitialized () const { return state == uninitialized; }
 
   bool load (const char *);
-  bool load (const char *posix_fname, passwd *&buf)
+  pwdgrp (passwd *&pbuf) :
+    pwdgrp_buf_elem_size (sizeof (*pbuf)), passwd_buf (&pbuf)
     {
-    passwd_buf = &buf;
+      read = &pwdgrp::read_passwd;
-    pwdgrp_buf_elem_size = sizeof (*buf);
+      parse = &pwdgrp::parse_passwd;
-    parse = &pwdgrp::parse_pwd;
+      InitializeCriticalSection (&lock);
-    return load (posix_fname);
     }
-  bool load (const char *posix_fname, __group32 *&buf)
+  pwdgrp (__group32 *&gbuf) :
+    pwdgrp_buf_elem_size (sizeof (*gbuf)), group_buf (&gbuf)
     {
-    group_buf = &buf;
+      read = &pwdgrp::read_group;
-    pwdgrp_buf_elem_size = sizeof (*buf);
+      parse = &pwdgrp::parse_group;
-    parse = &pwdgrp::parse_grp;
+      InitializeCriticalSection (&lock);
-    return load (posix_fname);
     }
 };

winsup/cygwin/uinfo.cc

@@ -429,7 +429,7 @@ pwdgrp::load (const char *posix_fname)
   buf = NULL;
 
   pc.check (posix_fname);
-  pwd_ix = etc::init (pwd_ix, pc);
+  etc_ix = etc::init (etc_ix, pc);
 
   paranoid_printf ("%s", posix_fname);
 
@@ -470,6 +470,6 @@ pwdgrp::load (const char *posix_fname)
 	}
     }
 
-  state = loaded;
+  initialized = true;
   return res;
 }