[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]

rpms/kernel/devel linux-2.6-drivers-add-qlogic-firmware.patch, NONE, 1.1.2.1 linux-2.6-ehea-ethernet-driver.patch, NONE, 1.1.2.1 linux-2.6-net-ipsec-labelling.patch, NONE, 1.1.2.1 linux-2.6-net-netlabel-cipso.patch, NONE, 1.1.2.1 linux-2.6-nfs-64-bit-inode-support.patch, NONE, 1.1.2.1 linux-2.6-ppc-fix-irq-mapping.patch, NONE, 1.1.2.1 linux-2.6-selinux-support-range-transitions.patch, NONE, 1.1.2.1 kernel-2.6.spec, 1.2519.4.4, 1.2519.4.5 linux-2.6-gfs2-dlm.patch, 1.12.4.2, 1.12.4.3 linux-2.6-gfs2-locking-exports.patch, 1.1.10.2, 1.1.10.3



Author: dzickus

Update of /cvs/dist/rpms/kernel/devel
In directory cvs.devel.redhat.com:/tmp/cvs-serv30905

Modified Files:
      Tag: kernel-2_6_17-1_2519_el5_beta1
	kernel-2.6.spec linux-2.6-gfs2-dlm.patch 
	linux-2.6-gfs2-locking-exports.patch 
Added Files:
      Tag: kernel-2_6_17-1_2519_el5_beta1
	linux-2.6-drivers-add-qlogic-firmware.patch 
	linux-2.6-ehea-ethernet-driver.patch 
	linux-2.6-net-ipsec-labelling.patch 
	linux-2.6-net-netlabel-cipso.patch 
	linux-2.6-nfs-64-bit-inode-support.patch 
	linux-2.6-ppc-fix-irq-mapping.patch 
	linux-2.6-selinux-support-range-transitions.patch 
Log Message:
added in a list of beta1 blockers, read changelog for exact list



linux-2.6-drivers-add-qlogic-firmware.patch:
 Makefile    |    3 
 ql2100_fw.c | 6419 +++++++++++++++++++++++
 ql2200_fw.c | 7066 +++++++++++++++++++++++++
 ql2300_fw.c |10283 ++++++++++++++++++++++++++++++++++++
 ql2322_fw.c |11100 +++++++++++++++++++++++++++++++++++++++
 ql2400_fw.c |16705 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 qla_os.c    |   14 
 7 files changed, 51583 insertions(+), 7 deletions(-)

--- NEW FILE linux-2.6-drivers-add-qlogic-firmware.patch ---
Date: Tue, 15 Aug 2006 11:07:15 -0400 (EDT)
From: Chip Coldwell <coldwell redhat com>

Part one, the content.

-- 
Charles M. "Chip" Coldwell
Senior Software Engineer
Red Hat, Inc
978-392-2426

diff -pruN a/drivers/scsi/qla2xxx/Makefile b/drivers/scsi/qla2xxx/Makefile
--- a/drivers/scsi/qla2xxx/Makefile	2006-08-15 10:45:32.000000000 -0400
+++ b/drivers/scsi/qla2xxx/Makefile	2006-08-15 10:50:42.000000000 -0400
@@ -1,4 +1,5 @@
 qla2xxx-y := qla_os.o qla_init.o qla_mbx.o qla_iocb.o qla_isr.o qla_gs.o \
-		qla_dbg.o qla_sup.o qla_attr.o
+		qla_dbg.o qla_sup.o qla_attr.o ql2100_fw.o ql2200_fw.o \
+		ql2300_fw.o ql2322_fw.o ql2400_fw.o
 
 obj-$(CONFIG_SCSI_QLA_FC) += qla2xxx.o
diff -pruN a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
--- a/drivers/scsi/qla2xxx/qla_os.c	2006-08-15 10:45:32.000000000 -0400
+++ b/drivers/scsi/qla2xxx/qla_os.c	2006-08-15 10:51:14.000000000 -0400
@@ -2575,12 +2575,14 @@ qla2x00_down_timeout(struct semaphore *s
 
 static DECLARE_MUTEX(qla_fw_lock);
 
+extern struct firmware ql2100_fw, ql2200_fw, ql2300_fw, ql2322_fw, ql2400_fw;
+
 static struct fw_blob qla_fw_blobs[FW_BLOBS] = {
-	{ .name = "ql2100_fw.bin", .segs = { 0x1000, 0 }, },
-	{ .name = "ql2200_fw.bin", .segs = { 0x1000, 0 }, },
-	{ .name = "ql2300_fw.bin", .segs = { 0x800, 0 }, },
-	{ .name = "ql2322_fw.bin", .segs = { 0x800, 0x1c000, 0x1e000, 0 }, },
-	{ .name = "ql2400_fw.bin", },
+	{ .name = "ql2100_fw.bin", .segs = { 0x1000, 0 }, .fw = &ql2100_fw },
+	{ .name = "ql2200_fw.bin", .segs = { 0x1000, 0 }, .fw = &ql2200_fw },
+	{ .name = "ql2300_fw.bin", .segs = { 0x800, 0 }, .fw = &ql2300_fw },
+	{ .name = "ql2322_fw.bin", .segs = { 0x800, 0x1c000, 0x1e000, 0 }, .fw = &ql2322_fw },
+	{ .name = "ql2400_fw.bin", .fw = &ql2400_fw },
 };
 
 struct fw_blob *
@@ -2699,7 +2701,7 @@ static void __exit
 qla2x00_module_exit(void)
 {
 	pci_unregister_driver(&qla2xxx_pci_driver);
-	qla2x00_release_firmware();
+	/* qla2x00_release_firmware(); */
 	kmem_cache_destroy(srb_cachep);
 	fc_release_transport(qla2xxx_transport_template);
 }

diff -pruN a/drivers/scsi/qla2xxx/ql2100_fw.c b/drivers/scsi/qla2xxx/ql2100_fw.c
--- a/drivers/scsi/qla2xxx/ql2100_fw.c	1969-12-31 19:00:00.000000000 -0500
+++ b/drivers/scsi/qla2xxx/ql2100_fw.c	2006-08-15 10:49:38.000000000 -0400
@@ -0,0 +1,6419 @@
+/*
+ * Firmware version 1.19 from
+ *
+ * ftp://ftp.qlogic.com/outgoing/linux/firmware/ql2100_fw.bin
+ *
+ * xxd -g 1 -i ql2100_fw.bin | indent -l80 -i8 -o ql2100_fw.c
+ *
+ */
+
+#include <linux/firmware.h>
+
+static u8 ql2100_fw_bin[] = {
+	0x00, 0x78, 0x10, 0x2d, 0x00, 0x00, 0x96, 0x01, 0x00, 0x00, 0x00, 0x01,
+	0x00, 0x13, 0x00, 0x19, 0x00, 0x17, 0x20, 0x43, 0x4f, 0x50, 0x59, 0x52,
+	0x49, 0x47, 0x48, 0x54, 0x20, 0x32, 0x30, 0x30, 0x31, 0x20, 0x51, 0x4c,
+	0x4f, 0x47, 0x49, 0x43, 0x20, 0x43, 0x4f, 0x52, 0x50, 0x4f, 0x52, 0x41,
+	0x54, 0x49, 0x4f, 0x4e, 0x20, 0x49, 0x53, 0x50, 0x32, 0x31, 0x30, 0x30,
+	0x20, 0x46, 0x69, 0x72, 0x6d, 0x77, 0x61, 0x72, 0x65, 0x20, 0x20, 0x56,
+	0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x20, 0x30, 0x31, 0x2e, 0x31, 0x39,
+	0x20, 0x20, 0x20, 0x20, 0x24, 0x00, 0x20, 0x91, 0x20, 0x00, 0x20, 0xc1,
+	0x00, 0x21, 0x20, 0x39, 0xff, 0xff, 0x20, 0x19, 0xaa, 0xaa, 0x27, 0x60,
+	0x20, 0x69, 0x7f, 0xff, 0x20, 0xc1, 0x00, 0x20, 0x2c, 0x2c, 0x2d, 0x34,
+	0x27, 0x62, 0x23, 0x6a, 0x2c, 0x24, 0x2d, 0x04, 0x26, 0x6a, 0x25, 0x62,
+	0xa4, 0x06, 0x00, 0xc0, 0x10, 0x52, 0x20, 0xc1, 0x00, 0x21, 0x2c, 0x2c,
+	0x23, 0x62, 0x2c, 0x04, 0x25, 0x62, 0xa3, 0x06, 0x00, 0x40, 0x10, 0x52,
+	0x20, 0xc1, 0x00, 0x20, 0x20, 0x39, 0x8f, 0xff, 0x20, 0xa1, 0xae, 0x00,
+	0x27, 0x08, 0x81, 0x0d, 0x81, 0x0d, 0x81, 0x0d, 0x81, 0x0d, 0xa1, 0x8c,
+	0x00, 0x0f, 0x20, 0x01, 0x00, 0x0a, 0xa1, 0x12, 0xa0, 0x0e, 0x21, 0xa8,
+	0x41, 0xa4, 0x34, 0x00, 0x82, 0x11, 0x00, 0xc0, 0x10, 0x5f, 0x27, 0x08,
+	0x34, 0x00, 0xa1, 0x02, 0x00, 0x40, 0x10, 0x6f, 0x00, 0x48, 0x10, 0x6f,
+	0x20, 0xa8, 0xa0, 0x0e, 0x41, 0xa4, 0x20, 0xa1, 0xa6, 0x01, 0x20, 0x09,
+	0x00, 0x00, 0x20, 0xa9, 0x07, 0xff, 0x41, 0xa4, 0x34, 0x00, 0x20, 0xc9,
+	0xab, 0xff, 0x20, 0x59, 0x00, 0x00, 0x2b, 0x78, 0x78, 0x23, 0x00, 0x04,
+	0x20, 0x89, 0x25, 0xc7, 0x20, 0x51, 0xa7, 0x00, 0x2a, 0x70, 0x77, 0x62,
+	0xa7, 0x86, 0x8f, 0xff, 0x00, 0x40, 0x10, 0x92, 0x70, 0x5f, 0xce, 0x00,
+	0x70, 0x5b, 0xcd, 0xf1, 0x70, 0x67, 0x02, 0x00, 0x70, 0x6b, 0x02, 0x00,
+	0x00, 0x78, 0x10, 0x9a, 0x70, 0x5b, 0xbe, 0x01, 0x70, 0x67, 0x01, 0x00,
+	0x70, 0x6b, 0x01, 0x00, 0x70, 0x5f, 0xbe, 0x00, 0x10, 0x78, 0x12, 0xdf,
+	0x10, 0x78, 0x13, 0xca, 0x10, 0x78, 0x15, 0x77, 0x10, 0x78, 0x1c, 0xe9,
+	0x10, 0x78, 0x42, 0xec, 0x10, 0x78, 0x76, 0xbf, 0x10, 0x78, 0x13, 0x55,
+	0x10, 0x78, 0x2a, 0xc0, 0x10, 0x78, 0x4e, 0x93, 0x10, 0x78, 0x49, 0xa3,
+	0x10, 0x78, 0x59, 0x4a, 0x10, 0x78, 0x22, 0x63, 0x10, 0x78, 0x5c, 0x43,
+	0x10, 0x78, 0x54, 0x85, 0x10, 0x78, 0x21, 0x62, 0x10, 0x78, 0x22, 0x40,
+	0x20, 0x91, 0x30, 0x09, 0x78, 0x23, 0x00, 0x00, 0x00, 0x90, 0x10, 0xcf,
+	0x78, 0x20, 0xa0, 0x86, 0x00, 0x02, 0x00, 0xc0, 0x10, 0xcf, 0x78, 0x23,
+	0x40, 0x00, 0x00, 0x68, 0x10, 0xc7, 0x78, 0x1b, 0x00, 0x01, 0x20, 0x91,
+	0x50, 0x00, 0x20, 0x91, 0x40, 0x80, 0x2a, 0x70, 0x70, 0x03, 0x00, 0x00,
+	0x20, 0x01, 0x01, 0x7f, 0x20, 0x03, 0x00, 0x00, 0x2a, 0x70, 0x70, 0x00,
+	0xa0, 0x8e, 0x00, 0x03, 0x00, 0xc0, 0x10, 0xef, 0x10, 0x78, 0x36, 0x5e,
+	0x10, 0x78, 0x2a, 0xe8, 0x10, 0x78, 0x4e, 0xe3, 0x10, 0x78, 0x4b, 0x66,
+	0x20, 0x09, 0x01, 0x00, 0x21, 0x04, 0xa0, 0x82, 0x00, 0x02, 0x00, 0x48,
+	0x10, 0xf3, 0x10, 0x78, 0x59, 0x66, 0x00, 0x78, 0x10, 0xd6, 0x10, 0x79,
+	0x10, 0xf7, 0x00, 0x78, 0x10, 0xdc, 0x10, 0x78, 0x71, 0x97, 0x00, 0x78,
+	0x10, 0xeb, 0x11, 0x01, 0x11, 0x02, 0x11, 0xbe, 0x10, 0xff, 0x12, 0x46,
+	0x12, 0xdc, 0x12, 0xdd, 0x12, 0xde, 0x10, 0x78, 0x13, 0x32, 0x00, 0x7c,
+	0x12, 0x7e, 0x0f, 0x7e, 0x20, 0x91, 0x80, 0x00, 0x70, 0x00, 0xa0, 0x86,
+	0x00, 0x01, 0x00, 0xc0, 0x11, 0x98, 0x10, 0x78, 0x3a, 0xec, 0x20, 0x79,
+	0x01, 0x00, 0x78, 0x44, 0xa0, 0x05, 0x00, 0xc0, 0x11, 0x98, 0x20, 0x11,
+	0x41, 0xdc, 0x10, 0x78, 0x5a, 0x45, 0x10, 0x78, 0x1a, 0xdf, 0x78, 0x0f,
+	0x00, 0xff, 0x78, 0x40, 0xa0, 0x84, 0xff, 0xfb, 0x78, 0x42, 0x20, 0x11,
+	0x80, 0x10, 0x73, 0xc4, 0x10, 0x78, 0x36, 0x1b, 0x20, 0x01, 0xff, 0xff,
+	0x10, 0x78, 0x5a, 0xe6, 0x72, 0x3c, 0xc2, 0x84, 0x72, 0x3e, 0x20, 0x01,
+	0xa7, 0x0c, 0x20, 0x14, 0xc2, 0xac, 0x22, 0x02, 0x10, 0x78, 0x6f, 0x9f,
+	0x20, 0x11, 0x00, 0x04, 0x10, 0x78, 0x8d, 0x2b, 0x10, 0x78, 0x48, 0x9e,
+	0x10, 0x78, 0x42, 0xd4, 0x00, 0x40, 0x11, 0x44, 0x70, 0x87, 0x00, 0x01,
+	0x70, 0xbf, 0x00, 0x00, 0x10, 0x78, 0x3c, 0x9e, 0x00, 0x78, 0x11, 0x98,
+	0x10, 0x78, 0x49, 0x67, 0x00, 0x40, 0x11, 0x4d, 0x7a, 0x0c, 0xc2, 0xb4,
+	0x7a, 0x0e, 0x00, 0x78, 0x11, 0x59, 0x10, 0x78, 0x90, 0xb6, 0x70, 0xcc,
+	0xd0, 0x9c, 0x00, 0xc0, 0x11, 0x59, 0x70, 0x98, 0xa0, 0x05, 0x00, 0x40,
+	0x11, 0x59, 0x10, 0x78, 0x42, 0xb8, 0x70, 0xd7, 0x00, 0x00, 0x70, 0xd3,
+	0x00, 0x00, 0x72, 0xcc, 0x20, 0x79, 0xa7, 0x52, 0x78, 0x04, 0xd0, 0xac,
+	0x00, 0x40, 0x11, 0x65, 0xc2, 0x95, 0x72, 0xce, 0xa2, 0x96, 0x00, 0x04,
+	0x00, 0x40, 0x11, 0x86, 0x20, 0x11, 0x00, 0x01, 0x10, 0x78, 0x8d, 0x2b,
+	0x70, 0x93, 0x00, 0x00, 0x70, 0x97, 0xff, 0xff, 0x70, 0x03, 0x00, 0x02,
+	0x0f, 0x7f, 0x10, 0x78, 0x26, 0x77, 0x20, 0x11, 0x00, 0x05, 0x10, 0x78,
+	0x70, 0xe0, 0x10, 0x78, 0x62, 0xd1, 0x0c, 0x7e, 0x20, 0x61, 0x01, 0x00,
+	0x60, 0xe3, 0x00, 0x08, 0x0c, 0x7f, 0x12, 0x7f, 0x00, 0x78, 0x11, 0x9a,
+	0x70, 0x93, 0x00, 0x00, 0x70, 0x97, 0xff, 0xff, 0x70, 0x03, 0x00, 0x02,
+	0x20, 0x11, 0x00, 0x05, 0x10, 0x78, 0x70, 0xe0, 0x10, 0x78, 0x62, 0xd1,
+	0x0c, 0x7e, 0x20, 0x61, 0x01, 0x00, 0x60, 0xe3, 0x00, 0x08, 0x0c, 0x7f,
+	0x0f, 0x7f, 0x12, 0x7f, 0x00, 0x7c, 0x0c, 0x7e, 0x20, 0xa9, 0x00, 0x82,
+	0x20, 0x09, 0x00, 0x7e, 0x01, 0x7e, 0x02, 0x7e, 0x03, 0x7e, 0x21, 0x10,
+	0x02, 0x7e, 0x20, 0x19, 0x00, 0x29, 0x10, 0x78, 0x73, 0xd0, 0x02, 0x7f,
+	0x10, 0x78, 0xa5, 0x01, 0x03, 0x7f, 0x02, 0x7f, 0x01, 0x7f, 0x10, 0x78,
+	0x29, 0x8e, 0x81, 0x08, 0x00, 0xf0, 0x11, 0xa0, 0x0c, 0x7f, 0x70, 0x6f,
+	0x00, 0x00, 0x70, 0x70, 0xa0, 0x84, 0x00, 0xff, 0x70, 0x72, 0x70, 0x9b,
+	0x00, 0x00, 0x00, 0x7c, 0x12, 0x7e, 0x20, 0x91, 0x80, 0x00, 0x70, 0x00,
+	0xa0, 0x86, 0x00, 0x02, 0x00, 0xc0, 0x12, 0x44, 0x70, 0x94, 0xa0, 0x86,
+	0xff, 0xff, 0x00, 0x40, 0x11, 0xd1, 0x10, 0x78, 0x26, 0x77, 0x10, 0x78,
+	0x62, 0xd1, 0x00, 0x78, 0x12, 0x44, 0x70, 0xcc, 0xd0, 0x9c, 0x00, 0x40,
+	0x11, 0xfd, 0xd0, 0x84, 0x00, 0x40, 0x11, 0xfd, 0x0f, 0x7e, 0x20, 0x79,
+	0x01, 0x00, 0x79, 0x0c, 0xc1, 0xb5, 0x79, 0x0e, 0x0f, 0x7f, 0xd0, 0x8c,
+	0x00, 0x40, 0x11, 0xfd, 0x70, 0xd0, 0xa0, 0x86, 0xff, 0xff, 0x00, 0x40,
+	0x11, 0xf9, 0x10, 0x78, 0x27, 0xf7, 0x10, 0x78, 0x62, 0xd1, 0x70, 0xcc,
+	0xd0, 0x94, 0x00, 0xc0, 0x12, 0x44, 0x20, 0x11, 0x00, 0x01, 0x20, 0x19,
+	0x00, 0x00, 0x10, 0x78, 0x28, 0x2f, 0x10, 0x78, 0x62, 0xd1, 0x00, 0x78,
+	0x12, 0x44, 0x70, 0xd4, 0xa0, 0x05, 0x00, 0xc0, 0x12, 0x44, 0x70, 0x90,
+	0xa0, 0x05, 0x00, 0xc0, 0x12, 0x44, 0x10, 0x78, 0x49, 0x67, 0x00, 0xc0,
+	0x12, 0x44, 0x20, 0x01, 0xa7, 0x53, 0x20, 0x04, 0xd0, 0xac, 0x00, 0x40,
+	0x12, 0x27, 0x15, 0x7e, 0x0c, 0x7e, 0x20, 0xa9, 0x00, 0x7f, 0x20, 0x09,
+	0x00, 0x00, 0x01, 0x7e, 0x10, 0x78, 0x45, 0xc4, 0x00, 0xc0, 0x12, 0x1a,
+	0x60, 0x00, 0xd0, 0xec, 0x00, 0xc0, 0x12, 0x22, 0x01, 0x7f, 0x81, 0x08,
+	0x00, 0xf0, 0x12, 0x11, 0x0c, 0x7f, 0x15, 0x7f, 0x00, 0x78, 0x12, 0x27,
+	0x01, 0x7f, 0x0c, 0x7f, 0x15, 0x7f, 0x00, 0x78, 0x12, 0x44, 0x70, 0x03,
+	0x00, 0x03, 0x70, 0x97, 0xff, 0xff, 0x20, 0x01, 0x00, 0x00, 0x10, 0x78,
+	0x24, 0xe8, 0x10, 0x78, 0x36, 0x99, 0x20, 0x01, 0xa9, 0xb2, 0x20, 0x04,
+	0xa0, 0x86, 0x00, 0x05, 0x00, 0xc0, 0x12, 0x3c, 0x20, 0x11, 0x00, 0x00,
+	0x10, 0x78, 0x70, 0xe0, 0x20, 0x11, 0x00, 0x00, 0x10, 0x78, 0x70, 0xea,
+	0x10, 0x78, 0x62, 0xd1, 0x10, 0x78, 0x63, 0x9b, 0x12, 0x7f, 0x00, 0x7c,
+	0x01, 0x7e, 0x0f, 0x7e, 0x12, 0x7e, 0x20, 0x91, 0x80, 0x00, 0x20, 0x79,
+	0x01, 0x00, 0x20, 0x09, 0x00, 0xf7, 0x10, 0x78, 0x42, 0xa1, 0x79, 0x40,
+	0xa1, 0x8c, 0x00, 0x10, 0x79, 0x42, 0x79, 0x24, 0xd1, 0xb4, 0x00, 0x40,
+	0x12, 0x5b, 0x78, 0x27, 0x00, 0x40, 0xd1, 0x9c, 0x00, 0x40, 0x12, 0x60,
+	0x78, 0x27, 0x00, 0x08, 0x00, 0x7e, 0x03, 0x7e, 0x15, 0x7e, 0xa0, 0x06,
+	0x10, 0x78, 0x5a, 0xe6, 0x79, 0x00, 0xa1, 0x8a, 0x00, 0x03, 0x00, 0x50,
+	0x12, 0x89, 0x79, 0x54, 0xd1, 0xac, 0x00, 0xc0, 0x12, 0x89, 0x20, 0x09,
+	0x00, 0xf8, 0x10, 0x78, 0x42, 0xa1, 0x78, 0x43, 0x00, 0x90, 0x78, 0x43,
+	0x00, 0x10, 0x20, 0xa9, 0x09, 0xc4, 0x78, 0x20, 0xd0, 0x9c, 0x00, 0xc0,
+	0x12, 0x81, 0x78, 0x24, 0xd0, 0xac, 0x00, 0xc0, 0x12, 0xca, 0x00, 0xf0,
+	0x12, 0x79, 0x20, 0x01, 0x00, 0x01, 0x10, 0x78, 0x24, 0xe8, 0x00, 0x78,
+	0x12, 0xd5, 0x78, 0x53, 0x00, 0x00, 0x78, 0x2f, 0x00, 0x20, 0x20, 0xa9,
+	0x00, 0x50, 0x00, 0xe0, 0x12, 0x8f, 0x20, 0x91, 0x60, 0x00, 0x00, 0xf0,
+	0x12, 0x8f, 0x78, 0x53, 0x04, 0x00, 0x78, 0x2f, 0x00, 0x00, 0x20, 0x09,
+	0x00, 0xf8, 0x10, 0x78, 0x42, 0xa1, 0x20, 0xa9, 0x00, 0x0e, 0x00, 0x05,
+	0x00, 0xf0, 0x12, 0x9f, 0x78, 0x53, 0x14, 0x00, 0x78, 0x43, 0x00, 0x90,
+	0x78, 0x43, 0x00, 0x10, 0x20, 0x19, 0x61, 0xa8, 0x78, 0x54, 0x00, 0x05,
+	0x00, 0x05, 0xd0, 0x8c, 0x00, 0x40, 0x12, 0xb4, 0x78, 0x24, 0xd0, 0xac,
+	0x00, 0xc0, 0x12, 0xca, 0x83, 0x19, 0x00, 0xc0, 0x12, 0xaa, 0x20, 0x09,
+	0xa7, 0x32, 0x21, 0x04, 0x80, 0x00, 0x20, 0x0a, 0xa0, 0x84, 0xff, 0xf0,
+	0x00, 0x40, 0x12, 0xc4, 0x20, 0x0b, 0x00, 0x00, 0x10, 0x78, 0x25, 0x88,
+	0x20, 0x01, 0x00, 0x01, 0x10, 0x78, 0x24, 0xe8, 0x00, 0x78, 0x12, 0xd3,
+	0x20, 0x01, 0xa7, 0x32, 0x20, 0x03, 0x00, 0x00, 0x78, 0x28, 0xc0, 0x9d,
+	0x78, 0x2a, 0x78, 0x27, 0x00, 0x48, 0x78, 0x53, 0x04, 0x00, 0x15, 0x7f,
+	0x03, 0x7f, 0x00, 0x7f, 0x12, 0x7f, 0x0f, 0x7f, 0x01, 0x7f, 0x00, 0x7c,
+	0x00, 0x7c, 0x00, 0x7c, 0x00, 0x7c, 0x2a, 0x70, 0x20, 0x61, 0xa9, 0xad,
+	0x20, 0x63, 0x00, 0x01, 0x60, 0x07, 0x00, 0x13, 0x60, 0x0b, 0x00, 0x19,
+	0x60, 0x0f, 0x00, 0x17, 0x20, 0x09, 0x01, 0x00, 0x21, 0x04, 0xa0, 0x82,
+	0x00, 0x02, 0x00, 0x48, 0x12, 0xf5, 0x70, 0x53, 0xff, 0xff, 0x00, 0x78,
+	0x12, 0xf7, 0x70, 0x53, 0x00, 0x00, 0x70, 0x57, 0xff, 0xff, 0x70, 0x6f,
+	0x00, 0x00, 0x70, 0x73, 0x00, 0x00, 0x10, 0x78, 0x90, 0xb6, 0x20, 0x61,
+	0xa9, 0x8d, 0x60, 0x03, 0x09, 0x09, 0x60, 0x07, 0x00, 0x00, 0x60, 0x0b,
[...51248 lines suppressed...]
+	0x06, 0x3f, 0x3c, 0x08, 0x06, 0x00, 0x00, 0x0d, 0x01, 0x3e, 0x40, 0x00,
+	0x06, 0x00, 0x00, 0x20, 0x04, 0x0f, 0x80, 0x1a, 0x03, 0x20, 0x00, 0x0a,
+	0x02, 0x20, 0x17, 0xd0, 0x03, 0x2f, 0xa0, 0x12, 0x02, 0x02, 0xc0, 0x13,
+	0x00, 0x80, 0x02, 0xcd, 0x04, 0x00, 0x70, 0x13, 0x07, 0xa0, 0x03, 0xcf,
+	0x00, 0x7a, 0x01, 0x01, 0x07, 0x05, 0x00, 0x00, 0x07, 0x30, 0x30, 0x00,
+	0x07, 0x00, 0x88, 0x90, 0x07, 0x4d, 0x00, 0x05, 0x06, 0x00, 0x60, 0x13,
+	0x05, 0x0f, 0x80, 0x1e, 0x03, 0x2f, 0xa0, 0x3a, 0x05, 0x60, 0x1a, 0x2b,
+	0x05, 0x0f, 0x80, 0xff, 0x02, 0x2f, 0xa0, 0x19, 0x04, 0x00, 0x10, 0x02,
+	0x04, 0x00, 0x20, 0x13, 0x04, 0x0f, 0x80, 0x1f, 0x02, 0x2f, 0xa0, 0x1a,
+	0x07, 0x3a, 0xa0, 0x0c, 0x06, 0x00, 0x00, 0x02, 0x07, 0x30, 0x0c, 0x03,
+	0x06, 0x00, 0x00, 0x0d, 0x02, 0x80, 0x03, 0xbc, 0x04, 0x00, 0x70, 0x13,
+	0x07, 0xa0, 0x03, 0xcf, 0x00, 0x7a, 0x01, 0x01, 0x03, 0x07, 0x00, 0x00,
+	0x06, 0x60, 0x28, 0x2a, 0x05, 0x0f, 0x80, 0xff, 0x07, 0x3f, 0xa0, 0x09,
+	0x06, 0x00, 0x00, 0x04, 0x02, 0x49, 0x90, 0x08, 0x06, 0x81, 0x03, 0x2a,
+	0x07, 0x30, 0x30, 0x00, 0x07, 0x00, 0x88, 0x90, 0x02, 0x80, 0x03, 0x2c,
+	0x07, 0x30, 0x30, 0x00, 0x04, 0x00, 0x89, 0x80, 0x05, 0x00, 0x70, 0x03,
+	0x07, 0x4d, 0x00, 0x05, 0x06, 0x00, 0x60, 0x13, 0x05, 0x0f, 0x80, 0x1e,
+	0x03, 0x2f, 0xa0, 0x3a, 0x07, 0x60, 0x14, 0x2b, 0x05, 0x0f, 0x80, 0xff,
+	0x03, 0x2f, 0xa0, 0x21, 0x06, 0x4b, 0x00, 0x02, 0x02, 0x49, 0x90, 0x08,
+	0x06, 0x81, 0x03, 0x38, 0x06, 0x44, 0xc0, 0x02, 0x05, 0x4b, 0x04, 0x00,
+	0x05, 0x00, 0x40, 0xff, 0x06, 0x69, 0x81, 0x04, 0x05, 0x81, 0x83, 0x4d,
+	0x06, 0x00, 0x00, 0x13, 0x04, 0x00, 0x10, 0x13, 0x04, 0x78, 0x01, 0x02,
+	0x06, 0x00, 0x00, 0x10, 0x06, 0x00, 0x30, 0x13, 0x04, 0x00, 0x40, 0x13,
+	0x06, 0x00, 0x50, 0x13, 0x06, 0x00, 0x60, 0x13, 0x04, 0x00, 0x70, 0x13,
+	0x00, 0x64, 0x40, 0x15, 0x06, 0x82, 0x03, 0x49, 0x04, 0x44, 0x80, 0x02,
+	0x02, 0x20, 0x50, 0x08, 0x04, 0x0f, 0x80, 0x1f, 0x03, 0x2f, 0xa0, 0x42,
+	0x04, 0x00, 0x80, 0x15, 0x02, 0x80, 0x03, 0x86, 0x04, 0x6c, 0x80, 0x04,
+	0x04, 0x81, 0x83, 0x5b, 0x01, 0x20, 0x80, 0x18, 0x06, 0x78, 0x00, 0x02,
+	0x07, 0x00, 0x00, 0x03, 0x04, 0x81, 0x83, 0x5e, 0x06, 0x00, 0x30, 0x01,
+	0x06, 0x00, 0x00, 0x13, 0x04, 0x00, 0x10, 0x13, 0x04, 0x00, 0x40, 0x13,
+	0x06, 0x00, 0x50, 0x13, 0x04, 0x0f, 0x80, 0x1f, 0x02, 0x2f, 0xa0, 0x32,
+	0x02, 0x80, 0x03, 0x86, 0x04, 0x0f, 0xd0, 0x2a, 0x07, 0xa0, 0x05, 0x3a,
+	0x03, 0x80, 0x00, 0x14, 0x03, 0x79, 0xff, 0x03, 0x07, 0x00, 0x00, 0xff,
+	0x04, 0x48, 0x80, 0x02, 0x07, 0x81, 0x03, 0x65, 0x07, 0x0f, 0xf0, 0x03,
+	0x04, 0x50, 0x04, 0x08, 0x05, 0x00, 0x80, 0xff, 0x03, 0x79, 0xff, 0x00,
+	0x07, 0x00, 0x00, 0xff, 0x06, 0x48, 0x90, 0x02, 0x07, 0x81, 0x03, 0x6c,
+	0x07, 0x0f, 0xf0, 0x00, 0x04, 0x50, 0x04, 0x08, 0x05, 0x00, 0x80, 0xff,
+	0x07, 0x00, 0x50, 0x03, 0x05, 0x00, 0x40, 0x00, 0x06, 0x00, 0x30, 0x01,
+	0x06, 0x00, 0x00, 0x13, 0x04, 0x00, 0x10, 0x13, 0x04, 0x0f, 0x80, 0x1f,
+	0x02, 0x2f, 0xa0, 0x32, 0x05, 0x60, 0x1c, 0x2b, 0x05, 0x0f, 0x80, 0xff,
+	0x02, 0x2f, 0xa0, 0x31, 0x06, 0x60, 0x0c, 0x1f, 0x05, 0x0f, 0x80, 0xff,
+	0x02, 0x2f, 0xa0, 0x32, 0x02, 0x68, 0x06, 0x08, 0x06, 0x81, 0x03, 0x86,
+	0x01, 0x64, 0x08, 0xff, 0x05, 0x7d, 0xfe, 0xff, 0x07, 0xff, 0xff, 0xff,
+	0x03, 0x40, 0x00, 0xff, 0x04, 0x5a, 0x04, 0x07, 0x07, 0x00, 0x00, 0xff,
+	0x07, 0x60, 0x06, 0x1e, 0x05, 0x0f, 0x80, 0xff, 0x03, 0x2f, 0xa0, 0x0a,
+	0x06, 0x60, 0x09, 0x08, 0x06, 0x69, 0xf9, 0x08, 0x02, 0x7a, 0x00, 0x08,
+	0x06, 0x00, 0x00, 0x20, 0x07, 0x0a, 0xa0, 0xff, 0x02, 0x4a, 0x24, 0x08,
+	0x03, 0x7a, 0x00, 0xff, 0x06, 0x00, 0x00, 0xdc, 0x07, 0x00, 0x00, 0xff,
+	0x02, 0x80, 0x03, 0xbc, 0x04, 0x00, 0x70, 0x13, 0x07, 0xa0, 0x03, 0xcf,
+	0x00, 0x7a, 0x01, 0x01, 0x07, 0x03, 0x00, 0x00, 0x07, 0x30, 0x30, 0x00,
+	0x07, 0x00, 0x81, 0x90, 0x06, 0x00, 0x60, 0x13, 0x05, 0x0f, 0x80, 0x1e,
+	0x03, 0x2f, 0xa0, 0x3a, 0x07, 0x3a, 0xa0, 0x00, 0x06, 0x00, 0x00, 0x02,
+	0x07, 0x30, 0x0c, 0x00, 0x07, 0x00, 0x00, 0x05, 0x02, 0x80, 0x03, 0xbc,
+	0x04, 0x00, 0x70, 0x13, 0x07, 0xa0, 0x03, 0xcf, 0x00, 0x7a, 0x01, 0x01,
+	0x07, 0x81, 0x00, 0x00, 0x07, 0x30, 0x30, 0x00, 0x07, 0x00, 0x00, 0x90,
+	0x06, 0x00, 0x60, 0x13, 0x06, 0x60, 0x0c, 0x2a, 0x05, 0x0f, 0x80, 0xff,
+	0x05, 0x3f, 0xa8, 0x09, 0x07, 0x00, 0x00, 0x03, 0x04, 0x78, 0x01, 0x07,
+	0x07, 0xff, 0xff, 0x00, 0x00, 0x7c, 0x01, 0x07, 0x07, 0x00, 0x05, 0x00,
+	0x05, 0x81, 0x83, 0xaf, 0x07, 0x30, 0x30, 0x00, 0x05, 0x00, 0x08, 0x90,
+	0x07, 0x4d, 0x00, 0x05, 0x06, 0x60, 0x28, 0x2a, 0x05, 0x0f, 0x80, 0xff,
+	0x05, 0x3f, 0xa8, 0x09, 0x07, 0x00, 0x00, 0x03, 0x00, 0x49, 0xd0, 0x07,
+	0x06, 0x81, 0x03, 0xb6, 0x02, 0x20, 0x60, 0x01, 0x05, 0x0f, 0x80, 0x1e,
+	0x03, 0x2f, 0xa0, 0x3a, 0x07, 0x3a, 0xa0, 0x00, 0x06, 0x00, 0x00, 0x02,
+	0x07, 0x30, 0x0c, 0x00, 0x07, 0x00, 0x00, 0x05, 0x01, 0x3e, 0x40, 0x00,
+	0x07, 0x00, 0x00, 0x30, 0x03, 0x98, 0x03, 0xbe, 0x07, 0x0f, 0xf0, 0xf6,
+	0x03, 0x68, 0x30, 0xff, 0x04, 0x81, 0x83, 0xbf, 0x07, 0x0f, 0x00, 0x1e,
+	0x04, 0x0f, 0x10, 0x1f, 0x07, 0x0f, 0x30, 0x00, 0x01, 0x3e, 0x40, 0x00,
+	0x06, 0x00, 0x00, 0x20, 0x04, 0x0f, 0x80, 0x1a, 0x03, 0x20, 0x00, 0x0a,
+	0x02, 0x20, 0x17, 0xd0, 0x03, 0x2f, 0xa0, 0x12, 0x00, 0x80, 0x02, 0xcd,
+	0x03, 0x20, 0x00, 0x00, 0x06, 0x00, 0x60, 0x76, 0x03, 0x80, 0x03, 0xd1,
+	0x03, 0x20, 0x00, 0x11, 0x06, 0x00, 0x60, 0x2a, 0x05, 0xa0, 0x04, 0x66,
+	0x05, 0x60, 0x04, 0x06, 0x05, 0x0f, 0x80, 0xff, 0x05, 0x3f, 0xa8, 0x09,
+	0x06, 0x00, 0x00, 0x02, 0x07, 0xc0, 0x00, 0x00, 0x02, 0x07, 0x60, 0x2f,
+	0x04, 0x60, 0x08, 0x76, 0x05, 0x0f, 0x80, 0xff, 0x02, 0x2f, 0xa0, 0x31,
+	0x03, 0x07, 0x50, 0x00, 0x00, 0x07, 0xb0, 0x04, 0x01, 0x01, 0x80, 0x05,
+	0x06, 0x60, 0x00, 0x76, 0x05, 0x00, 0x20, 0xff, 0x05, 0x0f, 0x80, 0xff,
+	0x03, 0x2f, 0xa0, 0x11, 0x03, 0x02, 0xf0, 0x00, 0x01, 0x86, 0x83, 0xee,
+	0x02, 0x02, 0xf0, 0x01, 0x00, 0x86, 0x83, 0xec, 0x00, 0x02, 0xe0, 0x13,
+	0x07, 0x60, 0x18, 0x18, 0x05, 0x0f, 0x80, 0xff, 0x05, 0x3f, 0xa8, 0x0a,
+	0x07, 0x00, 0x00, 0x09, 0x02, 0x80, 0x03, 0xf4, 0x00, 0x02, 0xe0, 0x01,
+	0x02, 0x80, 0x03, 0xf4, 0x04, 0x0f, 0xe0, 0x01, 0x03, 0x86, 0x03, 0xe7,
+	0x07, 0x60, 0x00, 0x2e, 0x05, 0x0f, 0x80, 0xff, 0x01, 0x2f, 0xa8, 0x0a,
+	0x00, 0x02, 0xe0, 0x01, 0x06, 0x00, 0x00, 0x13, 0x04, 0x00, 0x10, 0x13,
+	0x04, 0x0f, 0x80, 0x02, 0x03, 0x2f, 0xa0, 0x12, 0x06, 0x27, 0x30, 0x01,
+	0x04, 0x48, 0xb0, 0x75, 0x05, 0x81, 0x83, 0xff, 0x04, 0x60, 0x20, 0x76,
+	0x05, 0x0f, 0x80, 0xff, 0x05, 0x3f, 0xa8, 0x11, 0x07, 0x00, 0x00, 0x3c,
+	0x01, 0x79, 0xfe, 0x78, 0x07, 0x00, 0x00, 0xff, 0x03, 0x01, 0x90, 0xff,
+	0x02, 0x86, 0x84, 0x07, 0x05, 0xa0, 0x04, 0x1b, 0x00, 0x07, 0x80, 0x19,
+	0x00, 0x92, 0x04, 0x1a, 0x01, 0x80, 0x04, 0x5f, 0x04, 0x0f, 0xd0, 0x76,
+	0x04, 0x0f, 0xd0, 0x19, 0x04, 0x60, 0x02, 0x76, 0x05, 0x00, 0x20, 0xff,
+	0x05, 0x0f, 0x80, 0xff, 0x03, 0x2f, 0xa0, 0x09, 0x04, 0x0f, 0x80, 0x02,
+	0x05, 0x3f, 0xa8, 0x0a, 0x07, 0x00, 0x00, 0x09, 0x05, 0x0f, 0xe0, 0x00,
+	0x03, 0x86, 0x84, 0x17, 0x07, 0x60, 0x18, 0x18, 0x05, 0x0f, 0x80, 0xff,
+	0x05, 0x3f, 0xa8, 0x0a, 0x07, 0x00, 0x00, 0x09, 0x01, 0x80, 0x04, 0x18,
+	0x07, 0xa0, 0x00, 0xee, 0x07, 0x27, 0x30, 0x00, 0x02, 0x07, 0x60, 0x13,
+	0x03, 0x80, 0x00, 0x3c, 0x05, 0x8b, 0x04, 0x1b, 0x03, 0x38, 0x50, 0x00,
+	0x07, 0x03, 0x00, 0x00, 0x05, 0x60, 0x08, 0x18, 0x05, 0x0f, 0x80, 0xff,
+	0x03, 0x2f, 0xa0, 0x09, 0x05, 0x4b, 0x04, 0x00, 0x03, 0x08, 0xa0, 0xff,
+	0x01, 0x79, 0xfe, 0x00, 0x07, 0x00, 0x00, 0xff, 0x01, 0x08, 0x80, 0xff,
+	0x04, 0x48, 0xb0, 0x75, 0x05, 0x81, 0x04, 0x35, 0x07, 0x60, 0x14, 0x7b,
+	0x05, 0x0f, 0x80, 0xff, 0x00, 0x2f, 0xa8, 0x19, 0x06, 0x4b, 0x00, 0x01,
+	0x02, 0x08, 0x00, 0x02, 0x01, 0x08, 0x10, 0x03, 0x00, 0x08, 0x20, 0x01,
+	0x02, 0x08, 0x30, 0x01, 0x02, 0x07, 0x90, 0x01, 0x02, 0x07, 0xa0, 0x01,
+	0x00, 0x08, 0x40, 0x13, 0x02, 0x07, 0xf0, 0x13, 0x00, 0x80, 0x04, 0x57,
+	0x06, 0x48, 0x50, 0x75, 0x05, 0x81, 0x04, 0x4d, 0x02, 0x46, 0x50, 0x75,
+	0x06, 0x60, 0x14, 0x76, 0x05, 0x0f, 0x80, 0xff, 0x07, 0x3f, 0xa0, 0x21,
+	0x06, 0x00, 0x00, 0x3e, 0x07, 0x0f, 0xf0, 0x7d, 0x04, 0x50, 0x04, 0x7c,
+	0x05, 0x0f, 0x80, 0xff, 0x00, 0x2f, 0xa8, 0x19, 0x04, 0x8b, 0x04, 0x40,
+	0x02, 0x08, 0x00, 0x01, 0x00, 0x08, 0x10, 0x02, 0x01, 0x08, 0x20, 0x03,
+	0x03, 0x07, 0x90, 0x03, 0x02, 0x08, 0x30, 0x7a, 0x03, 0x40, 0x00, 0x7e,
+	0x06, 0x42, 0x00, 0x7f, 0x04, 0x81, 0x04, 0x52, 0x07, 0x0f, 0xf0, 0x7e,
+	0x05, 0xa0, 0x01, 0xe2, 0x02, 0x92, 0x84, 0x52, 0x00, 0x80, 0x04, 0x5e,
+	0x05, 0x8b, 0x04, 0x4d, 0x06, 0x60, 0x14, 0x76, 0x05, 0x0f, 0x80, 0xff,
+	0x07, 0x3f, 0xa0, 0x41, 0x06, 0x00, 0x00, 0x3e, 0x06, 0x60, 0x24, 0x76,
+	0x05, 0x0f, 0x80, 0xff, 0x07, 0x3f, 0xa0, 0x09, 0x06, 0x00, 0x00, 0x07,
+	0x00, 0x08, 0x40, 0x0e, 0x04, 0x8b, 0x04, 0x57, 0x03, 0x38, 0x50, 0x00,
+	0x03, 0x01, 0x00, 0x00, 0x06, 0x21, 0x90, 0x01, 0x04, 0x0f, 0xe0, 0x7f,
+	0x00, 0x86, 0x04, 0x5e, 0x00, 0x80, 0x01, 0xcb, 0x07, 0xc0, 0x00, 0x00,
+	0x00, 0x68, 0x3e, 0x75, 0x04, 0x81, 0x04, 0x64, 0x04, 0x48, 0xd0, 0x75,
+	0x04, 0x81, 0x04, 0x8a, 0x00, 0x80, 0x04, 0xbc, 0x06, 0xa0, 0x05, 0x1a,
+	0x00, 0x80, 0x04, 0x1a, 0x03, 0x97, 0x84, 0x71, 0x07, 0x60, 0x24, 0x18,
+	0x05, 0x0f, 0x80, 0xff, 0x01, 0x2f, 0xa8, 0x09, 0x06, 0x78, 0x00, 0x01,
+	0x07, 0x00, 0x00, 0xff, 0x07, 0x5a, 0x00, 0x00, 0x07, 0x0f, 0xf0, 0x14,
+	0x05, 0x69, 0xfe, 0xff, 0x05, 0x4b, 0x08, 0xff, 0x07, 0x5a, 0x00, 0x00,
+	0x05, 0x60, 0x04, 0x18, 0x05, 0x0f, 0x80, 0xff, 0x01, 0x2f, 0xa8, 0x09,
+	0x04, 0x0f, 0xe0, 0x07, 0x03, 0x86, 0x84, 0x78, 0x01, 0x20, 0x40, 0x00,
+	0x00, 0x80, 0x04, 0x86, 0x00, 0x70, 0x01, 0x01, 0x03, 0x01, 0x00, 0x00,
+	0x06, 0x78, 0x00, 0x01, 0x07, 0xff, 0x00, 0x00, 0x07, 0x6c, 0x00, 0xff,
+	0x06, 0x81, 0x84, 0x80, 0x00, 0x70, 0x01, 0x01, 0x03, 0x01, 0x00, 0x00,
+	0x05, 0x60, 0x04, 0x18, 0x05, 0x0f, 0x80, 0xff, 0x01, 0x2f, 0xa8, 0x0a,
+	0x06, 0x78, 0x00, 0x01, 0x07, 0xff, 0x00, 0x00, 0x05, 0x00, 0x40, 0xff,
+	0x02, 0x79, 0xff, 0x01, 0x07, 0x00, 0xff, 0xff, 0x05, 0x00, 0x20, 0x14,
+	0x07, 0xc0, 0x00, 0x00, 0x04, 0x00, 0x70, 0x76, 0x04, 0x48, 0xb0, 0x75,
+	0x04, 0x81, 0x04, 0xa4, 0x03, 0x20, 0x00, 0x11, 0x06, 0x00, 0x60, 0x76,
+	0x07, 0xa0, 0x03, 0xd1, 0x00, 0x7a, 0x01, 0x01, 0x07, 0x06, 0x00, 0x00,
+	0x07, 0x30, 0x30, 0x00, 0x07, 0x00, 0x82, 0x90, 0x07, 0x60, 0x00, 0x18,
+	0x05, 0x0f, 0x80, 0xff, 0x05, 0x3f, 0xa8, 0x09, 0x07, 0x00, 0x00, 0x03,
+	0x04, 0x48, 0xe0, 0x07, 0x07, 0x81, 0x84, 0x9c, 0x06, 0x00, 0x60, 0x13,
+	0x01, 0x80, 0x04, 0xb7, 0x02, 0x40, 0x00, 0x10, 0x05, 0x81, 0x04, 0x9c,
+	0x06, 0x00, 0x60, 0x10, 0x04, 0x60, 0x32, 0x76, 0x05, 0x0f, 0x80, 0xff,
+	0x07, 0x3f, 0xa0, 0x0a, 0x07, 0x00, 0x00, 0x03, 0x01, 0x80, 0x04, 0xb7,
+	0x06, 0x00, 0x00, 0x7a, 0x02, 0x49, 0x30, 0x75, 0x06, 0x81, 0x84, 0xad,
+	0x04, 0x60, 0x2a, 0x76, 0x05, 0x0f, 0x80, 0xff, 0x03, 0x2f, 0xa0, 0x09,
+	0x06, 0x0f, 0xf0, 0x7a, 0x05, 0x50, 0x04, 0x00, 0x07, 0x00, 0x00, 0xff,
+	0x06, 0x47, 0x30, 0x75, 0x04, 0x60, 0x2a, 0x76, 0x05, 0x0f, 0x80, 0xff,
+	0x03, 0x2f, 0xa0, 0x0a, 0x07, 0xa0, 0x03, 0xcc, 0x00, 0x7a, 0x01, 0x01,
+	0x03, 0x01, 0x00, 0x00, 0x06, 0x30, 0x30, 0x08, 0x05, 0x00, 0x80, 0x00,
+	0x06, 0x00, 0x60, 0x0e, 0x05, 0x0f, 0x80, 0x74, 0x03, 0x2f, 0xa0, 0x3a,
+	0x05, 0x30, 0x79, 0xa0, 0x07, 0x00, 0x00, 0x0c, 0x00, 0x80, 0x04, 0xfd,
+	0x00, 0x68, 0x3e, 0x75, 0x07, 0x6c, 0x0a, 0xff, 0x05, 0x81, 0x04, 0xdb,
+	0x04, 0x00, 0x70, 0x13, 0x03, 0x20, 0x00, 0x11, 0x06, 0x00, 0x60, 0x76,
+	0x07, 0xa0, 0x03, 0xd1, 0x00, 0x7a, 0x01, 0x01, 0x03, 0x07, 0x00, 0x00,
+	0x06, 0x60, 0x28, 0x76, 0x05, 0x0f, 0x80, 0xff, 0x05, 0x3f, 0xa8, 0x09,
+	0x06, 0x00, 0x00, 0x01, 0x03, 0x49, 0x90, 0x03, 0x04, 0x81, 0x04, 0xd0,
+	0x07, 0x30, 0x30, 0x00, 0x07, 0x00, 0x88, 0x90, 0x05, 0x30, 0x79, 0xa0,
+	0x07, 0x00, 0x00, 0x0c, 0x01, 0x80, 0x04, 0xd4, 0x07, 0x30, 0x30, 0x00,
+	0x04, 0x00, 0x89, 0x80, 0x04, 0x30, 0x79, 0x20, 0x07, 0x00, 0x00, 0x0c,
+	0x07, 0x4d, 0x00, 0x05, 0x06, 0x00, 0x60, 0x13, 0x05, 0x0f, 0x80, 0x74,
+	0x03, 0x2f, 0xa0, 0x3a, 0x04, 0x30, 0x79, 0x20, 0x07, 0x00, 0x00, 0x0c,
+	0x00, 0x80, 0x04, 0xfd, 0x04, 0x60, 0x2a, 0x76, 0x05, 0x0f, 0x80, 0xff,
+	0x03, 0x2f, 0xa0, 0x09, 0x06, 0x0f, 0xf0, 0x7a, 0x05, 0x50, 0x04, 0x00,
+	0x07, 0x00, 0x00, 0xff, 0x06, 0x47, 0x30, 0x75, 0x04, 0x60, 0x2a, 0x76,
+	0x05, 0x0f, 0x80, 0xff, 0x03, 0x2f, 0xa0, 0x0a, 0x04, 0x00, 0x70, 0x76,
+	0x07, 0xa0, 0x03, 0xcc, 0x00, 0x7a, 0x01, 0x01, 0x03, 0x01, 0x00, 0x00,
+	0x06, 0x30, 0x30, 0x08, 0x07, 0x00, 0x88, 0x00, 0x07, 0x4d, 0x00, 0x05,
+	0x06, 0x60, 0x0a, 0x76, 0x05, 0x0f, 0x80, 0xff, 0x07, 0x3f, 0xa0, 0x09,
+	0x07, 0x00, 0x00, 0x03, 0x05, 0x4b, 0x04, 0x06, 0x04, 0x5a, 0x04, 0x04,
+	0x05, 0x00, 0x40, 0xff, 0x06, 0x00, 0x60, 0x0e, 0x05, 0x0f, 0x80, 0x74,
+	0x03, 0x2f, 0xa0, 0x3a, 0x06, 0x48, 0xc0, 0x75, 0x04, 0x81, 0x04, 0xfb,
+	0x06, 0x30, 0x7d, 0x20, 0x07, 0x00, 0x00, 0x0c, 0x00, 0x80, 0x04, 0xfd,
+	0x04, 0x30, 0x79, 0x20, 0x07, 0x00, 0x00, 0x0c, 0x01, 0x3e, 0x40, 0x00,
+	0x07, 0x00, 0x00, 0x30, 0x01, 0x98, 0x04, 0xff, 0x07, 0x0f, 0xf0, 0xf6,
+	0x07, 0x48, 0x50, 0xff, 0x05, 0x81, 0x85, 0x00, 0x05, 0x0f, 0x20, 0x74,
+	0x06, 0x0a, 0x00, 0x07, 0x04, 0x00, 0x70, 0xfb, 0x04, 0x6a, 0x70, 0x07,
+	0x05, 0x0f, 0x40, 0xff, 0x01, 0x3e, 0x40, 0x00, 0x06, 0x00, 0x00, 0x20,
+	0x06, 0x78, 0x00, 0x7a, 0x07, 0xff, 0xf0, 0x00, 0x04, 0x81, 0x85, 0x10,
+	0x03, 0x20, 0x00, 0x0a, 0x02, 0x20, 0x17, 0xd0, 0x02, 0x80, 0x05, 0x13,
+	0x03, 0x20, 0x00, 0x0a, 0x06, 0x30, 0x1b, 0x58, 0x06, 0x00, 0x00, 0x01,
+	0x05, 0x0f, 0x80, 0x72, 0x03, 0x2f, 0xa0, 0x12, 0x00, 0x80, 0x04, 0x1a,
+	0x01, 0x20, 0x80, 0x60, 0x06, 0x00, 0x90, 0x2a, 0x04, 0x00, 0x20, 0x20,
+	0x02, 0x80, 0x05, 0x26, 0x04, 0x00, 0x80, 0xfb, 0x06, 0x6a, 0xe1, 0x08,
+	0x06, 0x00, 0x90, 0x76, 0x04, 0x00, 0x20, 0x75, 0x02, 0x80, 0x05, 0x26,
+	0x03, 0x20, 0x11, 0x00, 0x05, 0x84, 0x85, 0x24, 0x06, 0x42, 0x00, 0x01,
+	0x04, 0x81, 0x85, 0x20, 0x02, 0x80, 0x05, 0x3d, 0x02, 0x0e, 0x00, 0x08,
+	0x07, 0xc0, 0x00, 0x00, 0x05, 0x0f, 0xd0, 0x09, 0x04, 0x0f, 0xd0, 0x08,
+	0x03, 0x20, 0x11, 0x00, 0x05, 0x84, 0x85, 0x2d, 0x06, 0x42, 0x00, 0x01,
+	0x04, 0x81, 0x85, 0x29, 0x02, 0x80, 0x05, 0x3d, 0x00, 0x7a, 0x01, 0x02,
+	0x04, 0x00, 0x01, 0x01, 0x05, 0x60, 0x08, 0x09, 0x05, 0x0f, 0x80, 0xff,
+	0x07, 0x3f, 0xa0, 0x0a, 0x06, 0x00, 0x00, 0x01, 0x02, 0x0e, 0x00, 0x08,
+	0x06, 0x84, 0x05, 0x37, 0x03, 0x0e, 0x00, 0x09, 0x07, 0xc0, 0x00, 0x00,
+	0x01, 0x01, 0x10, 0x09, 0x05, 0x2e, 0x43, 0x00, 0x07, 0xc0, 0x00, 0x00,
+	0x05, 0x2e, 0x40, 0x0f, 0x01, 0x20, 0x80, 0x90, 0x02, 0x80, 0x05, 0x1f,
+	0x07, 0x0f, 0xc0, 0xff, 0x04, 0x0f, 0x80, 0x13, 0x03, 0x2f, 0xa0, 0x09,
+	0x02, 0x80, 0x05, 0x40, 0x77, 0x78, 0x21, 0xfa, 0xff, 0xee, 0xff, 0xd6
+};
+
+struct firmware ql2400_fw = {
+	.size = sizeof(ql2400_fw_bin),
+	.data = ql2400_fw_bin
+};

linux-2.6-ehea-ethernet-driver.patch:
 Makefile       |    7 
 ehea.h         |  434 +++++++++
 ehea_ethtool.c |  325 +++++++
 ehea_hcall.h   |   52 +
 ehea_hw.h      |  319 +++++++
 ehea_main.c    | 2560 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 ehea_phyp.c    | 1020 ++++++++++++++++++++++
 ehea_phyp.h    |  625 +++++++++++++
 ehea_qmr.c     |  719 ++++++++++++++++
 ehea_qmr.h     |  390 ++++++++
 10 files changed, 6451 insertions(+)

--- NEW FILE linux-2.6-ehea-ethernet-driver.patch ---
Date: Tue, 18 Jul 2006 12:39:16 -0400 (EDT)
From: Manoj Iyer <miyer redhat com>
--- linux-2.6.17-rc6-orig/drivers/net/ehea/ehea_main.c	1969-12-31 16:00:00.000000000 -0800
+++ kernel/drivers/net/ehea/ehea_main.c	2006-06-09 05:29:59.776161616 -0700
@@ -0,0 +1,2560 @@
+/*
+ *  linux/drivers/net/ehea/ehea_main.c
+ *
+ *  eHEA ethernet device driver for IBM eServer System p
+ *
+ *  (C) Copyright IBM Corp. 2006
+ *
+ *  Authors:
+ *       Christoph Raisch <raisch de ibm com>
+ *       Jan-Bernd Themann <themann de ibm com>
+ *       Heiko-Joerg Schick <schickhj de ibm com>
+ *       Thomas Klein <tklein de ibm com>
+ *
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#define DEB_PREFIX "main"
+
+#include <linux/in.h>
+#include <linux/ip.h>
+#include <linux/tcp.h>
+#include <linux/udp.h>
+#include <linux/if.h>
+#include <linux/list.h>
+#include <net/ip.h>
+
+#include "ehea.h"
+#include "ehea_qmr.h"
+#include "ehea_phyp.h"
+
+struct task_struct *ehea_irq_helper_thread;
+extern int ehea_irq_helper(void);
+
+
+#define USE_INTERRUPTS
+#define POLL_PORT_INTERVAL (HZ / 20)
+#define SKB_CLEANUP_INTERVAL (HZ / 1000)
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Christoph Raisch <raisch de ibm com>");
+MODULE_DESCRIPTION("IBM eServer HEA Driver");
+MODULE_VERSION(EHEA_DRIVER_VERSION);
+
+static int __devinit ehea_probe(struct ibmebus_dev *dev,
+				const struct of_device_id *id);
+static int __devexit ehea_remove(struct ibmebus_dev *dev);
+static int ehea_sense_port_attr(struct ehea_adapter *adapter, int portnum);
+
+int ehea_trace_level = 5;
+
+static struct net_device_stats *ehea_get_stats(struct net_device *dev)
+{
+	u64 hret;
+	struct ehea_port *port = (struct ehea_port*)dev->priv;
+	struct ehea_adapter *adapter = port->adapter;
+	struct hcp_query_ehea_port_cb_2 *cb2 = NULL;
+	struct net_device_stats *stats = &port->stats;
+
+	EDEB_EN(7, "net_device=%p", dev);
+
+	cb2 = kzalloc(H_CB_ALIGNMENT, GFP_KERNEL);
+	if(!cb2) {
+		EDEB_ERR(4, "No memory for cb2");
+		goto get_stat_exit;
+	}
+
+	hret = ehea_h_query_ehea_port(adapter->handle,
+				      port->logical_port_id,
+				      H_PORT_CB2,
+				      H_PORT_CB2_ALL,
+				      cb2);
+
+	if (hret != H_SUCCESS) {
+		EDEB_ERR(4, "query_ehea_port failed for cb2");
+		goto get_stat_exit;
+	}
+
+	EDEB_DMP(7, (u8*)cb2,
+		 sizeof(struct hcp_query_ehea_port_cb_2), "After HCALL");
+
+	stats->tx_packets = cb2->txucp + cb2->txmcp + cb2->txbcp;
+	stats->multicast = cb2->rxmcp;
+	stats->rx_errors = cb2->rxuerr;
+	stats->rx_bytes = cb2->rxo;
+	stats->tx_bytes = cb2->txo;
+
+get_stat_exit:
+	EDEB_EX(7, "");
+	return stats;
+}
+
+static inline int ehea_refill_rq1(struct ehea_port_res *port_res, int arr_index,
+				  int nr_of_wqes)
+{
+	int i;
+	int ret = 0;
+	struct ehea_qp *qp;
+	int skb_arr_rq1_len = port_res->skb_arr_rq1_len;
+	struct sk_buff **skb_arr_rq1 = port_res->skb_arr_rq1;
+	EDEB_EN(7, "port_res=%p, arr_index=%d, nr_of_wqes=%d, arr_rq1_len=%d",
+		port_res, arr_index, nr_of_wqes, skb_arr_rq1_len);
+
+	qp = port_res->qp;
+	if (unlikely(nr_of_wqes == 0))
+		return -EINVAL;
+	for (i = 0; i < nr_of_wqes; i++) {
+		int index = ((skb_arr_rq1_len + arr_index) - i)
+		    % skb_arr_rq1_len;
+		if (!skb_arr_rq1[index]) {
+			skb_arr_rq1[index] = dev_alloc_skb(EHEA_LL_PKT_SIZE);
+
+			if (!skb_arr_rq1[index]) {
+				EDEB_ERR(4, "No mem for skb/%d wqes filled", i);
+				ret = -ENOMEM;
+				break;
+			}
+		}
+	}
+	/* Ring doorbell */
+	ehea_update_rq1a(qp, nr_of_wqes);
+	EDEB_EX(7, "");
+	return ret;
+}
+
+static int ehea_init_fill_rq1(struct ehea_port_res *port_res, int nr_rq1a)
+{
+	int i;
+	int ret = 0;
+	struct ehea_qp *qp;
+	EDEB_EN(7, "port_res=%p, nr_rq1a=%d", port_res, nr_rq1a);
+	qp = port_res->qp;
+
+	for (i = 0; i < port_res->skb_arr_rq1_len; i++) {
+		port_res->skb_arr_rq1[i] = dev_alloc_skb(EHEA_LL_PKT_SIZE);
+		if (!port_res->skb_arr_rq1[i]) {
+			EDEB_ERR(4, "dev_alloc_skb failed. Only %d skb filled.",
+				 i);
+			ret = -ENOMEM;
+			break;
+		}
+	}
+	/* Ring doorbell */
+	ehea_update_rq1a(qp, nr_rq1a);
+	EDEB_EX(7, "");
+	return ret;
+}
+
+static inline int ehea_refill_rq2(struct ehea_port_res *pr, int nr_of_wqes)
+{
+	int i;
+	int ret = 0;
+	struct ehea_qp *qp;
+	struct ehea_rwqe *rwqe;
+	int skb_arr_rq2_len = pr->skb_arr_rq2_len;
+	struct sk_buff **skb_arr_rq2 = pr->skb_arr_rq2;
+
+	EDEB_EN(8, "pr=%p, nr_of_wqes=%d", pr, nr_of_wqes);
+	if (nr_of_wqes == 0)
+		return -EINVAL;
+	qp = pr->qp;
+	for (i = 0; i < nr_of_wqes; i++) {
+		int index = pr->skb_rq2_index++;
+		struct sk_buff *skb = dev_alloc_skb(EHEA_PAGESIZE);
+
+		if (!skb) {
+			EDEB_ERR(4, "dev_alloc_ask failed. Only %d skb filled.",
+				 i);
+			ret = -ENOMEM;
+			break;
+		}
+
+		rwqe = ehea_get_next_rwqe(qp, 2);
+		pr->skb_rq2_index %= skb_arr_rq2_len;
+		skb_arr_rq2[index] = skb;
+		rwqe->wr_id = EHEA_BMASK_SET(EHEA_WR_ID_TYPE, EHEA_RWQE2_TYPE)
+		            | EHEA_BMASK_SET(EHEA_WR_ID_INDEX, index);
+		rwqe->sg_list[0].l_key = ehea_get_lkey(pr->port->adapter,
+						       (void*)skb->data);
+		rwqe->sg_list[0].vaddr = (u64)skb->data;
+		rwqe->sg_list[0].len = EHEA_PAGESIZE;
+		rwqe->data_segments = 1;
[...6103 lines suppressed...]
+	u64 qpedx_rrva2;
+	u64 reserved4;
+	u64 qpedx_rrl3;
+	u64 qpedx_rrrkey3;
+	u64 qpedx_rrva3;
+};
+
+#define CQX_FECADDER EHEA_BMASK_IBM(32, 63)
+#define CQX_FEC_CQE_CNT EHEA_BMASK_IBM(32, 63)
+#define CQX_N1_GENERATE_COMP_EVENT EHEA_BMASK_IBM(0, 0)
+#define CQX_EP_EVENT_PENDING EHEA_BMASK_IBM(0, 0)
+
+#define CQTEMM_OFFSET(x) offsetof(struct ehea_cqtemm, x)
+
+struct ehea_cqtemm {
+	u64 cqx_hcr;
+	u64 cqx_c;
+	u64 cqx_herr;
+	u64 cqx_aer;
+	u64 cqx_ptp;
+	u64 cqx_tp;
+	u64 cqx_fec;
+	u64 cqx_feca;
+	u64 cqx_ep;
+	u64 cqx_eq;
+	u64 reserved1;
+	u64 cqx_n0;
+	u64 cqx_n1;
+	u64 reserved2[(0x1000 - 0x60) / 8];
+};
+
+#define EQTEMM_OFFSET(x) offsetof(struct ehea_eqtemm, x)
+
+struct ehea_eqtemm {
+	u64 EQx_HCR;
+	u64 EQx_C;
+	u64 EQx_HERR;
+	u64 EQx_AER;
+	u64 EQx_PTP;
+	u64 EQx_TP;
+	u64 EQx_SSBA;
+	u64 EQx_PSBA;
+	u64 EQx_CEC;
+	u64 EQx_MEQL;
+	u64 EQx_XISBI;
+	u64 EQx_XISC;
+	u64 EQx_IT;
+};
+
+static inline u64 hipz_galpa_load(struct h_galpa galpa, u32 offset)
+{
+	u64 addr = galpa.fw_handle + offset;
+	u64 out;
+	EDEB_EN(7, "addr=%lx offset=%x ", addr, offset);
+	out = *(volatile u64 *)addr;
+	EDEB_EX(7, "addr=%lx value=%lx", addr, out);
+	return out;
+};
+
+static inline void hipz_galpa_store(struct h_galpa galpa, u32 offset, u64 value)
+{
+	u64 addr = galpa.fw_handle + offset;
+	EDEB_EN(7, "addr=%lx offset=%x value=%lx", addr, offset,
+		value);
+	*(u64 *) addr = value;
+	hipz_galpa_load(galpa, offset);	/* synchronize explicitly to ehea */
+	EDEB_EX(7, "");
+};
+
+static inline void hipz_galpa_store_acc(struct h_galpa galpa, u32 offset,
+					u64 value)
+{
+	u64 addr = galpa.fw_handle + offset;
+	EDEB(7, "Accelerated store: addr=%lx offset=%x value=%lx",
+	     addr, offset, value);
+	*(u64 *) addr = value;
+};
+
+#define hipz_galpa_store_eq(gal, offset, value)\
+        hipz_galpa_store(gal, EQTEMM_OFFSET(offset), value)
+#define hipz_galpa_load_eq(gal, offset)\
+        hipz_galpa_load(gal, EQTEMM_OFFSET(offset))
+
+#define hipz_galpa_store_cq(gal, offset, value)\
+        hipz_galpa_store(gal, CQTEMM_OFFSET(offset), value)
+#define hipz_galpa_load_cq(gal, offset)\
+        hipz_galpa_load(gal, CQTEMM_OFFSET(offset))
+
+#define hipz_galpa_store_qp(gal, offset, value)\
+        hipz_galpa_store(gal, QPTEMM_OFFSET(offset), value)
+#define hipz_galpa_load_qp(gal, offset)\
+        hipz_galpa_load(gal, QPTEMM_OFFSET(offset))
+
+#define hipz_galpa_store_qped(gal, offset, value)\
+        hipz_galpa_store(gal, QPEDMM_OFFSET(offset), value)
+#define hipz_galpa_load_qped(gal, offset)\
+        hipz_galpa_load(gal, QPEDMM_OFFSET(offset))
+
+#define hipz_galpa_store_mrmw(gal, offset, value)\
+        hipz_galpa_store(gal, MRMWMM_OFFSET(offset), value)
+#define hipz_galpa_load_mrmw(gal, offset)\
+        hipz_galpa_load(gal, MRMWMM_OFFSET(offset))
+
+#define hipz_galpa_store_base(gal, offset, value)\
+        hipz_galpa_store(gal, HCAGR_OFFSET(offset), value)
+#define hipz_galpa_load_base(gal, offset)\
+        hipz_galpa_load(gal, HCAGR_OFFSET(offset))
+
+static inline void ehea_update_sqa(struct ehea_qp *qp, u16 nr_wqes)
+{
+	struct h_galpa gal = qp->galpas.kernel;
+	EDEB_EN(7, "qp=%p, nr_wqes=%d", qp, nr_wqes);
+
+	hipz_galpa_store_acc(gal, QPTEMM_OFFSET(qpx_sqa),
+			     EHEA_BMASK_SET(QPX_SQA_VALUE, nr_wqes));
+	EDEB_EX(7, "qpx_sqa = %i", nr_wqes);
+}
+
+static inline void ehea_update_rq3a(struct ehea_qp *qp, u16 nr_wqes)
+{
+	struct h_galpa gal = qp->galpas.kernel;
+	EDEB_EN(7, "ehea_qp=%p, nr_wqes=%d", qp, nr_wqes);
+	hipz_galpa_store_acc(gal, QPTEMM_OFFSET(qpx_rq3a),
+			     EHEA_BMASK_SET(QPX_RQ1A_VALUE, nr_wqes));
+	EDEB_EX(7, "QPx_RQA = %i", nr_wqes);
+}
+
+static inline void ehea_update_rq2a(struct ehea_qp *qp, u16 nr_wqes)
+{
+	struct h_galpa gal = qp->galpas.kernel;
+	EDEB_EN(7, "ehea_qp=%p, nr_wqes=%d", qp, nr_wqes);
+	hipz_galpa_store_acc(gal, QPTEMM_OFFSET(qpx_rq2a),
+			     EHEA_BMASK_SET(QPX_RQ1A_VALUE, nr_wqes));
+	EDEB_EX(7, "QPx_RQA = %i", nr_wqes);
+}
+
+static inline void ehea_update_rq1a(struct ehea_qp *qp, u16 nr_wqes)
+{
+	struct h_galpa gal = qp->galpas.kernel;
+	EDEB_EN(7, "ehea_qp=%p, nr_wqes=%d", qp, nr_wqes);
+	hipz_galpa_store_acc(gal, QPTEMM_OFFSET(qpx_rq1a),
+			     EHEA_BMASK_SET(QPX_RQ1A_VALUE, nr_wqes));
+	EDEB_EX(7, "QPx_RQA = %i", nr_wqes);
+}
+
+static inline void ehea_update_feca(struct ehea_cq *cq, u32 nr_cqes)
+{
+	struct h_galpa gal = cq->galpas.kernel;
+	EDEB_EN(7, "");
+	hipz_galpa_store_acc(gal, CQTEMM_OFFSET(cqx_feca),
+			     EHEA_BMASK_SET(CQX_FECADDER, nr_cqes));
+	EDEB_EX(7, "cqx_feca = %i", nr_cqes);
+}
+
+static inline void ehea_reset_cq_n1(struct ehea_cq *cq)
+{
+	struct h_galpa gal = cq->galpas.kernel;
+	EDEB_EN(7, "");
+	hipz_galpa_store_cq(gal,
+			    cqx_n1,
+			    EHEA_BMASK_SET(CQX_N1_GENERATE_COMP_EVENT, 1));
+	EDEB_EX(7, "");
+}
+
+static inline void ehea_reset_cq_ep(struct ehea_cq *my_cq)
+{
+	struct h_galpa gal = my_cq->galpas.kernel;
+	EDEB_EN(7, "");
+	hipz_galpa_store_acc(gal,
+			     CQTEMM_OFFSET(cqx_ep),
+			     EHEA_BMASK_SET(CQX_EP_EVENT_PENDING, 0));
+	EDEB_EX(7, "");
+}
+
+
+#endif	/* __EHEA_HW_H__ */


--- linux-2.6.17-rc6-orig/drivers/net/ehea/Makefile	1969-12-31 16:00:00.000000000 -0800
+++ kernel/drivers/net/ehea/Makefile	2006-06-09 05:29:59.170253728 -0700
@@ -0,0 +1,7 @@
+#
+# Makefile for the eHEA ethernet device driver for IBM eServer System p
+#
+
+ehea_mod-objs = ehea_main.o ehea_phyp.o ehea_qmr.o ehea_ethtool.o ehea_phyp.o
+obj-$(CONFIG_EHEA) += ehea_mod.o
+

--
Please review and ACK for RHEL5.0
----------
Manoj Iyer
IBM, Linux on PowerPC
Redhat Onsite Developer.
Phone: 1-978-392-3934
Cell: 1-512-350-3400
10 Technology Park Dr
Westford MA.


linux-2.6-net-ipsec-labelling.patch:
 Documentation/networking/secid.txt           |   14 +
 include/linux/security.h                     |  214 +++++++++++++++++++++++---
 include/net/flow.h                           |    5 
 include/net/request_sock.h                   |    1 
 include/net/route.h                          |    3 
 include/net/sock.h                           |   14 +
 include/net/xfrm.h                           |    2 
 net/core/flow.c                              |    7 
 net/core/sock.c                              |    2 
 net/dccp/ipv4.c                              |    4 
 net/dccp/ipv6.c                              |    9 +
 net/ipv4/af_inet.c                           |    1 
 net/ipv4/icmp.c                              |    2 
 net/ipv4/inet_connection_sock.c              |    3 
 net/ipv4/ip_output.c                         |    2 
 net/ipv4/netfilter/ipt_REJECT.c              |    1 
 net/ipv4/raw.c                               |    1 
 net/ipv4/syncookies.c                        |    5 
 net/ipv4/tcp_ipv4.c                          |    3 
 net/ipv4/udp.c                               |    1 
 net/ipv6/af_inet6.c                          |    1 
 net/ipv6/datagram.c                          |    2 
 net/ipv6/icmp.c                              |    2 
 net/ipv6/inet6_connection_sock.c             |    1 
 net/ipv6/ndisc.c                             |    1 
 net/ipv6/netfilter/ip6t_REJECT.c             |    1 
 net/ipv6/raw.c                               |    1 
 net/ipv6/tcp_ipv6.c                          |    9 +
 net/ipv6/udp.c                               |    2 
 net/key/af_key.c                             |   37 ++++
 net/xfrm/xfrm_policy.c                       |   27 +--
 net/xfrm/xfrm_state.c                        |   14 +
 net/xfrm/xfrm_user.c                         |   58 +++++--
 security/dummy.c                             |   58 ++++++-
 security/selinux/hooks.c                     |  183 +++++++++++++++-------
 security/selinux/include/av_perm_to_string.h |    1 
 security/selinux/include/av_permissions.h    |    1 
 security/selinux/include/objsec.h            |    1 
 security/selinux/include/security.h          |    2 
 security/selinux/include/xfrm.h              |   43 +++--
 security/selinux/ss/mls.c                    |   20 --
 security/selinux/ss/mls.h                    |   20 ++
 security/selinux/ss/services.c               |   69 ++++++++
 security/selinux/xfrm.c                      |  216 ++++++++++++++++++++++-----
 44 files changed, 854 insertions(+), 210 deletions(-)

--- NEW FILE linux-2.6-net-ipsec-labelling.patch ---
Date: Tue, 8 Aug 2006 00:20:01 -0400 (EDT)
From: James Morris <jmorris redhat com>
Subject: [SELINUX/NETWORK 1/2] IPsec labeling enhancements for MLS
Message-ID: <Pine LNX 4 44 0608080013270 13632-100000 redline boston redhat com>

This patch, from TCS, enhances the IPsec xfrm labeling for MLS, to allow 
Linux to be certified against LSPP.

The upstream post of the first patch is here:
http://marc.theaimsgroup.com/?l=linux-netdev&m=115324352321637&w=2

This code has been merged into the upstream 2.6.19 networking tree and is 
also included in the latest -mm kernel.

Signed-off-by: Venkat Yekkirala <vyekkirala TrustedCS com>
Signed-off-by: David S. Miller <davem davemloft net>
Signed-off-by: James Morris <jmorris redhat com>

---

 Documentation/networking/secid.txt           |   14 +
 include/linux/security.h                     |  214 +++++++++++++++++++++++---
 include/net/flow.h                           |    5 
 include/net/request_sock.h                   |    1 
 include/net/route.h                          |    3 
 include/net/sock.h                           |   14 +
 include/net/xfrm.h                           |    2 
 net/core/flow.c                              |    7 
 net/core/sock.c                              |    2 
 net/dccp/ipv4.c                              |    4 
 net/dccp/ipv6.c                              |    9 +
 net/ipv4/af_inet.c                           |    1 
 net/ipv4/icmp.c                              |    2 
 net/ipv4/inet_connection_sock.c              |    3 
 net/ipv4/ip_output.c                         |    2 
 net/ipv4/netfilter/ipt_REJECT.c              |    1 
 net/ipv4/raw.c                               |    1 
 net/ipv4/syncookies.c                        |    5 
 net/ipv4/tcp_ipv4.c                          |    3 
 net/ipv4/udp.c                               |    1 
 net/ipv6/af_inet6.c                          |    1 
 net/ipv6/datagram.c                          |    2 
 net/ipv6/icmp.c                              |    2 
 net/ipv6/inet6_connection_sock.c             |    1 
 net/ipv6/ndisc.c                             |    1 
 net/ipv6/netfilter/ip6t_REJECT.c             |    1 
 net/ipv6/raw.c                               |    1 
 net/ipv6/tcp_ipv6.c                          |    9 +
 net/ipv6/udp.c                               |    2 
 net/key/af_key.c                             |   37 ++++
 net/xfrm/xfrm_policy.c                       |   27 +--
 net/xfrm/xfrm_state.c                        |   14 +
 net/xfrm/xfrm_user.c                         |   58 +++++--
 security/dummy.c                             |   58 ++++++-
 security/selinux/hooks.c                     |  183 +++++++++++++++-------
 security/selinux/include/av_perm_to_string.h |    1 
 security/selinux/include/av_permissions.h    |    1 
 security/selinux/include/objsec.h            |    1 
 security/selinux/include/security.h          |    2 
 security/selinux/include/xfrm.h              |   43 +++--
 security/selinux/ss/mls.c                    |   20 --
 security/selinux/ss/mls.h                    |   20 ++
 security/selinux/ss/services.c               |   69 ++++++++
 security/selinux/xfrm.c                      |  216 ++++++++++++++++++++++-----
 44 files changed, 854 insertions(+), 210 deletions(-)


diff -purN -X dontdiff linux-2.6.17.i686/Documentation/networking/secid.txt linux-2.6.17.i686.w/Documentation/networking/secid.txt
--- linux-2.6.17.i686/Documentation/networking/secid.txt	1969-12-31 19:00:00.000000000 -0500
+++ linux-2.6.17.i686.w/Documentation/networking/secid.txt	2006-08-07 20:29:29.000000000 -0400
@@ -0,0 +1,14 @@
+flowi structure:
+
+The secid member in the flow structure is used in LSMs (e.g. SELinux) to indicate
+the label of the flow. This label of the flow is currently used in selecting
+matching labeled xfrm(s).
+
+If this is an outbound flow, the label is derived from the socket, if any, or
+the incoming packet this flow is being generated as a response to (e.g. tcp
+resets, timewait ack, etc.). It is also conceivable that the label could be
+derived from other sources such as process context, device, etc., in special
+cases, as may be appropriate.
+
+If this is an inbound flow, the label is derived from the IPSec security
+associations, if any, used by the packet.
diff -purN -X dontdiff linux-2.6.17.i686/include/linux/security.h linux-2.6.17.i686.w/include/linux/security.h
--- linux-2.6.17.i686/include/linux/security.h	2006-08-07 10:40:09.000000000 -0400
+++ linux-2.6.17.i686.w/include/linux/security.h	2006-08-07 20:34:49.000000000 -0400
@@ -31,6 +31,8 @@
 #include <linux/msg.h>
 #include <linux/sched.h>
 #include <linux/key.h>
+#include <linux/xfrm.h>
+#include <net/flow.h>
 
 struct ctl_table;
 
@@ -88,6 +90,7 @@ extern int cap_netlink_recv(struct sk_bu
 struct nfsctl_arg;
 struct sched_param;
 struct swap_info_struct;
+struct request_sock;
 
 /* bprm_apply_creds unsafe reasons */
 #define LSM_UNSAFE_SHARE	1
@@ -812,9 +815,19 @@ struct swap_info_struct;
  *      which is used to copy security attributes between local stream sockets.
  * @sk_free_security:
  *	Deallocate security structure.
- * @sk_getsid:
- *	Retrieve the LSM-specific sid for the sock to enable caching of network
+ * @sk_clone_security:
+ *	Clone/copy security structure.
+ * @sk_getsecid:
+ *	Retrieve the LSM-specific secid for the sock to enable caching of network
  *	authorizations.
+ * @sock_graft:
+ *	Sets the socket's isec sid to the sock's sid.
+ * @inet_conn_request:
+ *	Sets the openreq's sid to socket's sid with MLS portion taken from peer sid.
+ * @inet_csk_clone:
+ *	Sets the new child socket's sid to the openreq sid.
+ * @req_classify_flow:
+ *	Sets the flow's sid to the openreq sid.
  *
  * Security hooks for XFRM operations.
  *
@@ -823,9 +836,10 @@ struct swap_info_struct;
  *	used by the XFRM system.
  *	@sec_ctx contains the security context information being provided by
  *	the user-level policy update program (e.g., setkey).
- *	Allocate a security structure to the xp->security field.
- *	The security field is initialized to NULL when the xfrm_policy is
- *	allocated.
+ *	@sk refers to the sock from which to derive the security context.
+ *	Allocate a security structure to the xp->security field; the security
+ *	field is initialized to NULL when the xfrm_policy is allocated. Only
+ *	one of sec_ctx or sock can be specified.
  *	Return 0 if operation was successful (memory to allocate, legal context)
  * @xfrm_policy_clone_security:
  *	@old contains an existing xfrm_policy in the SPD.
@@ -844,9 +858,14 @@ struct swap_info_struct;
  *	Database by the XFRM system.
  *	@sec_ctx contains the security context information being provided by
  *	the user-level SA generation program (e.g., setkey or racoon).
- *	Allocate a security structure to the x->security field.  The
- *	security field is initialized to NULL when the xfrm_state is
- *	allocated.
+ *	@polsec contains the security context information associated with a xfrm
+ *	policy rule from which to take the base context. polsec must be NULL
+ *	when sec_ctx is specified.
+ *	@secid contains the secid from which to take the mls portion of the context.
+ *	Allocate a security structure to the x->security field; the security
+ *	field is initialized to NULL when the xfrm_state is allocated. Set the
+ *	context to correspond to either sec_ctx or polsec, with the mls portion
+ *	taken from secid in the latter case.
  *	Return 0 if operation was successful (memory to allocate, legal context).
  * @xfrm_state_free_security:
  *	@x contains the xfrm_state.
@@ -857,13 +876,27 @@ struct swap_info_struct;
  * @xfrm_policy_lookup:
  *	@xp contains the xfrm_policy for which the access control is being
  *	checked.
- *	@sk_sid contains the sock security label that is used to authorize
+ *	@fl_secid contains the flow security label that is used to authorize
  *	access to the policy xp.
  *	@dir contains the direction of the flow (input or output).
- *	Check permission when a sock selects a xfrm_policy for processing
+ *	Check permission when a flow selects a xfrm_policy for processing
  *	XFRMs on a packet.  The hook is called when selecting either a
  *	per-socket policy or a generic xfrm policy.
  *	Return 0 if permission is granted.
+ * @xfrm_state_pol_flow_match:
+ *	@x contains the state to match.
+ *	@xp contains the policy to check for a match.
+ *	@fl contains the flow to check for a match.
+ *	Return 1 if there is a match.
+ * @xfrm_flow_state_match:
+ *	@fl contains the flow key to match.
+ *	@xfrm points to the xfrm_state to match.
+ *	Return 1 if there is a match.
+ * @xfrm_decode_session:
+ *	@skb points to skb to decode.
+ *	@secid points to the flow key secid to set.
+ *	@ckall says if all xfrms used should be checked for same secid.
+ *	Return 0 if ckall is zero or all xfrms used have the same secid.
  *
  * Security hooks affecting all Key Management operations
  *
@@ -1332,18 +1365,31 @@ struct security_operations {
 	int (*socket_getpeersec_dgram) (struct socket *sock, struct sk_buff *skb, u32 *secid);
 	int (*sk_alloc_security) (struct sock *sk, int family, gfp_t priority);
 	void (*sk_free_security) (struct sock *sk);
-	unsigned int (*sk_getsid) (struct sock *sk, struct flowi *fl, u8 dir);
+	void (*sk_clone_security) (const struct sock *sk, struct sock *newsk);
+	void (*sk_getsecid) (struct sock *sk, u32 *secid);
+	void (*sock_graft)(struct sock* sk, struct socket *parent);
+	int (*inet_conn_request)(struct sock *sk, struct sk_buff *skb,
+					struct request_sock *req);
[...1949 lines suppressed...]
+				if (!sid_set) {
+					*sid = ctx->ctx_sid;
+					sid_set = 1;
+
+					if (!ckall)
+						break;
+				}
+				else if (*sid != ctx->ctx_sid)
+					return -EINVAL;
+			}
+		}
+	}
+
+	return 0;
+}
+
+/*
  * Security blob allocation for xfrm_policy and xfrm_state
  * CTX does not have a meaningful value on input
  */
-static int selinux_xfrm_sec_ctx_alloc(struct xfrm_sec_ctx **ctxp, struct xfrm_user_sec_ctx *uctx)
+static int selinux_xfrm_sec_ctx_alloc(struct xfrm_sec_ctx **ctxp,
+	struct xfrm_user_sec_ctx *uctx, struct xfrm_sec_ctx *pol, u32 sid)
 {
 	int rc = 0;
 	struct task_security_struct *tsec = current->security;
-	struct xfrm_sec_ctx *ctx;
+	struct xfrm_sec_ctx *ctx = NULL;
+	char *ctx_str = NULL;
+	u32 str_len;
+	u32 ctx_sid;
 
-	BUG_ON(!uctx);
-	BUG_ON(uctx->ctx_doi != XFRM_SC_ALG_SELINUX);
+	BUG_ON(uctx && pol);
+
+	if (!uctx)
+		goto not_from_user;
+
+	if (uctx->ctx_doi != XFRM_SC_ALG_SELINUX)
+		return -EINVAL;
 
 	if (uctx->ctx_len >= PAGE_SIZE)
 		return -ENOMEM;
@@ -141,9 +249,43 @@ static int selinux_xfrm_sec_ctx_alloc(st
 
 	return rc;
 
+not_from_user:
+	if (pol) {
+		rc = security_sid_mls_copy(pol->ctx_sid, sid, &ctx_sid);
+		if (rc)
+			goto out;
+	}
+	else
+		ctx_sid = sid;
+
+	rc = security_sid_to_context(ctx_sid, &ctx_str, &str_len);
+	if (rc)
+		goto out;
+
+	*ctxp = ctx = kmalloc(sizeof(*ctx) +
+			      str_len,
+			      GFP_ATOMIC);
+
+	if (!ctx) {
+		rc = -ENOMEM;
+		goto out;
+	}
+
+	ctx->ctx_doi = XFRM_SC_DOI_LSM;
+	ctx->ctx_alg = XFRM_SC_ALG_SELINUX;
+	ctx->ctx_sid = ctx_sid;
+	ctx->ctx_len = str_len;
+	memcpy(ctx->ctx_str,
+	       ctx_str,
+	       str_len);
+
+	goto out2;
+
 out:
 	*ctxp = NULL;
 	kfree(ctx);
+out2:
+	kfree(ctx_str);
 	return rc;
 }
 
@@ -151,13 +293,23 @@ out:
  * LSM hook implementation that allocs and transfers uctx spec to
  * xfrm_policy.
  */
-int selinux_xfrm_policy_alloc(struct xfrm_policy *xp, struct xfrm_user_sec_ctx *uctx)
+int selinux_xfrm_policy_alloc(struct xfrm_policy *xp,
+		struct xfrm_user_sec_ctx *uctx, struct sock *sk)
 {
 	int err;
+	u32 sid;
 
 	BUG_ON(!xp);
+	BUG_ON(uctx && sk);
 
-	err = selinux_xfrm_sec_ctx_alloc(&xp->security, uctx);
+	if (sk) {
+		struct sk_security_struct *ssec = sk->sk_security;
+		sid = ssec->sid;
+	}
+	else
+		sid = SECSID_NULL;
+
+	err = selinux_xfrm_sec_ctx_alloc(&xp->security, uctx, NULL, sid);
 	return err;
 }
 
@@ -217,13 +369,14 @@ int selinux_xfrm_policy_delete(struct xf
  * LSM hook implementation that allocs and transfers sec_ctx spec to
  * xfrm_state.
  */
-int selinux_xfrm_state_alloc(struct xfrm_state *x, struct xfrm_user_sec_ctx *uctx)
+int selinux_xfrm_state_alloc(struct xfrm_state *x, struct xfrm_user_sec_ctx *uctx,
+		struct xfrm_sec_ctx *pol, u32 secid)
 {
 	int err;
 
 	BUG_ON(!x);
 
-	err = selinux_xfrm_sec_ctx_alloc(&x->security, uctx);
+	err = selinux_xfrm_sec_ctx_alloc(&x->security, uctx, pol, secid);
 	return err;
 }
 
@@ -329,38 +482,30 @@ int selinux_xfrm_state_delete(struct xfr
  * we need to check for unlabelled access since this may not have
  * gone thru the IPSec process.
  */
-int selinux_xfrm_sock_rcv_skb(u32 isec_sid, struct sk_buff *skb)
+int selinux_xfrm_sock_rcv_skb(u32 isec_sid, struct sk_buff *skb,
+				struct avc_audit_data *ad)
 {
 	int i, rc = 0;
 	struct sec_path *sp;
+	u32 sel_sid = SECINITSID_UNLABELED;
 
 	sp = skb->sp;
 
 	if (sp) {
-		/*
-		 * __xfrm_policy_check does not approve unless xfrm_policy_ok
-		 * says that spi's match for policy and the socket.
-		 *
-		 *  Only need to verify the existence of an authorizable sp.
-		 */
 		for (i = 0; i < sp->len; i++) {
 			struct xfrm_state *x = sp->xvec[i];
 
-			if (x && selinux_authorizable_xfrm(x))
-				goto accept;
+			if (x && selinux_authorizable_xfrm(x)) {
+				struct xfrm_sec_ctx *ctx = x->security;
+				sel_sid = ctx->ctx_sid;
+				break;
+			}
 		}
 	}
 
-	/* check SELinux sock for unlabelled access */
-	rc = avc_has_perm(isec_sid, SECINITSID_UNLABELED, SECCLASS_ASSOCIATION,
-			  ASSOCIATION__RECVFROM, NULL);
-	if (rc)
-		goto drop;
-
-accept:
-	return 0;
+	rc = avc_has_perm(isec_sid, sel_sid, SECCLASS_ASSOCIATION,
+			  ASSOCIATION__RECVFROM, ad);
 
-drop:
 	return rc;
 }
 
@@ -371,7 +516,8 @@ drop:
  * If we do have a authorizable security association, then it has already been
  * checked in xfrm_policy_lookup hook.
  */
-int selinux_xfrm_postroute_last(u32 isec_sid, struct sk_buff *skb)
+int selinux_xfrm_postroute_last(u32 isec_sid, struct sk_buff *skb,
+					struct avc_audit_data *ad)
 {
 	struct dst_entry *dst;
 	int rc = 0;
@@ -391,7 +537,7 @@ int selinux_xfrm_postroute_last(u32 isec
 	}
 
 	rc = avc_has_perm(isec_sid, SECINITSID_UNLABELED, SECCLASS_ASSOCIATION,
-			  ASSOCIATION__SENDTO, NULL);
+			  ASSOCIATION__SENDTO, ad);
 out:
 	return rc;
 }


linux-2.6-net-netlabel-cipso.patch:
 Documentation/00-INDEX                                    |    2 
 Documentation/netlabel/00-INDEX                           |   10 
 Documentation/netlabel/cipso_ipv4.txt                     |   48 
 Documentation/netlabel/draft-ietf-cipso-ipsecurity-01.txt |  781 ++++++
 Documentation/netlabel/introduction.txt                   |   46 
 Documentation/netlabel/lsm_interface.txt                  |   47 
 Documentation/networking/ip-sysctl.txt                    |   35 
 include/linux/ip.h                                        |    1 
 include/linux/security.h                                  |   25 
 include/linux/sysctl.h                                    |    4 
 include/linux/utsrelease.h                                |    1 
 include/net/cipso_ipv4.h                                  |  250 ++
 include/net/inet_sock.h                                   |    2 
 include/net/netlabel.h                                    |  291 ++
 net/Kconfig                                               |    2 
 net/Makefile                                              |    1 
 net/ipv4/Makefile                                         |    1 
 net/ipv4/ah4.c                                            |    2 
 net/ipv4/cipso_ipv4.c                                     | 1607 ++++++++++++++
 net/ipv4/ip_options.c                                     |   19 
 net/ipv4/sysctl_net_ipv4.c                                |   35 
 net/netlabel/Kconfig                                      |   14 
 net/netlabel/Makefile                                     |   16 
 net/netlabel/netlabel_cipso_v4.c                          |  542 ++++
 net/netlabel/netlabel_cipso_v4.h                          |  217 +
 net/netlabel/netlabel_domainhash.c                        |  513 ++++
 net/netlabel/netlabel_domainhash.h                        |   63 
 net/netlabel/netlabel_kapi.c                              |  231 ++
 net/netlabel/netlabel_mgmt.c                              |  624 +++++
 net/netlabel/netlabel_mgmt.h                              |  246 ++
 net/netlabel/netlabel_unlabeled.c                         |  253 ++
 net/netlabel/netlabel_unlabeled.h                         |   98 
 net/netlabel/netlabel_user.c                              |  158 +
 net/netlabel/netlabel_user.h                              |  214 +
 net/socket.c                                              |   13 
 security/dummy.c                                          |    6 
 security/selinux/hooks.c                                  |   58 
 security/selinux/include/objsec.h                         |    8 
 security/selinux/include/selinux_netlabel.h               |  125 +
 security/selinux/ss/ebitmap.c                             |  144 +
 security/selinux/ss/ebitmap.h                             |    6 
 security/selinux/ss/mls.c                                 |  156 +
 security/selinux/ss/mls.h                                 |   21 
 security/selinux/ss/services.c                            |  488 ++++
 44 files changed, 7393 insertions(+), 31 deletions(-)

--- NEW FILE linux-2.6-net-netlabel-cipso.patch ---
Date: Tue, 8 Aug 2006 00:25:40 -0400 (EDT)
From: James Morris <jmorris redhat com>
Subject: [SELINUX/NETWORK 2/2] Netlabel: CIPSO labeled networking support

This patch implements a legacy MLS network labeling scheme (including, but 
generally referred to as CIPSO, with this particular implementation called 
Netlabel).

It's from HP, and is an alternative to the native Linux IPsec xfrm 
labeling.  Its purpose is to provide interoperability with legacy Trusted 
Solaris systems.

The upstream post of the first patch is here:
http://marc.theaimsgroup.com/?l=linux-netdev&m=115463625625389&w=2

This code has been merged into the upstream 2.6.19 networking tree and is 
also included in the latest -mm kernel.

This patch is a backport for FC6 and RHEL5.

Signed-off-by: Paul Moore <paul moore hp com>
Signed-off-by: David S. Miller <davem davemloft net>
Signed-off-by: James Morris <jmorris redhat com>

---

 Documentation/00-INDEX                                    |    2 
 Documentation/netlabel/00-INDEX                           |   10 
 Documentation/netlabel/cipso_ipv4.txt                     |   48 
 Documentation/netlabel/draft-ietf-cipso-ipsecurity-01.txt |  781 ++++++
 Documentation/netlabel/introduction.txt                   |   46 
 Documentation/netlabel/lsm_interface.txt                  |   47 
 Documentation/networking/ip-sysctl.txt                    |   35 
 include/linux/ip.h                                        |    1 
 include/linux/security.h                                  |   25 
 include/linux/sysctl.h                                    |    4 
 include/linux/utsrelease.h                                |    1 
 include/net/cipso_ipv4.h                                  |  250 ++
 include/net/inet_sock.h                                   |    2 
 include/net/netlabel.h                                    |  291 ++
 net/Kconfig                                               |    2 
 net/Makefile                                              |    1 
 net/ipv4/Makefile                                         |    1 
 net/ipv4/ah4.c                                            |    2 
 net/ipv4/cipso_ipv4.c                                     | 1607 ++++++++++++++
 net/ipv4/ip_options.c                                     |   19 
 net/ipv4/sysctl_net_ipv4.c                                |   35 
 net/netlabel/Kconfig                                      |   14 
 net/netlabel/Makefile                                     |   16 
 net/netlabel/netlabel_cipso_v4.c                          |  542 ++++
 net/netlabel/netlabel_cipso_v4.h                          |  217 +
 net/netlabel/netlabel_domainhash.c                        |  513 ++++
 net/netlabel/netlabel_domainhash.h                        |   63 
 net/netlabel/netlabel_kapi.c                              |  231 ++
 net/netlabel/netlabel_mgmt.c                              |  624 +++++
 net/netlabel/netlabel_mgmt.h                              |  246 ++
 net/netlabel/netlabel_unlabeled.c                         |  253 ++
 net/netlabel/netlabel_unlabeled.h                         |   98 
 net/netlabel/netlabel_user.c                              |  158 +
 net/netlabel/netlabel_user.h                              |  214 +
 net/socket.c                                              |   13 
 security/dummy.c                                          |    6 
 security/selinux/hooks.c                                  |   58 
 security/selinux/include/objsec.h                         |    8 
 security/selinux/include/selinux_netlabel.h               |  125 +
 security/selinux/ss/ebitmap.c                             |  144 +
 security/selinux/ss/ebitmap.h                             |    6 
 security/selinux/ss/mls.c                                 |  156 +
 security/selinux/ss/mls.h                                 |   21 
 security/selinux/ss/services.c                            |  488 ++++
 44 files changed, 7393 insertions(+), 31 deletions(-)


diff -purN -X dontdiff linux-2.6.17.i686.p/Documentation/00-INDEX linux-2.6.17.i686.w/Documentation/00-INDEX
--- linux-2.6.17.i686.p/Documentation/00-INDEX	2006-06-17 21:49:35.000000000 -0400
+++ linux-2.6.17.i686.w/Documentation/00-INDEX	2006-08-07 21:03:07.000000000 -0400
@@ -184,6 +184,8 @@ mtrr.txt
 	- how to use PPro Memory Type Range Registers to increase performance.
 nbd.txt
 	- info on a TCP implementation of a network block device.
+netlabel/
+	- directory with information on the NetLabel subsystem.
 networking/
 	- directory with info on various aspects of networking with Linux.
 nfsroot.txt
diff -purN -X dontdiff linux-2.6.17.i686.p/Documentation/netlabel/00-INDEX linux-2.6.17.i686.w/Documentation/netlabel/00-INDEX
--- linux-2.6.17.i686.p/Documentation/netlabel/00-INDEX	1969-12-31 19:00:00.000000000 -0500
+++ linux-2.6.17.i686.w/Documentation/netlabel/00-INDEX	2006-08-07 21:03:07.000000000 -0400
@@ -0,0 +1,10 @@
+00-INDEX
+	- this file.
+cipso_ipv4.txt
+	- documentation on the IPv4 CIPSO protocol engine.
+draft-ietf-cipso-ipsecurity-01.txt
+	- IETF draft of the CIPSO protocol, dated 16 July 1992.
+introduction.txt
+	- NetLabel introduction, READ THIS FIRST.
+lsm_interface.txt
+	- documentation on the NetLabel kernel security module API.
diff -purN -X dontdiff linux-2.6.17.i686.p/Documentation/netlabel/cipso_ipv4.txt linux-2.6.17.i686.w/Documentation/netlabel/cipso_ipv4.txt
--- linux-2.6.17.i686.p/Documentation/netlabel/cipso_ipv4.txt	1969-12-31 19:00:00.000000000 -0500
+++ linux-2.6.17.i686.w/Documentation/netlabel/cipso_ipv4.txt	2006-08-07 21:03:07.000000000 -0400
@@ -0,0 +1,48 @@
+NetLabel CIPSO/IPv4 Protocol Engine
+==============================================================================
+Paul Moore, paul moore hp com
+
+May 17, 2006
+
+ * Overview
+
+The NetLabel CIPSO/IPv4 protocol engine is based on the IETF Commercial IP
+Security Option (CIPSO) draft from July 16, 1992.  A copy of this draft can be
+found in this directory, consult '00-INDEX' for the filename.  While the IETF
+draft never made it to an RFC standard it has become a de-facto standard for
+labeled networking and is used in many trusted operating systems.
+
+ * Outbound Packet Processing
+
+The CIPSO/IPv4 protocol engine applies the CIPSO IP option to packets by
+adding the CIPSO label to the socket.  This causes all packets leaving the
+system through the socket to have the CIPSO IP option applied.  The socket's
+CIPSO label can be changed at any point in time, however, it is recommended
+that it is set upon the socket's creation.  The LSM can set the socket's CIPSO
+label by using the NetLabel security module API; if the NetLabel "domain" is
+configured to use CIPSO for packet labeling then a CIPSO IP option will be
+generated and attached to the socket.
+
+ * Inbound Packet Processing
+
+The CIPSO/IPv4 protocol engine validates every CIPSO IP option it finds at the
+IP layer without any special handling required by the LSM.  However, in order
+to decode and translate the CIPSO label on the packet the LSM must use the
+NetLabel security module API to extract the security attributes of the packet.
+This is typically done at the socket layer using the 'socket_sock_rcv_skb()'
+LSM hook.
+
+ * Label Translation
+
+The CIPSO/IPv4 protocol engine contains a mechanism to translate CIPSO security
+attributes such as sensitivity level and category to values which are
+appropriate for the host.  These mappings are defined as part of a CIPSO
+Domain Of Interpretation (DOI) definition and are configured through the
+NetLabel user space communication layer.  Each DOI definition can have a
+different security attribute mapping table.
+
+ * Label Translation Cache
+
+The NetLabel system provides a framework for caching security attribute
+mappings from the network labels to the corresponding LSM identifiers.  The
+CIPSO/IPv4 protocol engine supports this caching mechanism.
diff -purN -X dontdiff linux-2.6.17.i686.p/Documentation/netlabel/draft-ietf-cipso-ipsecurity-01.txt linux-2.6.17.i686.w/Documentation/netlabel/draft-ietf-cipso-ipsecurity-01.txt
--- linux-2.6.17.i686.p/Documentation/netlabel/draft-ietf-cipso-ipsecurity-01.txt	1969-12-31 19:00:00.000000000 -0500
+++ linux-2.6.17.i686.w/Documentation/netlabel/draft-ietf-cipso-ipsecurity-01.txt	2006-08-07 21:03:07.000000000 -0400
@@ -0,0 +1,791 @@
+IETF CIPSO Working Group
+16 July, 1992
+
+
+
+                 COMMERCIAL IP SECURITY OPTION (CIPSO 2.2)
+
+
+
+1.    Status
+
+This Internet Draft provides the high level specification for a Commercial
+IP Security Option (CIPSO).  This draft reflects the version as approved by
+the CIPSO IETF Working Group.  Distribution of this memo is unlimited.
+
+This document is an Internet Draft.  Internet Drafts are working documents
+of the Internet Engineering Task Force (IETF), its Areas, and its Working
+Groups. Note that other groups may also distribute working documents as
+Internet Drafts.
+
+Internet Drafts are draft documents valid for a maximum of six months.
+Internet Drafts may be updated, replaced, or obsoleted by other documents
+at any time.  It is not appropriate to use Internet Drafts as reference
+material or to cite them other than as a "working draft" or "work in
+progress."
+
+Please check the I-D abstract listing contained in each Internet Draft
+directory to learn the current status of this or any other Internet Draft.
+
+
+
+
+2.    Background
+
+Currently the Internet Protocol includes two security options.  One of
+these options is the DoD Basic Security Option (BSO) (Type 130) which allows
+IP datagrams to be labeled with security classifications.  This option
+provides sixteen security classifications and a variable number of handling
+restrictions.  To handle additional security information, such as security
+categories or compartments, another security option (Type 133) exists and
+is referred to as the DoD Extended Security Option (ESO).  The values for
+the fixed fields within these two options are administered by the Defense
+Information Systems Agency (DISA).
+
[...7591 lines suppressed...]
+/**
+ * selinux_netlbl_socket_post_create - Label a socket using NetLabel
+ * @sock: the socket to label
+ * @sock_family: the socket family
+ * @sid: the SID to use
+ *
+ * Description:
+ * Attempt to label a socket using the NetLabel mechanism using the given
+ * SID.  Returns zero values on success, negative values on failure.
+ *
+ */
+int selinux_netlbl_socket_post_create(struct socket *sock,
+				      int sock_family,
+				      u32 sid)
+{
+	struct inode_security_struct *isec = SOCK_INODE(sock)->i_security;
+	struct sk_security_struct *sksec = sock->sk->sk_security;
+
+	if (sock_family != PF_INET)
+		return 0;
+
+	sksec->sclass = isec->sclass;
+	sksec->nlbl_state = NLBL_REQUIRE;
+	return selinux_netlbl_socket_setsid(sock, sid);
+}
+
+/**
+ * selinux_netlbl_sock_graft - Netlabel the new socket
+ * @sk: the new connection
+ * @sock: the new socket
+ *
+ * Description:
+ * The connection represented by @sk is being grafted onto @sock so set the
+ * socket's NetLabel to match the SID of @sk.
+ *
+ */
+void selinux_netlbl_sock_graft(struct sock *sk, struct socket *sock)
+{
+	struct inode_security_struct *isec = SOCK_INODE(sock)->i_security;
+	struct sk_security_struct *sksec = sk->sk_security;
+
+	if (sk->sk_family != PF_INET)
+		return;
+
+	sksec->nlbl_state = NLBL_REQUIRE;
+	sksec->peer_sid = sksec->sid;
+	sksec->sclass = isec->sclass;
+
+	/* Try to set the NetLabel on the socket to save time later, if we fail
+	 * here we will pick up the pieces in later calls to
+	 * selinux_netlbl_inode_permission(). */
+	selinux_netlbl_socket_setsid(sock, sksec->sid);
+}
+
+/**
+ * selinux_netlbl_inet_conn_request - Handle a new connection request
+ * @skb: the packet
+ * @sock_sid: the SID of the parent socket
+ *
+ * Description:
+ * If present, use the security attributes of the packet in @skb and the
+ * parent sock's SID to arrive at a SID for the new child sock.  Returns the
+ * SID of the connection or SECSID_NULL on failure.
+ *
+ */
+u32 selinux_netlbl_inet_conn_request(struct sk_buff *skb, u32 sock_sid)
+{
+	int rc;
+	u32 peer_sid;
+
+	rc = selinux_netlbl_skbuff_getsid(skb, sock_sid, &peer_sid);
+	if (rc != 0)
+		return SECSID_NULL;
+
+	if (peer_sid == SECINITSID_UNLABELED)
+		return SECSID_NULL;
+
+	return peer_sid;
+}
+
+/**
+ * __selinux_netlbl_inode_permission - Label a socket using NetLabel
+ * @inode: the file descriptor's inode
+ * @mask: the permission mask
+ *
+ * Description:
+ * Try to label a socket with the inode's SID using NetLabel.  Returns zero on
+ * success, negative values on failure.
+ *
+ */
+int __selinux_netlbl_inode_permission(struct inode *inode, int mask)
+{
+	int rc;
+	struct socket *sock = SOCKET_I(inode);
+	struct sk_security_struct *sksec = sock->sk->sk_security;
+
+	lock_sock(sock->sk);
+	rc = selinux_netlbl_socket_setsid(sock, sksec->sid);
+	release_sock(sock->sk);
+
+	return rc;
+}
+
+/**
+ * selinux_netlbl_sock_rcv_skb - Do an inbound access check using NetLabel
+ * @sksec: the sock's sk_security_struct
+ * @skb: the packet
+ * @ad: the audit data
+ *
+ * Description:
+ * Fetch the NetLabel security attributes from @skb and perform an access check
+ * against the receiving socket.  Returns zero on success, negative values on
+ * error.
+ *
+ */
+int selinux_netlbl_sock_rcv_skb(struct sk_security_struct *sksec,
+				struct sk_buff *skb,
+				struct avc_audit_data *ad)
+{
+	int rc;
+	u32 netlbl_sid;
+	u32 recv_perm;
+
+	rc = selinux_netlbl_skbuff_getsid(skb, sksec->sid, &netlbl_sid);
+	if (rc != 0)
+		return rc;
+
+	if (netlbl_sid == SECINITSID_UNLABELED)
+		return 0;
+
+	switch (sksec->sclass) {
+	case SECCLASS_UDP_SOCKET:
+		recv_perm = UDP_SOCKET__RECV_MSG;
+		break;
+	case SECCLASS_TCP_SOCKET:
+		recv_perm = TCP_SOCKET__RECV_MSG;
+		break;
+	default:
+		recv_perm = RAWIP_SOCKET__RECV_MSG;
+	}
+
+	rc = avc_has_perm(sksec->sid,
+			  netlbl_sid,
+			  sksec->sclass,
+			  recv_perm,
+			  ad);
+	if (rc == 0)
+		return 0;
+
+	netlbl_skbuff_err(skb, rc);
+	return rc;
+}
+
+/**
+ * selinux_netlbl_socket_peersid - Return the peer SID of a connected socket
+ * @sock: the socket
+ *
+ * Description:
+ * Examine @sock to find the connected peer's SID.  Returns the SID on success
+ * or SECSID_NULL on error.
+ *
+ */
+u32 selinux_netlbl_socket_getpeersec_stream(struct socket *sock)
+{
+	struct sk_security_struct *sksec = sock->sk->sk_security;
+
+	if (sksec->peer_sid == SECINITSID_UNLABELED)
+		return SECSID_NULL;
+
+	return sksec->peer_sid;
+}
+
+/**
+ * selinux_netlbl_socket_getpeersec_dgram - Return the SID of a NetLabel packet
+ * @skb: the packet
+ *
+ * Description:
+ * Examine @skb to find the SID assigned to it by NetLabel.  Returns the SID on
+ * success, SECSID_NULL on error.
+ *
+ */
+u32 selinux_netlbl_socket_getpeersec_dgram(struct sk_buff *skb)
+{
+	int peer_sid;
+	struct sock *sk = skb->sk;
+	struct inode_security_struct *isec;
+
+	if (sk == NULL || sk->sk_socket == NULL)
+		return SECSID_NULL;
+
+	isec = SOCK_INODE(sk->sk_socket)->i_security;
+	if (selinux_netlbl_skbuff_getsid(skb, isec->sid, &peer_sid) != 0)
+		return SECSID_NULL;
+	if (peer_sid == SECINITSID_UNLABELED)
+		return SECSID_NULL;
+
+	return peer_sid;
+}
+#endif /* CONFIG_NETLABEL */


linux-2.6-nfs-64-bit-inode-support.patch:
 arch/alpha/kernel/osf_sys.c       |    6 +++++-
 arch/ia64/ia32/sys_ia32.c         |   23 ++++++++++++++++++-----
 arch/mips/kernel/linux32.c        |    2 ++
 arch/mips/kernel/sysirix.c        |   10 +++++++---
 arch/parisc/hpux/fs.c             |    6 +++++-
 arch/parisc/kernel/sys_parisc32.c |   19 ++++++++++++++++---
 arch/powerpc/kernel/sys_ppc32.c   |   15 ++++++++++++---
 arch/s390/kernel/compat_linux.c   |    5 +++++
 arch/sparc/kernel/sys_sunos.c     |   16 ++++++++++++----
 arch/sparc64/kernel/sys_sparc32.c |    5 +++++
 arch/sparc64/kernel/sys_sunos32.c |   12 ++++++++++--
 arch/sparc64/solaris/fs.c         |    7 ++++++-
 arch/x86_64/ia32/sys_ia32.c       |    7 ++++++-
 fs/afs/dir.c                      |    4 ++--
 fs/compat.c                       |   18 +++++++++++++-----
 fs/exportfs/expfs.c               |    2 +-
 fs/fat/dir.c                      |    2 +-
 fs/nfs/dir.c                      |    6 +++---
 fs/nfs/inode.c                    |   21 ++++++++++-----------
 fs/nfsd/nfs4recover.c             |    2 +-
 fs/readdir.c                      |   18 +++++++++++++-----
 fs/reiserfs/xattr.c               |    6 +++---
 fs/stat.c                         |    6 ++++++
 include/linux/fs.h                |    2 +-
 include/linux/nfs_fs.h            |    9 ---------
 include/linux/stat.h              |    2 +-
 26 files changed, 164 insertions(+), 67 deletions(-)

--- NEW FILE linux-2.6-nfs-64-bit-inode-support.patch ---
Date: Tue, 15 Aug 2006 16:36:05 +0100
From: David Howells <dhowells redhat com>

Make filldir_t take a 64-bit inode number and struct kstat carry a 64-bit inode
number so that 64-bit inode numbers can be passed back to userspace.

The stat functions then returns the full 64-bit inode number where available
and where possible.  If it is not possible to represent the inode number
supplied by the filesystem in the field provided by userspace, then error
EOVERFLOW will be issued.

Similarly, the getdents/readdir functions now pass the full 64-bit inode number
to userspace where possible, returning EOVERFLOW instead when a directory entry
is encountered that can't be properly represented.

Note that this means that some inodes will not be stat'able on a 32-bit system
with old libraries where they were before - but it does mean that there will be
no ambiguity over what a 32-bit inode number refers to.

Note similarly that directory scans may be cut short with an error on a 32-bit
system with old libraries where the scan would work before for the same
reasons.

It is judged unlikely that this situation will occur because modern glibc uses
64-bit capable versions of stat and getdents class functions exclusively, and
that older systems are unlikely to encounter unrepresentable inode numbers
anyway.

Signed-Off-By: David Howells <dhowells redhat com>
---

 arch/alpha/kernel/osf_sys.c       |    6 +++++-
 arch/ia64/ia32/sys_ia32.c         |   23 ++++++++++++++++++-----
 arch/mips/kernel/linux32.c        |    2 ++
 arch/mips/kernel/sysirix.c        |   10 +++++++---
 arch/parisc/hpux/fs.c             |    6 +++++-
 arch/parisc/kernel/sys_parisc32.c |   19 ++++++++++++++++---
 arch/powerpc/kernel/sys_ppc32.c   |   15 ++++++++++++---
 arch/s390/kernel/compat_linux.c   |    5 +++++
 arch/sparc/kernel/sys_sunos.c     |   16 ++++++++++++----
 arch/sparc64/kernel/sys_sparc32.c |    5 +++++
 arch/sparc64/kernel/sys_sunos32.c |   12 ++++++++++--
 arch/sparc64/solaris/fs.c         |    7 ++++++-
 arch/x86_64/ia32/sys_ia32.c       |    7 ++++++-
 fs/afs/dir.c                      |    4 ++--
 fs/compat.c                       |   18 +++++++++++++-----
 fs/exportfs/expfs.c               |    2 +-
 fs/fat/dir.c                      |    2 +-
 fs/nfsd/nfs4recover.c             |    2 +-
 fs/readdir.c                      |   18 +++++++++++++-----
 fs/reiserfs/xattr.c               |    6 +++---
 fs/stat.c                         |    6 ++++++
 include/linux/fs.h                |    2 +-
 include/linux/stat.h              |    2 +-
 23 files changed, 151 insertions(+), 44 deletions(-)

Index: latest/arch/alpha/kernel/osf_sys.c
===================================================================
--- latest.orig/arch/alpha/kernel/osf_sys.c
+++ latest/arch/alpha/kernel/osf_sys.c
@@ -116,17 +116,21 @@ osf_filldir(void *__buf, const char *nam
 	struct osf_dirent __user *dirent;
 	struct osf_dirent_callback *buf = (struct osf_dirent_callback *) __buf;
 	unsigned int reclen = ROUND_UP(NAME_OFFSET + namlen + 1);
+	unsigned int d_ino;
 
 	buf->error = -EINVAL;	/* only used if we fail */
 	if (reclen > buf->count)
 		return -EINVAL;
+	d_ino = ino;
+	if (sizeof(d_ino) < sizeof(ino) && d_ino != ino)
+		return -EOVERFLOW;
 	if (buf->basep) {
 		if (put_user(offset, buf->basep))
 			return -EFAULT;
 		buf->basep = NULL;
 	}
 	dirent = buf->dirent;
-	put_user(ino, &dirent->d_ino);
+	put_user(d_ino, &dirent->d_ino);
 	put_user(namlen, &dirent->d_namlen);
 	put_user(reclen, &dirent->d_reclen);
 	if (copy_to_user(dirent->d_name, name, namlen) ||
Index: latest/arch/ia64/ia32/sys_ia32.c
===================================================================
--- latest.orig/arch/ia64/ia32/sys_ia32.c
+++ latest/arch/ia64/ia32/sys_ia32.c
@@ -125,6 +125,7 @@ sys32_execve (char __user *name, compat_
 
 int cp_compat_stat(struct kstat *stat, struct compat_stat __user *ubuf)
 {
+	compat_ino_t ino;
 	int err;
 
 	if ((u64) stat->size > MAX_NON_LFS ||
@@ -132,11 +133,15 @@ int cp_compat_stat(struct kstat *stat, s
 	    !old_valid_dev(stat->rdev))
 		return -EOVERFLOW;
 
+	ino = stat->ino;
+	if (sizeof(ino) < sizeof(stat->ino) && ino != stat->ino)
+		return -EOVERFLOW;
+
 	if (clear_user(ubuf, sizeof(*ubuf)))
 		return -EFAULT;
 
 	err  = __put_user(old_encode_dev(stat->dev), &ubuf->st_dev);
-	err |= __put_user(stat->ino, &ubuf->st_ino);
+	err |= __put_user(ino, &ubuf->st_ino);
 	err |= __put_user(stat->mode, &ubuf->st_mode);
 	err |= __put_user(stat->nlink, &ubuf->st_nlink);
 	err |= __put_user(high2lowuid(stat->uid), &ubuf->st_uid);
@@ -1222,16 +1227,20 @@ struct readdir32_callback {
 };
 
 static int
-filldir32 (void *__buf, const char *name, int namlen, loff_t offset, ino_t ino,
+filldir32 (void *__buf, const char *name, int namlen, loff_t offset, u64 ino,
 	   unsigned int d_type)
 {
 	struct compat_dirent __user * dirent;
 	struct getdents32_callback * buf = (struct getdents32_callback *) __buf;
 	int reclen = ROUND_UP(offsetof(struct compat_dirent, d_name) + namlen + 1, 4);
+	u32 d_ino;
 
 	buf->error = -EINVAL;	/* only used if we fail.. */
 	if (reclen > buf->count)
 		return -EINVAL;
+	d_ino = ino;
+	if (sizeof(d_ino) < sizeof(ino) && d_ino != ino)
+		return -EOVERFLOW;
 	buf->error = -EFAULT;	/* only used if we fail.. */
 	dirent = buf->previous;
 	if (dirent)
@@ -1239,7 +1248,7 @@ filldir32 (void *__buf, const char *name
 			return -EFAULT;
 	dirent = buf->current_dir;
 	buf->previous = dirent;
-	if (put_user(ino, &dirent->d_ino)
+	if (put_user(d_ino, &dirent->d_ino)
 	    || put_user(reclen, &dirent->d_reclen)
 	    || copy_to_user(dirent->d_name, name, namlen)
 	    || put_user(0, dirent->d_name + namlen))
@@ -1287,17 +1296,21 @@ out:
 }
 
 static int
-fillonedir32 (void * __buf, const char * name, int namlen, loff_t offset, ino_t ino,
+fillonedir32 (void * __buf, const char * name, int namlen, loff_t offset, u64 ino,
 	      unsigned int d_type)
 {
 	struct readdir32_callback * buf = (struct readdir32_callback *) __buf;
 	struct old_linux32_dirent __user * dirent;
+	u32 d_ino;
 
 	if (buf->count)
 		return -EINVAL;
+	d_ino = ino;
+	if (sizeof(d_ino) < sizeof(ino) && d_ino != ino)
+		return -EOVERFLOW;
 	buf->count++;
 	dirent = buf->dirent;
-	if (put_user(ino, &dirent->d_ino)
+	if (put_user(d_ino, &dirent->d_ino)
 	    || put_user(offset, &dirent->d_offset)
 	    || put_user(namlen, &dirent->d_namlen)
 	    || copy_to_user(dirent->d_name, name, namlen)
Index: latest/arch/mips/kernel/linux32.c
===================================================================
--- latest.orig/arch/mips/kernel/linux32.c
+++ latest/arch/mips/kernel/linux32.c
@@ -77,6 +77,8 @@ int cp_compat_stat(struct kstat *stat, s
 	memset(&tmp, 0, sizeof(tmp));
 	tmp.st_dev = new_encode_dev(stat->dev);
 	tmp.st_ino = stat->ino;
+	if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino)
+		return -EOVERFLOW;
 	tmp.st_mode = stat->mode;
 	tmp.st_nlink = stat->nlink;
 	SET_UID(tmp.st_uid, stat->uid);
Index: latest/arch/mips/kernel/sysirix.c
===================================================================
--- latest.orig/arch/mips/kernel/sysirix.c
+++ latest/arch/mips/kernel/sysirix.c
@@ -1739,12 +1739,13 @@ struct irix_dirent32_callback {
 #define ROUND_UP32(x) (((x)+sizeof(u32)-1) & ~(sizeof(u32)-1))
 
 static int irix_filldir32(void *__buf, const char *name,
-	int namlen, loff_t offset, ino_t ino, unsigned int d_type)
+	int namlen, loff_t offset, u64 ino, unsigned int d_type)
 {
 	struct irix_dirent32 __user *dirent;
 	struct irix_dirent32_callback *buf = __buf;
 	unsigned short reclen = ROUND_UP32(NAME_OFFSET32(dirent) + namlen + 1);
 	int err = 0;
+	u32 d_ino;
 
 #ifdef DEBUG_GETDENTS
 	printk("\nirix_filldir32[reclen<%d>namlen<%d>count<%d>]",
@@ -1753,12 +1754,15 @@ static int irix_filldir32(void *__buf, c
 	buf->error = -EINVAL;	/* only used if we fail.. */
 	if (reclen > buf->count)
 		return -EINVAL;
+	d_ino = ino;
+	if (sizeof(d_ino) < sizeof(ino) && d_ino != ino)
+		return -EOVERFLOW;
 	dirent = buf->previous;
 	if (dirent)
 		err = __put_user(offset, &dirent->d_off);
 	dirent = buf->current_dir;
 	err |= __put_user(dirent, &buf->previous);
-	err |= __put_user(ino, &dirent->d_ino);
+	err |= __put_user(d_ino, &dirent->d_ino);
 	err |= __put_user(reclen, &dirent->d_reclen);
 	err |= copy_to_user((char __user *)dirent->d_name, name, namlen) ? -EFAULT : 0;
 	err |= __put_user(0, &dirent->d_name[namlen]);
@@ -1837,7 +1841,7 @@ struct irix_dirent64_callback {
 #define ROUND_UP64(x) (((x)+sizeof(u64)-1) & ~(sizeof(u64)-1))
 
 static int irix_filldir64(void *__buf, const char *name,
-	int namlen, loff_t offset, ino_t ino, unsigned int d_type)
+	int namlen, loff_t offset, u64 ino, unsigned int d_type)
 {
 	struct irix_dirent64 __user *dirent;
 	struct irix_dirent64_callback * buf = __buf;
Index: latest/arch/parisc/hpux/fs.c
===================================================================
--- latest.orig/arch/parisc/hpux/fs.c
+++ latest/arch/parisc/hpux/fs.c
@@ -77,17 +77,21 @@ static int filldir(void * __buf, const c
 {
 	struct hpux_dirent * dirent;
 	struct getdents_callback * buf = (struct getdents_callback *) __buf;
+	ino_t d_ino;
 	int reclen = ROUND_UP(NAME_OFFSET(dirent) + namlen + 1);
 
 	buf->error = -EINVAL;	/* only used if we fail.. */
 	if (reclen > buf->count)
 		return -EINVAL;
+	d_ino = ino;
+	if (sizeof(d_ino) < sizeof(ino) && d_ino != ino)
+		return -EOVERFLOW;
 	dirent = buf->previous;
 	if (dirent)
 		put_user(offset, &dirent->d_off);
 	dirent = buf->current_dir;
 	buf->previous = dirent;
-	put_user(ino, &dirent->d_ino);
+	put_user(d_ino, &dirent->d_ino);
 	put_user(reclen, &dirent->d_reclen);
 	put_user(namlen, &dirent->d_namlen);
 	copy_to_user(dirent->d_name, name, namlen);
Index: latest/arch/parisc/kernel/sys_parisc32.c
===================================================================
--- latest.orig/arch/parisc/kernel/sys_parisc32.c
+++ latest/arch/parisc/kernel/sys_parisc32.c
@@ -237,14 +237,19 @@ int sys32_settimeofday(struct compat_tim
 
 int cp_compat_stat(struct kstat *stat, struct compat_stat __user *statbuf)
 {
+	compat_ino_t ino;
 	int err;
 
 	if (stat->size > MAX_NON_LFS || !new_valid_dev(stat->dev) ||
 	    !new_valid_dev(stat->rdev))
 		return -EOVERFLOW;
 
+	ino = stat->ino;
+	if (sizeof(ino) < sizeof(stat->ino) && ino != stat->ino)
+		return -EOVERFLOW;
+
 	err  = put_user(new_encode_dev(stat->dev), &statbuf->st_dev);
-	err |= put_user(stat->ino, &statbuf->st_ino);
+	err |= put_user(ino, &statbuf->st_ino);
 	err |= put_user(stat->mode, &statbuf->st_mode);
 	err |= put_user(stat->nlink, &statbuf->st_nlink);
 	err |= put_user(0, &statbuf->st_reserved1);
@@ -312,16 +317,20 @@ filldir32 (void *__buf, const char *name
 	struct linux32_dirent __user * dirent;
 	struct getdents32_callback * buf = (struct getdents32_callback *) __buf;
 	int reclen = ROUND_UP(NAME_OFFSET(dirent) + namlen + 1, 4);
+	u32 d_ino;
 
 	buf->error = -EINVAL;	/* only used if we fail.. */
 	if (reclen > buf->count)
 		return -EINVAL;
+	d_ino = ino;
+	if (sizeof(d_ino) < sizeof(ino) && d_ino != ino)
+		return -EOVERFLOW;
 	dirent = buf->previous;
 	if (dirent)
 		put_user(offset, &dirent->d_off);
 	dirent = buf->current_dir;
 	buf->previous = dirent;
-	put_user(ino, &dirent->d_ino);
+	put_user(d_ino, &dirent->d_ino);
 	put_user(reclen, &dirent->d_reclen);
 	copy_to_user(dirent->d_name, name, namlen);
 	put_user(0, dirent->d_name + namlen);
@@ -371,12 +380,16 @@ fillonedir32 (void * __buf, const char *
 {
 	struct readdir32_callback * buf = (struct readdir32_callback *) __buf;
 	struct old_linux32_dirent __user * dirent;
+	u32 d_ino;
 
 	if (buf->count)
 		return -EINVAL;
+	d_ino = ino;
+	if (sizeof(d_ino) < sizeof(ino) && d_ino != ino)
+		return -EOVERFLOW;
 	buf->count++;
 	dirent = buf->dirent;
-	put_user(ino, &dirent->d_ino);
+	put_user(d_ino, &dirent->d_ino);
 	put_user(offset, &dirent->d_offset);
 	put_user(namlen, &dirent->d_namlen);
 	copy_to_user(dirent->d_name, name, namlen);
Index: latest/arch/powerpc/kernel/sys_ppc32.c
===================================================================
--- latest.orig/arch/powerpc/kernel/sys_ppc32.c
+++ latest/arch/powerpc/kernel/sys_ppc32.c
@@ -69,16 +69,20 @@ struct readdir_callback32 {
 };
 
 static int fillonedir(void * __buf, const char * name, int namlen,
-		                  off_t offset, ino_t ino, unsigned int d_type)
+		                  off_t offset, u64 ino, unsigned int d_type)
 {
 	struct readdir_callback32 * buf = (struct readdir_callback32 *) __buf;
 	struct old_linux_dirent32 __user * dirent;
+	ino_t d_ino;
 
 	if (buf->count)
 		return -EINVAL;
+	d_ino = ino;
+	if (sizeof(d_ino) < sizeof(ino) && d_ino != ino)
+		return -EOVERFLOW;
 	buf->count++;
 	dirent = buf->dirent;
-	put_user(ino, &dirent->d_ino);
+	put_user(d_ino, &dirent->d_ino);
 	put_user(offset, &dirent->d_offset);
 	put_user(namlen, &dirent->d_namlen);
 	copy_to_user(dirent->d_name, name, namlen);
@@ -120,15 +124,20 @@ asmlinkage long ppc32_select(u32 n, comp
 
 int cp_compat_stat(struct kstat *stat, struct compat_stat __user *statbuf)
 {
+	compat_ino_t ino;
 	long err;
 
 	if (stat->size > MAX_NON_LFS || !new_valid_dev(stat->dev) ||
 	    !new_valid_dev(stat->rdev))
 		return -EOVERFLOW;
 
+	ino = stat->ino;
+	if (sizeof(ino) < sizeof(stat->ino) && ino != stat->ino)
+		return -EOVERFLOW;
+
 	err  = access_ok(VERIFY_WRITE, statbuf, sizeof(*statbuf)) ? 0 : -EFAULT;
 	err |= __put_user(new_encode_dev(stat->dev), &statbuf->st_dev);
-	err |= __put_user(stat->ino, &statbuf->st_ino);
+	err |= __put_user(ino, &statbuf->st_ino);
 	err |= __put_user(stat->mode, &statbuf->st_mode);
 	err |= __put_user(stat->nlink, &statbuf->st_nlink);
 	err |= __put_user(stat->uid, &statbuf->st_uid);
Index: latest/arch/s390/kernel/compat_linux.c
===================================================================
--- latest.orig/arch/s390/kernel/compat_linux.c
+++ latest/arch/s390/kernel/compat_linux.c
@@ -357,11 +357,16 @@ asmlinkage long sys32_ftruncate64(unsign
 
 int cp_compat_stat(struct kstat *stat, struct compat_stat __user *statbuf)
 {
+	compat_ino_t ino;
 	int err;
 
 	if (!old_valid_dev(stat->dev) || !old_valid_dev(stat->rdev))
 		return -EOVERFLOW;
 
+	ino = stat->ino;
+	if (sizeof(ino) < sizeof(stat->ino) && ino != stat->ino)
+		return -EOVERFLOW;
+
 	err = put_user(old_encode_dev(stat->dev), &statbuf->st_dev);
 	err |= put_user(stat->ino, &statbuf->st_ino);
 	err |= put_user(stat->mode, &statbuf->st_mode);
Index: latest/arch/sparc/kernel/sys_sunos.c
===================================================================
--- latest.orig/arch/sparc/kernel/sys_sunos.c
+++ latest/arch/sparc/kernel/sys_sunos.c
@@ -325,21 +325,25 @@ struct sunos_dirent_callback {
 #define ROUND_UP(x) (((x)+sizeof(long)-1) & ~(sizeof(long)-1))
 
 static int sunos_filldir(void * __buf, const char * name, int namlen,
-			 loff_t offset, ino_t ino, unsigned int d_type)
+			 loff_t offset, u64 ino, unsigned int d_type)
 {
 	struct sunos_dirent __user *dirent;
 	struct sunos_dirent_callback * buf = __buf;
+	unsigned long d_ino;
 	int reclen = ROUND_UP(NAME_OFFSET(dirent) + namlen + 1);
 
 	buf->error = -EINVAL;	/* only used if we fail.. */
 	if (reclen > buf->count)
 		return -EINVAL;
+	d_ino = ino;
+	if (sizeof(d_ino) < sizeof(ino) && d_ino != ino)
+		return -EOVERFLOW;
 	dirent = buf->previous;
 	if (dirent)
 		put_user(offset, &dirent->d_off);
 	dirent = buf->curr;
 	buf->previous = dirent;
-	put_user(ino, &dirent->d_ino);
+	put_user(d_ino, &dirent->d_ino);
 	put_user(namlen, &dirent->d_namlen);
 	put_user(reclen, &dirent->d_reclen);
 	copy_to_user(dirent->d_name, name, namlen);
@@ -406,19 +410,23 @@ struct sunos_direntry_callback {
 };
 
 static int sunos_filldirentry(void * __buf, const char * name, int namlen,
-			      loff_t offset, ino_t ino, unsigned int d_type)
+			      loff_t offset, u64 ino, unsigned int d_type)
 {
 	struct sunos_direntry __user *dirent;
 	struct sunos_direntry_callback *buf = __buf;
+	unsigned long d_ino;
 	int reclen = ROUND_UP(NAME_OFFSET(dirent) + namlen + 1);
 
 	buf->error = -EINVAL;	/* only used if we fail.. */
 	if (reclen > buf->count)
 		return -EINVAL;
+	d_ino = ino;
+	if (sizeof(d_ino) < sizeof(ino) && d_ino != ino)
+		return -EOVERFLOW;
 	dirent = buf->previous;
 	dirent = buf->curr;
 	buf->previous = dirent;
-	put_user(ino, &dirent->d_ino);
+	put_user(d_ino, &dirent->d_ino);
 	put_user(namlen, &dirent->d_namlen);
 	put_user(reclen, &dirent->d_reclen);
 	copy_to_user(dirent->d_name, name, namlen);
Index: latest/arch/sparc64/kernel/sys_sparc32.c
===================================================================
--- latest.orig/arch/sparc64/kernel/sys_sparc32.c
+++ latest/arch/sparc64/kernel/sys_sparc32.c
@@ -337,12 +337,17 @@ asmlinkage long sys32_ftruncate64(unsign
 
 int cp_compat_stat(struct kstat *stat, struct compat_stat __user *statbuf)
 {
+	compat_ino_t ino;
 	int err;
 
 	if (stat->size > MAX_NON_LFS || !old_valid_dev(stat->dev) ||
 	    !old_valid_dev(stat->rdev))
 		return -EOVERFLOW;
 
+	ino = stat->ino;
+	if (sizeof(ino) < sizeof(stat->ino) && ino != stat->ino)
+		return -EOVERFLOW;
+
 	err  = put_user(old_encode_dev(stat->dev), &statbuf->st_dev);
 	err |= put_user(stat->ino, &statbuf->st_ino);
 	err |= put_user(stat->mode, &statbuf->st_mode);
Index: latest/arch/sparc64/kernel/sys_sunos32.c
===================================================================
--- latest.orig/arch/sparc64/kernel/sys_sunos32.c
+++ latest/arch/sparc64/kernel/sys_sunos32.c
@@ -280,16 +280,20 @@ static int sunos_filldir(void * __buf, c
 	struct sunos_dirent __user *dirent;
 	struct sunos_dirent_callback * buf = (struct sunos_dirent_callback *) __buf;
 	int reclen = ROUND_UP(NAME_OFFSET(dirent) + namlen + 1);
+	u32 d_ino;
 
 	buf->error = -EINVAL;	/* only used if we fail.. */
 	if (reclen > buf->count)
 		return -EINVAL;
+	d_ino = ino;
+	if (sizeof(d_ino) < sizeof(ino) && d_ino != ino)
+		return -EOVERFLOW;
 	dirent = buf->previous;
 	if (dirent)
 		put_user(offset, &dirent->d_off);
 	dirent = buf->curr;
 	buf->previous = dirent;
-	put_user(ino, &dirent->d_ino);
+	put_user(d_ino, &dirent->d_ino);
 	put_user(namlen, &dirent->d_namlen);
 	put_user(reclen, &dirent->d_reclen);
 	if (copy_to_user(dirent->d_name, name, namlen))
@@ -363,14 +367,18 @@ static int sunos_filldirentry(void * __b
 	struct sunos_direntry_callback * buf =
 		(struct sunos_direntry_callback *) __buf;
 	int reclen = ROUND_UP(NAME_OFFSET(dirent) + namlen + 1);
+	u32 d_ino;
 
 	buf->error = -EINVAL;	/* only used if we fail.. */
 	if (reclen > buf->count)
 		return -EINVAL;
+	d_ino = ino;
+	if (sizeof(d_ino) < sizeof(ino) && d_ino != ino)
+		return -EOVERFLOW;
 	dirent = buf->previous;
 	dirent = buf->curr;
 	buf->previous = dirent;
-	put_user(ino, &dirent->d_ino);
+	put_user(d_ino, &dirent->d_ino);
 	put_user(namlen, &dirent->d_namlen);
 	put_user(reclen, &dirent->d_reclen);
 	if (copy_to_user(dirent->d_name, name, namlen))
Index: latest/arch/sparc64/solaris/fs.c
===================================================================
--- latest.orig/arch/sparc64/solaris/fs.c
+++ latest/arch/sparc64/solaris/fs.c
@@ -82,12 +82,17 @@ struct sol_stat64 {
 
 static inline int putstat(struct sol_stat __user *ubuf, struct kstat *kbuf)
 {
+	u32 ino;
+
 	if (kbuf->size > MAX_NON_LFS ||
 	    !sysv_valid_dev(kbuf->dev) ||
 	    !sysv_valid_dev(kbuf->rdev))
 		return -EOVERFLOW;
+	ino = kbuf->ino;
+	if (sizeof(ino) < sizeof(kbuf->ino) && ino != kbuf->ino)
+		return -EOVERFLOW;
 	if (put_user (sysv_encode_dev(kbuf->dev), &ubuf->st_dev)	||
-	    __put_user (kbuf->ino, &ubuf->st_ino)		||
+	    __put_user (ino, &ubuf->st_ino)				||
 	    __put_user (kbuf->mode, &ubuf->st_mode)		||
 	    __put_user (kbuf->nlink, &ubuf->st_nlink)	||
 	    __put_user (kbuf->uid, &ubuf->st_uid)		||
Index: latest/arch/x86_64/ia32/sys_ia32.c
===================================================================
--- latest.orig/arch/x86_64/ia32/sys_ia32.c
+++ latest/arch/x86_64/ia32/sys_ia32.c
@@ -75,6 +75,8 @@
 
 int cp_compat_stat(struct kstat *kbuf, struct compat_stat __user *ubuf)
 {
+	compat_ino_t ino;
+
 	typeof(ubuf->st_uid) uid = 0;
 	typeof(ubuf->st_gid) gid = 0;
 	SET_UID(uid, kbuf->uid);
@@ -83,9 +85,12 @@ int cp_compat_stat(struct kstat *kbuf, s
 		return -EOVERFLOW;
 	if (kbuf->size >= 0x7fffffff)
 		return -EOVERFLOW;
+	ino = kbuf->ino;
+	if (sizeof(ino) < sizeof(kbuf->ino) && ino != kbuf->ino)
+		return -EOVERFLOW;
 	if (!access_ok(VERIFY_WRITE, ubuf, sizeof(struct compat_stat)) ||
 	    __put_user (old_encode_dev(kbuf->dev), &ubuf->st_dev) ||
-	    __put_user (kbuf->ino, &ubuf->st_ino) ||
+	    __put_user (ino, &ubuf->st_ino) ||
 	    __put_user (kbuf->mode, &ubuf->st_mode) ||
 	    __put_user (kbuf->nlink, &ubuf->st_nlink) ||
 	    __put_user (uid, &ubuf->st_uid) ||
Index: latest/fs/afs/dir.c
===================================================================
--- latest.orig/fs/afs/dir.c
+++ latest/fs/afs/dir.c
@@ -30,7 +30,7 @@ static int afs_dir_readdir(struct file *
 static int afs_d_revalidate(struct dentry *dentry, struct nameidata *nd);
 static int afs_d_delete(struct dentry *dentry);
 static int afs_dir_lookup_filldir(void *_cookie, const char *name, int nlen,
-				  loff_t fpos, ino_t ino, unsigned dtype);
+				  loff_t fpos, u64 ino, unsigned dtype);
 
 const struct file_operations afs_dir_file_operations = {
 	.open		= afs_dir_open,
@@ -408,7 +408,7 @@ static int afs_dir_readdir(struct file *
  *   uniquifier through dtype
  */
 static int afs_dir_lookup_filldir(void *_cookie, const char *name, int nlen,
-				  loff_t fpos, ino_t ino, unsigned dtype)
+				  loff_t fpos, u64 ino, unsigned dtype)
 {
 	struct afs_dir_lookup_cookie *cookie = _cookie;
 
Index: latest/fs/compat.c
===================================================================
--- latest.orig/fs/compat.c
+++ latest/fs/compat.c
@@ -918,20 +918,24 @@ struct compat_readdir_callback {
 };
 
 static int compat_fillonedir(void *__buf, const char *name, int namlen,
-			loff_t offset, ino_t ino, unsigned int d_type)
+			loff_t offset, u64 ino, unsigned int d_type)
 {
 	struct compat_readdir_callback *buf = __buf;
 	struct compat_old_linux_dirent __user *dirent;
+	compat_ulong_t d_ino;
 
 	if (buf->result)
 		return -EINVAL;
+	d_ino = ino;
+	if (sizeof(d_ino) < sizeof(ino) && d_ino != ino)
+		return -EOVERFLOW;
 	buf->result++;
 	dirent = buf->dirent;
 	if (!access_ok(VERIFY_WRITE, dirent,
 			(unsigned long)(dirent->d_name + namlen + 1) -
 				(unsigned long)dirent))
 		goto efault;
-	if (	__put_user(ino, &dirent->d_ino) ||
+	if (	__put_user(d_ino, &dirent->d_ino) ||
 		__put_user(offset, &dirent->d_offset) ||
 		__put_user(namlen, &dirent->d_namlen) ||
 		__copy_to_user(dirent->d_name, name, namlen) ||
@@ -982,22 +986,26 @@ struct compat_getdents_callback {
 };
 
 static int compat_filldir(void *__buf, const char *name, int namlen,
-		loff_t offset, ino_t ino, unsigned int d_type)
+		loff_t offset, u64 ino, unsigned int d_type)
 {
 	struct compat_linux_dirent __user * dirent;
 	struct compat_getdents_callback *buf = __buf;
+	compat_ulong_t d_ino;
 	int reclen = COMPAT_ROUND_UP(NAME_OFFSET(dirent) + namlen + 2);
 
 	buf->error = -EINVAL;	/* only used if we fail.. */
 	if (reclen > buf->count)
 		return -EINVAL;
+	d_ino = ino;
+	if (sizeof(d_ino) < sizeof(ino) && d_ino != ino)
+		return -EOVERFLOW;
 	dirent = buf->previous;
 	if (dirent) {
 		if (__put_user(offset, &dirent->d_off))
 			goto efault;
 	}
 	dirent = buf->current_dir;
-	if (__put_user(ino, &dirent->d_ino))
+	if (__put_user(d_ino, &dirent->d_ino))
 		goto efault;
 	if (__put_user(reclen, &dirent->d_reclen))
 		goto efault;
@@ -1068,7 +1076,7 @@ struct compat_getdents_callback64 {
 };
 
 static int compat_filldir64(void * __buf, const char * name, int namlen, loff_t offset,
-		     ino_t ino, unsigned int d_type)
+		     u64 ino, unsigned int d_type)
 {
 	struct linux_dirent64 __user *dirent;
 	struct compat_getdents_callback64 *buf = __buf;
Index: latest/fs/exportfs/expfs.c
===================================================================
--- latest.orig/fs/exportfs/expfs.c
+++ latest/fs/exportfs/expfs.c
@@ -315,7 +315,7 @@ struct getdents_callback {
  * the name matching the specified inode number.
  */
 static int filldir_one(void * __buf, const char * name, int len,
-			loff_t pos, ino_t ino, unsigned int d_type)
+			loff_t pos, u64 ino, unsigned int d_type)
 {
 	struct getdents_callback *buf = __buf;
 	int result = 0;
Index: latest/fs/fat/dir.c
===================================================================
--- latest.orig/fs/fat/dir.c
+++ latest/fs/fat/dir.c
@@ -647,7 +647,7 @@ static int fat_readdir(struct file *filp
 }
 
 static int fat_ioctl_filldir(void *__buf, const char *name, int name_len,
-			     loff_t offset, ino_t ino, unsigned int d_type)
+			     loff_t offset, u64 ino, unsigned int d_type)
 {
 	struct fat_ioctl_filldir_callback *buf = __buf;
 	struct dirent __user *d1 = buf->dirent;
Index: latest/fs/nfsd/nfs4recover.c
===================================================================
--- latest.orig/fs/nfsd/nfs4recover.c
+++ latest/fs/nfsd/nfs4recover.c
@@ -183,7 +183,7 @@ struct dentry_list_arg {
 
 static int
 nfsd4_build_dentrylist(void *arg, const char *name, int namlen,
-		loff_t offset, ino_t ino, unsigned int d_type)
+		loff_t offset, u64 ino, unsigned int d_type)
 {
 	struct dentry_list_arg *dla = arg;
 	struct list_head *dentries = &dla->dentries;
Index: latest/fs/readdir.c
===================================================================
--- latest.orig/fs/readdir.c
+++ latest/fs/readdir.c
@@ -69,20 +69,24 @@ struct readdir_callback {
 };
 
 static int fillonedir(void * __buf, const char * name, int namlen, loff_t offset,
-		      ino_t ino, unsigned int d_type)
+		      u64 ino, unsigned int d_type)
 {
 	struct readdir_callback * buf = (struct readdir_callback *) __buf;
 	struct old_linux_dirent __user * dirent;
+	unsigned long d_ino;
 
 	if (buf->result)
 		return -EINVAL;
+	d_ino = ino;
+	if (sizeof(d_ino) < sizeof(ino) && d_ino != ino)
+		return -EOVERFLOW;
 	buf->result++;
 	dirent = buf->dirent;
 	if (!access_ok(VERIFY_WRITE, dirent,
 			(unsigned long)(dirent->d_name + namlen + 1) -
 				(unsigned long)dirent))
 		goto efault;
-	if (	__put_user(ino, &dirent->d_ino) ||
+	if (	__put_user(d_ino, &dirent->d_ino) ||
 		__put_user(offset, &dirent->d_offset) ||
 		__put_user(namlen, &dirent->d_namlen) ||
 		__copy_to_user(dirent->d_name, name, namlen) ||
@@ -138,22 +142,26 @@ struct getdents_callback {
 };
 
 static int filldir(void * __buf, const char * name, int namlen, loff_t offset,
-		   ino_t ino, unsigned int d_type)
+		   u64 ino, unsigned int d_type)
 {
 	struct linux_dirent __user * dirent;
 	struct getdents_callback * buf = (struct getdents_callback *) __buf;
+	unsigned long d_ino;
 	int reclen = ROUND_UP(NAME_OFFSET(dirent) + namlen + 2);
 
 	buf->error = -EINVAL;	/* only used if we fail.. */
 	if (reclen > buf->count)
 		return -EINVAL;
+	d_ino = ino;
+	if (sizeof(d_ino) < sizeof(ino) && d_ino != ino)
+		return -EOVERFLOW;
 	dirent = buf->previous;
 	if (dirent) {
 		if (__put_user(offset, &dirent->d_off))
 			goto efault;
 	}
 	dirent = buf->current_dir;
-	if (__put_user(ino, &dirent->d_ino))
+	if (__put_user(d_ino, &dirent->d_ino))
 		goto efault;
 	if (__put_user(reclen, &dirent->d_reclen))
 		goto efault;
@@ -222,7 +230,7 @@ struct getdents_callback64 {
 };
 
 static int filldir64(void * __buf, const char * name, int namlen, loff_t offset,
-		     ino_t ino, unsigned int d_type)
+		     u64 ino, unsigned int d_type)
 {
 	struct linux_dirent64 __user *dirent;
 	struct getdents_callback64 * buf = (struct getdents_callback64 *) __buf;
Index: latest/fs/reiserfs/xattr.c
===================================================================
--- latest.orig/fs/reiserfs/xattr.c
+++ latest/fs/reiserfs/xattr.c
@@ -773,7 +773,7 @@ int reiserfs_xattr_del(struct inode *ino
 
 static int
 reiserfs_delete_xattrs_filler(void *buf, const char *name, int namelen,
-			      loff_t offset, ino_t ino, unsigned int d_type)
+			      loff_t offset, u64 ino, unsigned int d_type)
 {
 	struct dentry *xadir = (struct dentry *)buf;
 
@@ -851,7 +851,7 @@ struct reiserfs_chown_buf {
 /* XXX: If there is a better way to do this, I'd love to hear about it */
 static int
 reiserfs_chown_xattrs_filler(void *buf, const char *name, int namelen,
-			     loff_t offset, ino_t ino, unsigned int d_type)
+			     loff_t offset, u64 ino, unsigned int d_type)
 {
 	struct reiserfs_chown_buf *chown_buf = (struct reiserfs_chown_buf *)buf;
 	struct dentry *xafile, *xadir = chown_buf->xadir;
@@ -1036,7 +1036,7 @@ struct reiserfs_listxattr_buf {
 
 static int
 reiserfs_listxattr_filler(void *buf, const char *name, int namelen,
-			  loff_t offset, ino_t ino, unsigned int d_type)
+			  loff_t offset, u64 ino, unsigned int d_type)
 {
 	struct reiserfs_listxattr_buf *b = (struct reiserfs_listxattr_buf *)buf;
 	int len = 0;
Index: latest/fs/stat.c
===================================================================
--- latest.orig/fs/stat.c
+++ latest/fs/stat.c
@@ -140,6 +140,8 @@ static int cp_old_stat(struct kstat *sta
 	memset(&tmp, 0, sizeof(struct __old_kernel_stat));
 	tmp.st_dev = old_encode_dev(stat->dev);
 	tmp.st_ino = stat->ino;
+	if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino)
+		return -EOVERFLOW;
 	tmp.st_mode = stat->mode;
 	tmp.st_nlink = stat->nlink;
 	if (tmp.st_nlink != stat->nlink)
@@ -210,6 +212,8 @@ static int cp_new_stat(struct kstat *sta
 	tmp.st_dev = new_encode_dev(stat->dev);
 #endif
 	tmp.st_ino = stat->ino;
+	if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino)
+		return -EOVERFLOW;
 	tmp.st_mode = stat->mode;
 	tmp.st_nlink = stat->nlink;
 	if (tmp.st_nlink != stat->nlink)
@@ -347,6 +351,8 @@ static long cp_new_stat64(struct kstat *
 	tmp.st_rdev = huge_encode_dev(stat->rdev);
 #endif
 	tmp.st_ino = stat->ino;
+	if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino)
+		return -EOVERFLOW;
 #ifdef STAT64_HAS_BROKEN_ST_INO
 	tmp.__st_ino = stat->ino;
 #endif
Index: latest/include/linux/fs.h
===================================================================
--- latest.orig/include/linux/fs.h
+++ latest/include/linux/fs.h
@@ -1001,7 +1001,7 @@ int generic_osync_inode(struct inode *, 
  * This allows the kernel to read directories into kernel space or
  * to have different dirent layouts depending on the binary type.
  */
-typedef int (*filldir_t)(void *, const char *, int, loff_t, ino_t, unsigned);
+typedef int (*filldir_t)(void *, const char *, int, loff_t, u64, unsigned);
 
 struct block_device_operations {
 	int (*open) (struct inode *, struct file *);
Index: latest/include/linux/stat.h
===================================================================
--- latest.orig/include/linux/stat.h
+++ latest/include/linux/stat.h
@@ -57,7 +57,7 @@
 #include <linux/time.h>
 
 struct kstat {
-	unsigned long	ino;
+	u64		ino;
 	dev_t		dev;
 	umode_t		mode;
 	unsigned int	nlink;
Date: Tue, 15 Aug 2006 16:36:17 +0100
From: David Howells <dhowells redhat com>

Building on the previous patch that expanded the inode numbers in struct kstat
and filldir_t to an obligate 64-bits, make NFS represent 64-bit fileids as
64-bit inode numbers rather than compressing them down to 32-bits.

Signed-Off-By: David Howells <dhowells redhat com>
---

 fs/nfs/dir.c           |    6 +++---
 fs/nfs/inode.c         |   21 ++++++++++-----------
 include/linux/nfs_fs.h |    9 ---------
 3 files changed, 13 insertions(+), 23 deletions(-)

Index: latest/fs/nfs/dir.c
===================================================================
--- latest.orig/fs/nfs/dir.c
+++ latest/fs/nfs/dir.c
@@ -397,7 +397,7 @@ int nfs_do_filldir(nfs_readdir_descripto
 	struct file	*file = desc->file;
 	struct nfs_entry *entry = desc->entry;
 	struct dentry	*dentry = NULL;
-	unsigned long	fileid;
+	u64		fileid;
 	int		loop_count = 0,
 			res;
 
@@ -408,7 +408,7 @@ int nfs_do_filldir(nfs_readdir_descripto
 		unsigned d_type = DT_UNKNOWN;
 		/* Note: entry->prev_cookie contains the cookie for
 		 *	 retrieving the current dirent on the server */
-		fileid = nfs_fileid_to_ino_t(entry->ino);
+		fileid = entry->ino;
 
 		/* Get a dentry if we have one */
 		if (dentry != NULL)
@@ -418,7 +418,7 @@ int nfs_do_filldir(nfs_readdir_descripto
 		/* Use readdirplus info */
 		if (dentry != NULL && dentry->d_inode != NULL) {
 			d_type = dt_type(dentry->d_inode);
-			fileid = dentry->d_inode->i_ino;
+			fileid = NFS_FILEID(dentry->d_inode);
 		}
 
 		res = filldir(dirent, entry->name, entry->len, 
Index: latest/fs/nfs/inode.c
===================================================================
--- latest.orig/fs/nfs/inode.c
+++ latest/fs/nfs/inode.c
@@ -57,12 +57,6 @@ static void nfs_zap_acl_cache(struct ino
 
 static kmem_cache_t * nfs_inode_cachep;
 
-static inline unsigned long
-nfs_fattr_to_ino_t(struct nfs_fattr *fattr)
-{
-	return nfs_fileid_to_ino_t(fattr->fileid);
-}
-
 int nfs_write_inode(struct inode *inode, int sync)
 {
 	int flags = sync ? FLUSH_SYNC : 0;
@@ -226,7 +220,9 @@ nfs_fhget(struct super_block *sb, struct
 		goto out_no_inode;
 	}
 
-	hash = nfs_fattr_to_ino_t(fattr);
+	hash = fattr->fileid;
+	if (sizeof(hash) < sizeof(u64))
+		hash ^= fattr->fileid >> (sizeof(u64) - sizeof(ino_t)) * 8;
 
 	inode = iget5_locked(sb, hash, nfs_find_actor, nfs_init_locked, &desc);
 	if (inode == NULL) {
@@ -237,9 +233,10 @@ nfs_fhget(struct super_block *sb, struct
 	if (inode->i_state & I_NEW) {
 		struct nfs_inode *nfsi = NFS_I(inode);
 
-		/* We set i_ino for the few things that still rely on it,
-		 * such as stat(2) */
-		inode->i_ino = hash;
+		/* We set i_ino for the few things that still rely on it, such
+		 * as printing messages; stat and filldir use the fileid
+		 * directly since i_ino may not be large enough */
+		inode->i_ino = fattr->fileid;
 
 		/* We can't support update_atime(), since the server will reset it */
 		inode->i_flags |= S_NOATIME|S_NOCMTIME;
@@ -446,8 +443,10 @@ int nfs_getattr(struct vfsmount *mnt, st
 		err = __nfs_revalidate_inode(NFS_SERVER(inode), inode);
 	else
 		err = nfs_revalidate_inode(NFS_SERVER(inode), inode);
-	if (!err)
+	if (!err) {
 		generic_fillattr(inode, stat);
+		stat->ino = NFS_FILEID(inode);
+	}
 	return err;
 }
 
Index: latest/include/linux/nfs_fs.h
===================================================================
--- latest.orig/include/linux/nfs_fs.h
+++ latest/include/linux/nfs_fs.h
@@ -541,15 +541,6 @@ nfs_size_to_loff_t(__u64 size)
 	return (loff_t) size;
 }
 
-static inline ino_t
-nfs_fileid_to_ino_t(u64 fileid)
-{
-	ino_t ino = (ino_t) fileid;
-	if (sizeof(ino_t) < sizeof(u64))
-		ino ^= fileid >> (sizeof(u64)-sizeof(ino_t)) * 8;
-	return ino;
-}
-
 /* NFS root */
 
 extern void * nfs_root_data(void);

linux-2.6-ppc-fix-irq-mapping.patch:
 irq.c |    2 +-
 1 files changed, 1 insertion(+), 1 deletion(-)

--- NEW FILE linux-2.6-ppc-fix-irq-mapping.patch ---
Date: Thu, 17 Aug 2006 15:55:20 -0400 (EDT)
From: Manoj Iyer <miyer redhat com>
Subject: [RHEL5 PPC PATCH] RHBZ# 201731 ((BETA BLOCKER)) fix IDE device
 getting assigned the wrong irq number


RHBZ#:
------
https://bugzilla.redhat.com/bugzilla/show_bug.cgi?id=201731

Description:
------------
The code for using the radix tree for reverse mapping of interrupts has
a typo that causes it to create incorrect mappings if the software and
hardware numbers happen to be different. This would, among others, cause
the IDE interrupt to fail on js20's. This fixes it.

RHEL Version Found:
-------------------
RHEL5 pre-beta1

Upstream Status:
----------------
Ben Herrenschmidt is working on getting this patch upstream.

Test Status:
------------
I will need to install FC6 or RHEL5-prebata inorder to build  this kernel 
and test it. Since FC6 and RHEL5-prebeta have install problems on a JS20, 
I am unable to test this patch on a JS20. I talked to peter martuccille 
and he agreed that it was acceptable to submit this patch without the 
usual testing.

Proposed Patch:
---------------
ndex: linux-work/arch/powerpc/kernel/irq.c
===================================================================
Index: latest/arch/powerpc/kernel/irq.c
===================================================================
--- latest.orig/arch/powerpc/kernel/irq.c
+++ latest/arch/powerpc/kernel/irq.c
@@ -693,7 +693,7 @@ unsigned int irq_radix_revmap(struct irq
 	/* If not there, try to insert it */
 	virq = irq_find_mapping(host, hwirq);
 	if (virq != NO_IRQ)
-		radix_tree_insert(tree, virq, &irq_map[virq]);
+		radix_tree_insert(tree, hwirq, &irq_map[virq]);
  bail:
 	spin_unlock_irqrestore(&irq_big_lock, flags);
 	return virq;

linux-2.6-selinux-support-range-transitions.patch:
 Kconfig            |   35 ++++++++++++++++++++++++++++++++++-
 include/security.h |    9 +++++++--
 ss/mls.c           |   21 ++++++++++-----------
 ss/policydb.c      |   27 ++++++++++++++++++++-------
 ss/policydb.h      |    7 ++++---
 5 files changed, 75 insertions(+), 24 deletions(-)

--- NEW FILE linux-2.6-selinux-support-range-transitions.patch ---
Date: Mon, 14 Aug 2006 17:27:49 -0400
From: Eric Paris <eparis redhat com>

Subject: selinux: enable configuration of max policy version
From: Stephen Smalley <sds tycho nsa gov>

Enable configuration of SELinux maximum supported policy version to support
legacy userland (init) that does not gracefully handle kernels that support
newer policy versions two or more beyond the installed policy, as in FC3
and FC4.

Signed-off-by: Stephen Smalley <sds tycho nsa gov>
Acked-by: James Morris <jmorris namei org>
Acked-by: Eric Paris <eparis redhat com>
Signed-off-by: Andrew Morton <akpm osdl org>
---

 security/selinux/Kconfig            |   33 ++++++++++++++++++++++++++
 security/selinux/include/security.h |    6 +++-
 2 files changed, 38 insertions(+), 1 deletion(-)

diff -puN security/selinux/Kconfig~selinux-enable-configuration-of-max-policy-version security/selinux/Kconfig
--- a/security/selinux/Kconfig~selinux-enable-configuration-of-max-policy-version
+++ a/security/selinux/Kconfig
@@ -124,3 +124,36 @@ config SECURITY_SELINUX_ENABLE_SECMARK_D
 
 	  If you are unsure what do do here, select N.
 
+config SECURITY_SELINUX_POLICYDB_VERSION_MAX
+	bool "NSA SELinux maximum supported policy format version"
+	depends on SECURITY_SELINUX
+	default n
+	help
+	  This option enables the maximum policy format version supported
+	  by SELinux to be set to a particular value.  This value is reported
+	  to userspace via /selinux/policyvers and used at policy load time.
+	  It can be adjusted downward to support legacy userland (init) that
+	  does not correctly handle kernels that support newer policy versions.
+
+	  Examples:  For FC3 or FC4, enable this option and set the value via
+	  the next option.  For FC5 and later, do not enable this option.
+
+	  If you are unsure how to answer this question, answer N.
+
+config SECURITY_SELINUX_POLICYDB_VERSION_MAX_VALUE
+	int "NSA SELinux maximum supported policy format version value"
+	depends on SECURITY_SELINUX_POLICYDB_VERSION_MAX
+	range 15 20
+	default 19
+	help
+	  This option sets the value for the maximum policy format version
+	  supported by SELinux.
+
+	  Examples:  For FC3, use 18.  For FC4, use 19.
+
+	  If you are unsure how to answer this question, look for the
+	  policy format version supported by your policy toolchain, by
+	  running 'checkpolicy -V'. Or look at what policy you have
+	  installed under /etc/selinux/$SELINUXTYPE/policy, where
+	  SELINUXTYPE is defined in your /etc/selinux/config.
+
diff -puN security/selinux/include/security.h~selinux-enable-configuration-of-max-policy-version security/selinux/include/security.h
--- a/security/selinux/include/security.h~selinux-enable-configuration-of-max-policy-version
+++ a/security/selinux/include/security.h
@@ -27,7 +27,11 @@
 
 /* Range of policy versions we understand*/
 #define POLICYDB_VERSION_MIN   POLICYDB_VERSION_BASE
-#define POLICYDB_VERSION_MAX   POLICYDB_VERSION_AVTAB
+#ifdef CONFIG_SECURITY_SELINUX_POLICYDB_VERSION_MAX
+#define POLICYDB_VERSION_MAX	CONFIG_SECURITY_SELINUX_POLICYDB_VERSION_MAX_VALUE
+#else
+#define POLICYDB_VERSION_MAX	POLICYDB_VERSION_AVTAB
+#endif
 
 extern int selinux_enabled;
 extern int selinux_mls_enabled;

Date: Mon, 14 Aug 2006 17:27:51 -0400
From: Eric Paris <eparis redhat com>

Subject: selinux: add support for range transitions on object classes
From: Darrel Goeddel <dgoeddel TrustedCS com>

Introduces support for policy version 21.  This version of the binary
kernel policy allows for defining range transitions on security classes
other than the process security class.  As always, backwards compatibility
for older formats is retained.  The security class is read in as specified
when using the new format, while the "process" security class is assumed
when using an older policy format.

Signed-off-by: Darrel Goeddel <dgoeddel trustedcs com>
Signed-off-by: Stephen Smalley <sds tycho nsa gov>
Acked-by: James Morris <jmorris namei org>
Acked-by: Eric Paris <eparis redhat com>
Signed-off-by: Andrew Morton <akpm osdl org>
---

 security/selinux/Kconfig            |    2 -
 security/selinux/include/security.h |    3 +-
 security/selinux/ss/mls.c           |   21 +++++++++-----------
 security/selinux/ss/policydb.c      |   27 +++++++++++++++++++-------
 security/selinux/ss/policydb.h      |    7 +++---
 5 files changed, 37 insertions(+), 23 deletions(-)

diff -puN security/selinux/Kconfig~selinux-add-support-for-range-transitions-on-object security/selinux/Kconfig
--- a/security/selinux/Kconfig~selinux-add-support-for-range-transitions-on-object
+++ a/security/selinux/Kconfig
@@ -143,7 +143,7 @@ config SECURITY_SELINUX_POLICYDB_VERSION
 config SECURITY_SELINUX_POLICYDB_VERSION_MAX_VALUE
 	int "NSA SELinux maximum supported policy format version value"
 	depends on SECURITY_SELINUX_POLICYDB_VERSION_MAX
-	range 15 20
+	range 15 21
 	default 19
 	help
 	  This option sets the value for the maximum policy format version
diff -puN security/selinux/include/security.h~selinux-add-support-for-range-transitions-on-object security/selinux/include/security.h
--- a/security/selinux/include/security.h~selinux-add-support-for-range-transitions-on-object
+++ a/security/selinux/include/security.h
@@ -24,13 +24,14 @@
 #define POLICYDB_VERSION_VALIDATETRANS	19
 #define POLICYDB_VERSION_MLS		19
 #define POLICYDB_VERSION_AVTAB		20
+#define POLICYDB_VERSION_RANGETRANS	21
 
 /* Range of policy versions we understand*/
 #define POLICYDB_VERSION_MIN   POLICYDB_VERSION_BASE
 #ifdef CONFIG_SECURITY_SELINUX_POLICYDB_VERSION_MAX
 #define POLICYDB_VERSION_MAX	CONFIG_SECURITY_SELINUX_POLICYDB_VERSION_MAX_VALUE
 #else
-#define POLICYDB_VERSION_MAX	POLICYDB_VERSION_AVTAB
+#define POLICYDB_VERSION_MAX	POLICYDB_VERSION_RANGETRANS
 #endif
 
 extern int selinux_enabled;
diff -puN security/selinux/ss/mls.c~selinux-add-support-for-range-transitions-on-object security/selinux/ss/mls.c
--- a/security/selinux/ss/mls.c~selinux-add-support-for-range-transitions-on-object
+++ a/security/selinux/ss/mls.c
@@ -530,22 +530,21 @@ int mls_compute_sid(struct context *scon
 		    u32 specified,
 		    struct context *newcontext)
 {
+	struct range_trans *rtr;
+
 	if (!selinux_mls_enabled)
 		return 0;
 
 	switch (specified) {
 	case AVTAB_TRANSITION:
-		if (tclass == SECCLASS_PROCESS) {
-			struct range_trans *rangetr;
-			/* Look for a range transition rule. */
-			for (rangetr = policydb.range_tr; rangetr;
-			     rangetr = rangetr->next) {
-				if (rangetr->dom == scontext->type &&
-				    rangetr->type == tcontext->type) {
-					/* Set the range from the rule */
-					return mls_range_set(newcontext,
-					                     &rangetr->range);
-				}
+		/* Look for a range transition rule. */
+		for (rtr = policydb.range_tr; rtr; rtr = rtr->next) {
+			if (rtr->source_type == scontext->type &&
+			    rtr->target_type == tcontext->type &&
+			    rtr->target_class == tclass) {
+				/* Set the range from the rule */
+				return mls_range_set(newcontext,
+				                     &rtr->target_range);
 			}
 		}
 		/* Fallthrough */
diff -puN security/selinux/ss/policydb.c~selinux-add-support-for-range-transitions-on-object security/selinux/ss/policydb.c
--- a/security/selinux/ss/policydb.c~selinux-add-support-for-range-transitions-on-object
+++ a/security/selinux/ss/policydb.c
@@ -96,6 +96,11 @@ static struct policydb_compat_info polic
 		.sym_num        = SYM_NUM,
 		.ocon_num       = OCON_NUM,
 	},
+	{
+		.version        = POLICYDB_VERSION_RANGETRANS,
+		.sym_num        = SYM_NUM,
+		.ocon_num       = OCON_NUM,
+	},
 };
 
 static struct policydb_compat_info *policydb_lookup_compat(int version)
@@ -645,15 +650,15 @@ void policydb_destroy(struct policydb *p
 
 	for (rt = p->range_tr; rt; rt = rt -> next) {
 		if (lrt) {
-			ebitmap_destroy(&lrt->range.level[0].cat);
-			ebitmap_destroy(&lrt->range.level[1].cat);
+			ebitmap_destroy(&lrt->target_range.level[0].cat);
+			ebitmap_destroy(&lrt->target_range.level[1].cat);
 			kfree(lrt);
 		}
 		lrt = rt;
 	}
 	if (lrt) {
-		ebitmap_destroy(&lrt->range.level[0].cat);
-		ebitmap_destroy(&lrt->range.level[1].cat);
+		ebitmap_destroy(&lrt->target_range.level[0].cat);
+		ebitmap_destroy(&lrt->target_range.level[1].cat);
 		kfree(lrt);
 	}
 
@@ -1829,6 +1834,7 @@ int policydb_read(struct policydb *p, vo
 	}
 
 	if (p->policyvers >= POLICYDB_VERSION_MLS) {
+		int new_rangetr = p->policyvers >= POLICYDB_VERSION_RANGETRANS;
 		rc = next_entry(buf, fp, sizeof(u32));
 		if (rc < 0)
 			goto bad;
@@ -1847,9 +1853,16 @@ int policydb_read(struct policydb *p, vo
 			rc = next_entry(buf, fp, (sizeof(u32) * 2));
 			if (rc < 0)
 				goto bad;
-			rt->dom = le32_to_cpu(buf[0]);
-			rt->type = le32_to_cpu(buf[1]);
-			rc = mls_read_range_helper(&rt->range, fp);
+			rt->source_type = le32_to_cpu(buf[0]);
+			rt->target_type = le32_to_cpu(buf[1]);
+			if (new_rangetr) {
+				rc = next_entry(buf, fp, sizeof(u32));
+				if (rc < 0)
+					goto bad;
+				rt->target_class = le32_to_cpu(buf[0]);
+			} else
+				rt->target_class = SECCLASS_PROCESS;
+			rc = mls_read_range_helper(&rt->target_range, fp);
 			if (rc)
 				goto bad;
 			lrt = rt;
diff -puN security/selinux/ss/policydb.h~selinux-add-support-for-range-transitions-on-object security/selinux/ss/policydb.h
--- a/security/selinux/ss/policydb.h~selinux-add-support-for-range-transitions-on-object
+++ a/security/selinux/ss/policydb.h
@@ -106,9 +106,10 @@ struct cat_datum {
 };
 
 struct range_trans {
-	u32 dom;			/* current process domain */
-	u32 type;			/* program executable type */
-	struct mls_range range;		/* new range */
+	u32 source_type;
+	u32 target_type;
+	u32 target_class;
+	struct mls_range target_range;
 	struct range_trans *next;
 };
 



Index: kernel-2.6.spec
===================================================================
RCS file: /cvs/dist/rpms/kernel/devel/kernel-2.6.spec,v
retrieving revision 1.2519.4.4
retrieving revision 1.2519.4.5
diff -u -r1.2519.4.4 -r1.2519.4.5
--- kernel-2.6.spec	16 Aug 2006 21:50:29 -0000	1.2519.4.4
+++ kernel-2.6.spec	17 Aug 2006 22:59:24 -0000	1.2519.4.5
@@ -282,6 +282,7 @@
 Patch209: linux-2.6-x86_64-opterons-synchronize-p-state-using-TSC.patch
 
 # 300 - 399   ppc(64)
+Patch304: linux-2.6-ppc-fix-irq-mapping.patch
 Patch305: linux-2.6-cell-mambo-drivers.patch
 Patch306: linux-2.6-hvc-console.patch
 Patch314: linux-2.6-ppc-rtas-check.patch
@@ -365,7 +366,9 @@
 Patch1201: linux-2.6-NFSD-ctlbits.patch
 Patch1203: linux-2.6-NFSD-badness.patch
 
-# NIC driver updates
+# core networking changes.
+Patch1300: linux-2.6-net-ipsec-labelling.patch
+Patch1301: linux-2.6-net-netlabel-cipso.patch
 
 # Filesystem stuff.
 # Squashfs
@@ -388,6 +391,9 @@
 Patch1432: linux-2.6-filesystem-caching-for-afs-and-nfs.patch
 Patch1433: linux-2.6-nfs-superblock-unmount-optimization.patch
 
+# NFS uses 64-bit inodes
+Patch1440: linux-2.6-nfs-64-bit-inode-support.patch
+
 # Device mapper / MD layer
 Patch1500: linux-2.6-dm-mirroring.patch
 
@@ -404,9 +410,12 @@
 Patch1720: linux-2.6-proc-self-maps-fix.patch
 Patch1740: linux-2.6-softlockup-disable.patch
 Patch1770: linux-2.6-optimise-spinlock-debug.patch
+Patch1780: linux-2.6-ehea-ethernet-driver.patch
+Patch1790: linux-2.6-drivers-add-qlogic-firmware.patch
 
 # SELinux/audit patches.
 Patch1801: linux-2.6-selinux-mprotect-checks.patch
+Patch1802: linux-2.6-selinux-support-range-transitions.patch
 
 # Warn about usage of various obsolete functionality that may go away.
 Patch1900: linux-2.6-obsolete-oss-warning.patch
@@ -750,6 +759,8 @@
 #
 # PowerPC
 #
+# fix ppc irq mapping for JS20s
+%patch304 -p1
 # Support the IBM Mambo simulator; core as well as disk and network drivers.
 %patch305 -p1
 # Make HVC console generic; support simulator console device using it.
@@ -884,7 +895,9 @@
 # Fix badness.
 %patch1203 -p1
 
-# NIC driver fixes.
+# core networking changes.
+%patch1300 -p1
+%patch1301 -p1
 
 # Filesystem patches.
 # Squashfs
@@ -907,6 +920,9 @@
 %patch1432 -p1
 %patch1433 -p1
 
+# NFS supports 64-bit inodes
+%patch1440 -p1
+
 # Device mapper / MD layer
 # dm mirroring
 %patch1500 -p1
@@ -936,9 +952,15 @@
 %patch1740 -p1
 # Speed up spinlock debug.
 %patch1770 -p1
+# support EHEA ethernet driver
+%patch1780 -p1
+# qlogic firmware 
+%patch1790 -p1
 
 # Fix the SELinux mprotect checks on executable mappings
 %patch1801 -p1
+# Add support for SELinux range transitions
+%patch1802 -p1
 
 # Warn about obsolete functionality usage.
 %patch1900 -p1
@@ -1700,6 +1722,16 @@
 %endif
 
 %changelog
+* Thu Aug 17 2006 Don Zickus <dzickus redhat com>
+- added #202779
+- added #202597
+- added #196082
+- added #196075
+- added #201604
+- added #202461
+- added #184752
+- added #201731
+
 * Wed Aug 16 2006 Don Zickus <dzickus redhat com>
 - added #200740
 - forgot to disable utrace on ia64

linux-2.6-gfs2-dlm.patch:
 CREDITS                            |    6 
 Documentation/filesystems/gfs2.txt |   43 
 MAINTAINERS                        |   18 
 fs/Kconfig                         |    2 
 fs/Makefile                        |    2 
 fs/configfs/item.c                 |    2 
 fs/dlm/Kconfig                     |   21 
 fs/dlm/Makefile                    |   19 
 fs/dlm/ast.c                       |  172 +
 fs/dlm/ast.h                       |   26 
 fs/dlm/config.c                    |  789 +++++++
 fs/dlm/config.h                    |   42 
 fs/dlm/debug_fs.c                  |  387 +++
 fs/dlm/dir.c                       |  423 ++++
 fs/dlm/dir.h                       |   30 
 fs/dlm/dlm_internal.h              |  541 +++++
 fs/dlm/lock.c                      | 3846 +++++++++++++++++++++++++++++++++++++
 fs/dlm/lock.h                      |   61 
 fs/dlm/lockspace.c                 |  716 ++++++
 fs/dlm/lockspace.h                 |   25 
 fs/dlm/lowcomms.c                  | 1238 +++++++++++
 fs/dlm/lowcomms.h                  |   26 
 fs/dlm/lvb_table.h                 |   18 
 fs/dlm/main.c                      |   97 
 fs/dlm/member.c                    |  327 +++
 fs/dlm/member.h                    |   24 
 fs/dlm/memory.c                    |  116 +
 fs/dlm/memory.h                    |   29 
 fs/dlm/midcomms.c                  |  140 +
 fs/dlm/midcomms.h                  |   21 
 fs/dlm/rcom.c                      |  471 ++++
 fs/dlm/rcom.h                      |   24 
 fs/dlm/recover.c                   |  776 +++++++
 fs/dlm/recover.h                   |   34 
 fs/dlm/recoverd.c                  |  286 ++
 fs/dlm/recoverd.h                  |   24 
 fs/dlm/requestqueue.c              |  184 +
 fs/dlm/requestqueue.h              |   22 
 fs/dlm/user.c                      |  785 +++++++
 fs/dlm/user.h                      |   16 
 fs/dlm/util.c                      |  161 +
 fs/dlm/util.h                      |   22 
 fs/gfs2/Kconfig                    |   44 
 fs/gfs2/Makefile                   |   10 
 fs/gfs2/acl.c                      |  313 +++
 fs/gfs2/acl.h                      |   37 
 fs/gfs2/bmap.c                     | 1236 +++++++++++
 fs/gfs2/bmap.h                     |   27 
 fs/gfs2/daemon.c                   |  196 +
 fs/gfs2/daemon.h                   |   19 
 fs/gfs2/dir.c                      | 1976 +++++++++++++++++++
 fs/gfs2/dir.h                      |   73 
 fs/gfs2/eaops.c                    |  230 ++
 fs/gfs2/eaops.h                    |   29 
 fs/gfs2/eattr.c                    | 1548 ++++++++++++++
 fs/gfs2/eattr.h                    |   97 
 fs/gfs2/format.h                   |   21 
 fs/gfs2/gfs2.h                     |   31 
 fs/gfs2/glock.c                    | 2282 +++++++++++++++++++++
 fs/gfs2/glock.h                    |  152 +
 fs/gfs2/glops.c                    |  564 +++++
 fs/gfs2/glops.h                    |   23 
 fs/gfs2/incore.h                   |  659 ++++++
 fs/gfs2/inode.c                    | 1344 ++++++++++++
 fs/gfs2/inode.h                    |   56 
 fs/gfs2/lm.c                       |  244 ++
 fs/gfs2/lm.h                       |   41 
 fs/gfs2/lm_interface.h             |  290 ++
 fs/gfs2/locking.c                  |  191 +
 fs/gfs2/locking/dlm/Makefile       |    3 
 fs/gfs2/locking/dlm/lock.c         |  541 +++++
 fs/gfs2/locking/dlm/lock_dlm.h     |  188 +
 fs/gfs2/locking/dlm/main.c         |   64 
 fs/gfs2/locking/dlm/mount.c        |  256 ++
 fs/gfs2/locking/dlm/plock.c        |  302 ++
 fs/gfs2/locking/dlm/sysfs.c        |  225 ++
 fs/gfs2/locking/dlm/thread.c       |  359 +++
 fs/gfs2/locking/nolock/Makefile    |    3 
 fs/gfs2/locking/nolock/main.c      |  259 ++
 fs/gfs2/log.c                      |  601 +++++
 fs/gfs2/log.h                      |   61 
 fs/gfs2/lops.c                     |  800 +++++++
 fs/gfs2/lops.h                     |   96 
 fs/gfs2/lvb.c                      |   45 
 fs/gfs2/lvb.h                      |   19 
 fs/gfs2/main.c                     |  127 +
 fs/gfs2/meta_io.c                  |  780 +++++++
 fs/gfs2/meta_io.h                  |   74 
 fs/gfs2/mount.c                    |  214 ++
 fs/gfs2/mount.h                    |   15 
 fs/gfs2/ondisk.c                   |  308 ++
 fs/gfs2/ops_address.c              |  797 +++++++
 fs/gfs2/ops_address.h              |   18 
 fs/gfs2/ops_dentry.c               |  123 +
 fs/gfs2/ops_dentry.h               |   15 
 fs/gfs2/ops_export.c               |  293 ++
 fs/gfs2/ops_export.h               |   19 
 fs/gfs2/ops_file.c                 |  812 +++++++
 fs/gfs2/ops_file.h                 |   20 
 fs/gfs2/ops_fstype.c               |  840 ++++++++
 fs/gfs2/ops_fstype.h               |   16 
 fs/gfs2/ops_inode.c                | 1165 +++++++++++
 fs/gfs2/ops_inode.h                |   18 
 fs/gfs2/ops_super.c                |  471 ++++
 fs/gfs2/ops_super.h                |   15 
 fs/gfs2/ops_vm.c                   |  188 +
 fs/gfs2/ops_vm.h                   |   16 
 fs/gfs2/quota.c                    | 1286 ++++++++++++
 fs/gfs2/quota.h                    |   32 
 fs/gfs2/recovery.c                 |  573 +++++
 fs/gfs2/recovery.h                 |   32 
 fs/gfs2/rgrp.c                     | 1528 ++++++++++++++
 fs/gfs2/rgrp.h                     |   62 
 fs/gfs2/super.c                    |  979 +++++++++
 fs/gfs2/super.h                    |   52 
 fs/gfs2/sys.c                      |  579 +++++
 fs/gfs2/sys.h                      |   24 
 fs/gfs2/trans.c                    |  184 +
 fs/gfs2/trans.h                    |   34 
 fs/gfs2/util.c                     |  245 ++
 fs/gfs2/util.h                     |  169 +
 include/linux/Kbuild               |   33 
 include/linux/dlm.h                |  302 ++
 include/linux/dlm_device.h         |   86 
 include/linux/fs.h                 |    3 
 include/linux/gfs2_ondisk.h        |  443 ++++
 include/linux/iflags.h             |  102 
 include/linux/kernel.h             |    1 
 include/linux/lock_dlm_plock.h     |   41 
 mm/filemap.c                       |    3 
 mm/readahead.c                     |    1 
 131 files changed, 40684 insertions(+), 21 deletions(-)

Index: linux-2.6-gfs2-dlm.patch
===================================================================
RCS file: /cvs/dist/rpms/kernel/devel/linux-2.6-gfs2-dlm.patch,v
retrieving revision 1.12.4.2
retrieving revision 1.12.4.3
diff -u -r1.12.4.2 -r1.12.4.3
--- linux-2.6-gfs2-dlm.patch	16 Aug 2006 20:42:30 -0000	1.12.4.2
+++ linux-2.6-gfs2-dlm.patch	17 Aug 2006 22:59:24 -0000	1.12.4.3
@@ -67,10 +67,10 @@
 +  mount.gfs2	to help mount(8) mount a filesystem
 +  mkfs.gfs2	to make a filesystem
 diff --git a/MAINTAINERS b/MAINTAINERS
-index b2afc7a..e42e143 100644
+index e3e1515..a050d7c 100644
 --- a/MAINTAINERS
 +++ b/MAINTAINERS
-@@ -862,6 +862,16 @@ M:	jack suse cz
+@@ -875,6 +875,16 @@ M:	jack suse cz
  L:	linux-kernel vger kernel org
  S:	Maintained
  
@@ -87,7 +87,7 @@
  DAVICOM FAST ETHERNET (DMFE) NETWORK DRIVER
  P:	Tobias Ringstrom
  M:	tori unhappy mine nu
-@@ -1112,6 +1122,14 @@ M:	khc pm waw pl
+@@ -1129,6 +1139,14 @@ M:	khc pm waw pl
  W:	http://www.kernel.org/pub/linux/utils/net/hdlc/
  S:	Maintained
  
@@ -1256,10 +1256,10 @@
 +
 diff --git a/fs/dlm/debug_fs.c b/fs/dlm/debug_fs.c
 new file mode 100644
-index 0000000..8f471d9
+index 0000000..9c3aedd
 --- /dev/null
 +++ b/fs/dlm/debug_fs.c
-@@ -0,0 +1,384 @@
+@@ -0,0 +1,387 @@
 +/******************************************************************************
 +*******************************************************************************
 +**
@@ -1572,16 +1572,19 @@
 +{
 +	struct dlm_ls *ls = file->private_data;
 +	struct dlm_lkb *lkb;
-+	size_t len = DLM_DEBUG_BUF_LEN, pos = 0, rv;
++	size_t len = DLM_DEBUG_BUF_LEN, pos = 0, ret, rv;
 +
 +	mutex_lock(&debug_buf_lock);
 +	mutex_lock(&ls->ls_waiters_mutex);
 +	memset(debug_buf, 0, sizeof(debug_buf));
 +
 +	list_for_each_entry(lkb, &ls->ls_waiters, lkb_wait_reply) {
-+		pos += snprintf(debug_buf + pos, len - pos, "%x %d %d %s\n",
-+				lkb->lkb_id, lkb->lkb_wait_type,
-+				lkb->lkb_nodeid, lkb->lkb_resource->res_name);
++		ret = snprintf(debug_buf + pos, len - pos, "%x %d %d %s\n",
++			       lkb->lkb_id, lkb->lkb_wait_type,
++			       lkb->lkb_nodeid, lkb->lkb_resource->res_name);
++		if (ret >= len - pos)
++			break;
++		pos += ret;
 +	}
 +	mutex_unlock(&ls->ls_waiters_mutex);
 +
@@ -2111,10 +2114,10 @@
 +
 diff --git a/fs/dlm/dlm_internal.h b/fs/dlm/dlm_internal.h
 new file mode 100644
-index 0000000..7c3c2d2
+index 0000000..da75099
 --- /dev/null
 +++ b/fs/dlm/dlm_internal.h
-@@ -0,0 +1,539 @@
+@@ -0,0 +1,541 @@
 +/******************************************************************************
 +*******************************************************************************
 +**
@@ -2584,6 +2587,8 @@
 +	struct list_head	ls_requestqueue;/* queue remote requests */
 +	struct mutex		ls_requestqueue_mutex;
 +	char			*ls_recover_buf;
++	int			ls_recover_nodeid; /* for debugging */
++	uint64_t		ls_rcom_seq;
 +	struct list_head	ls_recover_list;
 +	spinlock_t		ls_recover_list_lock;
 +	int			ls_recover_list_count;
@@ -2656,10 +2661,10 @@
 +
 diff --git a/fs/dlm/lock.c b/fs/dlm/lock.c
 new file mode 100644
-index 0000000..7d38f91
+index 0000000..bb2e351
 --- /dev/null
 +++ b/fs/dlm/lock.c
-@@ -0,0 +1,3845 @@
+@@ -0,0 +1,3846 @@
 +/******************************************************************************
 +*******************************************************************************
 +**
@@ -6361,6 +6366,7 @@
 +	if (lvb_in && ua->lksb.sb_lvbptr)
 +		memcpy(ua->lksb.sb_lvbptr, lvb_in, DLM_USER_LVB_LEN);
 +	ua->castparam = ua_tmp->castparam;
++	ua->user_lksb = ua_tmp->user_lksb;
 +
 +	error = set_unlock_args(flags, ua, &args);
 +	if (error)
@@ -6574,10 +6580,10 @@
 +
 diff --git a/fs/dlm/lockspace.c b/fs/dlm/lockspace.c
 new file mode 100644
-index 0000000..31ed0fe
+index 0000000..7adaad5
 --- /dev/null
 +++ b/fs/dlm/lockspace.c
-@@ -0,0 +1,705 @@
+@@ -0,0 +1,716 @@
 +/******************************************************************************
 +*******************************************************************************
 +**
@@ -6661,6 +6667,11 @@
 +	return sprintf(buf, "%x\n", status);
 +}
 +
++static ssize_t dlm_recover_nodeid_show(struct dlm_ls *ls, char *buf)
++{
++	return sprintf(buf, "%d\n", ls->ls_recover_nodeid);
++}
++
 +struct dlm_attr {
 +	struct attribute attr;
 +	ssize_t (*show)(struct dlm_ls *, char *);
@@ -6688,11 +6699,17 @@
 +	.show  = dlm_recover_status_show
 +};
 +
++static struct dlm_attr dlm_attr_recover_nodeid = {
++	.attr  = {.name = "recover_nodeid", .mode = S_IRUGO},
++	.show  = dlm_recover_nodeid_show
++};
++
 +static struct attribute *dlm_attrs[] = {
 +	&dlm_attr_control.attr,
 +	&dlm_attr_event.attr,
 +	&dlm_attr_id.attr,
 +	&dlm_attr_recover_status.attr,
++	&dlm_attr_recover_nodeid.attr,
 +	NULL,
 +};
 +
@@ -7316,7 +7333,7 @@
 +
 diff --git a/fs/dlm/lowcomms.c b/fs/dlm/lowcomms.c
 new file mode 100644
-index 0000000..7ab4042
+index 0000000..23f5ce1
 --- /dev/null
 +++ b/fs/dlm/lowcomms.c
 @@ -0,0 +1,1238 @@
@@ -8256,11 +8273,11 @@
 +			break;
 +		e = list_entry(ni->writequeue.next, struct writequeue_entry,
 +			       list);
-+		kmap(e->page);
 +		len = e->len;
 +		offset = e->offset;
 +		BUG_ON(len == 0 && e->users == 0);
 +		spin_unlock(&ni->writequeue_lock);
++		kmap(e->page);
 +
 +		ret = 0;
 +		if (len) {
@@ -8719,10 +8736,10 @@
 +
 diff --git a/fs/dlm/member.c b/fs/dlm/member.c
 new file mode 100644
-index 0000000..cd0c51e
+index 0000000..a3f7de7
 --- /dev/null
 +++ b/fs/dlm/member.c
-@@ -0,0 +1,312 @@
+@@ -0,0 +1,327 @@
 +/******************************************************************************
 +*******************************************************************************
 +**
@@ -8887,11 +8904,23 @@
 +
 +/* send a status request to all members just to establish comms connections */
 +
-+static void ping_members(struct dlm_ls *ls)
++static int ping_members(struct dlm_ls *ls)
 +{
 +	struct dlm_member *memb;
-+	list_for_each_entry(memb, &ls->ls_nodes, list)
-+		dlm_rcom_status(ls, memb->nodeid);
++	int error = 0;
++
++	list_for_each_entry(memb, &ls->ls_nodes, list) {
++		error = dlm_recovery_stopped(ls);
++		if (error)
++			break;
++		error = dlm_rcom_status(ls, memb->nodeid);
++		if (error)
++			break;
++	}
++	if (error)
++		log_debug(ls, "ping_members aborted %d last nodeid %d",
++			  error, ls->ls_recover_nodeid);
++	return error;
 +}
 +
 +int dlm_recover_members(struct dlm_ls *ls, struct dlm_recover *rv, int *neg_out)
@@ -8937,10 +8966,13 @@
 +	dlm_set_recover_status(ls, DLM_RS_NODES);
 +	*neg_out = neg;
 +
-+	ping_members(ls);
++	error = ping_members(ls);
++	if (error)
++		goto out;
 +
 +	error = dlm_recover_members_wait(ls);
-+	log_debug(ls, "total members %d", ls->ls_num_nodes);
++ out:
++	log_debug(ls, "total members %d error %d", ls->ls_num_nodes, error);
 +	return error;
 +}
 +
@@ -9067,10 +9099,10 @@
 +
 diff --git a/fs/dlm/memory.c b/fs/dlm/memory.c
 new file mode 100644
-index 0000000..48dfc27
+index 0000000..989b608
 --- /dev/null
 +++ b/fs/dlm/memory.c
-@@ -0,0 +1,115 @@
+@@ -0,0 +1,116 @@
 +/******************************************************************************
 +*******************************************************************************
 +**
@@ -9173,7 +9205,8 @@
 +{
 +	struct dlm_direntry *de;
 +
-+	DLM_ASSERT(namelen <= DLM_RESNAME_MAXLEN,);
++	DLM_ASSERT(namelen <= DLM_RESNAME_MAXLEN,
++		   printk("namelen = %d\n", namelen););
 +
 +	de = kmalloc(sizeof(*de) + namelen, GFP_KERNEL);
 +	if (de)
@@ -9396,10 +9429,10 @@
 +
 diff --git a/fs/dlm/rcom.c b/fs/dlm/rcom.c
 new file mode 100644
-index 0000000..55fbe31
+index 0000000..64ba492
 --- /dev/null
 +++ b/fs/dlm/rcom.c
-@@ -0,0 +1,457 @@
+@@ -0,0 +1,471 @@
 +/******************************************************************************
 +*******************************************************************************
 +**
@@ -9499,6 +9532,7 @@
 +	int error = 0;
 +
 +	memset(ls->ls_recover_buf, 0, dlm_config.buffer_size);
++	ls->ls_recover_nodeid = nodeid;
 +
 +	if (nodeid == dlm_our_nodeid()) {
 +		rc = (struct dlm_rcom *) ls->ls_recover_buf;
@@ -9509,6 +9543,7 @@
 +	error = create_rcom(ls, nodeid, DLM_RCOM_STATUS, 0, &rc, &mh);
 +	if (error)
 +		goto out;
++	rc->rc_id = ++ls->ls_rcom_seq;
 +
 +	send_rcom(ls, mh, rc);
 +
@@ -9541,19 +9576,30 @@
 +			    sizeof(struct rcom_config), &rc, &mh);
 +	if (error)
 +		return;
++	rc->rc_id = rc_in->rc_id;
 +	rc->rc_result = dlm_recover_status(ls);
 +	make_config(ls, (struct rcom_config *) rc->rc_buf);
 +
 +	send_rcom(ls, mh, rc);
 +}
 +
-+static void receive_rcom_status_reply(struct dlm_ls *ls, struct dlm_rcom *rc_in)
++static void receive_sync_reply(struct dlm_ls *ls, struct dlm_rcom *rc_in)
 +{
++	if (rc_in->rc_id != ls->ls_rcom_seq) {
++		log_debug(ls, "reject old reply %d got %llx wanted %llx",
++			  rc_in->rc_type, rc_in->rc_id, ls->ls_rcom_seq);
++		return;
++	}
 +	memcpy(ls->ls_recover_buf, rc_in, rc_in->rc_header.h_length);
 +	set_bit(LSFL_RCOM_READY, &ls->ls_flags);
 +	wake_up(&ls->ls_wait_general);
 +}
 +
++static void receive_rcom_status_reply(struct dlm_ls *ls, struct dlm_rcom *rc_in)
++{
++	receive_sync_reply(ls, rc_in);
++}
++
 +int dlm_rcom_names(struct dlm_ls *ls, int nodeid, char *last_name, int last_len)
 +{
 +	struct dlm_rcom *rc;
@@ -9561,6 +9607,7 @@
 +	int error = 0, len = sizeof(struct dlm_rcom);
 +
 +	memset(ls->ls_recover_buf, 0, dlm_config.buffer_size);
++	ls->ls_recover_nodeid = nodeid;
 +
 +	if (nodeid == dlm_our_nodeid()) {
 +		dlm_copy_master_names(ls, last_name, last_len,
@@ -9573,6 +9620,7 @@
 +	if (error)
 +		goto out;
 +	memcpy(rc->rc_buf, last_name, last_len);
++	rc->rc_id = ++ls->ls_rcom_seq;
 +
 +	send_rcom(ls, mh, rc);
 +
@@ -9609,6 +9657,7 @@
 +	error = create_rcom(ls, nodeid, DLM_RCOM_NAMES_REPLY, outlen, &rc, &mh);
 +	if (error)
 +		return;
++	rc->rc_id = rc_in->rc_id;
 +
 +	dlm_copy_master_names(ls, rc_in->rc_buf, inlen, rc->rc_buf, outlen,
 +			      nodeid);
@@ -9617,9 +9666,7 @@
 +
 +static void receive_rcom_names_reply(struct dlm_ls *ls, struct dlm_rcom *rc_in)
 +{
-+	memcpy(ls->ls_recover_buf, rc_in, rc_in->rc_header.h_length);
-+	set_bit(LSFL_RCOM_READY, &ls->ls_flags);
-+	wake_up(&ls->ls_wait_general);
++	receive_sync_reply(ls, rc_in);
 +}
 +
 +int dlm_send_rcom_lookup(struct dlm_rsb *r, int dir_nodeid)
@@ -10711,10 +10758,10 @@
 +
 diff --git a/fs/dlm/recoverd.c b/fs/dlm/recoverd.c
 new file mode 100644
-index 0000000..7010353
+index 0000000..eac8e9f
 --- /dev/null
 +++ b/fs/dlm/recoverd.c
-@@ -0,0 +1,285 @@
+@@ -0,0 +1,286 @@
 +/******************************************************************************
 +*******************************************************************************
 +**
@@ -10992,6 +11039,7 @@
 +
 +void dlm_recoverd_suspend(struct dlm_ls *ls)
 +{
++	wake_up(&ls->ls_wait_general);
 +	mutex_lock(&ls->ls_recoverd_active);
 +}
 +
@@ -18241,10 +18289,10 @@
 +
 diff --git a/fs/gfs2/glock.c b/fs/gfs2/glock.c
 new file mode 100644
-index 0000000..b6edf7c
+index 0000000..a5e16e5
 --- /dev/null
 +++ b/fs/gfs2/glock.c
-@@ -0,0 +1,2279 @@
+@@ -0,0 +1,2282 @@
 +/*
 + * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
 + * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
@@ -20414,7 +20462,9 @@
 +
 +	spin_lock(&gl->gl_spin);
 +
-+	printk(KERN_INFO "Glock (%u, %llu)\n", gl->gl_name.ln_type,
++	printk(KERN_INFO "Glock 0x%p (%u, %llu)\n",
++	       gl,
++	       gl->gl_name.ln_type,
 +	       (unsigned long long)gl->gl_name.ln_number);
 +	printk(KERN_INFO "  gl_flags =");
 +	for (x = 0; x < 32; x++)
@@ -20434,8 +20484,9 @@
 +	printk(KERN_INFO "  reclaim = %s\n",
 +		    (list_empty(&gl->gl_reclaim)) ? "no" : "yes");
 +	if (gl->gl_aspace)
-+		printk(KERN_INFO "  aspace = %lu\n",
-+			    gl->gl_aspace->i_mapping->nrpages);
++		printk(KERN_INFO "  aspace = 0x%p nrpages = %lu\n",
++		       gl->gl_aspace,
++		       gl->gl_aspace->i_mapping->nrpages);
 +	else
 +		printk(KERN_INFO "  aspace = no\n");
 +	printk(KERN_INFO "  ail = %d\n", atomic_read(&gl->gl_ail_count));
@@ -21283,10 +21334,10 @@
 +#endif /* __GLOPS_DOT_H__ */
 diff --git a/fs/gfs2/incore.h b/fs/gfs2/incore.h
 new file mode 100644
-index 0000000..90e0624
+index 0000000..e98c14f
 --- /dev/null
 +++ b/fs/gfs2/incore.h
-@@ -0,0 +1,658 @@
+@@ -0,0 +1,659 @@
 +/*
 + * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
 + * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
@@ -21568,6 +21619,7 @@
 +
 +enum {
 +	GFF_DID_DIRECT_ALLOC	= 0,
++	GFF_EXLOCK = 1,
 +};
 +
 +struct gfs2_file {
@@ -23656,10 +23708,10 @@
 +#endif /* __LM_DOT_H__ */
 diff --git a/fs/gfs2/lm_interface.h b/fs/gfs2/lm_interface.h
 new file mode 100644
-index 0000000..9d34bf3
+index 0000000..1da95a5
 --- /dev/null
 +++ b/fs/gfs2/lm_interface.h
-@@ -0,0 +1,295 @@
+@@ -0,0 +1,290 @@
 +/*
 + * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
 + * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
@@ -23927,16 +23979,11 @@
 +/*
 + * Lock module bottom interface.  A lock module makes itself available to GFS
 + * with these functions.
-+ *
-+ * For the time being, we copy the gfs1 lock module bottom interface so the
-+ * same lock modules can be used with both gfs1 and gfs2 (it won't be possible
-+ * to load both gfs1 and gfs2 at once.)  Eventually the lock modules will fork
-+ * for gfs1/gfs2 and this API can change to the gfs2_ prefix.
 + */
 +
-+int gfs_register_lockproto(struct lm_lockops *proto);
++int gfs2_register_lockproto(struct lm_lockops *proto);
 +
-+void gfs_unregister_lockproto(struct lm_lockops *proto);
++void gfs2_unregister_lockproto(struct lm_lockops *proto);
 +
 +/*
 + * Lock module top interface.  GFS calls these functions when mounting or
@@ -23957,7 +24004,7 @@
 +
 diff --git a/fs/gfs2/locking.c b/fs/gfs2/locking.c
 new file mode 100644
-index 0000000..1831928
+index 0000000..ded1ef6
 --- /dev/null
 +++ b/fs/gfs2/locking.c
 @@ -0,0 +1,191 @@
@@ -23994,13 +24041,13 @@
 +static struct mutex lmh_lock;
 +
 +/**
-+ * gfs_register_lockproto - Register a low-level locking protocol
++ * gfs2_register_lockproto - Register a low-level locking protocol
 + * @proto: the protocol definition
 + *
 + * Returns: 0 on success, -EXXX on failure
 + */
 +
-+int gfs_register_lockproto(struct lm_lockops *proto)
++int gfs2_register_lockproto(struct lm_lockops *proto)
 +{
 +	struct lmh_wrapper *lw;
 +
@@ -24030,12 +24077,12 @@
 +}
 +
 +/**
-+ * gfs_unregister_lockproto - Unregister a low-level locking protocol
++ * gfs2_unregister_lockproto - Unregister a low-level locking protocol
 + * @proto: the protocol definition
 + *
 + */
 +
-+void gfs_unregister_lockproto(struct lm_lockops *proto)
++void gfs2_unregister_lockproto(struct lm_lockops *proto)
 +{
 +	struct lmh_wrapper *lw;
 +
@@ -24080,7 +24127,7 @@
 +	int try = 0;
 +	int error, found;
 +
-+ retry:
++retry:
 +	mutex_lock(&lmh_lock);
 +
 +	found = 0;
@@ -24114,7 +24161,7 @@
 +				     min_lvb_size, flags, lockstruct, fskobj);
 +	if (error)
 +		module_put(lw->lw_ops->lm_owner);
-+ out:
++out:
 +	mutex_unlock(&lmh_lock);
 +	return error;
 +}
@@ -24149,8 +24196,8 @@
 +	INIT_LIST_HEAD(&lmh_list);
 +}
 +
-+EXPORT_SYMBOL_GPL(gfs_register_lockproto);
-+EXPORT_SYMBOL_GPL(gfs_unregister_lockproto);
++EXPORT_SYMBOL_GPL(gfs2_register_lockproto);
++EXPORT_SYMBOL_GPL(gfs2_unregister_lockproto);
 +
 diff --git a/fs/gfs2/locking/dlm/Makefile b/fs/gfs2/locking/dlm/Makefile
 new file mode 100644
@@ -24904,7 +24951,7 @@
 +
 diff --git a/fs/gfs2/locking/dlm/main.c b/fs/gfs2/locking/dlm/main.c
 new file mode 100644
-index 0000000..89728c9
+index 0000000..870a1cd
 --- /dev/null
 +++ b/fs/gfs2/locking/dlm/main.c
 @@ -0,0 +1,64 @@
@@ -24930,7 +24977,7 @@
 +{
 +	int error;
 +
-+	error = gfs_register_lockproto(&gdlm_ops);
++	error = gfs2_register_lockproto(&gdlm_ops);
 +	if (error) {
 +		printk(KERN_WARNING "lock_dlm:  can't register protocol: %d\n",
 +		       error);
@@ -24939,14 +24986,14 @@
 +
 +	error = gdlm_sysfs_init();
 +	if (error) {
-+		gfs_unregister_lockproto(&gdlm_ops);
++		gfs2_unregister_lockproto(&gdlm_ops);
 +		return error;
 +	}
 +
 +	error = gdlm_plock_init();
 +	if (error) {
 +		gdlm_sysfs_exit();
-+		gfs_unregister_lockproto(&gdlm_ops);
++		gfs2_unregister_lockproto(&gdlm_ops);
 +		return error;
 +	}
 +
@@ -24962,7 +25009,7 @@
 +{
 +	gdlm_plock_exit();
 +	gdlm_sysfs_exit();
-+	gfs_unregister_lockproto(&gdlm_ops);
++	gfs2_unregister_lockproto(&gdlm_ops);
 +}
 +
 +module_init(init_lock_dlm);
@@ -25236,10 +25283,10 @@
 +
 diff --git a/fs/gfs2/locking/dlm/plock.c b/fs/gfs2/locking/dlm/plock.c
 new file mode 100644
-index 0000000..e5b11f0
+index 0000000..1acb251
 --- /dev/null
 +++ b/fs/gfs2/locking/dlm/plock.c
-@@ -0,0 +1,301 @@
+@@ -0,0 +1,302 @@
 +/*
 + * Copyright (C) 2005 Red Hat, Inc.  All rights reserved.
 + *
@@ -25474,7 +25521,8 @@
 +	spin_lock(&ops_lock);
 +	list_for_each_entry(op, &recv_list, list) {
 +		if (op->info.fsid == info.fsid &&
-+		    op->info.number == info.number) {
++		    op->info.number == info.number &&
++		    op->info.owner == info.owner) {
 +			list_del_init(&op->list);
 +			found = 1;
 +			op->done = 1;
@@ -26148,7 +26196,7 @@
 +
 diff --git a/fs/gfs2/locking/nolock/main.c b/fs/gfs2/locking/nolock/main.c
 new file mode 100644
-index 0000000..97ffac5
+index 0000000..748aa5d
 --- /dev/null
 +++ b/fs/gfs2/locking/nolock/main.c
 @@ -0,0 +1,259 @@
@@ -26387,7 +26435,7 @@
 +{
 +	int error;
 +
-+	error = gfs_register_lockproto(&nolock_ops);
++	error = gfs2_register_lockproto(&nolock_ops);
 +	if (error) {
 +		printk(KERN_WARNING
 +		       "lock_nolock: can't register protocol: %d\n", error);
@@ -26401,7 +26449,7 @@
 +
 +static void __exit exit_nolock(void)
 +{
-+	gfs_unregister_lockproto(&nolock_ops);
++	gfs2_unregister_lockproto(&nolock_ops);
 +}
 +
 +module_init(init_nolock);
@@ -26413,7 +26461,7 @@
 +
 diff --git a/fs/gfs2/log.c b/fs/gfs2/log.c
 new file mode 100644
-index 0000000..60fdc94
+index 0000000..a591fb8
 --- /dev/null
 +++ b/fs/gfs2/log.c
 @@ -0,0 +1,601 @@
@@ -26675,8 +26723,8 @@
 +	if (list_empty(&sdp->sd_ail1_list))
 +		tail = sdp->sd_log_head;
 +	else {
-+		ai = list_entry(sdp->sd_ail1_list.prev,
-+				struct gfs2_ail, ai_list);
++		ai = list_entry(sdp->sd_ail1_list.prev, struct gfs2_ail,
++				ai_list);
 +		tail = ai->ai_first;
 +	}
 +
@@ -29625,10 +29673,10 @@
 +
 diff --git a/fs/gfs2/ops_address.c b/fs/gfs2/ops_address.c
 new file mode 100644
-index 0000000..fca69f1
+index 0000000..45afd05
 --- /dev/null
 +++ b/fs/gfs2/ops_address.c
-@@ -0,0 +1,778 @@
+@@ -0,0 +1,797 @@
 +/*
 + * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
 + * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
@@ -29762,8 +29810,8 @@
 +static int gfs2_writepage(struct page *page, struct writeback_control *wbc)
 +{
 +	struct inode *inode = page->mapping->host;
-+	struct gfs2_inode *ip = GFS2_I(page->mapping->host);
-+	struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);
++	struct gfs2_inode *ip = GFS2_I(inode);
++	struct gfs2_sbd *sdp = GFS2_SB(inode);
 +	loff_t i_size = i_size_read(inode);
 +	pgoff_t end_index = i_size >> PAGE_CACHE_SHIFT;
 +	unsigned offset;
@@ -29789,6 +29837,10 @@
 +		error = gfs2_trans_begin(sdp, RES_DINODE + 1, 0);
 +		if (error)
 +			goto out_ignore;
++		if (!page_has_buffers(page)) {
++			create_empty_buffers(page, inode->i_sb->s_blocksize,
++					     (1 << BH_Dirty)|(1 << BH_Uptodate));
++		}
 +		gfs2_page_add_databufs(ip, page, 0, sdp->sd_vfs->s_blocksize-1);
 +		done_trans = 1;
 +	}
@@ -29868,14 +29920,22 @@
 +	struct gfs2_sbd *sdp = GFS2_SB(page->mapping->host);
 +	struct gfs2_holder gh;
 +	int error;
++	int do_unlock = 0;
 +
 +	if (likely(file != &gfs2_internal_file_sentinal)) {
++		if (file) {
++			struct gfs2_file *gf = file->private_data;
++			if (test_bit(GFF_EXLOCK, &gf->f_flags))
++				goto skip_lock;
++		}
 +		gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME|GL_AOP, &gh);
++		do_unlock = 1;
 +		error = gfs2_glock_nq_m_atime(1, &gh);
 +		if (unlikely(error))
 +			goto out_unlock;
 +	}
 +
++skip_lock:
 +	if (gfs2_is_stuffed(ip)) {
 +		error = stuffed_readpage(ip, page);
 +		unlock_page(page);
@@ -29893,7 +29953,7 @@
 +	return error;
 +out_unlock:
 +	unlock_page(page);
-+	if (file != &gfs2_internal_file_sentinal)
++	if (do_unlock)
 +		gfs2_holder_uninit(&gh);
 +	goto out;
 +}
@@ -29922,17 +29982,24 @@
 +	struct gfs2_holder gh;
 +	unsigned page_idx;
 +	int ret;
++	int do_unlock = 0;
 +
 +	if (likely(file != &gfs2_internal_file_sentinal)) {
++		if (file) {
++			struct gfs2_file *gf = file->private_data;
++			if (test_bit(GFF_EXLOCK, &gf->f_flags))
++				goto skip_lock;
++		}
 +		gfs2_holder_init(ip->i_gl, LM_ST_SHARED,
 +				 LM_FLAG_TRY_1CB|GL_ATIME|GL_AOP, &gh);
++		do_unlock = 1;
 +		ret = gfs2_glock_nq_m_atime(1, &gh);
 +		if (ret == GLR_TRYFAILED) 
 +			goto out_noerror;
 +		if (unlikely(ret))
 +			goto out_unlock;
 +	}
-+
++skip_lock:
 +	if (gfs2_is_stuffed(ip)) {
 +		struct pagevec lru_pvec;
 +		pagevec_init(&lru_pvec, 0);
@@ -29957,7 +30024,7 @@
 +		ret = mpage_readpages(mapping, pages, nr_pages, gfs2_get_block);
 +	}
 +
-+	if (likely(file != &gfs2_internal_file_sentinal)) {
++	if (do_unlock) {
 +		gfs2_glock_dq_m(1, &gh);
 +		gfs2_holder_uninit(&gh);
 +	}
@@ -29975,7 +30042,7 @@
 +		unlock_page(page);
 +		page_cache_release(page);
 +	}
-+	if (likely(file != &gfs2_internal_file_sentinal))
++	if (do_unlock)
 +		gfs2_holder_uninit(&gh);
 +	goto out;
 +}
@@ -31751,10 +31818,10 @@
 +#endif /* __OPS_FILE_DOT_H__ */
 diff --git a/fs/gfs2/ops_fstype.c b/fs/gfs2/ops_fstype.c
 new file mode 100644
-index 0000000..de18923
+index 0000000..4440009
 --- /dev/null
 +++ b/fs/gfs2/ops_fstype.c
-@@ -0,0 +1,836 @@
+@@ -0,0 +1,840 @@
 +/*
 + * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
 + * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
@@ -32036,6 +32103,10 @@
 +	int error = 0;
 +
 +	if (undo) {
++		if (sb->s_root) {
++			dput(sb->s_root);
++			sb->s_root = NULL;
++		}
 +		return 0;
 +	}
 +	
@@ -34308,10 +34379,10 @@
 +#endif /* __OPS_SUPER_DOT_H__ */
 diff --git a/fs/gfs2/ops_vm.c b/fs/gfs2/ops_vm.c
 new file mode 100644
-index 0000000..aff6637
+index 0000000..875a769
 --- /dev/null
 +++ b/fs/gfs2/ops_vm.c
-@@ -0,0 +1,194 @@
+@@ -0,0 +1,188 @@
 +/*
 + * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
 + * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
@@ -34360,13 +34431,7 @@
 +					unsigned long address, int *type)
 +{
 +	struct gfs2_inode *ip = GFS2_I(area->vm_file->f_mapping->host);
-+	struct gfs2_holder i_gh;
 +	struct page *result;
-+	int error;
-+
-+	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &i_gh);
-+	if (error)
-+		return NULL;
 +
 +	set_bit(GIF_PAGED, &ip->i_flags);
 +
@@ -34375,8 +34440,6 @@
 +	if (result && result != NOPAGE_OOM)
 +		pfault_be_greedy(ip);
 +
-+	gfs2_glock_dq_uninit(&i_gh);
-+
 +	return result;
 +}
 +
@@ -34455,7 +34518,9 @@
 +static struct page *gfs2_sharewrite_nopage(struct vm_area_struct *area,
 +					   unsigned long address, int *type)
 +{
-+	struct gfs2_inode *ip = GFS2_I(area->vm_file->f_mapping->host);
++	struct file *file = area->vm_file;
++	struct gfs2_file *gf = file->private_data;
++	struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
 +	struct gfs2_holder i_gh;
 +	struct page *result = NULL;
 +	unsigned long index = ((address - area->vm_start) >> PAGE_CACHE_SHIFT) +
@@ -34470,13 +34535,14 @@
 +	set_bit(GIF_PAGED, &ip->i_flags);
 +	set_bit(GIF_SW_PAGED, &ip->i_flags);
 +
-+	error = gfs2_write_alloc_required(ip,
-+					  (uint64_t)index << PAGE_CACHE_SHIFT,
++	error = gfs2_write_alloc_required(ip, (u64)index << PAGE_CACHE_SHIFT,
 +					  PAGE_CACHE_SIZE, &alloc_required);
 +	if (error)
 +		goto out;
 +
++	set_bit(GFF_EXLOCK, &gf->f_flags);
 +	result = filemap_nopage(area, address, type);
++	clear_bit(GFF_EXLOCK, &gf->f_flags);
 +	if (!result || result == NOPAGE_OOM)
 +		goto out;
 +
@@ -34491,8 +34557,7 @@
 +	}
 +
 +	pfault_be_greedy(ip);
-+
-+ out:
++out:
 +	gfs2_glock_dq_uninit(&i_gh);
 +
 +	return result;
@@ -35860,10 +35925,10 @@
 +#endif /* __QUOTA_DOT_H__ */
 diff --git a/fs/gfs2/recovery.c b/fs/gfs2/recovery.c
 new file mode 100644
-index 0000000..7aabc03
+index 0000000..8fe518c
 --- /dev/null
 +++ b/fs/gfs2/recovery.c
-@@ -0,0 +1,575 @@
+@@ -0,0 +1,573 @@
 +/*
 + * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
 + * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
@@ -36019,8 +36084,7 @@
 +
 +	if (lh.lh_header.mh_magic != GFS2_MAGIC ||
 +	    lh.lh_header.mh_type != GFS2_METATYPE_LH ||
-+	    lh.lh_blkno != blk ||
-+	    lh.lh_hash != hash)
++	    lh.lh_blkno != blk || lh.lh_hash != hash)
 +		return 1;
 +
 +	*head = lh;
@@ -36192,6 +36256,7 @@
 +			error = get_log_header(jd, start, &lh);
 +			if (!error) {
 +				gfs2_replay_incr_blk(sdp, &start);
++				brelse(bh);
 +				continue;
 +			}
 +			if (error == 1) {
@@ -36263,7 +36328,7 @@
 +	lh = (struct gfs2_log_header *)bh->b_data;
 +	memset(lh, 0, sizeof(struct gfs2_log_header));
 +	lh->lh_header.mh_magic = cpu_to_be32(GFS2_MAGIC);
-+	lh->lh_header.mh_type = cpu_to_be16(GFS2_METATYPE_LH);
++	lh->lh_header.mh_type = cpu_to_be32(GFS2_METATYPE_LH);
 +	lh->lh_header.mh_format = cpu_to_be32(GFS2_FORMAT_LH);
 +	lh->lh_sequence = cpu_to_be64(head->lh_sequence + 1);
 +	lh->lh_flags = cpu_to_be32(GFS2_LOG_HEAD_UNMOUNT);
@@ -36348,11 +36413,9 @@
 +
 +		/* Acquire a shared hold on the transaction lock */
 +
-+		error = gfs2_glock_nq_init(sdp->sd_trans_gl,
-+					   LM_ST_SHARED,
++		error = gfs2_glock_nq_init(sdp->sd_trans_gl, LM_ST_SHARED,
 +					   LM_FLAG_NOEXP | LM_FLAG_PRIORITY |
-+					   GL_NOCANCEL | GL_NOCACHE,
-+					   &t_gh);
++					   GL_NOCANCEL | GL_NOCACHE, &t_gh);
 +		if (error)
 +			goto fail_gunlock_ji;
 +

linux-2.6-gfs2-locking-exports.patch:
 locking.c |    4 +++-
 1 files changed, 3 insertions(+), 1 deletion(-)

Index: linux-2.6-gfs2-locking-exports.patch
===================================================================
RCS file: /cvs/dist/rpms/kernel/devel/linux-2.6-gfs2-locking-exports.patch,v
retrieving revision 1.1.10.2
retrieving revision 1.1.10.3
diff -u -r1.1.10.2 -r1.1.10.3
--- linux-2.6-gfs2-locking-exports.patch	16 Aug 2006 20:42:35 -0000	1.1.10.2
+++ linux-2.6-gfs2-locking-exports.patch	17 Aug 2006 22:59:25 -0000	1.1.10.3
@@ -1,12 +1,10 @@
-*** gfs2-2.6-18-rc2/fs/gfs2/locking.c	2006-07-20 10:44:33.000000000 -0500
---- gfs2-devel/fs/gfs2/locking.c	2006-07-20 12:27:53.000000000 -0500
-*************** void __init gfs2_init_lmh(void)
-*** 188,191 ****
---- 188,194 ----
-  
-  EXPORT_SYMBOL_GPL(gfs_register_lockproto);
-  EXPORT_SYMBOL_GPL(gfs_unregister_lockproto);
-+ EXPORT_SYMBOL_GPL(gfs2_withdraw_lockproto);
-+ EXPORT_SYMBOL_GPL(gfs2_mount_lockproto);
-+ EXPORT_SYMBOL_GPL(gfs2_unmount_lockproto);
-  
+--- linux-2.6.17.noarch/fs/gfs2/locking.c~	2006-08-10 13:33:09.000000000 -0400
++++ linux-2.6.17.noarch/fs/gfs2/locking.c	2006-08-10 13:33:23.000000000 -0400
+@@ -188,4 +188,6 @@ void __init gfs2_init_lmh(void)
+ 
+ EXPORT_SYMBOL_GPL(gfs2_register_lockproto);
+ EXPORT_SYMBOL_GPL(gfs2_unregister_lockproto);
+-
++EXPORT_SYMBOL_GPL(gfs2_withdraw_lockproto);
++EXPORT_SYMBOL_GPL(gfs2_mount_lockproto);
++EXPORT_SYMBOL_GPL(gfs2_unmount_lockproto);


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]