Holy! Kernel spawns 16k threads and growing!

My 10.7.5 has serious issue.
The kernel process spawn threads non-stop, and continues to eat up all available RAM. Number of threads is 16k and growing. Real Mem is at 800MB and growing.
In Console, I have tons of these :
28/9/12 12:49:31.000 AM kernel: Backtrace 0xffffff80006288b3 0xffffff8000623068 0xffffff7f81f3894e 0xffffff7f824d9db0 0xffffff7f824e1909 0xffffff7f824db981 0xffffff7f824e0f7c
28/9/12 12:49:31.000 AM kernel: Kernel Extensions in backtrace:
28/9/12 12:49:31.000 AM kernel: com.apple.iokit.IOAudioFamily(1.8.6f18)[8D690452-BF17-3DA0-BCAD-F1BCF1495926]@0 xffffff7f81f33000->0xffffff7f81f5ffff
28/9/12 12:49:31.000 AM kernel: dependency: com.apple.kext.OSvKernDSPLib(1.3)[3D9EA2A9-E433-3F0A-AEFC-24E4B964505E]@0xfffff f7f81f2d000
28/9/12 12:49:31.000 AM kernel: com.apple.driver.AppleHDA(2.2.5a5)[AF748B07-3A60-38D7-805E-7E9E351F4A0F]@0xffff ff7f824c7000->0xffffff7f82541fff
28/9/12 12:49:31.000 AM kernel: dependency: com.apple.driver.AppleHDAController(2.2.5a5)[D206E58E-D672-3190-8B19-40E17F0050 67]@0xffffff7f82408000
28/9/12 12:49:31.000 AM kernel: dependency: com.apple.iokit.IONDRVSupport(2.3.4)[7C8672C4-8B0D-3CCF-A79A-23C62E90F895]@0xff ffff7f808de000
28/9/12 12:49:31.000 AM kernel: dependency: com.apple.iokit.IOAudioFamily(1.8.6fc18)[8D690452-BF17-3DA0-BCAD-F1BCF1495926]@ 0xffffff7f81f33000
28/9/12 12:49:31.000 AM kernel: dependency: com.apple.iokit.IOHDAFamily(2.2.5a5)[D49E7BD7-D244-36F1-81FD-C4C3269A3D71]@0xff ffff7f823f9000
28/9/12 12:49:31.000 AM kernel: dependency: com.apple.iokit.IOGraphicsFamily(2.3.4)[D0A1F6BD-E66E-3DD8-9913-A3AB8746F422]@0 xffffff7f808a5000
28/9/12 12:49:31.000 AM kernel: dependency: com.apple.driver.DspFuncLib(2.2.5a5)[DF597284-FA3E-332E-A827-D8D68044663D]@0xff ffff7f8241c000
28/9/12 12:49:31.000 AM kernel: AppleHDAEngineOutput: bad busy count (255,1)
This list of error msg repeats continuosly too!
Christ, am I having HW problems?!

Same problem here. MacBook Pro, OS X 10.7.5.
90,371 (...) kernel_tasks... and a kernel.log full with these msgs:
Jul 17 14:55:14 ErwinsMacBook kernel[0]: Kernel Extensions in backtrace:
Jul 17 14:55:14 ErwinsMacBook kernel[0]: com.apple.iokit.IOAudioFamily(1.8.6f18)[8D690452-BF17-3DA0-BCAD-F1BCF1495926]@0 xffffff7f81eed000->0xffffff7f81f19fff
Jul 17 14:55:14 ErwinsMacBook kernel[0]: dependency: com.apple.kext.OSvKernDSPLib(1.3)[3D9EA2A9-E433-3F0A-AEFC-24E4B964505E]@0xfffff f7f81ee7000
Jul 17 14:55:14 ErwinsMacBook kernel[0]: com.apple.driver.AppleHDA(2.2.5a5)[AF748B07-3A60-38D7-805E-7E9E351F4A0F]@0xffff ff7f8247c000->0xffffff7f824f6fff
Jul 17 14:55:14 ErwinsMacBook kernel[0]: dependency: com.apple.driver.AppleHDAController(2.2.5a5)[D206E58E-D672-3190-8B19-40E17F0050 67]@0xffffff7f823bd000
Jul 17 14:55:14 ErwinsMacBook kernel[0]: dependency: com.apple.iokit.IONDRVSupport(2.3.4)[7C8672C4-8B0D-3CCF-A79A-23C62E90F895]@0xff ffff7f808ed000
Jul 17 14:55:14 ErwinsMacBook kernel[0]: dependency: com.apple.iokit.IOAudioFamily(1.8.6fc18)[8D690452-BF17-3DA0-BCAD-F1BCF1495926]@ 0xffffff7f81eed000
Jul 17 14:55:14 ErwinsMacBook kernel[0]: dependency: com.apple.iokit.IOHDAFamily(2.2.5a5)[D49E7BD7-D244-36F1-81FD-C4C3269A3D71]@0xff ffff7f823ae000
Jul 17 14:55:14 ErwinsMacBook kernel[0]: dependency: com.apple.iokit.IOGraphicsFamily(2.3.4)[D0A1F6BD-E66E-3DD8-9913-A3AB8746F422]@0 xffffff7f808b4000
Jul 17 14:55:14 ErwinsMacBook kernel[0]: dependency: com.apple.driver.DspFuncLib(2.2.5a5)[DF597284-FA3E-332E-A827-D8D68044663D]@0xff ffff7f823d1000
Jul 17 14:55:14 ErwinsMacBook kernel[0]: AppleHDAEngineOutput: bad busy count (255,1)
Jul 17 14:55:14 ErwinsMacBook kernel[0]: Backtrace 0xffffff80006288b3 0xffffff8000623068 0xffffff7f81ef294e 0xffffff7f8248edb0 0xffffff7f82496909 0xffffff7f82490981 0xffffff7f82495f7c
It appears to be related (cause or effect) to non-functional head phone output.

Similar Messages

Spawning multiple threads ?

Hi,
          In our application, the content of the main page is being
          retrieved from different databases. All the requests originiate from
          one JSP to different databases to retrieve the info. As the JSP
          processes each of the request sequentailly, there is considerable delay
          before the contents are displayed to the user.
          What I want to acheive is spawn multiple threads and display the content
          to the user in fractions as each thread returns. For eaxmple, if the
          user has subscribed to three news servers.. I want to be able to
          display the news from first server to the user without waiting to
          recieve response from the other two servers.
          What is the best approach to follow for such requirements ?? Any
          thoughts on this would be highly appreciated.
          Thanks,
          Sam


I think you may need to spawn it into HTML frame. Each frame will perform
          and download independently.
          Is it what you need ?
          Siros
          "sam ernie" <[email protected]> wrote in message
          news:[email protected]..
          > Hi,
          >
          > In our application, the content of the main page is being
          > retrieved from different databases. All the requests originiate from
          > one JSP to different databases to retrieve the info. As the JSP
          > processes each of the request sequentailly, there is considerable delay
          > before the contents are displayed to the user.
          >
          > What I want to acheive is spawn multiple threads and display the content
          > to the user in fractions as each thread returns. For eaxmple, if the
          > user has subscribed to three news servers.. I want to be able to
          > display the news from first server to the user without waiting to
          > recieve response from the other two servers.
          >
          > What is the best approach to follow for such requirements ?? Any
          > thoughts on this would be highly appreciated.
          >
          > Thanks,
          >
          > Sam
          >

Servlet spawning multiple threads causes server to freeze PC

I'm attempting to write a servlet which, upon receipt of a particular GET request, spawns a thread to do various work which can then be queried by a different GET request. A third type of GET request stops a specified thread.
This is working fine, except that I can only seem to have spawned one thread at a time. When I spawn another thread, my entire PC stops responding (even Windows Task Manager becomes so sluggish that I cannot kill the server) , and I have to do a hard reset of my PC. I'm using Sun Java System Application Server. The server logs do not contain any errors. I've tried the NetBeans debugger a bit, and it seems to happen when I call the start() method of the Thread.
This is my first experience with servlets, as well as my first experience with Sun Java System Application Server. I'm also not a Java expert by any means. I'm sure I'm doing something stupid, but I haven't a clue what.
I can post my code if necessary, but does anyone have any idea what could be causing the server to stop responding just because a servlet spawns two threads? Should I post my code?
Sorry if this is a n00b question. Thanks in advance.

I think you may need to spawn it into HTML frame. Each frame will perform
          and download independently.
          Is it what you need ?
          Siros
          "sam ernie" <[email protected]> wrote in message
          news:[email protected]..
          > Hi,
          >
          > In our application, the content of the main page is being
          > retrieved from different databases. All the requests originiate from
          > one JSP to different databases to retrieve the info. As the JSP
          > processes each of the request sequentailly, there is considerable delay
          > before the contents are displayed to the user.
          >
          > What I want to acheive is spawn multiple threads and display the content
          > to the user in fractions as each thread returns. For eaxmple, if the
          > user has subscribed to three news servers.. I want to be able to
          > display the news from first server to the user without waiting to
          > recieve response from the other two servers.
          >
          > What is the best approach to follow for such requirements ?? Any
          > thoughts on this would be highly appreciated.
          >
          > Thanks,
          >
          > Sam
          >

Java threads and WinLogon processes taking CPU!

We are seeing a strange problem. We have a multi-threaded java application
that is deployed on a Microsoft Windows 2000 server (SP4) with Citrix
Metaframe XP (Feature release 2). When this application starts, we start to see
multiple WINLOGON.EXE processes (20 plus) each taking up 1-2% of CPU -
this raises the CPU usage on the server significantly, impacting performance.
We have tested with JDK 1.3, 1.4, and 1.5 and see the same issues. If we
run the java application in a single thread, we dont see the same issue.
Has any one seen this problem before? Any suggestion on how this can be resolved?
Thanks in advance!

Thanks for your replies. This is a Citrix environment where there are 50 plus
users logged in and there are 50 plus instances of Winlogon.exe always
running. Most of the time the cpu usage of these processes is 0.
We tried a multi-threaded program that lists files in a directory every few
seconds. There are 40 plus servers in the farm that we are deploying this
application on. We are seeing this problem on only some of the servers.
If we run a single thread from main(), we dont see the issue. But if we spawn
10 threads doing the scans periodically, we notice that as soon as all the threads
start, the WinLogons appear to start to take up CPU. When we stop the java
program, the WinLogon processes drop in CPU usage.
Is it possible that Java and WinLogon share some dlls that could be triggering
the WinLogon processes off?
We have tried running the single thread and multi-threaded programs around
same time and the correlation with the winlogons is clearly visible. If we add
sleep() soon after we start a thread, the winlogons seem to kick in later.

Kernel parameters -maximum threads per process

How can we change the kernel parameters also how can we increase the maximum number of threads allowed .
How can we increase maimum perocess per used id .

There is no kernel parameter limiting the maximum
number of threads allowed. If you are talking about
user level threads, you will run into virtual address
space limitations at about 3000 for a process
assuming 32-bit address space and default
stack size of 1M per thread, and assuming you are
not using the alternate thread library (see threads(3thr))
or Solaris 9. If you need more than this many
threads at the same time, I suspect you are doing something
incorrectly. Otherwise, try using a smaller stack size
per thread. If you are running on Solaris 9, or using
the alternate thread library, both give you a 1x1
thread model, i.e., each user thread has a corresponding
kernel entity (lwp). In this case, you will cause
your machine to hang by eating up all available
space for lwp's. In either case, the question should be:
"how do I limit the number of threads per process?", since
there is currently no limitation other than space.
In Solaris 9, you can use resource management to
limit the number of lwp's (and therefore user threads)
per process.

Sys_refcursor spawning maximum threads

Hello All , i have a procedure which outputs 10 refcursors. It is called called by a .NET utility which then writes the data to 18 different flat files. The proc is of below format
CREATE OR REPLACE PROCEDURE FILE_EXTRACT
(OUTREC1 OUT SYS_REFCURSOR,
OUTREC2 OUT SYS_REFCURSOR,)
AS
BEGIN
OPEN OUTREC1 FOR
SELECT /*+PARALLEL(A,8)*/
COL1,COL2
FROM TABLE A;
OPEN OUTREC2 FOR
SELECT /*+PARALLEL(B,8)*/
COL1,COL2
FROM TABLE B;
I have used parallel hint because all the tables used in the queries a huge tables and this is a nightly batch job. The issue here is that i have expected oracle to use 8 processes for this execution so all my select statements have parallel hint with degree 8 , but unusaully the procedure is erroring out on production databases because of maximum number of connections are being spawned and the database is not able to create any new session.
When i debuged and did a quick test proc where i used only one out refcursor it ran only 9 threads . then i ran by adding one more out ref cursor it spawn 17 threads. I think its the way .NET is fetching data from each of these cursors.When i print the first refcursor i do see queries which are running for the second along with the first causing the parallel queries run more than expected. The cause of the problem here is all the refcursors are executed and waiting to return data. SO when .net starts reading first cursor the other queries also run.
Can somebody suggest me a better approach where we are not using lots of processes and still try to parallise things ??

I have checked the open cursor of my session:
SQL> SELECT o.sid, s.username, substr(machine,1,32),
count(*)
2 FROM v$open_cursor o, v$session s
3 WHERE o.sid = s.sid
4 GROUP BY o.sid, s.username, machine
5 HAVING COUNT(*) > 1
6 ORDER BY count(*) desc;
SID USERNAME
SUBSTR(MACHINE,1,32)
COUNT(*)
146 MAD bello
557This proves nothing as the cursors may have been closed after the SQL finished.
The problem is that for each row of data you are opening a ref cursor, but these opened cursors are not being closed for each row.
Can you not just join to the address table that is in the function and retrieve the data as an additional column? It doesn't really seem like you need to use a function in this case.
Also bear in mind that calling user defined functions from within SQL causes a performance issue when dealing with lots of rows of data due to the context switching between SQL and PL/SQL that has to take place.
If you can do it just in SQL then do that. Ony resort to PL/SQL when absolutely necessary.

Question about using threads and synchronizing objects

Hi all,
I am not that familiar and I have 2 questions.
QUESTION 1
I have a server which just sits and accepts incomming connections, then I spawn off a new thread which implements Runnable, and then call the run method. But the loop would not iterate, it would just sit inside the run method (which has rather long loop in it). I changed the class to extend Thread and called the start() method, rather than run(), and everything worked out fine.
Anyone know why this is?
QUESTION 2
So I am building a client server chat application where a user can be in multiple chat rooms. I have this personObject which has output/input streams. In the personObject, I create writeObject/ readObject method, which simply does as it implies.
I figured that I should make these methods synchronized, to ensure things run smoothly. however, when I made a call to readObject, which sat there and waited, and then made a call to writeObject, I would not enter the writeObject method. I took out the synchronized on the writeObject, and everything worked out fine.
I was under the assumption that synchronizing a method only synchronized on that method, not on the whole class. How come then was I not able to enter the writeObject method?
The more I think about it, I don't think I need to have these methods synchronized, but I thought it wouldn't hurt.
Thanks for the help.

Hi all,
I am not that familiar and I have 2 questions.
QUESTION 1
I have a server which just sits and accepts incomming
connections, then I spawn off a new thread which
implements Runnable, and then call the run method.
But the loop would not iterate, it would just sit
inside the run method (which has rather long loop in
it). I changed the class to extend Thread and called
the start() method, rather than run(), and everything
worked out fine.
Anyone know why this is?
You should still implement Runnable, rather than extending Thread. Like this: Runnable r = new MyRunnable();
Thread t = new Thread(r);
t.start(); run() is just another method. Nothing special about it as far as multithreading or anything else goes.
start() is the method that actually spawns a new thread of execution.
I was under the assumption that synchronizing a
method only synchronized on that method, not on the
whole class. How come then was I not able to enter
the writeObject method?When you synchronize, you obtain a lock. As long as you hold that lock--until you exit the sync block or call wait()--no other thread can enter that block or any other block that obtains the same lock.
Two synchronized methods on the same object rely on obtaining the same lock--there's one lock for each object.

Why are the weblogic.kernel.Default Execute Threads used by WLS Kernel

In my Admin Console, it's displaying 10 out of the 15 weblogic.kernel.Default Execute Threads are used by the WLS Kernel user. The total requests column for these threads are showing 0. The other 5 threads are showing 20K to 40K requests. Why is the WLS Kernel users hogging these threads and not allowing the applications to use them?

Hi,
As work enters a WebLogic Server, it is placed in an execute queue. This work is then assigned to a thread within the queue that performs the work.
By default, a new server instance is configured with a default execute queue, weblogic.kernel.default, that contains 15 threads.
Go through the following link and find the usefull information on this issue.
http://e-docs.bea.com/wls/docs81/ConsoleHelp/domain_executequeuetable.html
Regards
Anilkumar kari

Does setQueryTimeout still spawn a thread with Microsoft JDBC Driver 4.0?

Hi,
Does setQueryTimeout still spawn a thread with Microsoft JDBC Driver 4.0?
This link here indicates this was fixed awhile ago:
http://msdn.microsoft.com/en-us/sqlserver/aa937724.aspx
However, we are using Microsoft JDBC Driver 4.0 but are noticing that a setQueryTimeout thread is being spawned (of class com.microsoft.sqlserver.jdbc.TimeoutTimer) for every query we execute.
And, the thread seems to stay around even after the query has finished executing.
Can anyone confirm whether this is actually fixed?
Or, does anyone have any ideas how we can avoid having a new thread spawned for monitoring for a query timeout?
Thanks!

Hi,
Does setQueryTimeout still spawn a thread with Microsoft JDBC Driver 4.0?
This link here indicates this was fixed awhile ago:
http://msdn.microsoft.com/en-us/sqlserver/aa937724.aspx
However, we are using Microsoft JDBC Driver 4.0 but are noticing that a setQueryTimeout thread is being spawned (of class com.microsoft.sqlserver.jdbc.TimeoutTimer) for every query we execute.
And, the thread seems to stay around even after the query has finished executing.
Can anyone confirm whether this is actually fixed?
Or, does anyone have any ideas how we can avoid having a new thread spawned for monitoring for a query timeout?
Thanks!

Pass messages between main thread and FX application thread

I'm launching an FX Application thread from a Main thread using Application.launch [outlined here: {thread:id=2530636}]
I'm trying to have the Aplication thread return information to the Main thread, but Application.launch returns void. Is there an easy way to communicate between the Main thread and the Application thread?
So far I have googled and found:
- MOM (Message Orientated Middleware)
- Sockets
Any thoughts/ideas/examples are appreciated - especially examples ;) - right now I am looking at using Sockets to show/hide the application and for passing data.
What is the preferred method? Are there others which I have not found (gasp) via Google?
Dave.
Edited by: cr0ck3t on 30-Apr-2013 21:04
Edited by: cr0ck3t on 30-Apr-2013 21:05

Is there an easy way to get a reference to these objects from both the Main thread and the FX Application thread - called via Application.launch() from the Main thread? Or do I have to use Sockets or MOM?Not much to do with concurrent programming is what I would call easy. It seems easy - but it's not.
You can kind of do what you are describing using Java concurrency constructs without using sockets or some Message Oriented Middleware (MOM) package.
With the Java concurrency stuff you are really implementing your own form or lightweight MOM.
If you have quite a complex application with lots of messages going back and forth then some kind of MOM package such as camel or ActiveMQ (http://camel.apache.org) is useful.
You can find a sample of various thread interactions with JavaFX here:
https://gist.github.com/jewelsea/5500981 "Simulation of dragons eating dwarves using multiple threads"
Linked code is just demo-ware to try out different concurrency facilities and not necessarily a recommended strategy.
If your curious, you could take a look at it and try to work out what it is, what it does and how it does it.
The main pattern followed is that from a blocking queue:
http://docs.oracle.com/javase/6/docs/api/java/util/concurrent/BlockingQueue.html
Note that once you call launch from the main thread, no subsequent statements in the main method will be run until the JavaFX application shuts down. So you can't really launch from the main thread and communicate with a JavaFX app from the main thread. Instead you need to spawn another thread (or set of threads) for communication with the JavaFX app.
But really, in most cases, the best solution with concurrency is not to deal with it at all (or at least as little as possible). Write everything in JavaFX, use the JavaFX animation framework for timing related stuff and use the JavaFX concurrency utilities for times when you really need multiple thread interaction.
http://docs.oracle.com/javafx/2/threads/jfxpub-threads.htm
To get further help, you might be better off describing exactly (i.e. really specific) what you are trying to do in a new question, perhaps with a sample solution in an sscce http://sscce.org

Kernels 3.10.6 and 3.10.7 fail to boot with EFI stub

Been using rEFInd for some time now. Current installed version is 0.7.1. Kernels 3.10.5 and earlier would boot without incident. Yesterday I upgraded to 3.10.6 and boot failed. As a workaround, I copied the Liquorix kernel and initramfs from my Kubuntu partition; to my mild surprise, this worked. My next test was to install the 3.10.7 Zen kernel from heftig's repository. This kernel boots fine (I added a version number string to the name of the kernel image and the initramfs so that rEFInd would automatically match them). After that, I enabled Arch testing and updated the Arch kernel to 3.10.7; this also fails to boot just like the 3.10.6 kernel did.
I'm a fan of boot text, so I've configured rEFInd in text mode only. Here's my refind.conf, with almost no changes from defaults:
timeout 20
textonly 1
use_graphics_for
scan_all_linux_kernels
And my /boot/refind_linux.conf:
"Boot to X" "ro root=/dev/sda3 nox2apic nmi_watchdog=0 elevator=noop acpi_osi=Linux pcie_aspm=force raid=noautodetect systemd.unit=graphical.target"
"Boot to single user" "ro root=/dev/sda3 nox2apic nmi_watchdog=0 elevator=noop acpi_osi=Linux pcie_aspm=force raid=noautodetect systemd.unit=multi-user.target"
# "Boot to recovery" "ro root=/dev/sda3 nox2apic nomodeset systemd.unit=rescue.target"
Finally, details abot my laptop -- a ThinkPad T520:
steve@t520 ~ $ inxi -xxSMCGDp
System: Host: t520 Kernel: 3.10.7-1-zen x86_64 (64 bit, gcc: 4.8.1)
Desktop: KDE 4.11.00 (Qt 4.8.5) dm: kdm Distro: Arch Linux
Machine: System: LENOVO product: 423926U version: ThinkPad T520 Chassis: type: 10
Mobo: LENOVO model: 423926U Bios: LENOVO version: 8AET63WW (1.43 ) date: 05/08/2013
CPU: Dual core Intel Core i7-2620M CPU (-HT-MCP-) cache: 4096 KB flags: (lm nx sse sse2 sse3 sse4_1 sse4_2 ssse3 vmx) bmips: 10769.3
Clock Speeds: 1: 1188.00 MHz 2: 1809.00 MHz 3: 1809.00 MHz 4: 1080.00 MHz
Graphics: Card: NVIDIA GF119M [Quadro NVS 4200M] bus-ID: 01:00.0 chip-ID: 10de:1057
X.Org: 1.14.2 driver: nvidia Resolution: [email protected]
GLX Renderer: NVS 4200M/PCIe/SSE2 GLX Version: 4.3.0 NVIDIA 325.15 Direct Rendering: Yes
Drives: HDD Total Size: 1256.3GB (8.2% used)
1: id: /dev/sda model: M4 size: 256.1GB serial: 000000001140031E608A temp: 0C
2: id: /dev/sdb model: HGST_HTS721010A9 size: 1000.2GB serial: JG40006PG61HKC temp: 43C
Partition: ID: / size: 108G used: 37G (37%) fs: ext4
ID: /boot/efi size: 511M used: 3.1M (1%) fs: vfat
ID: /mnt/kubuntu size: 118G used: 59G (53%) fs: ext4
ID: swap-1 size: 9.64GB used: 0.00GB (0%) fs: swap
Last edited by steveriley (2013-08-19 05:27:15)

Steve, your picture is far too large for these forums. You are going to want to put it in some kind of a picture sharing/hosting site and link back to it. Otherwise it will end up disappeared (likely via black magic) from your post. I don't think that it provides any useful information anyway. If you want to post your kernel command line that is great. But posting a picture of a frozen screen with no output... doesn't really do much good.
Efistub has been a bit shaky since 3.6 actually. There is a monster thread about this already, the title of which references 3.6, but the content continues on through several kernel releases. Still people continually report this as being an issue. What I do is I keep a normal efi bootloader (one that doesn't rely on efistub) at the ready all the time. My choice was elilo, but since [testing] started including syslinux-efi in the syslinxu package, I have started using that... though I still have elilo set up.
Can you boot with efistub from the UEFI Shell or gummiboot? I prefer gummiboot, but I have had this problem in the past, and when I did, I was able to boot with rEFInd... which was strange. Some people even report that simply having a direct efibootmgr entry in their firmware causes it to magically work. Though there should be to reasonable explanation for this, it was confirmed by several people in the mentioned thread.

Kernel panic with ipf and patch 125014-02?

Hi,
After bringing a bunch of Sparc servers running Solaris 10 up to current patch level I've been experiencing strange and unstable behavior. All servers are running with an ipfilter configuration.
One server has been freezing on the network interface at least once every day without any syslog notice. A reboot is the only way up again.
Now today one server (a Internet proxy server) did a kernel panic twice - never seen that before on this server.
It seems like it was caused by the kernel module ipf. And since it has never happend before I guess it could be caused by the IP filter patch 125014-02.
Anyone experiencing something similar and am I on the right track with suspecting this patch to be bad?
Thanks
Kasper
Message from syslog:
Feb 20 14:53:00 ceres unix: [ID 836849 kern.notice]
Feb 20 14:53:00 ceres ^Mpanic[cpu0]/thread=2a10053dcc0:
Feb 20 14:53:00 ceres unix: [ID 340138 kern.notice] BAD TRAP: type=31 rp=2a10053ca70 addr=18 mmu_fsr=0 occurred in module "ipf" due to a NULL pointer dereference
Feb 20 14:53:00 ceres unix: [ID 100000 kern.notice]
Feb 20 14:53:00 ceres unix: [ID 839527 kern.notice] sched:
Feb 20 14:53:00 ceres unix: [ID 520581 kern.notice] trap type = 0x31
Feb 20 14:53:00 ceres unix: [ID 381800 kern.notice] addr=0x18
Feb 20 14:53:00 ceres unix: [ID 101969 kern.notice] pid=0, pc=0x7bb3ad30, sp=0x2a10053c311, tstate=0x80001602, context=0x0
Feb 20 14:53:00 ceres unix: [ID 743441 kern.notice] g1-g7: 0, 0, 2621c, 1aa10, ea0a, 16, 2a10053dcc0
Feb 20 14:53:00 ceres unix: [ID 100000 kern.notice]
Feb 20 14:53:00 ceres genunix: [ID 723222 kern.notice] 000002a10053c790 unix:die+78 (31, 2a10053ca70, 18, 0, 2a10053c850, 1076000)
Feb 20 14:53:00 ceres genunix: [ID 179002 kern.notice] %l0-3: 0000000000001fff 0000000000000031 0000000001000000 0000000000002000
Feb 20 14:53:00 ceres %l4-7: 000000000181a1d8 000000000181a000 0000000000000000 00000000e85e2018
Feb 20 14:53:00 ceres genunix: [ID 723222 kern.notice] 000002a10053c870 unix:trap+9d4 (2a10053ca70, 10000, 1fff, 5, 0, 1)
Feb 20 14:53:00 ceres genunix: [ID 179002 kern.notice] %l0-3: 0000000000000000 00000000018364c0 0000000000000031 0000000000000000
Feb 20 14:53:00 ceres %l4-7: ffffffffffffe000 0000000000f250af 0000000000000001 0000000000000005
Feb 20 14:53:01 ceres genunix: [ID 723222 kern.notice] 000002a10053c9c0 unix:ktl0+48 (b80c, c006, b7f2, 3511, 1a, 82e1)
Feb 20 14:53:01 ceres genunix: [ID 179002 kern.notice] %l0-3: 0000000000000003 0000000000001400 0000000080001602 000000000101aa04
Feb 20 14:53:01 ceres %l4-7: 0000000000000008 00000600009a6e04 0000000000000006 000002a10053ca70
Feb 20 14:53:01 ceres genunix: [ID 562518 kern.notice] 000002a10053cb10 6 (0, 600009a6df0, 4, 600009a6e04, f332, 0)
Feb 20 14:53:01 ceres genunix: [ID 179002 kern.notice] %l0-3: 00000600009a6e14 0000000000000014 0000000000000006 0000000000000014
Feb 20 14:53:01 ceres %l4-7: 0000000000000028 0000000000000005 0000000000000045 0000000000000000
Feb 20 14:53:01 ceres genunix: [ID 723222 kern.notice] 000002a10053cbc0 ipf:appr_check+32c (2a10053cff8, 60002a0ef00, 0, 2a10053d000, 600010ad7b0, 0)
Feb 20 14:53:01 ceres genunix: [ID 179002 kern.notice] %l0-3: 0000000000000000 00000600009a6df0 00000600009a6e04 0000000000000000
Feb 20 14:53:01 ceres %l4-7: 000000000000ffff 00000000701734b8 000000000000ffff 000000000000fc00
Feb 20 14:53:01 ceres genunix: [ID 723222 kern.notice] 000002a10053cc70 ipf:fr_natout+248 (2a10053cff8, 60002a0ef00, 1, 600009a6e14, a85a, fffff4e3)
Feb 20 14:53:01 ceres genunix: [ID 179002 kern.notice] %l0-3: 0000000000000000 000006000115b500 0000060002a0f008 00000600009a6df0
Feb 20 14:53:01 ceres %l4-7: 0000000082e13511 0000000000000001 00000000701734b8 0000000000000001
Feb 20 14:53:01 ceres genunix: [ID 723222 kern.notice] 000002a10053cd20 ipf:fr_checknatout+4a8 (2a10053cff8, 6000115b500, 2a10053d000, 6000106bdf0, 70173388, fc)
Feb 20 14:53:02 ceres genunix: [ID 179002 kern.notice] %l0-3: 0000000080000000 0000000000040007 ffffffff00000000 0000000100000000
Feb 20 14:53:02 ceres %l4-7: 0000000082e13511 0000060002a0ef00 0000000000000000 0000000000000001
Feb 20 14:53:02 ceres genunix: [ID 723222 kern.notice] 000002a10053ce20 ipf:fr_fastroute+278 (600036e3000, 2a10053d188, 2a10053cff8, 0, 4, 6000106bdf0)
Feb 20 14:53:02 ceres genunix: [ID 179002 kern.notice] %l0-3: 0000000000000000 0000000000000000 000006000106bdf0 0000000000000001
Feb 20 14:53:02 ceres %l4-7: 00000600036e3040 000002a10053cfa8 00000600009a6df0 00000600009a6df0
Feb 20 14:53:02 ceres genunix: [ID 723222 kern.notice] 000002a10053cef0 ipf:fr_send_ip+168 (2a10053d258, 600036e3040, 2a10053d188, 4000, ff, 600009a6df0)
Feb 20 14:53:02 ceres genunix: [ID 179002 kern.notice] %l0-3: 0000000040000000 0000000000000000 0000000000000000 000000000000000e
Feb 20 14:53:02 ceres %l4-7: 0000060000b969c0 000002a10053d410 000006000106beac 0000060000aee2a0
Feb 20 14:53:02 ceres genunix: [ID 723222 kern.notice] 000002a10053d0d0 ipf:fr_send_reset+258 (2a10053d258, c006ea0a, 600009a6e04, 600009a6df0, 0, 82e13511)
Feb 20 14:53:02 ceres genunix: [ID 179002 kern.notice] %l0-3: 000002a10053d260 0000000000000000 00000600009a7de0 0000000000000028
Feb 20 14:53:02 ceres %l4-7: 0000000000000006 0000000000000045 0000000000000040 0000000000000040
Feb 20 14:53:03 ceres genunix: [ID 723222 kern.notice] 000002a10053d190 ipf:fr_check+59c (3000, 0, 0, 701720d0, 600022d5900, 2a10053d518)
Feb 20 14:53:03 ceres genunix: [ID 179002 kern.notice] %l0-3: 000002a10053d258 0000000000000001 0000000000000000 0000000000000000
Feb 20 14:53:03 ceres %l4-7: 000002a10053d254 0000000000000000 0000000040009101 0000000000080000
Feb 20 14:53:03 ceres genunix: [ID 723222 kern.notice] 000002a10053d330 pfil:pfil_precheck+6c8 (0, 1, 14, 6000106bdf0, 0, 0)
Feb 20 14:53:03 ceres genunix: [ID 179002 kern.notice] %l0-3: 000002a10053d410 00000600009a7e08 0000060001109900 000006000311b1c0
Feb 20 14:53:03 ceres %l4-7: 00000000700cfef0 0000000000000000 00000600009a7de0 0000000000000800
Feb 20 14:53:03 ceres genunix: [ID 723222 kern.notice] 000002a10053d460 pfil:pfilmodrput+2c0 (60000aee2a0, 6000311b1c0, 2a100538000, 41, 6000106bdf0, 0)
Feb 20 14:53:03 ceres genunix: [ID 179002 kern.notice] %l0-3: 00000000010076e4 0000000000000006 0000004480001600 00000000000007c8
Feb 20 14:53:03 ceres %l4-7: 00000300000b3c80 0000000023800000 0000000000000042 0000000000000043
Feb 20 14:53:03 ceres genunix: [ID 723222 kern.notice] 000002a10053d520 unix:putnext+218 (60000aee490, 60000aee2a0, 6000311b1c0, 100, 60000aee530, 0)
Feb 20 14:53:03 ceres genunix: [ID 179002 kern.notice] %l0-3: 0000000000000000 0000000000000000 0000000000000000 00000000000055d0
Feb 20 14:53:03 ceres %l4-7: 000000000000010d 000000007016ba40 000000007bb24418 fffffd5effac8000
Feb 20 14:53:04 ceres genunix: [ID 723222 kern.notice] 000002a10053d5d0 dld:dld_str_rx_fastpath+24 (60001043e08, 0, 6000311b1c0, e, 0, 0)
Feb 20 14:53:04 ceres genunix: [ID 179002 kern.notice] %l0-3: 0000060001069f10 0000000000000006 000006000311b1c0 0000000000000000
Feb 20 14:53:04 ceres %l4-7: 0000000000000003 0000000000000003 0000060001069f54 0000000000001e71
Feb 20 14:53:04 ceres genunix: [ID 723222 kern.notice] 000002a10053d680 dls:i_dls_link_ether_rx+1c8 (0, 0, 133a850, 2a10053d740, 2a10053d748, 2a10053d730)
Feb 20 14:53:04 ceres genunix: [ID 179002 kern.notice] %l0-3: 000002a10053d738 0000000000000000 0000000000000000 00000600008c4940
Feb 20 14:53:04 ceres %l4-7: 0000060001061f80 0000060001061fa8 0000000000000001 0000000000000000
Feb 20 14:53:04 ceres genunix: [ID 723222 kern.notice] 000002a10053d770 mac:mac_rx+58 (6000105fce8, 0, 6000311b1c0, 133c5fc, 0, 6000105fa78)
Feb 20 14:53:04 ceres genunix: [ID 179002 kern.notice] %l0-3: 0000000000000005 00000600009a7d40 0000000000000002 0000000000000002
Feb 20 14:53:04 ceres %l4-7: 0000000000000001 0000000000000000 0000060000ac9308 0000000000000000
Feb 20 14:53:04 ceres genunix: [ID 723222 kern.notice] 000002a10053d820 bge:bge_receive+350 (60000e2fe10, 6000098f000, 0, 6000098fb40, 6000311b1c0, 6000311b1c0)
Feb 20 14:53:04 ceres genunix: [ID 179002 kern.notice] %l0-3: 00000300016c6800 00000600009908e0 000006000098f840 000006000311b1c0
Feb 20 14:53:04 ceres %l4-7: 00000300016db012 000000000000012e 0000000000000200 0000000000000040
Feb 20 14:53:05 ceres genunix: [ID 723222 kern.notice] 000002a10053d970 bge:bge_intr+108 (6000098f000, 18e0, 50000002a000000, 1800, 600009908e0, 1a20)
Feb 20 14:53:05 ceres genunix: [ID 179002 kern.notice] %l0-3: 0000000100000000 0000000000000000 0000000000000400 0000000000000002
Feb 20 14:53:05 ceres %l4-7: 0000000000001a20 0000000000006808 0000000000006800 00000300016db000
Feb 20 14:53:05 ceres genunix: [ID 723222 kern.notice] 000002a10053da20 pcisch:pci_intr_wrapper+b4 (300000c21c8, 60000b0b600, 0, 0, 0, 600010172d0)
Feb 20 14:53:05 ceres genunix: [ID 179002 kern.notice] %l0-3: 00000000018d3bb0 00000600009cc580 00000000018d3bf8 0000000000f26e20
Feb 20 14:53:05 ceres %l4-7: 00000300003e0970 000006000098f000 0000000000000000 000000007bb19110
Feb 20 14:53:05 ceres unix: [ID 100000 kern.notice]
Feb 20 14:53:05 ceres genunix: [ID 672855 kern.notice] syncing file systems...
Feb 20 14:53:05 ceres genunix: [ID 433738 kern.notice] [1]
Feb 20 14:53:05 ceres genunix: [ID 733762 kern.notice] 35
Feb 20 14:53:07 ceres genunix: [ID 433738 kern.notice] [1]
Feb 20 14:53:07 ceres genunix: [ID 733762 kern.notice] 28
Feb 20 14:53:08 ceres genunix: [ID 433738 kern.notice] [1]
Feb 20 14:53:29 ceres last message repeated 20 times
Feb 20 14:53:30 ceres genunix: [ID 622722 kern.notice] done (not all i/o completed)
Feb 20 14:53:33 ceres genunix: [ID 111219 kern.notice] dumping to /dev/dsk/c1t0d0s0, offset 430374912, content: kernel
Feb 20 14:53:40 ceres genunix: [ID 409368 kern.notice] ^M100% done: 20967 pages dumped, compression ratio 4.92,
Feb 20 14:53:40 ceres genunix: [ID 851671 kern.notice] dump succeeded

me too - I'm still waiting for a patch:
Case# 65340046 - panic due to IPF firewall
From: Fletcher Cocquyt
To: <[email protected]>
Date: Feb 12 2007 - 10:09am
We had another panic & reboot, so we will be forced to disable IPF firewall
(is svcadm disable sufficient, or do I need to do more to prevent the
panics?)
How can I be notified when there is a proper Sun patch to fix this?
thanks
-----Original Message-----
From: Fletcher Cocquyt
Sent: Tuesday, February 06, 2007 8:08 AM
To: '[email protected]'
Subject: RE: Case# 65340046
Is it IPF firewall related?
Will disabling ipf (until there is a fix) avoid this bug ?
Thanks
-----Original Message-----
From: [email protected] [mailto:[email protected]]
Sent: Tuesday, February 06, 2007 8:01 AM
To: fcocquyt@
Subject: Case# 65340046
Fletcher,
This system panic'd due to bug 6490522: S10 System panic bad mutex in
ipf:fr_derefrule. Unfortunately at this time we do not have an offical fix
for
this bug, however we do have a test binary built. Please let me know if you
would like to test this binary on this system.
Thanks.
Christine Perrigo
Kernel Technical Support Engineer
Sun Services
http://www.sun.com/service/online
E-mail: [email protected]
1-800-USA4-SUN (option 1, option 1, then case #)

A problem with Threads and MMapi

I am tring to execute a class based on Game canvas.
The problem begin when I try to Play both a MIDI tone and to run an infinit Thread loop.
The MIDI tone "Stammers".
How to over come the problem?
Thanks in advance
Kobi
See Code example below:
import java.io.IOException;
import java.io.InputStream;
import javax.microedition.lcdui.Graphics;
import javax.microedition.lcdui.Image;
import javax.microedition.lcdui.game.GameCanvas;
import javax.microedition.media.Manager;
import javax.microedition.media.MediaException;
import javax.microedition.media.Player;
public class MainScreenCanvas extends GameCanvas implements Runnable {
     private MainMIDlet parent;
     private boolean mTrucking = false;
     Image imgBackgound = null;
     int imgBackgoundX = 0, imgBackgoundY = 0;
     Player player;
     public MainScreenCanvas(MainMIDlet parent)
          super(true);
          this.parent = parent;
          try
               imgBackgound = Image.createImage("/images/area03_bkg0.png");
               imgBackgoundX = this.getWidth() - imgBackgound.getWidth();
               imgBackgoundY = this.getHeight() - imgBackgound.getHeight();
          catch(Exception e)
               System.out.println(e.getMessage());
      * starts thread
     public void start()
          mTrucking = true;
          Thread t = new Thread(this);
          t.start();
      * stops thread
     public void stop()
          mTrucking = false;
     public void play()
          try
               InputStream is = getClass().getResourceAsStream("/sounds/scale.mid");
               player = Manager.createPlayer(is, "audio/midi");
               player.setLoopCount(-1);
               player.prefetch();
               player.start();
          catch(Exception e)
               System.out.println(e.getMessage());
     public void run()
          Graphics g = getGraphics();
          play();
          while (true)
               tick();
               input();
               render(g);
      * responsible for object movements
     private void tick()
      * response to key input
     private void input()
          int keyStates = getKeyStates();
          if ((keyStates & LEFT_PRESSED) != 0)
               imgBackgoundX++;
               if (imgBackgoundX > 0)
                    imgBackgoundX = 0;
          if ((keyStates & RIGHT_PRESSED) != 0)
               imgBackgoundX--;
               if (imgBackgoundX < this.getWidth() - imgBackgound.getWidth())
                    imgBackgoundX = this.getWidth() - imgBackgound.getWidth();
      * Responsible for the drawing
      * @param g
     private void render(Graphics g)
          g.drawImage(imgBackgound, imgBackgoundX, imgBackgoundY, Graphics.TOP | Graphics.LEFT);
          this.flushGraphics();
}

You can also try to provide a greater Priority to your player thread so that it gains the CPU time when ever it needs it and don't harm the playback.
However a loop in a Thread and that to an infinite loop is one kind of very bad programming, 'cuz the loop eats up most of your CPU time which in turn adds up more delays of the execution of other tasks (just as in your case it is the playback). By witting codes bit efficiently and planning out the architectural execution flow of the app before start writing the code helps solve these kind of issues.
You can go through [this simple tutorial|http://oreilly.com/catalog/expjava/excerpt/index.html] about Basics of Java and Threads to know more about threads.
Regds,
SD
N.B. And yes there are more articles and tutorials available but much of them targets the Java SE / EE, but if you want to read them here is [another great one straight from SUN|http://java.sun.com/docs/books/tutorial/essential/concurrency/index.html] .
Edited by: find_suvro@SDN on 7 Nov, 2008 12:00 PM

Problem with threads and ProgressMonitor

Dear Friends:
I have a little problem with a thread and a ProgressMonitor. I have a long time process that runs in a thread (the thread is in an separate class). The thread has a ProgressMonitor that works fine and shows the tasks progress.
But I need deactivate the main class(the main class is the user interface) until the thread ends.
I use something like this:
LongTask myTask=new LongTask();
myTask.start();
myTask.join();
Now, the main class waits for the task to end, but the progress monitor don`t works fine: it shows only the dialog but not the progress bar.
What's wrong?

Is the dialog a modal dialog? This can block other UI updates.
In general, you should make sure that it isn't modal, and that your workThread has a fairly low priority so that the UI can do its updating

Having a problem with threads and using locks

I was hoping someone could give me some hits on getting my code to run properly. The problem I am having is I think my locks and unlocks are not working properly. Plus, for some reason I always get the same output, which is:
Withdrawal Threads         Deposit Threads            Balance
Thread 2 attempts $29 Withdrawal - Blocked - Insufficient Funds
Thread 4 attempts $45 Withdrawal - Blocked - Insufficient Funds
Thread 6 attempts $34 Withdrawal - Blocked - Insufficient Funds
Thread 7 attempts $40 Withdrawal - Blocked - Insufficient Funds
                                Thread 1 deposits $187          $187
                                Thread 3 deposits $169          $356
                                Thread 5 deposits $61           $417
Press any key to continue...If someone can see the error I made and doesn't mind explaining it to me, so I can learn from it, I would appreciate that very much.
/************Assign2_Main.java************/
import java.util.concurrent.*;
public class Assign2_Main
{//start Assign2_Main
    public static void main(String[] args)
    {//start main
           // create ExecutorService to manage threads
           ExecutorService threadExecutor = Executors.newCachedThreadPool();
        Account account = new SynchronizedThreads();
        Deposit deposit1 = new Deposit(account, "Thread 1");
        Deposit deposit2 = new Deposit(account, "Thread 3");
        Deposit deposit3 = new Deposit(account, "Thread 5");
        Withdrawal withdrawal1 = new Withdrawal(account, "Thread 2");
        Withdrawal withdrawal2 = new Withdrawal(account, "Thread 4");
        Withdrawal withdrawal3 = new Withdrawal(account, "Thread 6");
        Withdrawal withdrawal4 = new Withdrawal(account, "Thread 7");
        System.out.println("Withdrawal Threads\t\tDeposit Threads\t\t\tBalance");
        System.out.println("------------------\t\t---------------\t\t\t-------\n");
        try
            threadExecutor.execute(withdrawal1);
            threadExecutor.execute(deposit1);
            threadExecutor.execute(withdrawal2);
            threadExecutor.execute(deposit2);
            threadExecutor.execute(withdrawal3);
            threadExecutor.execute(deposit3);
            threadExecutor.execute(withdrawal4);
        catch ( Exception e )
             e.printStackTrace();
            //shutdown worker threads
           threadExecutor.shutdown();
    }//end main
}//end Assign2_Main/******************Withdrawal.java****************************/
public class Withdrawal implements Runnable
{//start class Withdrawal
      *constructor
    public Withdrawal(Account money, String n)
         account = money;
         name = n;
    public void run()
    {//start ruin
         int newNum = 0;
            newNum = account.getBalance(name);
           Thread.yield();
    }//end run
    private Account account;
    private String name;
}//end class Withdrawal/*******************Deposit.java***************/
import java.util.Random;
public class Deposit implements Runnable
{//start class Deposit
      *constructor
    public Deposit(Account money, String n)
         account = money;
         name = n;
    public void run()
    {//start run
            try
                 Thread.sleep(100);
               account.setBalance(random.nextInt(200), name);
            }// end try
            catch (InterruptedException e)
              e.printStackTrace();
   }//end run
   private Account account;
   private Random random = new Random();
   private String name;
}//end class Deposit/********************Account.java*****************/
*Account interface specifies methods called by Producer and Consumer.
public interface Account
     //place sum into Account
     public void setBalance(int sum, String name);
     //return value of Account
        public int getBalance(String name);
} /**************SynchronizedThreads.java****************/
import java.util.concurrent.locks.*;
import java.util.Random;
public class SynchronizedThreads implements Account
{//start SynchronizedThreads
      *place money into buffer
    public void setBalance(int amount, String name)
    {//start setBalance
         // lock object
         myLock.lock();
        sum += amount;
        System.out.println("\t\t\t\t" + name + " deposits $" + amount +"\t\t$"+ sum+"\n");
           //threads are singnaled to wakeup
        MakeWD.signalAll();
          // unlock object
        myLock.unlock();
     }//end setBalance
      *gets the balance from buffer
     public int getBalance(String name)
    {//start getBalance
         int NewSum = random.nextInt(50);
         //lock object
        myLock.lock();
        try
             if(sum > NewSum)
                 //takes NewSum away from the account
                 sum -= NewSum;
                    System.out.println(name + " withdraws $" + NewSum +"\t\t\t\t\t\t$"+ sum+"\n");
            else
                 System.out.println(name + " attempts $" + NewSum + " Withdrawal - Blocked - Insufficient Funds\n");
                 //not enough funds so thread waits
                    MakeWD.await();
            //threads are singnaled to wakeup
            MakeD.signalAll();
            }//end try
        catch (InterruptedException e)
               e.printStackTrace();
        finally
             //unlock object
             myLock.unlock();
        return NewSum;
     }//end getBalance
     private Random random = new Random();
     private Lock myLock = new ReentrantLock();
     private Condition MakeD = myLock.newCondition();
     private Condition MakeWD = myLock.newCondition();
     private int sum = 0;
}//end SynchronizedThreads

You can also try to provide a greater Priority to your player thread so that it gains the CPU time when ever it needs it and don't harm the playback.
However a loop in a Thread and that to an infinite loop is one kind of very bad programming, 'cuz the loop eats up most of your CPU time which in turn adds up more delays of the execution of other tasks (just as in your case it is the playback). By witting codes bit efficiently and planning out the architectural execution flow of the app before start writing the code helps solve these kind of issues.
You can go through [this simple tutorial|http://oreilly.com/catalog/expjava/excerpt/index.html] about Basics of Java and Threads to know more about threads.
Regds,
SD
N.B. And yes there are more articles and tutorials available but much of them targets the Java SE / EE, but if you want to read them here is [another great one straight from SUN|http://java.sun.com/docs/books/tutorial/essential/concurrency/index.html] .
Edited by: find_suvro@SDN on 7 Nov, 2008 12:00 PM

Holy! Kernel spawns 16k threads and growing!

Similar Messages

Maybe you are looking for