From owner-kdb@oss.sgi.com Thu Jan 10 11:48:48 2002 Received: (from majordomo@localhost) by oss.sgi.com (8.11.2/8.11.3) id g0AJmm821556 for kdb-outgoing; Thu, 10 Jan 2002 11:48:48 -0800 Received: from ecbull20.frec.bull.fr (ecbull20.frec.bull.fr [129.183.4.3]) by oss.sgi.com (8.11.2/8.11.3) with SMTP id g0AJmbg21552 for ; Thu, 10 Jan 2002 11:48:38 -0800 Received: from egalis.frec.bull.fr (egalis.frec.bull.fr [129.183.10.1]) by ecbull20.frec.bull.fr (8.9.2/8.9.1) with ESMTP id TAA17042; Thu, 10 Jan 2002 19:48:35 +0100 Received: (from brux@localhost) by egalis.frec.bull.fr (AIX4.3/8.9.3/8.9.3) id TAA187254; Thu, 10 Jan 2002 19:48:27 +0100 From: Xavier Bru MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Transfer-Encoding: 7bit Message-ID: <15421.57850.152808.163299@egalis.frec.bull.fr> Date: Thu, 10 Jan 2002 19:48:26 +0100 (NFT) To: Keith Owens Cc: kdb@oss.sgi.com, linux-ia64@linuxia64.org Subject: Re: Announce: kdb v2.0 is available for kernel 2.4.17 In-Reply-To: <7539.1009011037@kao2.melbourne.sgi.com> References: <7539.1009011037@kao2.melbourne.sgi.com> X-Mailer: VM 6.72 under 21.1 "20 Minutes to Nikko" XEmacs Lucid (patch 2) Sender: owner-kdb@oss.sgi.com Precedence: bulk We must take care that the common KDB patch (kdb-v2.0-2.4.17-common-3) conflicts with the IA64 patch on 2.4.17(linux-2.4.17-ia64-011226.diff). (needs to merge both patches). I did not notice that first time and got a strange KDB behavior ( kdb_init() was not called, and no way to quit kdb after breaking into it ). -- Sinceres salutations. _____________________________________________________________________ Xavier BRU BULL ISD/R&D/INTEL office: FREC B1-422 tel : +33 (0)4 76 29 77 45 http://www-frec.bull.fr fax : +33 (0)4 76 29 77 70 mailto:Xavier.Bru@bull.net addr: BULL, 1 rue de Provence, BP 208, 38432 Echirolles Cedex, FRANCE _____________________________________________________________________ Keith Owens writes: > -----BEGIN PGP SIGNED MESSAGE----- > Hash: SHA1 > > Content-Type: text/plain; charset=us-ascii > > ftp://oss.sgi.com/projects/kdb/download/v2.0/ > > kdb-v2.0-2.4.17-common-1.bz2 > kdb-v2.0-2.4.17-i386-1.bz2 > > Starting with kdb v2.0 there is a common patch against each kernel which > contains all the architecture independent code plus separate architecture > dependent patches. Apply the common patch for your kernel plus at least > one architecture dependent patch, the architecture patches activate kdb. > > The naming convention for kdb patches is :- > > vx.y The version of kdb. x.y is updated as new features are added to kdb. > - -v.p.s The kernel version that the patch applies to. 's' may include -pre, > -rc or whatever numbering system the kernel keepers have thought up this > week. > - -common The common kdb code. Everybody needs this. > - -i386 Architecture dependent code for i386. > - -ia64 Architecture dependent code for ia64, etc. > - -n If there are multiple kdb patches against the same kernel version then > the last number is incremented. > > To build kdb for your kernel, apply the common kdb patch which is less > than or equal to the kernel v.p.s, taking the highest value of '-n' > if there is more than one. Apply the relevant arch dependent patch > with the same value of 'vx.y-v.p.s-', taking the highest value of '-n' > if there is more than one. > > For example, to use kdb v2.0 for i386 on kernel 2.4.17, apply > kdb-v2.0-2.4.17-common-1 > kdb-v2.0-2.4.17-i386-1 > in that order. > > > This release is functionally equivalent to kdb v1.9-2.4.16, the only > change is the reorganisation. I have a backlog of kdb changes which > were on hold until the patches had been split, it was getting too messy > trying to maintain at least six versions of the common kdb code and > keep them in sync. I hope to clear the backlog soon. > > Ethan Solomita (ethan@cs.columbia.edu) has done a port of kdb to > sparc64 against 2.4.13. I will upgrade that to 2.4.17 and issue > kdb-v2.0-2.4.17-sparc64-1.bz2 "soon". kdb for ia64 has to wait until > the 2.4.17-ia64 kernel patch is issued. > > Changelog extract. > > 2001-12-22 Keith Owens > > * Upgrade to 2.4.17. > * Clean up ifdef CONFIG_KDB. > * Add ifdef CONFIG_KDB around include kdb.h. > * Delete dummy kdb.h files for unsupported architectures. > * Delete arch i386 and ia64 specific files. This changelog now > applies to kdb common code only. > * Release as kdb v2.0-2.4.17-common-1. > > -----BEGIN PGP SIGNATURE----- > Version: GnuPG v1.0.4 (GNU/Linux) > Comment: Exmh version 2.1.1 10/15/1999 > > iD8DBQE8JElbi4UHNye0ZOoRArPiAKCYlVUzS3EYrE5XC8sn3Xz8L9mBeQCeLHGn > Wdx2YfBSiLgCmg6nlUPr+8A= > =BFtm > -----END PGP SIGNATURE----- > From owner-kdb@oss.sgi.com Thu Jan 10 14:09:35 2002 Received: (from majordomo@localhost) by oss.sgi.com (8.11.2/8.11.3) id g0AM9Zs25594 for kdb-outgoing; Thu, 10 Jan 2002 14:09:35 -0800 Received: from mail.ocs.com.au (mail.ocs.com.au [203.34.97.2]) by oss.sgi.com (8.11.2/8.11.3) with SMTP id g0AM9Tg25590 for ; Thu, 10 Jan 2002 14:09:29 -0800 Received: (qmail 29153 invoked from network); 10 Jan 2002 21:09:22 -0000 Received: from ocs3.intra.ocs.com.au (192.168.255.3) by mail.ocs.com.au with SMTP; 10 Jan 2002 21:09:22 -0000 Received: by ocs3.intra.ocs.com.au (Postfix, from userid 16331) id AB902300095; Fri, 11 Jan 2002 08:09:20 +1100 (EST) Received: from ocs3.intra.ocs.com.au (localhost [127.0.0.1]) by ocs3.intra.ocs.com.au (Postfix) with ESMTP id 3364E94; Fri, 11 Jan 2002 08:09:20 +1100 (EST) X-Mailer: exmh version 2.2 06/23/2000 with nmh-1.0.4 From: Keith Owens To: Xavier Bru Cc: kdb@oss.sgi.com, linux-ia64@linuxia64.org Subject: Re: Announce: kdb v2.0 is available for kernel 2.4.17 In-reply-to: Your message of "Thu, 10 Jan 2002 19:48:26 BST." <15421.57850.152808.163299@egalis.frec.bull.fr> Mime-Version: 1.0 Content-Type: text/plain; charset=us-ascii Date: Fri, 11 Jan 2002 08:09:14 +1100 Message-ID: <30083.1010696954@ocs3.intra.ocs.com.au> Sender: owner-kdb@oss.sgi.com Precedence: bulk On Thu, 10 Jan 2002 19:48:26 +0100 (NFT), Xavier Bru wrote: >We must take care that the common KDB patch (kdb-v2.0-2.4.17-common-3) >conflicts with the IA64 patch on 2.4.17(linux-2.4.17-ia64-011226.diff). (needs to merge both patches). >I did not notice that first time and got a strange KDB behavior ( kdb_init() >was not called, and no way to quit kdb after breaking into it ). That is due to the ia64 patch adding CONFIG_PERMON patches into init/main.c. AFAICT there is no reason that this patch cannot be sent to Marcelo to reduce the footprint of the ia64 patch on common code. David, can you send these ia64 patches to Marcelo for inclusion in base kernel? If you are too busy I will package them up and send them. Documentation/Configure.help Documentation/kernel-parameters.txt init/main.c Makefile (second chunk only, adding AFLAGS_KERNEL) include/linux/mm.h (just to reserve the bits) include/linux/prctl.h (reserve the bits) include/linux/time.h kernel/ksyms.c kernel/signal.c kernel/sys.c The list above excludes anything that might affect other architectures. The patch to ensure that the console variables are contiguous is already in 2.4.18-pre1. I would like to get crc32 in base as well but I believe that another person has been working on this as well. If you like I will reconcile the two versions and get one crc32 into base kernel. From owner-kdb@oss.sgi.com Thu Jan 10 14:33:30 2002 Received: (from majordomo@localhost) by oss.sgi.com (8.11.2/8.11.3) id g0AMXUN27031 for kdb-outgoing; Thu, 10 Jan 2002 14:33:30 -0800 Received: from deimos.hpl.hp.com (deimos.hpl.hp.com [192.6.19.190]) by oss.sgi.com (8.11.2/8.11.3) with SMTP id g0AMXMg27027 for ; Thu, 10 Jan 2002 14:33:26 -0800 Received: from hplms2.hpl.hp.com (hplms2.hpl.hp.com [15.0.152.33]) by deimos.hpl.hp.com (8.9.3 (PHNE_24419)/HPL-PA Relay) with ESMTP id NAA17135; Thu, 10 Jan 2002 13:33:11 -0800 (PST) Received: from napali.hpl.hp.com (napali.hpl.hp.com [15.4.89.123]) by hplms2.hpl.hp.com (8.10.2/8.10.2 HPL-PA Hub) with ESMTP id g0ALXHv05058; Thu, 10 Jan 2002 13:33:17 -0800 (PST) Received: from napali.hpl.hp.com (localhost [127.0.0.1]) by napali.hpl.hp.com (8.12.1/8.12.1/Debian -5) with ESMTP id g0ALXHdx028682; Thu, 10 Jan 2002 13:33:17 -0800 Received: (from davidm@localhost) by napali.hpl.hp.com (8.12.1/8.12.1/Debian -5) id g0ALXGqh028678; Thu, 10 Jan 2002 13:33:16 -0800 From: David Mosberger MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Transfer-Encoding: 7bit Message-ID: <15422.2204.894092.26790@napali.hpl.hp.com> Date: Thu, 10 Jan 2002 13:33:16 -0800 To: Keith Owens Cc: Xavier Bru , kdb@oss.sgi.com, linux-ia64@linuxia64.org Subject: Re: [Linux-ia64] Re: Announce: kdb v2.0 is available for kernel 2.4.17 In-Reply-To: <30083.1010696954@ocs3.intra.ocs.com.au> References: <15421.57850.152808.163299@egalis.frec.bull.fr> <30083.1010696954@ocs3.intra.ocs.com.au> X-Mailer: VM 7.00 under Emacs 21.1.1 Reply-To: davidm@hpl.hp.com X-URL: http://www.hpl.hp.com/personal/David_Mosberger/ Sender: owner-kdb@oss.sgi.com Precedence: bulk >>>>> On Fri, 11 Jan 2002 08:09:14 +1100, Keith Owens said: Keith> David, can you send these ia64 patches to Marcelo for Keith> inclusion in base kernel? If you are too busy I will package Keith> them up and send them. That would be fine with me. But could you send me the patch for a final sanity check before sending it off to Marcelo? Also, do not send it the linux/mm.h changes. Due to the multiple memory attribute issue, I'm not sure the VM_NONCACHED and VM_WRITECOMBINED are such good ideas (besides, I don't think they're really needed anymore). Keith> Documentation/Configure.help Keith> Documentation/kernel-parameters.txt init/main.c Makefile Keith> (second chunk only, adding AFLAGS_KERNEL) include/linux/mm.h Keith> (just to reserve the bits) include/linux/prctl.h (reserve the Keith> bits) include/linux/time.h kernel/ksyms.c kernel/signal.c Keith> kernel/sys.c Keith> The list above excludes anything that might affect other Keith> architectures. The patch to ensure that the console Keith> variables are contiguous is already in 2.4.18-pre1. Keith> I would like to get crc32 in base as well but I believe that Keith> another person has been working on this as well. If you like Keith> I will reconcile the two versions and get one crc32 into base Keith> kernel. Matt was working on this. Is that who you were referring two? Yes, there is no reason this patch shouldn't be in 2.4.xx as far as I'm concerned. Thanks, --david From owner-kdb@oss.sgi.com Tue Jan 15 16:01:41 2002 Received: (from majordomo@localhost) by oss.sgi.com (8.11.2/8.11.3) id g0G01fr08721 for kdb-outgoing; Tue, 15 Jan 2002 16:01:41 -0800 Received: from randall.mail.atl.earthlink.net (randall.mail.atl.earthlink.net [207.69.200.237]) by oss.sgi.com (8.11.2/8.11.3) with SMTP id g0G01cP08718 for ; Tue, 15 Jan 2002 16:01:39 -0800 Received: from smui04.slb.mindspring.net ([199.174.114.26]) by randall.mail.atl.earthlink.net with esmtp (Exim 3.33 #1) id 16QcZg-0000sf-00 for kdb@oss.sgi.com; Tue, 15 Jan 2002 18:01:00 -0500 Received: by smui04.slb.mindspring.net id SAA0000031325; Tue, 15 Jan 2002 18:01:00 -0500 (EST) Date: Tue, 15 Jan 2002 18:01:00 -0500 From: To: kdb@oss.sgi.com Subject: redhat Message-ID: X-Originating-IP: 24.25.8.65 Sender: owner-kdb@oss.sgi.com Precedence: bulk Hi, I just wanted to know if kdb is compatible with non-vanilla kernels, such as RedHat 7.2 or SuSE 7.3? Thanks, Kevin Stansell From owner-kdb@oss.sgi.com Tue Jan 15 16:32:10 2002 Received: (from majordomo@localhost) by oss.sgi.com (8.11.2/8.11.3) id g0G0WAb09862 for kdb-outgoing; Tue, 15 Jan 2002 16:32:10 -0800 Received: from sgi.com (sgi.SGI.COM [192.48.153.1]) by oss.sgi.com (8.11.2/8.11.3) with SMTP id g0G0W8P09851 for ; Tue, 15 Jan 2002 16:32:08 -0800 Received: from nodin.corp.sgi.com (nodin.corp.sgi.com [192.26.51.193]) by sgi.com (980327.SGI.8.8.8-aspam/980304.SGI-aspam: SGI does not authorize the use of its proprietary systems or networks for unsolicited or bulk email from the Internet.) via ESMTP id PAA00038 for ; Tue, 15 Jan 2002 15:31:52 -0800 (PST) mail_from (kaos@sgi.com) Received: from kao2.melbourne.sgi.com (kao2.melbourne.sgi.com [134.14.55.180]) by nodin.corp.sgi.com (8.11.4/8.11.2/nodin-1.0) with ESMTP id g0FNV4423818276; Tue, 15 Jan 2002 15:31:04 -0800 (PST) Received: by kao2.melbourne.sgi.com (Postfix, from userid 16331) id 1618D3000AD; Wed, 16 Jan 2002 10:31:02 +1100 (EST) Received: from kao2.melbourne.sgi.com (localhost [127.0.0.1]) by kao2.melbourne.sgi.com (Postfix) with ESMTP id 0845494; Wed, 16 Jan 2002 10:31:01 +1100 (EST) X-Mailer: exmh version 2.2 06/23/2000 with nmh-1.0.4 From: Keith Owens To: kstansell@mindspring.com Cc: kdb@oss.sgi.com Subject: Re: redhat In-reply-to: Your message of "Tue, 15 Jan 2002 18:01:00 CDT." Mime-Version: 1.0 Content-Type: text/plain; charset=us-ascii Date: Wed, 16 Jan 2002 10:30:56 +1100 Message-ID: <12190.1011137456@kao2.melbourne.sgi.com> Sender: owner-kdb@oss.sgi.com Precedence: bulk On Tue, 15 Jan 2002 18:01:00 -0500, wrote: >I just wanted to know if kdb is compatible with non-vanilla kernels, such as RedHat 7.2 or SuSE 7.3? > It depends on which patches the distributor has applied to their kernel. Redhat in particular apply bits of the -ac tree which breaks kdb. If you want kdb on a distributor's kernel, ask the distributor, kdb only tracks vanilla kernels. From owner-kdb@oss.sgi.com Thu Jan 17 20:03:41 2002 Received: (from majordomo@localhost) by oss.sgi.com (8.11.2/8.11.3) id g0I43fI09459 for kdb-outgoing; Thu, 17 Jan 2002 20:03:41 -0800 Received: from yog-sothoth.sgi.com (eugate.sgi.com [192.48.160.10]) by oss.sgi.com (8.11.2/8.11.3) with SMTP id g0I43TP09452 for ; Thu, 17 Jan 2002 20:03:29 -0800 Received: from nodin.corp.sgi.com (fddi-nodin.corp.sgi.com [198.29.75.193]) by yog-sothoth.sgi.com (980305.SGI.8.8.8-aspam-6.2/980304.SGI-aspam-europe) via ESMTP id EAA90765 for ; Fri, 18 Jan 2002 04:00:57 +0100 (CET) mail_from (kaos@sgi.com) Received: from kao2.melbourne.sgi.com (kao2.melbourne.sgi.com [134.14.55.180]) by nodin.corp.sgi.com (8.11.4/8.11.2/nodin-1.0) with ESMTP id g0I30r424603367; Thu, 17 Jan 2002 19:00:53 -0800 (PST) Received: by kao2.melbourne.sgi.com (Postfix, from userid 16331) id 07DC53000AD; Fri, 18 Jan 2002 14:00:50 +1100 (EST) Received: from kao2.melbourne.sgi.com (localhost [127.0.0.1]) by kao2.melbourne.sgi.com (Postfix) with ESMTP id 84E7D94; Fri, 18 Jan 2002 14:00:50 +1100 (EST) X-Mailer: exmh version 2.2 06/23/2000 with nmh-1.0.4 From: Keith Owens To: kdb@oss.sgi.com Cc: linux-kernel@vger.kernel.org, linux-ia64@linuxia64.org Subject: Announce: kdb v2.1 is available for kernel 2.4.17 Date: Fri, 18 Jan 2002 14:00:44 +1100 Message-ID: <7170.1011322844@kao2.melbourne.sgi.com> Sender: owner-kdb@oss.sgi.com Precedence: bulk -----BEGIN PGP SIGNED MESSAGE----- Hash: SHA1 Content-Type: text/plain; charset=us-ascii ftp://oss.sgi.com/projects/kdb/download/v2.1/ kdb-v2.1-2.4.17-common-1.bz2 kdb-v2.1-2.4.17-i386-1.bz2 Starting with kdb v2.0 there is a common patch against each kernel which contains all the architecture independent code plus separate architecture dependent patches. Apply the common patch for your kernel plus at least one architecture dependent patch, the architecture patches activate kdb. The naming convention for kdb patches is :- vx.y The version of kdb. x.y is updated as new features are added to kdb. - -v.p.s The kernel version that the patch applies to. 's' may include -pre, -rc or whatever numbering system the kernel keepers have thought up this week. - -common The common kdb code. Everybody needs this. - -i386 Architecture dependent code for i386. - -ia64 Architecture dependent code for ia64, etc. - -n If there are multiple kdb patches against the same kernel version then the last number is incremented. To build kdb for your kernel, apply the common kdb patch which is less than or equal to the kernel v.p.s, taking the highest value of '-n' if there is more than one. Apply the relevant arch dependent patch with the same value of 'vx.y-v.p.s-', taking the highest value of '-n' if there is more than one. For example, to use kdb v2.1 for i386 on kernel 2.4.17, apply kdb-v2.1-2.4.17-common-1 kdb-v2.1-2.4.17-i386-1 in that order. Changelog extracts. The bulk of this release is rewriting the data accessing to rely on the MMU instead of trying to validate an address by hand. The auto repeat of commands has been changed, some commands auto repeat, others do not. Dead code has been removed. common 2002-01-18 Keith Owens * Ignore single stepping during panic. * Remove kdba_getword, kdba_putword. Replace with kdb_getword, kdb_putword that rely on copy_xx_user. The new functions return an error code, like copy_xx_user. * New functions kdb_getarea, kdb_putarea for copying areas of data such as structures. These functions also return an error code. * Change all common code to use the new functions. * bp command checks that it can read and write the word at the breakpoint before accepting the address. * Break points are now set FIFO and cleared LIFO so overlapping entries give sensible results. * Verify address before disassembling code. * Common changes for sparc64. Ethan Solomita, Tom Duffy. * Remove ss , never supported. * Remove kallsyms entries from arch vmlinux.lds files. * Specify which commands auto repeat. * kdb v2.1-2.4.17-common-1. i386 2002-01-18 Keith Owens * Use new kdb_get/put functions. * Define kdba_{get,put}area_size functions for i386. * Remove over-engineered dblist callback functions. * Correctly handle failing call disp32 in backtrace. * Remove bp_instvalid flag, redundant code. * Remove dead code. * kdb v2.1-2.4.17-i386-1. ia64-011226 2002-01-18 Keith Owens * Replace kdb_get/putword with kdb_get/putarea functions. * Wrap kdb references in #ifdef CONFIG_KDB. * Delete sample i386 code. * Refuse to update kernel text on NUMA systems. * Reject hardware breakpoints, not supported yet. * kdb v2.1-2.4.17-ia64-011226-1. -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.0.4 (GNU/Linux) Comment: Exmh version 2.1.1 10/15/1999 iD8DBQE8R4/ai4UHNye0ZOoRAjJeAJ94HepPodstKmk+Aa5hAjXGv8i+YgCbBdR6 HBXdtKRGpw2cUBNk9x9Jg+U= =j8j6 -----END PGP SIGNATURE----- From owner-kdb@oss.sgi.com Wed Jan 23 14:20:07 2002 Received: (from majordomo@localhost) by oss.sgi.com (8.11.2/8.11.3) id g0NMK7k27672 for kdb-outgoing; Wed, 23 Jan 2002 14:20:07 -0800 Received: from youri (intbg-globaltech.internet-bg.net [212.124.67.194]) by oss.sgi.com (8.11.2/8.11.3) with SMTP id g0NMK2P27651 for ; Wed, 23 Jan 2002 14:20:03 -0800 Message-Id: <200201232220.g0NMK2P27651@oss.sgi.com> Reply-To: romantic@marriage.com From: romantic@marriage.com To: kdb@oss.sgi.com Subject: Incredible Information Mime-Version: 1.0 Content-Type: text/plain; charset="iso-8859-1" Date: Wed, 23 Jan 2002 23:20:04 +0200 Sender: owner-kdb@oss.sgi.com Precedence: bulk How much does a romantic marriage proposal cost? Well, a lot less that you think. Most guys actually ruin the day by spending too much. Find out the secrets the jewelry, candy and flower stores don't want you to know. http://hop.clickbank.net/hop.cgi?helloworld/proposals From owner-kdb@oss.sgi.com Wed Jan 23 22:50:58 2002 Received: (from majordomo@localhost) by oss.sgi.com (8.11.2/8.11.3) id g0O6owh17414 for kdb-outgoing; Wed, 23 Jan 2002 22:50:58 -0800 Received: from aol.com (ACBC385D.ipt.aol.com [172.188.56.93]) by oss.sgi.com (8.11.2/8.11.3) with SMTP id g0O6obP17320 for ; Wed, 23 Jan 2002 22:50:38 -0800 Message-Id: <200201240650.g0O6obP17320@oss.sgi.com> From: "kriss rolo" To: Subject: SOME ITEMS THAT YOU MAY BE INTERESTED IN OR BE ABLE TO ADVISE ME ON Mime-Version: 1.0 Content-Type: text/plain; charset="ISO-8859-1" Date: Thu, 24 Jan 2002 05:37:38 -0000 Reply-To: "kriss rolo" X-Priority: 1 (Highest) Content-Transfer-Encoding: 8bit Sender: owner-kdb@oss.sgi.com Precedence: bulk These are the items that iam interested in selling.. Could you help me with some details on the goods, history, origin etc. are these worth anything and if so who would i contact with regards to selling them? and the best way to sell them ie auction etc APOLOGISE IF YOU HAVE ALREADY RECEIVED THIS E-MAIL JPEGS ARE AVAILABLE AT YOUR REQUEST MANY THANX kriss rolo tel: 0044 182760393 office (uk) 0044 1216864211 home (uk) 0044 7814294018 mobile (uk) return e-mail address krissrolo@aol.com UK ONLY VEHICLE REGISTRATION NUMBER N64 CON NINTENDO 64 CONSOLE item 1 hand carved round table with metal chain link in the middle item 2 magnum laurent perrier vintage 1988 champagne item 3 miniture football on stand from euro96 signed by pele and bobby charlton item 4 is a bit more interesting. its a protana minifon attache, as u will see ive enclosed notes from a web site regarding this and you will see back in the 50's it cost $340.00 so i could imagine this to be worth a bit. it also has an original tape inside i do not know what is on this tape, but judging by who made it and the cost of the machine, the tape could have some important information on it. heres the note..... The Minifon, developed in the early 1950s by Monske GMBH of Hanover(or by Protona GMBH- I'm not certain), was an ultra-miniaturized, battery operated magnetic recording device. It could not (initially at least) record the full range of sounds and was thus limited to voice recording, but it did offer easy portability in a very small package. The idea of offering a pocket dictating machine was novel, since dictation had previously been done in the office. However, it was thought that people like salesmen could take the machine "on the road" with them. Once on the market, the Minifon's promoters discovered that many people took advantage of the recorder's small size to make secret recordings to be used as evidence, as in court.

The "legitimate" use of the Minifon, as a dictating machine, was somewhat problematical. Recordings made on regular dictating equipment were usually letters, and thus were normally sent almost immediately to a typist. The Minifon offered no obvious advantages over standard dictation equipment for office use, but its developers hoped to cultivate new uses for dictation equipment, such as stock taking in warehouses, or the use of the machine as a substitute for note-taking by reporters, insurance adjusters, salesmen, and others. In its original form, the Minifon was a wire recorder, using a type of wire medium developed by the Armour Research Foundation of Chicago and employed in many similar devices since the late 1940s. The machine at its introduction in 1952 had a recording time of one hour, which was remarkably long, and weighed only about 3 pounds at a time when a typical office dictating machine weighed upwards of 10 pounds. It accomplished this small size and light weight in part through the use of miniature tubes and clever mechanical design. The basic machine cost $289.50-- a price that sounds high today but was very much in line with competing office dictating machines. The parent company attempted to set up distribution, sales and service networks in the United States. It established a business office called the Minifon Export Corp in New York, and an existing company, Harvey Radio in New York City became the main distributor. Although smaller tape recorders appeared at about the same time, the main competition in the voice recording field was from an American company, Mohawk, which made a small, battery-operated cartridge tape recorder called the Migetape. Both products sold less than 10,000 units per year in the U.S.
After a few years, the Minifon was modified to use transistors and magnetic tape, further lowering its weight and cost. By 1962 the basic machine weighed in at only 1.5 pounds. Competition by this time had helped bring the cost down to $249.50. The Minifon after about 1962 was distributed by the international conglomerate ITT through its subsidiary in the U.S., Federal Electric Corp. A little later, distribution was taken over by the ITT Distributor Products Division in Lodi, New Jersey. (I don't know whether these were the same company with different names) By the time ITT became associated with this product, it had taken on the name of Minifon "Attache," and a new line of models and options appeared. These included a hi-fi model, the 978H, which sold for $330.50.Usinga two-track, 1/4 inch tape cartridge operating at 1 7/8 inches per second, the machine claimed a frequency response of up to 12,000 Hz, plus or minus 3db. The coming of magnetic tape did not completely displace wire. The Model 240 series of recorders introduced in the early 1960s were probably the last wire recorders in regular production. The 240L, at a price of $269.50 used a special long-playing wire cartridge that held 4 hours of wire. Otherwise it looked like both the tape model and the 240S, which used a 2-hour wire cartridge and sold for $249.50. Another innovation was the introduction of more conventional recorders. After years of offering only "half" of a complete dictation system, Minifon finally developed a restyled, non-portable "office" machine, mainly for use by a transcriber, with pedal controls. By the mid-1960s, Minifon was trying to market its machines as multi-purpose devices suitable for nearly any recording need. In addition to the hi-fi and long-playing machines, the company offered an astounding variety of optional equipment such as foot controls, microphones, external amplifiers and loudspeakers, headsets, external power supplies, telephone recording attachments, conference recording adapters. One of the most interesting options were the miniature microphones intended to allow users to make "spy" recordings. In addition to a small tie-clip microphone, the Minifon could be equipped with a microphone disguised as a wrist- watch. From owner-kdb@oss.sgi.com Sun Jan 27 23:00:12 2002 Received: (from majordomo@localhost) by oss.sgi.com (8.11.2/8.11.3) id g0S70CZ18835 for kdb-outgoing; Sun, 27 Jan 2002 23:00:12 -0800 Received: from linux.local (207-172-216-88.s596.apx1.sbo.ma.dialup.rcn.com [207.172.216.88]) by oss.sgi.com (8.11.2/8.11.3) with SMTP id g0S6w3P18627 for ; Sun, 27 Jan 2002 22:58:03 -0800 Received: (from jim@localhost) by linux.local (8.11.2/8.11.2/SuSE Linux 8.11.1-0.5) id g0S0t7O01098; Sun, 27 Jan 2002 19:55:07 -0500 Date: Sun, 27 Jan 2002 19:55:07 -0500 Message-Id: <200201280055.g0S0t7O01098@linux.local> X-Authentication-Warning: linux.local: jim set sender to jhouston@ma.ultranet.com using -f From: Jim Houston To: kdb@oss.sgi.com Subject: PATCH - kernel trace mechanism for kdb Reply-to: jhouston@ma.ultranet.com Sender: owner-kdb@oss.sgi.com Precedence: bulk Hi! The attached patch implements a kernel trace mechanism as an addition to kdb. It's set up to build a kernel with the -finstrument-functions compiler option. By default it gathers data on every function call and return. It also includes logic to filter the data collected, capturing data only for selected functions or all but selected functions. Each entry in the trace includes a timestamp, the called function and the calling address. Function calls also include the frame pointer and 3 words from the stack that might be arguments. Here is a sample of the output: 63 ret 6.803 us 0xc0121140 (spin_lock) 0xc012011c (__wake_up+0x2c) 64 call 6.899 us 0xc0121140 (spin_lock) 0xc012011c (__wake_up+0x2c) fp=c045de84 args = c044d560 00000003 00000045 65 call 6.970 us 0xc01200f0 (__wake_up) 0xc0225176 (put_queue+0x26) fp=c045dea0 args = c045dec4 c0224eab 00000045 66 call 7.072 us 0xc0225150 (put_queue) 0xc0224eab (handle_scancode+0xab) fp=c045dea8 args = 00000045 c00001c8 00000000 INSTALL Install kernel and kdb: linux-2.4.17 kernel kdb-v2.1-2.4.17-common-2.bz2 kdb-v2.1-2.4.17-i386-1.bz2. Apply this patch. Run the script "scripts/inline-fix.pl" included in this patch. This changes "extern inline" to "static inline" globally. Install modutils-2.4.12.tar, and patch it using the file "patch_kallsyms" which was dropped in the kernel tree. Build kallsyms and install. Enable the "Trace kernel function calls" configuration option. How to use it. At the kdb prompt: tr Displays the contents of the trace buffer. trd Default to not collecting trace data tre Add functions which should be traced. tre Default to trace everything trd Add function to exception list not to be traced trp Display trace enable/disable status list of exceptions. trc Clear list of functions with tracing explictly enabled or disabled. Why change kallsyms? The symbol table that kallsyms creates doesn't include information for symbols which have several static definitions. This change preserves these local definitions. Using -finstrument-functions means that inline functions get a static version created in every file that calls them. Multiple symbols with the same name, eh? With the patch the symbol table now has multiple entries for the same name. It does the right thing for address to name translations but just picks the first entry when it is asked to find an address from a name. It would be nice if kdb could warn when there are multiple defintions for the same symbol. Oh no not the stupid extern inline thread again... The -finstrument-functions option generates calls to the functions __cyg_profile_func_enter and __cyg_profile_func_exit for each function passing the address of the function and the caller. This is done even for inline functions. This results in taking the address of inline functions which would normally always be inlined. For functions declared "extern inline" this results in undefined symbol errors. For "static inline" it causes a static version to be compiled in each object file that uses the inline function. Given this choice, multiple copies beats link errors so the inline-fix.pl script make the global change from extern to static inline. Why defeat inlining? With functions inlined and compiled with -finstrument-functions the return address gets confusing. If function 'A' calls 'B' which has 'C' inlined, the trace shows 'C' called by 'A'. I turned of inlining by adding "-fno-inline" in the toplevel makefile. If your are tracing every function call you probably don't get much performance benifit out of inlining anyway. Why did I do this? I wrote this code while chasing a bug on an old off-brand laptop which locks up with a combination of X and PCMCIA network cards. I was able to reproduce the problem with the trace running sending the trace data to an unused corner of the video ram (which survives reset). Now I know that the lockup happens in the Xserver sigh:-) What is the performance impact? On a 1 GHz. Athlon it doesn't seem slow. I have been running it as my normal kernel for a few weeks. On average it takes 70 cycles per call or return with a trace buffer which fits in cache. E.g. getpid() takes 422 cycle instead of 280. It is painfully slow running on an old pentium with the trace going to real memory. I hope that others will find this trace mechanism useful. I'm sending this to both the SGI kdb mailing list and the linux kernel mailing list. I hope that it might become a standard part of kdb. Jim Houston jhouston@ma.ultranet.com diff -urN -X /home/jim/dontdiff linux.orig/Documentation/Configure.help linux/Documentation/Configure.help --- linux.orig/Documentation/Configure.help Sun Jan 27 06:42:49 2002 +++ linux/Documentation/Configure.help Sun Jan 27 09:03:59 2002 @@ -18976,6 +18976,11 @@ this option. See "man kallsyms" for the data format, it adds 10-20% to the size of the kernel and the loaded modules. If unsure, say N. +Trace kernel function calls +CONFIG_INSTRUMENT_FUNC + Compile kernel with -finstrument-functions. This allows a function + level trace of kernel code. + ISDN support CONFIG_ISDN ISDN ("Integrated Services Digital Networks", called RNIS in France) diff -urN -X /home/jim/dontdiff linux.orig/Makefile linux/Makefile --- linux.orig/Makefile Sun Jan 27 06:42:49 2002 +++ linux/Makefile Sun Jan 27 09:03:59 2002 @@ -97,6 +97,9 @@ ifndef CONFIG_FRAME_POINTER CFLAGS += -fomit-frame-pointer endif +ifeq ($(CONFIG_INSTRUMENT_FUNC),y) +CFLAGS += -finstrument-functions -fno-inline +endif AFLAGS := -D__ASSEMBLY__ $(CPPFLAGS) # diff -urN -X /home/jim/dontdiff linux.orig/arch/i386/boot/compressed/misc.c linux/arch/i386/boot/compressed/misc.c --- linux.orig/arch/i386/boot/compressed/misc.c Wed Nov 28 08:12:08 2001 +++ linux/arch/i386/boot/compressed/misc.c Sun Jan 27 09:03:59 2002 @@ -381,3 +381,18 @@ if (high_loaded) close_output_buffer_if_we_run_high(mv); return high_loaded; } + +#ifdef CONFIG_INSTRUMENT_FUNC +void __cyg_profile_func_enter(void *, void *) + __attribute__ ((no_instrument_function)); +void __cyg_profile_func_exit(void *, void *) + __attribute__ ((no_instrument_function)); + +void __cyg_profile_func_enter(void *a1, void *a2) +{ +} + +void __cyg_profile_func_exit(void *a1, void *a2) +{ +} +#endif diff -urN -X /home/jim/dontdiff linux.orig/arch/i386/config.in linux/arch/i386/config.in --- linux.orig/arch/i386/config.in Sun Jan 27 06:46:02 2002 +++ linux/arch/i386/config.in Sun Jan 27 09:03:59 2002 @@ -419,6 +419,7 @@ bool ' KDB off by default' CONFIG_KDB_OFF comment ' Load all symbols for debugging is required for KDB' define_bool CONFIG_KALLSYMS y + bool ' Trace kernel function calls' CONFIG_INSTRUMENT_FUNC else bool ' Load all symbols for debugging' CONFIG_KALLSYMS fi diff -urN -X /home/jim/dontdiff linux.orig/arch/i386/kdb/kdbasupport.c linux/arch/i386/kdb/kdbasupport.c --- linux.orig/arch/i386/kdb/kdbasupport.c Sun Jan 27 06:46:03 2002 +++ linux/arch/i386/kdb/kdbasupport.c Sun Jan 27 09:03:59 2002 @@ -1030,6 +1030,8 @@ } #ifdef KDB_HAVE_LONGJMP +int kdba_setjmp(kdb_jmp_buf *jb) + __attribute__ ((no_instrument_function)); int kdba_setjmp(kdb_jmp_buf *jb) { @@ -1059,6 +1061,8 @@ return 0; } +void kdba_longjmp(kdb_jmp_buf *jb, int reason) + __attribute__ ((no_instrument_function)); void kdba_longjmp(kdb_jmp_buf *jb, int reason) { diff -urN -X /home/jim/dontdiff linux.orig/drivers/parport/parport_pc.c linux/drivers/parport/parport_pc.c --- linux.orig/drivers/parport/parport_pc.c Sun Jan 27 06:29:54 2002 +++ linux/drivers/parport/parport_pc.c Sun Jan 27 09:03:59 2002 @@ -256,6 +256,11 @@ parport_generic_irq(irq, (struct parport *) dev_id, regs); } +/* + * Actually it cause problems to have both static inline and a + * global version. + */ +#if 0 void parport_pc_write_data(struct parport *p, unsigned char d) { outb (d, DATA (p)); @@ -343,6 +348,7 @@ { __parport_pc_frob_control (p, 0x20, 0x20); } +#endif void parport_pc_init_state(struct pardevice *dev, struct parport_state *s) { diff -urN -X /home/jim/dontdiff linux.orig/include/asm-i386/current.h linux/include/asm-i386/current.h --- linux.orig/include/asm-i386/current.h Fri Aug 14 19:35:22 1998 +++ linux/include/asm-i386/current.h Sun Jan 27 09:03:59 2002 @@ -4,6 +4,8 @@ struct task_struct; static inline struct task_struct * get_current(void) + __attribute__ ((no_instrument_function)); +static inline struct task_struct * get_current(void) { struct task_struct *current; __asm__("andl %%esp,%0; ":"=r" (current) : "0" (~8191UL)); diff -urN -X /home/jim/dontdiff linux.orig/kdb/Makefile linux/kdb/Makefile --- linux.orig/kdb/Makefile Sun Jan 27 06:42:49 2002 +++ linux/kdb/Makefile Sun Jan 27 09:03:59 2002 @@ -2,6 +2,9 @@ export-objs := kdbmain.o kdb_io.o obj-y := kdb_bt.o kdb_bp.o kdb_id.o kdbsupport.o gen-kdb_cmds.o kdbmain.o kdb_io.o +obj-$(CONFIG_INSTRUMENT_FUNC) += kdb_tr.o +CFLAGS_kdb_tr.o += -finline + subdir-$(CONFIG_KDB_MODULES) := modules obj-y += $(addsuffix /vmlinux-obj.o, $(subdir-y)) diff -urN -X /home/jim/dontdiff linux.orig/kdb/kdb_tr.c linux/kdb/kdb_tr.c --- linux.orig/kdb/kdb_tr.c Wed Dec 31 19:00:00 1969 +++ linux/kdb/kdb_tr.c Sun Jan 27 17:31:24 2002 @@ -0,0 +1,601 @@ +/* + * Copyright (C) 2002 Jim Houston jhouston@ma.ultranet.com + * + * This software may be used and distributed according to the terms + * of the GNU General Public License (GPL), incorporated herein by + * reference. + * + * Its a quick hack to trace the kernel at the function call level + * using the -finstrument-functions compiler option. The trace is + * stored in a circular buffer. + * + * Here is a summary of the new commands it adds to kdb: + * + * tr + * Display content of trace buffer. + * tre + * tre + * Enable tracing of all function calls, or the + * specified functions. + * trd + * tre + * Disable tracing all functions, or the specifed + * functions. + * trc + * trc + * Clear list of per function trace requests, or remove + * the 'trd' or 'tre' entry for the specified function. + * trp + * Print list of functions which have been explicity + * enabled or disabled for tracing. + * trstop + * trstart + * Global control to disable/re-enable tracing. You + * might use trstop to stop tracing so that the trace + * could be read with a user level tool. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "kdb_tr.h" + +char *trc_tname[] = { "call", "ret ", "user " }; + +struct trce trc_buf[TRC_SZ]; +struct trc trc = { TRC_ENABLE, TRC_ENABLE, trc_buf, TRC_SZ-1, 0, 0 }; +struct trc *trcp = &trc; + +void +kdb_trc_init() +{ + kdb_register_repeat("tr", kdb_tr, "", + "Display kernel trace", 0, KDB_REPEAT_NONE); + kdb_register_repeat("trp", kdb_trp, "", + "Display trace enable/disable status", 0, KDB_REPEAT_NONE); + kdb_register_repeat("tre", kdb_tre, "", + "Enable trace for function", 0, KDB_REPEAT_NONE); + kdb_register_repeat("trd", kdb_trd, "", + "Disable trace for function", 0, KDB_REPEAT_NONE); + kdb_register_repeat("trc", kdb_trc, "", + "Clear per function trace enable/disble", 0, KDB_REPEAT_NONE); + kdb_register_repeat("trstop", kdb_trstop, "", + "Disable kernel trace", 0, KDB_REPEAT_NONE); + kdb_register_repeat("trstart", kdb_trstart, "", + "Enable kernel trace", 0, KDB_REPEAT_NONE); +} +/* + * Simple hash table to control the trace. Each function entry + * and exit goes through here so it has to be quick. Its a fixed + * sized hash table with the data store directly in the hash table. + */ +struct trc_hash trc_hash[TRC_HASH_SZ]; +int trc_hash_cnt = 0; + +inline int trc_hashfn(kdb_machreg_t addr) +{ + unsigned int i = (unsigned int) addr; + + return((i ^ (i >> 5) ^ (i >> 10) ^ (i >> 15)) % TRC_HASH_SZ); +} + + +inline int trc_get_flags(kdb_machreg_t addr) +{ + unsigned int i, flags; + + i = trc_hashfn(addr); + for ( ; (flags = trc_hash[i].flags) ; i = (i+1) % TRC_HASH_SZ) + if (trc_hash[i].addr == addr) + return(flags); + return(0); +} + + +/* + * Create or update a hash table entry. + */ + +void +trc_set_flags(kdb_machreg_t addr, int flags) +{ + int i; + + if (!flags) + return; + i = trc_hashfn(addr); + for ( ; trc_hash[i].flags ; i = (i+1) % TRC_HASH_SZ) + if (trc_hash[i].addr == addr) { + trc_hash[i].flags = flags; + return; + } + /* + * Seaches take literally forever if the table is completly full. + * Warn and fail if the table is more than half full. + */ + if (trc_hash_cnt >= TRC_HASH_SZ/2) { + kdb_printf("no more entries\n"); + return; + } + trc_hash_cnt++; + trc_hash[i].addr = addr; + trc_hash[i].flags = flags; +} + +void +trc_clr_flags(kdb_machreg_t addr) +{ + int i, flags; + + i = trc_hashfn(addr); + for ( ; ; i = (i+1) % TRC_HASH_SZ) { + if (!(flags = trc_hash[i].flags)) + return; + if (trc_hash[i].addr == addr) + break; + } + + /* + * Found it. Take it out. + */ + trc_hash[i].addr = 0; + trc_hash[i].flags = 0; + trc_hash_cnt--; + /* + * Now check that adjacent entries don't get lost. + */ + i = (i+1) % TRC_HASH_SZ; + for ( ; (flags = trc_hash[i].flags); i = (i+1) % TRC_HASH_SZ) { + if (i != trc_hashfn(trc_hash[i].addr)) { + /* + * This entry might want the slot we just + * cleared, take it out and put it back in. + */ + addr = trc_hash[i].addr; + trc_hash[i].addr = 0; + trc_hash[i].flags = 0; + trc_set_flags(addr, flags); + } + } +} + +void +trc_clr_all_flags( void ) +{ + int i; + + for (i = 0; i < TRC_HASH_SZ; i++) { + trc_hash[i].addr = 0; + trc_hash[i].flags = 0; + } + trc_hash_cnt = 0; +} +void + +trc_print_hash( void ) +{ + int i; + + for (i = 0; i < TRC_HASH_SZ; i++) { + if (trc_hash[i].flags) { + if (trc_hash[i].flags & TRC_ENABLE) + kdb_printf("ENABLE "); + if (trc_hash[i].flags & TRC_DISABLE) + kdb_printf("DISABLE "); + kdb_symbol_print(trc_hash[i].addr, NULL, KDB_SP_DEFAULT); + kdb_printf("\n"); + } + + } +} + +/* + * Functions to disable/re-enable the trace on entry to kdb. + */ +void kdb_trc_disable( void ) +{ + struct trc *tp; + + tp = trcp; + if (!tp) + return; + tp->enable_save = tp->enable; + tp->enable = 0; +} + +void kdb_trc_continue( void ) +{ + struct trc *tp; + + tp = trcp; + if (!tp) + return; + tp->enable = tp->enable_save; +} + + +static inline struct trce *next_t(struct trc *tp) +{ + unsigned int i; + + /* It would be nice if this was atomic */ + if ((i = tp->offset++) == ~0) + tp->offsetu++; + return(&(tp->buf[i & tp->mask])); +} + +void __cyg_profile_func_enter(kdb_machreg_t this_fn, kdb_machreg_t call_site) +{ + register unsigned int t1, t2; + struct trc *tp; + struct trce *t; + kdb_machreg_t *fp = __builtin_frame_address(1); + + tp = trcp; + if (!tp || tp->enable & TRC_STOP) + return; + t1 = trc_get_flags((kdb_machreg_t)this_fn); + if ((tp->enable | t1) != TRC_ENABLE) + return; + rdtsc(t1,t2); + t = next_t(tp); + t->time = t1; + t->timeu = t2; + t->type = T_ENTER; + t->a1 = this_fn; + t->a2 = call_site; + /* + * Save the frame ptr and first 3 args + */ + t->a3 = (kdb_machreg_t)fp; + t->a4 = fp[2]; + t->a5 = fp[3]; + t->a6 = fp[4]; +} + +void __cyg_profile_func_exit(kdb_machreg_t this_fn, kdb_machreg_t call_site) +{ + register unsigned int t1, t2; + struct trc *tp; + struct trce *t; + + tp = trcp; + if (!tp || tp->enable & TRC_STOP) + return; + t1 = trc_get_flags((kdb_machreg_t)this_fn); + if ((tp->enable | t1) != TRC_ENABLE) + return; + rdtsc(t1,t2); + t = next_t(tp); + t->time = t1; + t->timeu = t2; + t->type = T_EXIT; + t->a1 = this_fn; + t->a2 = call_site; +} + +void __trace_user(kdb_machreg_t a1, kdb_machreg_t a2) +{ + register unsigned int t1, t2; + struct trc *tp; + struct trce *t; + + tp = trcp; + if (!tp || tp->enable & TRC_STOP) + return; + rdtsc(t1,t2); + t = next_t(tp); + t->time = t1; + t->timeu = t2; + t->type = T_USER; + t->a1 = a1; + t->a2 = a2; +} + + +void __trace_stop() +{ + struct trc *tp; + + tp = trcp; + tp->enable |= TRC_STOP; +} + +/* + * Choose format for time, absolute cycles, delta from previous line + * or relative to most recent sample. + */ +enum tm_format { absolute, delta, relative }; +char *tfname[] = {"absolute", "delta", "relative", 0 }; + +enum tm_format +get_time_format(void) +{ + enum tm_format i; + char *s; + + if ((s = kdbgetenv("TIME_FORMAT"))) + for (i = absolute; ; i++) { + if (tfname[i] && strcmp(tfname[i], s) == 0) + return(i); + } + return(relative); +} + + +extern unsigned long fast_gettimeoffset_quotient; + +char *frac_format[] = { " ", ".%01d ", ".%02d ", ".%03d ", ".%04d ", + ".%05d ", ".%06d ", ".%07d ", ".%08d "}; + +void +display_time(unsigned long long dt) +{ + int n; + unsigned int de, frac; + char *unit; + int n_digits, min_frac; + unsigned int cycles; + unsigned long long ll; + + ll = 1LL << 32; + do_div(ll, fast_gettimeoffset_quotient); + cycles = (unsigned int)ll; + + /* guess how many significant digits we have, count the bits */ + /* and multiply by log10(2) */ + for (n = 0; n < 63 && dt > (1LL << n); n++) ; + n_digits = (n * 1233) >> 12; + + min_frac = 0; + if (dt < 1000*cycles) { + de = cycles; + unit = "us"; + min_frac = 2; + } else if (dt < 1000000*cycles) { + de = cycles * 1000; + unit = "ms"; + min_frac = 3; + } else { + de = cycles * 1000000; + unit = "s"; + } + frac = do_div(dt, de); + /* Pick number of digits for fraction */ + for (n = 0; n < 63 && dt > (1LL << n); n++) ; + n_digits -= (n * 1233) >> 12; + if (n_digits < min_frac) + n_digits = min_frac; + + if (n_digits > 7) + n_digits = 7; + kdb_printf("%d", (unsigned int)dt); + dt = frac; + for (n = 0; n < n_digits; n++) + dt *= 10; + dt += de/2; + frac = do_div(dt, de); + kdb_printf(frac_format[n_digits], (unsigned int)dt); + kdb_printf("%s ", unit); +} + +void +kdb_tr_display(unsigned int from, unsigned int to) +{ + unsigned int i; + struct trc *tp; + struct trce *t; + enum tm_format tf; + long long t0, t1; + + tp = trcp; + if (!tp) { + kdb_printf("No trace buffer?\n"); + return; + } + if ((from & ~tp->mask) || (to & ~tp->mask)) { + kdb_printf("Offset larger than trace buffer?\n"); + return; + } + tf =get_time_format(); + + if (tf == relative) + t = &(tp->buf[(tp->offset-1) & tp->mask]); + else + t = &(tp->buf[(tp->offset-from-1) & tp->mask]); + t0 = (unsigned long long)t->timeu << 32; + t0 |= t->time; + for (i = from; i <= to; i++) { + t = &(tp->buf[(tp->offset-i-1) & tp->mask]); + kdb_printf("%3d %s ", i, trc_tname[t->type]); + if (tf == absolute) + kdb_printf("%6x%08x ", t->timeu, t->time); + else { + t1 = (unsigned long long)t->timeu << 32; + t1 |= t->time; + display_time(t0 - t1); + if (tf == delta) + t0 = t1; + } + kdb_symbol_print((kdb_machreg_t)t->a1, NULL, KDB_SP_DEFAULT); + kdb_printf(" "); + kdb_symbol_print((kdb_machreg_t)t->a2, NULL, KDB_SP_DEFAULT); + kdb_printf("\n"); + if (t->type == T_ENTER) { + kdb_printf(" fp=%08lx args = %08lx %08lx %08lx\n", + t->a3, t->a4, t->a5, t->a6); + } + } +} + + +int +kdb_tr(int argc, const char **argv, const char **envp, struct pt_regs *regs) +{ + unsigned int from, to; + struct trc *tp; + + tp = trcp; + /* + * default to display the whole buffer. + */ + from = 0; + to = tp->mask; + if (argc >= 1) + from = simple_strtoul(argv[1], NULL, 10); + if (argc >= 2) + to = simple_strtoul(argv[2], NULL, 10); + kdb_tr_display(from, to); + return(0); +} + +int +kdb_trstop(int argc, const char **argv, const char **envp, struct pt_regs *regs) +{ + struct trc *tp; + + tp = trcp; + tp->enable_save |= TRC_STOP; + return(0); +} + +int +kdb_trstart(int argc, const char **argv, const char **envp, struct pt_regs *regs) +{ + struct trc *tp; + + tp = trcp; + tp->enable_save &= ~TRC_STOP; + return(0); +} + +int +kdb_trd(int argc, const char **argv, const char **envp, struct pt_regs *regs) +{ + int diag, nextarg; + kdb_machreg_t addr; + long offset; + struct trc *tp; + + tp = trcp; + if (argc == 0) { + tp->enable_save &= ~TRC_ENABLE; + } else { + nextarg = 1; + while (argc >= nextarg) { + diag = kdbgetaddrarg(argc, argv, &nextarg, + &addr, &offset, NULL, regs); + if (diag) + return(diag); + trc_set_flags(addr, TRC_DISABLE); + } + } + return(0); +} + +int +kdb_tre(int argc, const char **argv, const char **envp, struct pt_regs *regs) +{ + int diag, nextarg; + kdb_machreg_t addr; + long offset; + struct trc *tp; + + tp = trcp; + if (argc == 0) { + tp->enable_save |= TRC_ENABLE; + } else { + nextarg = 1; + while (argc >= nextarg) { + diag = kdbgetaddrarg(argc, argv, &nextarg, + &addr, &offset, NULL, regs); + if (diag) + return(diag); + trc_set_flags(addr, TRC_ENABLE); + } + } + return(0); +} + +int +kdb_trc(int argc, const char **argv, const char **envp, struct pt_regs *regs) +{ + int diag, nextarg; + kdb_machreg_t addr; + long offset; + struct trc *tp; + + tp = trcp; + if (argc == 0) { + trc_clr_all_flags(); + } else { + nextarg = 1; + while (argc >= nextarg) { + diag = kdbgetaddrarg(argc, argv, &nextarg, + &addr, &offset, NULL, regs); + if (diag) + return(diag); + trc_clr_flags(addr); + } + } + return(0); +} + +int +kdb_trp(int argc, const char **argv, const char **envp, struct pt_regs *regs) +{ + struct trc *tp; + + tp = trcp; + kdb_printf("Tracing %s by default.\n", + tp->enable_save&TRC_ENABLE?"enabled":"disabled"); + trc_print_hash(); + return(0); +} + +/* + * The calls for these functions are normally not generated because + * in the inlined version the compiler eliminates the call as dead + * code. When instrument-functions takes the address of the function + * forcing a non-inlined version the code is nolonger dead. + */ + +void __br_lock_usage_bug(void) +{ + printk(KERN_WARNING "__br_lock_usage_bug called\n"); +} + +void __this_fixmap_does_not_exist(void) +{ + printk(KERN_WARNING "__this_fixmap_does_not_exist called\n"); +} + +void +kdb_print_trace(void) +{ + + struct trce *t; + struct trc *tp; + int from, to, i; + + tp = trcp; + tp->enable = 0; + from = 0; + to = 20; + + for (i = from; i <= to; i++) { + t = &(tp->buf[(tp->offset-i-1) & tp->mask]); + printk("%s %08x ", trc_tname[t->type], + t->time); + printk("%08lx ", (kdb_machreg_t)t->a1); + printk("%08lx ", (kdb_machreg_t)t->a2); + printk("\n"); + } +} diff -urN -X /home/jim/dontdiff linux.orig/kdb/kdb_tr.h linux/kdb/kdb_tr.h --- linux.orig/kdb/kdb_tr.h Wed Dec 31 19:00:00 1969 +++ linux/kdb/kdb_tr.h Sun Jan 27 09:03:59 2002 @@ -0,0 +1,89 @@ +/* + * Quick hack to trace the linux kernel at the function call level + * using the -finstrument-functions compiler option. + * + * Copyright (C) 2002 Jim Houston jhouston@ma.ultranet.com + * + * This software may be used and distributed according to the terms of the + * GNU General Public License (GPL), incorporated herein by reference. + */ + + +#define rdtsc(low,high) \ + __asm__ __volatile__("rdtsc" : "=a" (low), "=d" (high)) + +#define TRC_ENABLE 1 +#define TRC_DISABLE 2 +#define TRC_STOP 4 + +#define TRC_SZ 0x1000 +#define TRC_HASH_SZ 0x100 + +#define T_ENTER 0 +#define T_EXIT 1 +#define T_USER 2 + +struct trce { + unsigned int type: 8 ; + unsigned int timeu : 24 ; + unsigned int time; + kdb_machreg_t a1, a2, a3, a4, a5, a6; +}; + +struct trc { + int enable; + int enable_save; + struct trce *buf; + unsigned int mask; + unsigned int offset; + unsigned int offsetu; +}; + +/* + * The data collected by the trace is filtered by looking the + * called function address up in a simple hash table. The flags + * currently only two bits provide explicit enable/disable of + * tracing on a per function basis. + */ + +struct trc_hash { + kdb_machreg_t addr; + int flags; +}; + +int trc_hashfn(kdb_machreg_t addr) + __attribute__ ((no_instrument_function)); +int trc_get_flags(kdb_machreg_t addr) + __attribute__ ((no_instrument_function)); + +void __cyg_profile_func_enter(kdb_machreg_t , kdb_machreg_t ) + __attribute__ ((no_instrument_function)); + +void __cyg_profile_func_exit(kdb_machreg_t , kdb_machreg_t ) + __attribute__ ((no_instrument_function)); + +void __trace_user(kdb_machreg_t , kdb_machreg_t ) + __attribute__ ((no_instrument_function)); + +void __trace_stop( void ) + __attribute__ ((no_instrument_function)); + +void kdb_trc_disable( void ) + __attribute__ ((no_instrument_function)); + +void kdb_trc_continue( void ) + __attribute__ ((no_instrument_function)); + +static struct trce *next_t(struct trc *) + __attribute__ ((no_instrument_function)); + +void kdb_trc_init(void); +void kdb_trc_disable(void); +void kdb_trc_continue(void); +int kdb_tr(int , const char **, const char **, struct pt_regs *); +int kdb_trstop(int , const char **, const char **, struct pt_regs *); +int kdb_trstart(int , const char **, const char **, struct pt_regs *); +int kdb_trd(int , const char **, const char **, struct pt_regs *); +int kdb_tre(int , const char **, const char **, struct pt_regs *); +int kdb_trc(int , const char **, const char **, struct pt_regs *); +int kdb_trp(int , const char **, const char **, struct pt_regs *); diff -urN -X /home/jim/dontdiff linux.orig/kdb/kdbmain.c linux/kdb/kdbmain.c --- linux.orig/kdb/kdbmain.c Sun Jan 27 06:42:49 2002 +++ linux/kdb/kdbmain.c Sun Jan 27 09:03:59 2002 @@ -91,6 +91,13 @@ kdb_jmp_buf kdbjmpbuf[NR_CPUS]; #endif /* KDB_HAVE_LONGJMP */ +#if defined(CONFIG_INSTRUMENT_FUNC) +/* Hooks to automaticly disable kernel trace on entry to kdb */ +extern void kdb_trc_disable(void); +extern void kdb_trc_continue(void); +extern void kdb_trc_init(void); +#endif /* CONFIG_INSTRUMENT_FUNC */ + /* * kdb_commands describes the available commands. */ @@ -1212,6 +1219,11 @@ if (!kdb_on) return 0; +#if defined(CONFIG_INSTRUMENT_FUNC) + /* disable kernel trace while in kdb */ + kdb_trc_disable(); +#endif + KDB_DEBUG_STATE("kdb 1", reason); KDB_STATE_CLEAR(SUPPRESS); @@ -1228,6 +1240,10 @@ if ((reason == KDB_REASON_BREAK || reason == KDB_REASON_DEBUG) && db_result == KDB_DB_NOBPT) { KDB_DEBUG_STATE("kdb 2", reason); + /* re-enable kernel trace */ +#if defined(CONFIG_INSTRUMENT_FUNC) + kdb_trc_continue(); +#endif return 0; /* Not one of mine */ } @@ -1305,11 +1321,19 @@ } if (!recover) { kdb_printf(" Cannot recover, allowing event to proceed\n"); + /* re-enable kernel trace */ +#if defined(CONFIG_INSTRUMENT_FUNC) + kdb_trc_continue(); +#endif return(0); } } } else if (!KDB_IS_RUNNING()) { kdb_printf("kdb: CPU switch without kdb running, I'm confused\n"); + /* re-enable kernel trace */ +#if defined(CONFIG_INSTRUMENT_FUNC) + kdb_trc_continue(); +#endif return(0); } @@ -1434,6 +1458,10 @@ KDB_STATE_CLEAR(RECURSE); KDB_DEBUG_STATE("kdb 17", reason); + /* re-enable kernel trace */ +#if defined(CONFIG_INSTRUMENT_FUNC) + kdb_trc_continue(); +#endif return(result != 0); } @@ -2711,6 +2739,9 @@ #endif #if defined(CONFIG_MAGIC_SYSRQ) kdb_register_repeat("sr", kdb_sr, "", "Magic SysRq key", 0, KDB_REPEAT_NONE); +#endif +#if defined(CONFIG_INSTRUMENT_FUNC) + kdb_trc_init(); #endif } diff -urN -X /home/jim/dontdiff linux.orig/kernel/ksyms.c linux/kernel/ksyms.c --- linux.orig/kernel/ksyms.c Sun Jan 27 06:42:49 2002 +++ linux/kernel/ksyms.c Sun Jan 27 09:03:59 2002 @@ -571,3 +571,21 @@ EXPORT_SYMBOL(tasklist_lock); EXPORT_SYMBOL(pidhash); + +#ifdef CONFIG_INSTRUMENT_FUNC +extern void __br_lock_usage_bug(void); +extern void __this_fixmap_does_not_exist(void); +extern void __cyg_profile_func_enter(void *, void *); +extern void __cyg_profile_func_exit(void *, void *); +extern void __trace_user(void *, void *); +extern void __trace_stop(); +extern void *trcp; + +EXPORT_SYMBOL(__br_lock_usage_bug); +EXPORT_SYMBOL(__this_fixmap_does_not_exist); +EXPORT_SYMBOL_NOVERS(__cyg_profile_func_enter); +EXPORT_SYMBOL_NOVERS(__cyg_profile_func_exit); +EXPORT_SYMBOL(__trace_user); +EXPORT_SYMBOL(__trace_stop); +EXPORT_SYMBOL(trcp); +#endif diff -urN -X /home/jim/dontdiff linux.orig/patch_kallsyms linux/patch_kallsyms --- linux.orig/patch_kallsyms Wed Dec 31 19:00:00 1969 +++ linux/patch_kallsyms Sun Jan 27 09:03:59 2002 @@ -0,0 +1,35 @@ +--- modutils-2.4.12/obj/obj_kallsyms.c.orig Thu Jan 4 20:45:19 2001 ++++ modutils-2.4.12/obj/obj_kallsyms.c Tue Jan 15 05:17:43 2002 +@@ -250,6 +250,8 @@ + for (sym = fin->symtab[i]; sym ; sym = sym->next) { + if (!sym || sym->secidx >= fin->header.e_shnum) + continue; ++ if (ELFW(ST_BIND)(sym->info) == STB_LOCAL) ++ continue; + if ((a_sym.section_off = fin_to_allsym_map[sym->secidx]) == -1) + continue; + if (strcmp(sym->name, "gcc2_compiled.") == 0 || +@@ -263,6 +265,23 @@ + append_string(sym->name, &strings, &strings_size, &strings_left); + ++a_hdr->symbols; + } ++ } ++ for (i = 0; i < fin->local_symtab_size; ++i) { ++ struct obj_symbol *sym = fin->local_symtab[i]; ++ if (!sym || sym->secidx >= fin->header.e_shnum) ++ continue; ++ if ((a_sym.section_off = fin_to_allsym_map[sym->secidx]) == -1) ++ continue; ++ if (strcmp(sym->name, "gcc2_compiled.") == 0 || ++ strncmp(sym->name, "__insmod_", 9) == 0) ++ continue; ++ a_sym.symbol_addr = sym->value; ++ if (fin->header.e_type == ET_REL) ++ a_sym.symbol_addr += fin->sections[sym->secidx]->header.sh_addr; ++ a_sym.name_off = strings_size - strings_left; ++ append_symbol(&a_sym, &symbols, &symbols_size, &symbols_left); ++ append_string(sym->name, &strings, &strings_size, &strings_left); ++ ++a_hdr->symbols; + } + free(fin_to_allsym_map); + diff -urN -X /home/jim/dontdiff linux.orig/scripts/inline-fix.pl linux/scripts/inline-fix.pl --- linux.orig/scripts/inline-fix.pl Wed Dec 31 19:00:00 1969 +++ linux/scripts/inline-fix.pl Sun Jan 27 09:03:59 2002 @@ -0,0 +1,91 @@ +#!/usr/bin/perl +# +# This script changes "extern inline" to "static inline" in header +# files. I did this so that I could use -finstrument-functions to +# trace Linux kernel code. The script is pretty stupid if it finds +# extern and inline togther its likely to make a change. It removes +# the inline from forward references and changes extern to static +# for definitions. + +open(FIND, "find . -name \*.[ch] |") || die "couldn't run find on *.[ch]\n"; +while ($f = ) { + chop $f; + if (!open(FILE, $f)) { + print STDERR "Can't open $f\n"; + next; + } +# print STDERR "scanning $f\n"; + undef $file_content; + $file_content = ""; + $modified = 0; +OUT: + while ($line = ) { + # check for comment, ignore lines that start with + # a comment. Ignore block comments + if ($line =~ /^\s*\/\*.*\*\//) { + $file_content .= $line; + next; + } + if ($line =~ /^\s*\/\*/) { + $file_content .= $line; + while ($line = ) { + $file_content .= $line; + if ($line =~ /\*\//) { + next OUT; + } + } + print STDERR "??? $f: end of file in comment?"; + + } + if ($line =~ /extern\s+(.*)(inline|__inline|__inline__)\s/) { + $extra = 0; + if ($line =~ /^#define/) { + # Alpha & ARM have defines + # for extern inline which I'm + #ignoring for now. + $file_content .= $line; + next; + } + while (!($line =~ /;|{/)) { + if (!($nl = )) { + die "hit EOF... file=$f\n"; + } + if (++$extra > 8) { + print STDERR "??? $f: $line"; + last; + } + $line .= $nl; + } + if ($line =~ /{/) { + $line =~ s/extern/static/; + $modified = 1; + } elsif ($line =~ /;/) { + $line =~ s/[ ]*__inline__[ ]*/ /; + $line =~ s/[ ]*__inline[ ]*/ /; + $line =~ s/[ ]*inline[ ]*/ /; + $modified = 1; + } + } + $file_content .= $line; + } + close(FILE); + $name = $f . ".orig"; + if ($modified && -e $name) { + print STDERR "$name already exists - no changes made\n"; + next; + } + if ($modified) { + if (link($f, $name)) { + unlink($f); + } else { + print STDERR "Can't move $f to $name\n"; + next; + } + if (!open(FILE, ">$f")) { + prinf STDERR "Can't open $f for output\n"; + next; + } + print FILE $file_content; + close(FILE); + } +} From owner-kdb@oss.sgi.com Mon Jan 28 02:45:09 2002 Received: (from majordomo@localhost) by oss.sgi.com (8.11.2/8.11.3) id g0SAj9410394 for kdb-outgoing; Mon, 28 Jan 2002 02:45:09 -0800 Received: from ns.caldera.de (ns.caldera.de [212.34.180.1]) by oss.sgi.com (8.11.2/8.11.3) with SMTP id g0SAj6P10382 for ; Mon, 28 Jan 2002 02:45:06 -0800 Received: (from hch@localhost) by ns.caldera.de (8.11.6/8.11.6) id g0S9iJc26322; Mon, 28 Jan 2002 10:44:19 +0100 Date: Mon, 28 Jan 2002 10:44:19 +0100 From: Christoph Hellwig To: Jim Houston Cc: kdb@oss.sgi.com Subject: Re: PATCH - kernel trace mechanism for kdb Message-ID: <20020128104419.A26140@caldera.de> References: <200201280055.g0S0t7O01098@linux.local> Mime-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline User-Agent: Mutt/1.2.5i In-Reply-To: <200201280055.g0S0t7O01098@linux.local>; from jhouston@ma.ultranet.com on Sun, Jan 27, 2002 at 07:55:07PM -0500 Sender: owner-kdb@oss.sgi.com Precedence: bulk On Sun, Jan 27, 2002 at 07:55:07PM -0500, Jim Houston wrote: > Run the script "scripts/inline-fix.pl" included in this patch. This > changes "extern inline" to "static inline" globally. What do you think about preparing such a patch for Linus & Marcelo? I know we've been bitten by extern inline all the time for various reasons.. > I hope that others will find this trace mechanism useful. I'm sending > this to both the SGI kdb mailing list and the linux kernel mailing list. > I hope that it might become a standard part of kdb. This looks very nice, I'll try it ASAP. Christoph -- Of course it doesn't work. We've performed a software upgrade. From owner-kdb@oss.sgi.com Mon Jan 28 11:01:14 2002 Received: (from majordomo@localhost) by oss.sgi.com (8.11.2/8.11.3) id g0SJ1EP15806 for kdb-outgoing; Mon, 28 Jan 2002 11:01:14 -0800 Received: from ligarius-fe0.ultra.net (ligarius-fe0.ultra.net [146.115.8.189]) by oss.sgi.com (8.11.2/8.11.3) with SMTP id g0SJ1AP15789 for ; Mon, 28 Jan 2002 11:01:10 -0800 Received: from ma.ultranet.com (209-122-234-99.s2163.apx2.sbo.ma.dialup.rcn.com [209.122.234.99]) by ligarius-fe0.ultra.net (8.8.8/ult/n26500/mtc.v2) with ESMTP id NAA26390; Mon, 28 Jan 2002 13:01:01 -0500 (EST) Message-ID: <3C554BCC.ECACEA56@ma.ultranet.com> Date: Mon, 28 Jan 2002 08:02:04 -0500 From: Jim Houston Reply-To: jhouston@ma.ultranet.com X-Mailer: Mozilla 4.76 [en] (X11; U; Linux 2.4.17 i686) X-Accept-Language: en MIME-Version: 1.0 To: Christoph Hellwig CC: kdb@oss.sgi.com Subject: Re: PATCH - kernel trace mechanism for kdb References: <200201280055.g0S0t7O01098@linux.local> <20020128104419.A26140@caldera.de> Content-Type: text/plain; charset=us-ascii Content-Transfer-Encoding: 7bit Sender: owner-kdb@oss.sgi.com Precedence: bulk Christoph Hellwig wrote: > > On Sun, Jan 27, 2002 at 07:55:07PM -0500, Jim Houston wrote: > > Run the script "scripts/inline-fix.pl" included in this patch. This > > changes "extern inline" to "static inline" globally. > > What do you think about preparing such a patch for Linus & Marcelo? > I know we've been bitten by extern inline all the time for various > reasons.. I'm not sure if it's my fight or if its the right fight. It would be nice if the kernel were more consistent. Is there a precident for Linus running scripts against the kernel? I suspect that a patch with the global change might be considered large. Would all of the affected maintainers have to sign up? I also wonder if there is a way to make "extern inline" work and produce a single global instance. In the case of my little trace, it would be much more useable if you could filter out all calls to spin_lock() without having to lookup the addresses of all of the static instances. Jim Houston