Update.

1999-08-02  Jakub Jelinek  <jj@ultra.linux.cz>

	* sysdeps/unix/sysv/linux/sparc/sparc64/sigaction.c (__sigaction):
	Only allow rt signal frames. No SA_SIGINFO signals will have the
	siginfo_t just not filled out with SI_NOINFO code.
	* sysdeps/unix/sysv/linux/sparc/sparc64/register-dump.h
	(register_dump): Take the above change into account.
	* sysdeps/unix/sysv/linux/sparc/sparc64/sigcontextinfo.h
	(rt_signal_frame): Likewise.

	* sysdeps/unix/sysv/linux/sparc/getsysstats.c: New file.

ChangeLog

@@ -1,3 +1,15 @@
+1999-08-02  Jakub Jelinek  <jj@ultra.linux.cz>
+
+	* sysdeps/unix/sysv/linux/sparc/sparc64/sigaction.c (__sigaction):
+	Only allow rt signal frames. No SA_SIGINFO signals will have the
+	siginfo_t just not filled out with SI_NOINFO code.
+	* sysdeps/unix/sysv/linux/sparc/sparc64/register-dump.h
+	(register_dump): Take the above change into account.
+	* sysdeps/unix/sysv/linux/sparc/sparc64/sigcontextinfo.h
+	(rt_signal_frame): Likewise.
+
+	* sysdeps/unix/sysv/linux/sparc/getsysstats.c: New file.
+
 1999-08-02  Thorsten Kukuk  <kukuk@suse.de>
 
 	* nis/nis_callback.c (internal_nis_do_callback) use poll()

FAQ.in

@@ -848,14 +848,12 @@ files.  You don't necessarily need to recompile the GNU C library since the
 only place where OPEN_MAX and FD_SETSIZE is really needed in the library
 itself is the size of fd_set which is used by select.
 
-The GNU C library is now (nearly) select free.  This means it internally has
+The GNU C library is now select free.  This means it internally has no
-no limits imposed by the `fd_set' type.  Instead almost all places where the
+limits imposed by the `fd_set' type.  Instead all places where the
 functionality is needed the `poll' function is used.
 
 If you increase the number of file descriptors in the kernel you don't need
-to recompile the C library.  The remaining select calls are in the RPC code.
+to recompile the C library. 
-If your RPC daemons don't need more than FD_SETSIZE file descriptors, you
-don't need to change anything at all.
 
 {UD} You can always get the maximum number of file descriptors a process is
 allowed to have open at any time using

sysdeps/unix/sysv/linux/sparc/getsysstats.c

@@ -0,0 +1,55 @@
+/* Determine various system internal values, Linux/Sparc version.
+   Copyright (C) 1999 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Andreas Schwab <schwab@suse.de> and
+		  Jakub Jelinek <jj@ultra.linux.cz>
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public
+   License along with the GNU C Library; see the file COPYING.LIB.  If not,
+   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+
+/* We need to define a special parser for /proc/cpuinfo.  */
+#define GET_NPROCS_PARSER(FP, BUFFER, RESULT)				  \
+  do									  \
+    {									  \
+      (RESULT) = 0;							  \
+      /* Find the line that contains the information about the number of  \
+	 active cpus.  We don't have to fear extremely long lines since	  \
+	 the kernel will not generate them.  8192 bytes are really	  \
+	 enough.  */							  \
+      while (fgets_unlocked (BUFFER, sizeof (BUFFER), FP) != NULL)	  \
+	if (sscanf (BUFFER, "ncpus active : %d", &(RESULT)) == 1)	  \
+	  break;							  \
+    }									  \
+  while (0)
+
+
+/* On the Sparc we can distinguish between the number of configured and
+   active cpus.  */
+#define GET_NPROCS_CONF_PARSER(FP, BUFFER, RESULT)			 \
+  do									 \
+    {									 \
+      (RESULT) = 0;							 \
+      /* Find the line that contains the information about the number of \
+	 probed cpus.  We don't have to fear extremely long lines since	 \
+	 the kernel will not generate them.  8192 bytes are really	 \
+	 enough.  */							 \
+      while (fgets_unlocked ((BUFFER), sizeof (BUFFER), (FP)) != NULL)	 \
+	if (sscanf (buffer, "ncpus probed : %d", &(RESULT)) == 1)	 \
+	  break;							 \
+    }									 \
+  while (0)
+
+#include <sysdeps/unix/sysv/linux/getsysstats.c>

sysdeps/unix/sysv/linux/sparc/sparc64/register-dump.h

@@ -39,7 +39,7 @@
  i3: XXXXXXXXXXXXXXXX  i4: XXXXXXXXXXXXXXXX  i5: XXXXXXXXXXXXXXXX
  fp: XXXXXXXXXXXXXXXX  i7: XXXXXXXXXXXXXXXX
 
- Old mask: XXXXXXXX XFSR: XXXXXXXXXXXXXXXX GSR: XX FPRS: X
+ Mask: XXXXXXXXXXXXXXXX XFSR: XXXXXXXXXXXXXXXX GSR: XX FPRS: X
   f0: XXXXXXXXXXXXXXXX   f2: XXXXXXXXXXXXXXXX   f4: XXXXXXXXXXXXXXXX
   f6: XXXXXXXXXXXXXXXX   f8: XXXXXXXXXXXXXXXX  f10: XXXXXXXXXXXXXXXX
  f12: XXXXXXXXXXXXXXXX  f14: XXXXXXXXXXXXXXXX  f16: XXXXXXXXXXXXXXXX
@@ -79,7 +79,7 @@ register_dump (int fd, SIGCONTEXT ctx)
   size_t nr = 0;
   int i;
   struct reg_window *r = (struct reg_window *)
-    ctx->si_regs.u_regs[14];
+    ctx->sf_regs.u_regs[14];
   struct __siginfo_sparc64_fpu *f;
 
 #define ADD_STRING(str) \
@@ -92,15 +92,15 @@ register_dump (int fd, SIGCONTEXT ctx)
   ++nr
 
   /* Generate strings of register contents.  */
-  hexvalue (ctx->si_regs.tstate,	regs[0], 16);
+  hexvalue (ctx->sf_regs.tstate,	regs[0], 16);
-  hexvalue (ctx->si_regs.tpc,		regs[1], 16);
+  hexvalue (ctx->sf_regs.tpc,		regs[1], 16);
-  hexvalue (ctx->si_regs.tnpc,		regs[2], 16);
+  hexvalue (ctx->sf_regs.tnpc,		regs[2], 16);
-  hexvalue (ctx->si_regs.y,		regs[3], 8);
+  hexvalue (ctx->sf_regs.y,		regs[3], 8);
   for (i = 1; i <= 15; i++)
-    hexvalue (ctx->si_regs.u_regs[i], 	regs[3+i], 16);
+    hexvalue (ctx->sf_regs.u_regs[i], 	regs[3+i], 16);
   for (i = 0; i <= 15; i++)
     hexvalue (r->locals[i],		regs[19+i], 16);
-  hexvalue (ctx->si_mask,		regs[35], 8);
+  hexvalue (ctx->sf_mask,		regs[35], 16);
 
   /* Generate the output.  */
   ADD_STRING ("Register dump:\n\n TSTATE: ");
@@ -173,8 +173,8 @@ register_dump (int fd, SIGCONTEXT ctx)
   ADD_MEM (regs[33], 16);
   ADD_STRING ("  i7: ");
   ADD_MEM (regs[34], 16);
-  ADD_STRING ("\n\n Old mask: ");
+  ADD_STRING ("\n\n Mask: ");
-  ADD_MEM (regs[35], 8);
+  ADD_MEM (regs[35], 16);
 
   f = *(struct __siginfo_sparc64_fpu **)(ctx + 1);
   if (f != NULL)

sysdeps/unix/sysv/linux/sparc/sparc64/sigaction.c

@@ -32,24 +32,18 @@ extern int __syscall_rt_sigaction (int, const struct kernel_sigaction *,
 				   size_t);
 
 static void __rt_sigreturn_stub (void);
-static void __sigreturn_stub (void);
 
 int
 __sigaction (int sig, __const struct sigaction *act, struct sigaction *oact)
 {
   int ret;
   struct kernel_sigaction kact, koact;
-  unsigned long stub = 0;
+  unsigned long stub = ((unsigned long) &__rt_sigreturn_stub) - 8;
 
   if (act)
     {
       kact.k_sa_handler = act->sa_handler;
       memcpy (&kact.sa_mask, &act->sa_mask, sizeof (sigset_t));
-      if (((kact.sa_flags = act->sa_flags) & SA_SIGINFO) != 0)
-	stub = (unsigned long) &__rt_sigreturn_stub;
-      else
-	stub = (unsigned long) &__sigreturn_stub;
-      stub -= 8;
       kact.sa_restorer = NULL;
     }
 
@@ -79,12 +73,3 @@ __rt_sigreturn_stub (void)
 	   : /* no outputs */
 	   : "i" (__NR_rt_sigreturn));
 }
-
-static void
-__sigreturn_stub (void)
-{
-  __asm__ ("mov %0, %%g1\n\t"
-	   "ta	0x6d\n\t"
-	   : /* no outputs */
-	   : "i" (__NR_sigreturn));
-}

sysdeps/unix/sysv/linux/sparc/sparc64/sigcontextinfo.h

@@ -17,13 +17,25 @@
    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.  */
 
+struct __rt_signal_frame {
+	siginfo_t	sf_info;
+	struct pt_regs	sf_regs;
+	__siginfo_fpu_t *fpu_save;
+	struct {
+		void	*ss_sp;
+		int	ss_flags;
+		size_t	ss_size;
+	}		sf_stack;
+	unsigned long	sf_mask;
+};
+
 #ifndef STACK_BIAS
 #define STACK_BIAS 2047
 #endif
-#define SIGCONTEXT __siginfo_t *
+#define SIGCONTEXT struct __rt_signal_frame *
-#define GET_PC(__ctx)	((void *) ((__ctx)->si_regs.tpc))
+#define GET_PC(__ctx)	((void *) ((__ctx)->sf_regs.tpc))
 #define ADVANCE_STACK_FRAME(__next) \
 	((void *) &((struct reg_window *) (((unsigned long int) (__next))     \
 					   + STACK_BIAS))->ins[6])
-#define GET_STACK(__ctx)	((void *) ((__ctx)->si_regs.u_regs[14]))
+#define GET_STACK(__ctx)	((void *) ((__ctx)->sf_regs.u_regs[14]))
 #define GET_FRAME(__ctx)	ADVANCE_STACK_FRAME (GET_STACK (__ctx))