Author: waldi
Date: Sat Apr 14 15:46:17 2007
New Revision: 8475
Added:
dists/sid/linux-2.6/debian/patches/bugfix/all/stable/2.6.20.7.patch
(contents, props changed)
Modified:
dists/sid/linux-2.6/debian/changelog
dists/sid/linux-2.6/debian/patches/series/2
Log:
Add stable release 2.6.20.7.
* debian/changelog: Update.
* debian/patches/bugfix/all/stable/2.6.20.7.patch: Add.
* debian/patches/series/2: Update.
Modified: dists/sid/linux-2.6/debian/changelog
==============================================================================
--- dists/sid/linux-2.6/debian/changelog (original)
+++ dists/sid/linux-2.6/debian/changelog Sat Apr 14 15:46:17 2007
@@ -4,13 +4,46 @@
* Rename linux-libc-headers into linux-libc-dev.
* [mips] Drop sb1250 uart support.
* [alpha] Temporary disable alpha images.
+ * Add stable release 2.6.20.7:
+ - Linux 2.6.20.7
+ - Update libata drive blacklist to the latest from 2.6.21
+ - fix page leak during core dump
+ - revert "retries in ext4_prepare_write() violate ordering requirements"
+ - revert "retries in ext3_prepare_write() violate ordering requirements"
+ - libata: Clear tf before doing request sense (take 3)
+ - fix lba48 bug in libata fill_result_tf()
+ - ahci.c: walkaround for SB600 SATA internal error issue
+ - libata bugfix: preserve LBA bit for HDIO_DRIVE_TASK
+ - softmac: avoid assert in ieee80211softmac_wx_get_rate
+ - knfsd: allow nfsd READDIR to return 64bit cookies
+ - ide: use correct IDE error recovery
+ - Fix TCP slow_start_after_idle sysctl
+ - Fix tcindex classifier ABI borkage...
+ - Fix IPSEC replay window handling
+ - Fix TCP receiver side SWS handling.
+ - Fix scsi sense handling
+ - Fix length validation in rawv6_sendmsg()
+ - Fix IFB net driver input device crashes
+ - NETFILTER: ipt_CLUSTERIP: fix oops in checkentry function
+ - 8139too: RTNL and flush_scheduled_work deadlock
+ - Fix calculation for size of filemap_attr array in md/bitmap.
+ - HID: Do not discard truncated input reports
+ - DVB: pluto2: fix incorrect TSCR register setting
+ - DVB: tda10086: fix DiSEqC message length
+ - sky2: phy workarounds for Yukon EC-U A1
+ - sky2: turn on clocks when doing resume
+ - sky2: turn carrier off when down
+ - skge: turn carrier off when down
+ - sky2: reliable recovery
+ - i386: fix file_read_actor() and pipe_read() for original i386 systems
+ - kbuild: fix dependency generation
[ dann frazier ]
* [hppa] Add parisc arch patch from Kyle McMartin
* [hppa] Enable CONFIG_TULIP_MMIO (closes: #332962)
* [hppa] Disable ni52 driver, it doesn't build (and wouldn't work if it did)
- -- Bastian Blank <[EMAIL PROTECTED]> Thu, 12 Apr 2007 19:49:00 +0200
+ -- Bastian Blank <[EMAIL PROTECTED]> Sat, 14 Apr 2007 17:44:02 +0200
linux-2.6 (2.6.20-1) unstable; urgency=low
Added: dists/sid/linux-2.6/debian/patches/bugfix/all/stable/2.6.20.7.patch
==============================================================================
--- (empty file)
+++ dists/sid/linux-2.6/debian/patches/bugfix/all/stable/2.6.20.7.patch Sat Apr
14 15:46:17 2007
@@ -0,0 +1,1264 @@
+diff --git a/Makefile b/Makefile
+index e81e106..bc99522 100644
+diff --git a/arch/i386/lib/usercopy.c b/arch/i386/lib/usercopy.c
+index d22cfc9..086b372 100644
+--- a/arch/i386/lib/usercopy.c
++++ b/arch/i386/lib/usercopy.c
+@@ -10,6 +10,7 @@
+ #include <linux/blkdev.h>
+ #include <linux/module.h>
+ #include <linux/backing-dev.h>
++#include <linux/interrupt.h>
+ #include <asm/uaccess.h>
+ #include <asm/mmx.h>
+
+@@ -719,6 +720,14 @@ unsigned long __copy_to_user_ll(void __user *to, const
void *from,
+ #ifndef CONFIG_X86_WP_WORKS_OK
+ if (unlikely(boot_cpu_data.wp_works_ok == 0) &&
+ ((unsigned long )to) < TASK_SIZE) {
++ /*
++ * When we are in an atomic section (see
++ * mm/filemap.c:file_read_actor), return the full
++ * length to take the slow path.
++ */
++ if (in_atomic())
++ return n;
++
+ /*
+ * CPU does not honor the WP bit when writing
+ * from supervisory mode, and due to preemption or SMP,
+diff --git a/drivers/ata/ahci.c b/drivers/ata/ahci.c
+index dc2c082..21fb66f 100644
+--- a/drivers/ata/ahci.c
++++ b/drivers/ata/ahci.c
+@@ -82,6 +82,7 @@ enum {
+ board_ahci_pi = 1,
+ board_ahci_vt8251 = 2,
+ board_ahci_ign_iferr = 3,
++ board_ahci_sb600 = 4,
+
+ /* global controller registers */
+ HOST_CAP = 0x00, /* host capabilities */
+@@ -173,6 +174,7 @@ enum {
+ AHCI_FLAG_NO_NCQ = (1 << 24),
+ AHCI_FLAG_IGN_IRQ_IF_ERR = (1 << 25), /* ignore IRQ_IF_ERR */
+ AHCI_FLAG_HONOR_PI = (1 << 26), /* honor PORTS_IMPL */
++ AHCI_FLAG_IGN_SERR_INTERNAL = (1 << 27), /* ignore SERR_INTERNAL */
+ };
+
+ struct ahci_cmd_hdr {
+@@ -365,6 +367,18 @@ static const struct ata_port_info ahci_port_info[] = {
+ .udma_mask = 0x7f, /* udma0-6 ; FIXME */
+ .port_ops = &ahci_ops,
+ },
++ /* board_ahci_sb600 */
++ {
++ .sht = &ahci_sht,
++ .flags = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY |
++ ATA_FLAG_MMIO | ATA_FLAG_PIO_DMA |
++ ATA_FLAG_SKIP_D2H_BSY |
++ AHCI_FLAG_IGN_SERR_INTERNAL,
++ .pio_mask = 0x1f, /* pio0-4 */
++ .udma_mask = 0x7f, /* udma0-6 ; FIXME */
++ .port_ops = &ahci_ops,
++ },
++
+ };
+
+ static const struct pci_device_id ahci_pci_tbl[] = {
+@@ -404,7 +418,7 @@ static const struct pci_device_id ahci_pci_tbl[] = {
+ { PCI_VDEVICE(JMICRON, 0x2366), board_ahci_ign_iferr }, /* JMB366 */
+
+ /* ATI */
+- { PCI_VDEVICE(ATI, 0x4380), board_ahci }, /* ATI SB600 non-raid */
++ { PCI_VDEVICE(ATI, 0x4380), board_ahci_sb600 }, /* ATI SB600 non-raid */
+ { PCI_VDEVICE(ATI, 0x4381), board_ahci }, /* ATI SB600 raid */
+
+ /* VIA */
+@@ -1076,8 +1090,11 @@ static void ahci_error_intr(struct ata_port *ap, u32
irq_stat)
+ if (ap->flags & AHCI_FLAG_IGN_IRQ_IF_ERR)
+ irq_stat &= ~PORT_IRQ_IF_ERR;
+
+- if (irq_stat & PORT_IRQ_TF_ERR)
++ if (irq_stat & PORT_IRQ_TF_ERR) {
+ err_mask |= AC_ERR_DEV;
++ if (ap->flags & AHCI_FLAG_IGN_SERR_INTERNAL)
++ serror &= ~SERR_INTERNAL;
++ }
+
+ if (irq_stat & (PORT_IRQ_HBUS_ERR | PORT_IRQ_HBUS_DATA_ERR)) {
+ err_mask |= AC_ERR_HOST_BUS;
+diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
+index d6fcf0a..9a472c2 100644
+--- a/drivers/ata/libata-core.c
++++ b/drivers/ata/libata-core.c
+@@ -3316,7 +3316,6 @@ static const struct ata_blacklist_entry
ata_device_blacklist [] = {
+ { "WPI CDD-820", NULL, ATA_HORKAGE_NODMA },
+ { "SAMSUNG CD-ROM SC-148C", NULL, ATA_HORKAGE_NODMA },
+ { "SAMSUNG CD-ROM SC", NULL, ATA_HORKAGE_NODMA },
+- { "SanDisk SDP3B-64", NULL, ATA_HORKAGE_NODMA },
+ { "ATAPI CD-ROM DRIVE 40X MAXIMUM",NULL,ATA_HORKAGE_NODMA },
+ { "_NEC DV5800A", NULL, ATA_HORKAGE_NODMA },
+ { "SAMSUNG CD-ROM SN-124","N001", ATA_HORKAGE_NODMA },
+@@ -3326,6 +3325,17 @@ static const struct ata_blacklist_entry
ata_device_blacklist [] = {
+ /* Devices where NCQ should be avoided */
+ /* NCQ is slow */
+ { "WDC WD740ADFD-00", NULL, ATA_HORKAGE_NONCQ },
++ /* http://thread.gmane.org/gmane.linux.ide/14907 */
++ { "FUJITSU MHT2060BH", NULL, ATA_HORKAGE_NONCQ },
++ /* NCQ is broken */
++ { "Maxtor 6L250S0", "BANC1G10", ATA_HORKAGE_NONCQ },
++ /* NCQ hard hangs device under heavier load, needs hard power cycle */
++ { "Maxtor 6B250S0", "BANC1B70", ATA_HORKAGE_NONCQ },
++ /* Blacklist entries taken from Silicon Image 3124/3132
++ Windows driver .inf file - also several Linux problem reports */
++ { "HTS541060G9SA00", "MB3OC60D", ATA_HORKAGE_NONCQ, },
++ { "HTS541080G9SA00", "MB4OC60D", ATA_HORKAGE_NONCQ, },
++ { "HTS541010G9SA00", "MBZOC60D", ATA_HORKAGE_NONCQ, },
+
+ /* Devices with NCQ limits */
+
+@@ -4742,8 +4752,8 @@ static void fill_result_tf(struct ata_queued_cmd *qc)
+ {
+ struct ata_port *ap = qc->ap;
+
+- ap->ops->tf_read(ap, &qc->result_tf);
+ qc->result_tf.flags = qc->tf.flags;
++ ap->ops->tf_read(ap, &qc->result_tf);
+ }
+
+ /**
+diff --git a/drivers/ata/libata-eh.c b/drivers/ata/libata-eh.c
+index 7484358..e1b0bff 100644
+--- a/drivers/ata/libata-eh.c
++++ b/drivers/ata/libata-eh.c
+@@ -954,26 +954,27 @@ static int ata_eh_read_log_10h(struct ata_device *dev,
+ * RETURNS:
+ * 0 on success, AC_ERR_* mask on failure
+ */
+-static unsigned int atapi_eh_request_sense(struct ata_device *dev,
+- unsigned char *sense_buf)
++static unsigned int atapi_eh_request_sense(struct ata_queued_cmd *qc)
+ {
++ struct ata_device *dev = qc->dev;
++ unsigned char *sense_buf = qc->scsicmd->sense_buffer;
+ struct ata_port *ap = dev->ap;
+ struct ata_taskfile tf;
+ u8 cdb[ATAPI_CDB_LEN];
+
+ DPRINTK("ATAPI request sense\n");
+
+- ata_tf_init(dev, &tf);
+-
+ /* FIXME: is this needed? */
+ memset(sense_buf, 0, SCSI_SENSE_BUFFERSIZE);
+
+- /* XXX: why tf_read here? */
+- ap->ops->tf_read(ap, &tf);
+-
+- /* fill these in, for the case where they are -not- overwritten */
++ /* initialize sense_buf with the error register,
++ * for the case where they are -not- overwritten
++ */
+ sense_buf[0] = 0x70;
+- sense_buf[2] = tf.feature >> 4;
++ sense_buf[2] = qc->result_tf.feature >> 4;
++
++ /* some devices time out if garbage left in tf */
++ ata_tf_init(dev, &tf);
+
+ memset(cdb, 0, ATAPI_CDB_LEN);
+ cdb[0] = REQUEST_SENSE;
+@@ -1137,8 +1138,7 @@ static unsigned int ata_eh_analyze_tf(struct
ata_queued_cmd *qc,
+
+ case ATA_DEV_ATAPI:
+ if (!(qc->ap->pflags & ATA_PFLAG_FROZEN)) {
+- tmp = atapi_eh_request_sense(qc->dev,
+- qc->scsicmd->sense_buffer);
++ tmp = atapi_eh_request_sense(qc);
+ if (!tmp) {
+ /* ATA_QCFLAG_SENSE_VALID is used to
+ * tell atapi_qc_complete() that sense
+diff --git a/drivers/ata/libata-scsi.c b/drivers/ata/libata-scsi.c
+index 1790542..fc436f6 100644
+--- a/drivers/ata/libata-scsi.c
++++ b/drivers/ata/libata-scsi.c
+@@ -295,7 +295,7 @@ int ata_task_ioctl(struct scsi_device *scsidev, void
__user *arg)
+ scsi_cmd[8] = args[3];
+ scsi_cmd[10] = args[4];
+ scsi_cmd[12] = args[5];
+- scsi_cmd[13] = args[6] & 0x0f;
++ scsi_cmd[13] = args[6] & 0x4f;
+ scsi_cmd[14] = args[0];
+
+ /* Good values for timeout and retries? Values below
+diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
+index 5cb2500..1ecad3e 100644
+--- a/drivers/hid/hid-core.c
++++ b/drivers/hid/hid-core.c
+@@ -975,7 +975,7 @@ int hid_input_report(struct hid_device *hid, int type, u8
*data, int size, int i
+
+ if (size < rsize) {
+ dbg("report %d is too short, (%d < %d)", report->id, size,
rsize);
+- return -1;
++ memset(data + size, 0, rsize - size);
+ }
+
+ if ((hid->claimed & HID_CLAIMED_HIDDEV) && hid->hiddev_report_event)
+diff --git a/drivers/ide/ide-io.c b/drivers/ide/ide-io.c
+index 99d1c43..d6ff4f2 100644
+--- a/drivers/ide/ide-io.c
++++ b/drivers/ide/ide-io.c
+@@ -519,21 +519,24 @@ static ide_startstop_t ide_ata_error(ide_drive_t *drive,
struct request *rq, u8
+ if ((stat & DRQ_STAT) && rq_data_dir(rq) == READ &&
hwif->err_stops_fifo == 0)
+ try_to_flush_leftover_data(drive);
+
++ if (rq->errors >= ERROR_MAX || blk_noretry_request(rq)) {
++ ide_kill_rq(drive, rq);
++ return ide_stopped;
++ }
++
+ if (hwif->INB(IDE_STATUS_REG) & (BUSY_STAT|DRQ_STAT))
+- /* force an abort */
+- hwif->OUTB(WIN_IDLEIMMEDIATE, IDE_COMMAND_REG);
++ rq->errors |= ERROR_RESET;
+
+- if (rq->errors >= ERROR_MAX || blk_noretry_request(rq))
+- ide_kill_rq(drive, rq);
+- else {
+- if ((rq->errors & ERROR_RESET) == ERROR_RESET) {
+- ++rq->errors;
+- return ide_do_reset(drive);
+- }
+- if ((rq->errors & ERROR_RECAL) == ERROR_RECAL)
+- drive->special.b.recalibrate = 1;
++ if ((rq->errors & ERROR_RESET) == ERROR_RESET) {
+ ++rq->errors;
++ return ide_do_reset(drive);
+ }
++
++ if ((rq->errors & ERROR_RECAL) == ERROR_RECAL)
++ drive->special.b.recalibrate = 1;
++
++ ++rq->errors;
++
+ return ide_stopped;
+ }
+
+@@ -1025,6 +1028,13 @@ static ide_startstop_t start_request (ide_drive_t
*drive, struct request *rq)
+ if (!drive->special.all) {
+ ide_driver_t *drv;
+
++ /*
++ * We reset the drive so we need to issue a SETFEATURES.
++ * Do it _after_ do_special() restored device parameters.
++ */
++ if (drive->current_speed == 0xff)
++ ide_config_drive_speed(drive, drive->desired_speed);
++
+ if (rq->cmd_type == REQ_TYPE_ATA_CMD ||
+ rq->cmd_type == REQ_TYPE_ATA_TASK ||
+ rq->cmd_type == REQ_TYPE_ATA_TASKFILE)
+diff --git a/drivers/ide/ide-iops.c b/drivers/ide/ide-iops.c
+index 59b10a0..133d9cd 100644
+--- a/drivers/ide/ide-iops.c
++++ b/drivers/ide/ide-iops.c
+@@ -1123,6 +1123,9 @@ static void pre_reset(ide_drive_t *drive)
+ if (HWIF(drive)->pre_reset != NULL)
+ HWIF(drive)->pre_reset(drive);
+
++ if (drive->current_speed != 0xff)
++ drive->desired_speed = drive->current_speed;
++ drive->current_speed = 0xff;
+ }
+
+ /*
+diff --git a/drivers/md/bitmap.c b/drivers/md/bitmap.c
+index 059704f..cef1287 100644
+--- a/drivers/md/bitmap.c
++++ b/drivers/md/bitmap.c
+@@ -863,9 +863,7 @@ static int bitmap_init_from_disk(struct bitmap *bitmap,
sector_t start)
+
+ /* We need 4 bits per page, rounded up to a multiple of sizeof(unsigned
long) */
+ bitmap->filemap_attr = kzalloc(
+- (((num_pages*4/8)+sizeof(unsigned long)-1)
+- /sizeof(unsigned long))
+- *sizeof(unsigned long),
++ roundup( DIV_ROUND_UP(num_pages*4, 8), sizeof(unsigned long)),
+ GFP_KERNEL);
+ if (!bitmap->filemap_attr)
+ goto out;
+diff --git a/drivers/media/dvb/frontends/tda10086.c
b/drivers/media/dvb/frontends/tda10086.c
+index 4c27a2d..ccc429c 100644
+--- a/drivers/media/dvb/frontends/tda10086.c
++++ b/drivers/media/dvb/frontends/tda10086.c
+@@ -212,7 +212,7 @@ static int tda10086_send_master_cmd (struct dvb_frontend*
fe,
+ for(i=0; i< cmd->msg_len; i++) {
+ tda10086_write_byte(state, 0x48+i, cmd->msg[i]);
+ }
+- tda10086_write_byte(state, 0x36, 0x08 | ((cmd->msg_len + 1) << 4));
++ tda10086_write_byte(state, 0x36, 0x08 | ((cmd->msg_len - 1) << 4));
+
+ tda10086_diseqc_wait(state);
+
+diff --git a/drivers/media/dvb/pluto2/pluto2.c
b/drivers/media/dvb/pluto2/pluto2.c
+index ffda71d..058df5c 100644
+--- a/drivers/media/dvb/pluto2/pluto2.c
++++ b/drivers/media/dvb/pluto2/pluto2.c
+@@ -149,6 +149,15 @@ static inline void pluto_rw(struct pluto *pluto, u32 reg,
u32 mask, u32 bits)
+ writel(val, &pluto->io_mem[reg]);
+ }
+
++static void pluto_write_tscr(struct pluto *pluto, u32 val)
++{
++ /* set the number of packets */
++ val &= ~TSCR_ADEF;
++ val |= TS_DMA_PACKETS / 2;
++
++ pluto_writereg(pluto, REG_TSCR, val);
++}
++
+ static void pluto_setsda(void *data, int state)
+ {
+ struct pluto *pluto = data;
+@@ -213,11 +222,11 @@ static void pluto_reset_ts(struct pluto *pluto, int
reenable)
+
+ if (val & TSCR_RSTN) {
+ val &= ~TSCR_RSTN;
+- pluto_writereg(pluto, REG_TSCR, val);
++ pluto_write_tscr(pluto, val);
+ }
+ if (reenable) {
+ val |= TSCR_RSTN;
+- pluto_writereg(pluto, REG_TSCR, val);
++ pluto_write_tscr(pluto, val);
+ }
+ }
+
+@@ -339,7 +348,7 @@ static irqreturn_t pluto_irq(int irq, void *dev_id)
+ }
+
+ /* ACK the interrupt */
+- pluto_writereg(pluto, REG_TSCR, tscr | TSCR_IACK);
++ pluto_write_tscr(pluto, tscr | TSCR_IACK);
+
+ return IRQ_HANDLED;
+ }
+@@ -348,9 +357,6 @@ static void __devinit pluto_enable_irqs(struct pluto
*pluto)
+ {
+ u32 val = pluto_readreg(pluto, REG_TSCR);
+
+- /* set the number of packets */
+- val &= ~TSCR_ADEF;
+- val |= TS_DMA_PACKETS / 2;
+ /* disable AFUL and LOCK interrupts */
+ val |= (TSCR_MSKA | TSCR_MSKL);
+ /* enable DMA and OVERFLOW interrupts */
+@@ -358,7 +364,7 @@ static void __devinit pluto_enable_irqs(struct pluto
*pluto)
+ /* clear pending interrupts */
+ val |= TSCR_IACK;
+
+- pluto_writereg(pluto, REG_TSCR, val);
++ pluto_write_tscr(pluto, val);
+ }
+
+ static void pluto_disable_irqs(struct pluto *pluto)
+@@ -370,7 +376,7 @@ static void pluto_disable_irqs(struct pluto *pluto)
+ /* clear pending interrupts */
+ val |= TSCR_IACK;
+
+- pluto_writereg(pluto, REG_TSCR, val);
++ pluto_write_tscr(pluto, val);
+ }
+
+ static int __devinit pluto_hw_init(struct pluto *pluto)
+diff --git a/drivers/net/8139too.c b/drivers/net/8139too.c
+index 35ad5cf..99304b2 100644
+--- a/drivers/net/8139too.c
++++ b/drivers/net/8139too.c
+@@ -1109,6 +1109,8 @@ static void __devexit rtl8139_remove_one (struct pci_dev
*pdev)
+
+ assert (dev != NULL);
+
++ flush_scheduled_work();
++
+ unregister_netdev (dev);
+
+ __rtl8139_cleanup_dev (dev);
+@@ -1603,18 +1605,21 @@ static void rtl8139_thread (struct work_struct *work)
+ struct net_device *dev = tp->mii.dev;
+ unsigned long thr_delay = next_tick;
+
++ rtnl_lock();
++
++ if (!netif_running(dev))
++ goto out_unlock;
++
+ if (tp->watchdog_fired) {
+ tp->watchdog_fired = 0;
+ rtl8139_tx_timeout_task(work);
+- } else if (rtnl_trylock()) {
+- rtl8139_thread_iter (dev, tp, tp->mmio_addr);
+- rtnl_unlock ();
+- } else {
+- /* unlikely race. mitigate with fast poll. */
+- thr_delay = HZ / 2;
+- }
++ } else
++ rtl8139_thread_iter(dev, tp, tp->mmio_addr);
+
+- schedule_delayed_work(&tp->thread, thr_delay);
++ if (tp->have_thread)
++ schedule_delayed_work(&tp->thread, thr_delay);
++out_unlock:
++ rtnl_unlock ();
+ }
+
+ static void rtl8139_start_thread(struct rtl8139_private *tp)
+@@ -1626,19 +1631,11 @@ static void rtl8139_start_thread(struct
rtl8139_private *tp)
+ return;
+
+ tp->have_thread = 1;
++ tp->watchdog_fired = 0;
+
+ schedule_delayed_work(&tp->thread, next_tick);
+ }
+
+-static void rtl8139_stop_thread(struct rtl8139_private *tp)
+-{
+- if (tp->have_thread) {
+- cancel_rearming_delayed_work(&tp->thread);
+- tp->have_thread = 0;
+- } else
+- flush_scheduled_work();
+-}
+-
+ static inline void rtl8139_tx_clear (struct rtl8139_private *tp)
+ {
+ tp->cur_tx = 0;
+@@ -1696,12 +1693,11 @@ static void rtl8139_tx_timeout (struct net_device *dev)
+ {
+ struct rtl8139_private *tp = netdev_priv(dev);
+
++ tp->watchdog_fired = 1;
+ if (!tp->have_thread) {
+- INIT_DELAYED_WORK(&tp->thread, rtl8139_tx_timeout_task);
++ INIT_DELAYED_WORK(&tp->thread, rtl8139_thread);
+ schedule_delayed_work(&tp->thread, next_tick);
+- } else
+- tp->watchdog_fired = 1;
+-
++ }
+ }
+
+ static int rtl8139_start_xmit (struct sk_buff *skb, struct net_device *dev)
+@@ -2233,8 +2229,6 @@ static int rtl8139_close (struct net_device *dev)
+
+ netif_stop_queue (dev);
+
+- rtl8139_stop_thread(tp);
+-
+ if (netif_msg_ifdown(tp))
+ printk(KERN_DEBUG "%s: Shutting down ethercard, status was
0x%4.4x.\n",
+ dev->name, RTL_R16 (IntrStatus));
+diff --git a/drivers/net/ifb.c b/drivers/net/ifb.c
+index ca2b21f..07b4c0d 100644
+--- a/drivers/net/ifb.c
++++ b/drivers/net/ifb.c
+@@ -96,17 +96,24 @@ static void ri_tasklet(unsigned long dev)
+ skb->tc_verd = SET_TC_NCLS(skb->tc_verd);
+ stats->tx_packets++;
+ stats->tx_bytes +=skb->len;
++
++ skb->dev = __dev_get_by_index(skb->iif);
++ if (!skb->dev) {
++ dev_kfree_skb(skb);
++ stats->tx_dropped++;
++ break;
++ }
++ skb->iif = _dev->ifindex;
++
+ if (from & AT_EGRESS) {
+ dp->st_rx_frm_egr++;
+ dev_queue_xmit(skb);
+ } else if (from & AT_INGRESS) {
+-
+ dp->st_rx_frm_ing++;
++ skb_pull(skb, skb->dev->hard_header_len);
+ netif_rx(skb);
+- } else {
+- dev_kfree_skb(skb);
+- stats->tx_dropped++;
+- }
++ } else
++ BUG();
+ }
+
+ if (netif_tx_trylock(_dev)) {
+@@ -157,26 +164,10 @@ static int ifb_xmit(struct sk_buff *skb, struct
net_device *dev)
+ stats->rx_packets++;
+ stats->rx_bytes+=skb->len;
+
+- if (!from || !skb->input_dev) {
+-dropped:
++ if (!(from & (AT_INGRESS|AT_EGRESS)) || !skb->iif) {
+ dev_kfree_skb(skb);
+ stats->rx_dropped++;
+ return ret;
+- } else {
+- /*
+- * note we could be going
+- * ingress -> egress or
+- * egress -> ingress
+- */
+- skb->dev = skb->input_dev;
+- skb->input_dev = dev;
+- if (from & AT_INGRESS) {
+- skb_pull(skb, skb->dev->hard_header_len);
+- } else {
+- if (!(from & AT_EGRESS)) {
+- goto dropped;
+- }
+- }
+ }
+
+ if (skb_queue_len(&dp->rq) >= dev->tx_queue_len) {
+diff --git a/drivers/net/skge.c b/drivers/net/skge.c
+index 45283f3..9bc9427 100644
+--- a/drivers/net/skge.c
++++ b/drivers/net/skge.c
+@@ -2462,6 +2462,7 @@ static int skge_down(struct net_device *dev)
+ printk(KERN_INFO PFX "%s: disabling interface\n", dev->name);
+
+ netif_stop_queue(dev);
++ netif_carrier_off(dev);
+ if (hw->chip_id == CHIP_ID_GENESIS && hw->phy_type == SK_PHY_XMAC)
+ cancel_rearming_delayed_work(&skge->link_thread);
+
+diff --git a/drivers/net/sky2.c b/drivers/net/sky2.c
+index f44c397..38e75cf 100644
+--- a/drivers/net/sky2.c
++++ b/drivers/net/sky2.c
+@@ -524,9 +524,9 @@ static void sky2_phy_init(struct sky2_hw *hw, unsigned
port)
+ ledover &= ~PHY_M_LED_MO_RX;
+ }
+
+- if (hw->chip_id == CHIP_ID_YUKON_EC_U && hw->chip_rev ==
CHIP_REV_YU_EC_A1) {
++ if (hw->chip_id == CHIP_ID_YUKON_EC_U &&
++ hw->chip_rev == CHIP_REV_YU_EC_U_A1) {
+ /* apply fixes in PHY AFE */
+- pg = gm_phy_read(hw, port, PHY_MARV_EXT_ADR);
+ gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 255);
+
+ /* increase differential signal amplitude in 10BASE-T */
+@@ -538,7 +538,7 @@ static void sky2_phy_init(struct sky2_hw *hw, unsigned
port)
+ gm_phy_write(hw, port, 0x17, 0x2002);
+
+ /* set page register to 0 */
+- gm_phy_write(hw, port, PHY_MARV_EXT_ADR, pg);
++ gm_phy_write(hw, port, PHY_MARV_EXT_ADR, 0);
+ } else {
+ gm_phy_write(hw, port, PHY_MARV_LED_CTRL, ledctrl);
+
+@@ -1506,6 +1506,7 @@ static int sky2_down(struct net_device *dev)
+
+ /* Stop more packets from being queued */
+ netif_stop_queue(dev);
++ netif_carrier_off(dev);
+
+ /* Disable port IRQ */
+ imask = sky2_read32(hw, B0_IMSK);
+@@ -1802,38 +1803,22 @@ static void sky2_tx_timeout(struct net_device *dev)
+ {
+ struct sky2_port *sky2 = netdev_priv(dev);
+ struct sky2_hw *hw = sky2->hw;
+- unsigned txq = txqaddr[sky2->port];
+- u16 report, done;
++ unsigned port = sky2->port;
+
+ if (netif_msg_timer(sky2))
+ printk(KERN_ERR PFX "%s: tx timeout\n", dev->name);
+
+- report = sky2_read16(hw, sky2->port == 0 ? STAT_TXA1_RIDX :
STAT_TXA2_RIDX);
+- done = sky2_read16(hw, Q_ADDR(txq, Q_DONE));
+-
+- printk(KERN_DEBUG PFX "%s: transmit ring %u .. %u report=%u done=%u\n",
+- dev->name,
+- sky2->tx_cons, sky2->tx_prod, report, done);
+-
+- if (report != done) {
+- printk(KERN_INFO PFX "status burst pending (irq
moderation?)\n");
+-
+- sky2_write8(hw, STAT_TX_TIMER_CTRL, TIM_STOP);
+- sky2_write8(hw, STAT_TX_TIMER_CTRL, TIM_START);
+- } else if (report != sky2->tx_cons) {
+- printk(KERN_INFO PFX "status report lost?\n");
+- sky2_tx_complete(sky2, report);
+- } else {
+- printk(KERN_INFO PFX "hardware hung? flushing\n");
+-
+- sky2_write32(hw, Q_ADDR(txq, Q_CSR), BMU_STOP);
+- sky2_write32(hw, Y2_QADDR(txq, PREF_UNIT_CTRL),
PREF_UNIT_RST_SET);
++ /* Get information for bug report :-) */
++ printk(KERN_INFO PFX "%s: transmit ring %u .. %u report=%u done=%u\n",
++ dev->name, sky2->tx_cons, sky2->tx_prod,
++ sky2_read16(hw, port == 0 ? STAT_TXA1_RIDX : STAT_TXA2_RIDX),
++ sky2_read16(hw, Q_ADDR(txqaddr[sky2->port], Q_DONE)));
+
+- sky2_tx_complete(sky2, sky2->tx_prod);
++ printk(KERN_INFO PFX "gmac control %#x status %#x\n",
++ gma_read16(hw, port, GM_GP_CTRL), gma_read16(hw, port,
GM_GP_STAT));
+
+- sky2_qset(hw, txq);
+- sky2_prefetch_init(hw, txq, sky2->tx_le_map, TX_RING_SIZE - 1);
+- }
++ /* can't restart safely under softirq */
++ schedule_work(&hw->restart_work);
+ }
+
+ static int sky2_change_mtu(struct net_device *dev, int new_mtu)
+@@ -2436,6 +2421,10 @@ static int sky2_reset(struct sky2_hw *hw)
+ return -EOPNOTSUPP;
+ }
+
++ /* Make sure and enable all clocks */
++ if (hw->chip_id == CHIP_ID_YUKON_EC_U)
++ sky2_pci_write32(hw, PCI_DEV_REG3, 0);
++
+ hw->chip_rev = (sky2_read8(hw, B2_MAC_CFG) & CFG_CHIP_R_MSK) >> 4;
+
+ /* This rev is really old, and requires untested workarounds */
+@@ -2565,6 +2554,49 @@ static int sky2_reset(struct sky2_hw *hw)
+ return 0;
+ }
+
++static void sky2_restart(struct work_struct *work)
++{
++ struct sky2_hw *hw = container_of(work, struct sky2_hw, restart_work);
++ struct net_device *dev;
++ int i, err;
++
++ dev_dbg(&hw->pdev->dev, "restarting\n");
++
++ del_timer_sync(&hw->idle_timer);
++
++ rtnl_lock();
++ sky2_write32(hw, B0_IMSK, 0);
++ sky2_read32(hw, B0_IMSK);
++
++ netif_poll_disable(hw->dev[0]);
++
++ for (i = 0; i < hw->ports; i++) {
++ dev = hw->dev[i];
++ if (netif_running(dev))
++ sky2_down(dev);
++ }
++
++ sky2_reset(hw);
++ sky2_write32(hw, B0_IMSK, Y2_IS_BASE);
++ netif_poll_enable(hw->dev[0]);
++
++ for (i = 0; i < hw->ports; i++) {
++ dev = hw->dev[i];
++ if (netif_running(dev)) {
++ err = sky2_up(dev);
++ if (err) {
++ printk(KERN_INFO PFX "%s: could not restart
%d\n",
++ dev->name, err);
++ dev_close(dev);
++ }
++ }
++ }
++
++ sky2_idle_start(hw);
++
++ rtnl_unlock();
++}
++
+ static u32 sky2_supported_modes(const struct sky2_hw *hw)
+ {
+ if (sky2_is_copper(hw)) {
+@@ -3508,6 +3540,8 @@ static int __devinit sky2_probe(struct pci_dev *pdev,
+ }
+
+ setup_timer(&hw->idle_timer, sky2_idle, (unsigned long) hw);
++ INIT_WORK(&hw->restart_work, sky2_restart);
++
+ sky2_idle_start(hw);
+
+ pci_set_drvdata(pdev, hw);
+@@ -3609,6 +3643,9 @@ static int sky2_resume(struct pci_dev *pdev)
+
+ pci_restore_state(pdev);
+ pci_enable_wake(pdev, PCI_D0, 0);
++
++ if (hw->chip_id == CHIP_ID_YUKON_EC_U)
++ sky2_pci_write32(hw, PCI_DEV_REG3, 0);
+ sky2_set_power_state(hw, PCI_D0);
+
+ err = sky2_reset(hw);
+diff --git a/drivers/net/sky2.h b/drivers/net/sky2.h
+index 148aab2..5193714 100644
+--- a/drivers/net/sky2.h
++++ b/drivers/net/sky2.h
+@@ -1898,6 +1898,7 @@ struct sky2_hw {
+ dma_addr_t st_dma;
+
+ struct timer_list idle_timer;
++ struct work_struct restart_work;
+ int msi;
+ wait_queue_head_t msi_wait;
+ };
+diff --git a/drivers/scsi/scsi_error.c b/drivers/scsi/scsi_error.c
+index 2ecb6ff..e71a8e6 100644
+--- a/drivers/scsi/scsi_error.c
++++ b/drivers/scsi/scsi_error.c
+@@ -595,7 +595,7 @@ static int scsi_send_eh_cmnd(struct scsi_cmnd *scmd,
unsigned char *cmnd,
+ */
+ if (copy_sense) {
+ if (!SCSI_SENSE_VALID(scmd)) {
+- memcpy(scmd->sense_buffer, scmd->request_buffer,
++ memcpy(scmd->sense_buffer, page_address(sgl.page),
+ sizeof(scmd->sense_buffer));
+ }
+ __free_page(sgl.page);
+diff --git a/fs/binfmt_elf.c b/fs/binfmt_elf.c
+index 51db118..b172b01 100644
+--- a/fs/binfmt_elf.c
++++ b/fs/binfmt_elf.c
+@@ -1704,7 +1704,10 @@ static int elf_core_dump(long signr, struct pt_regs
*regs, struct file *file)
+ DUMP_SEEK(PAGE_SIZE);
+ } else {
+ if (page == ZERO_PAGE(addr)) {
+- DUMP_SEEK(PAGE_SIZE);
++ if (!dump_seek(file, PAGE_SIZE)) {
++ page_cache_release(page);
++ goto end_coredump;
++ }
+ } else {
+ void *kaddr;
+ flush_cache_page(vma, addr,
+diff --git a/fs/binfmt_elf_fdpic.c b/fs/binfmt_elf_fdpic.c
+index a4d933a..a852eb7 100644
+--- a/fs/binfmt_elf_fdpic.c
++++ b/fs/binfmt_elf_fdpic.c
+@@ -1473,8 +1473,8 @@ static int elf_fdpic_dump_segments(struct file *file,
struct mm_struct *mm,
+ DUMP_SEEK(file->f_pos + PAGE_SIZE);
+ }
+ else if (page == ZERO_PAGE(addr)) {
+- DUMP_SEEK(file->f_pos + PAGE_SIZE);
+ page_cache_release(page);
++ DUMP_SEEK(file->f_pos + PAGE_SIZE);
+ }
+ else {
+ void *kaddr;
+diff --git a/fs/ext3/inode.c b/fs/ext3/inode.c
+index beaf25f..03ba5bc 100644
+--- a/fs/ext3/inode.c
++++ b/fs/ext3/inode.c
+@@ -1148,102 +1148,37 @@ static int do_journal_get_write_access(handle_t
*handle,
+ return ext3_journal_get_write_access(handle, bh);
+ }
+
+-/*
+- * The idea of this helper function is following:
+- * if prepare_write has allocated some blocks, but not all of them, the
+- * transaction must include the content of the newly allocated blocks.
+- * This content is expected to be set to zeroes by block_prepare_write().
+- * 2006/10/14 SAW
+- */
+-static int ext3_prepare_failure(struct file *file, struct page *page,
+- unsigned from, unsigned to)
+-{
+- struct address_space *mapping;
+- struct buffer_head *bh, *head, *next;
+- unsigned block_start, block_end;
+- unsigned blocksize;
+- int ret;
+- handle_t *handle = ext3_journal_current_handle();
+-
+- mapping = page->mapping;
+- if (ext3_should_writeback_data(mapping->host)) {
+- /* optimization: no constraints about data */
+-skip:
+- return ext3_journal_stop(handle);
+- }
+-
+- head = page_buffers(page);
+- blocksize = head->b_size;
+- for ( bh = head, block_start = 0;
+- bh != head || !block_start;
+- block_start = block_end, bh = next)
+- {
+- next = bh->b_this_page;
+- block_end = block_start + blocksize;
+- if (block_end <= from)
+- continue;
+- if (block_start >= to) {
+- block_start = to;
+- break;
+- }
+- if (!buffer_mapped(bh))
+- /* prepare_write failed on this bh */
+- break;
+- if (ext3_should_journal_data(mapping->host)) {
+- ret = do_journal_get_write_access(handle, bh);
+- if (ret) {
+- ext3_journal_stop(handle);
+- return ret;
+- }
+- }
+- /*
+- * block_start here becomes the first block where the current iteration
+- * of prepare_write failed.
+- */
+- }
+- if (block_start <= from)
+- goto skip;
+-
+- /* commit allocated and zeroed buffers */
+- return mapping->a_ops->commit_write(file, page, from, block_start);
+-}
+-
+ static int ext3_prepare_write(struct file *file, struct page *page,
+ unsigned from, unsigned to)
+ {
+ struct inode *inode = page->mapping->host;
+- int ret, ret2;
+- int needed_blocks = ext3_writepage_trans_blocks(inode);
++ int ret, needed_blocks = ext3_writepage_trans_blocks(inode);
+ handle_t *handle;
+ int retries = 0;
+
+ retry:
+ handle = ext3_journal_start(inode, needed_blocks);
+- if (IS_ERR(handle))
+- return PTR_ERR(handle);
++ if (IS_ERR(handle)) {
++ ret = PTR_ERR(handle);
++ goto out;
++ }
+ if (test_opt(inode->i_sb, NOBH) && ext3_should_writeback_data(inode))
+ ret = nobh_prepare_write(page, from, to, ext3_get_block);
+ else
+ ret = block_prepare_write(page, from, to, ext3_get_block);
+ if (ret)
+- goto failure;
++ goto prepare_write_failed;
+
+ if (ext3_should_journal_data(inode)) {
+ ret = walk_page_buffers(handle, page_buffers(page),
+ from, to, NULL, do_journal_get_write_access);
+- if (ret)
+- /* fatal error, just put the handle and return */
+- journal_stop(handle);
+ }
+- return ret;
+-
+-failure:
+- ret2 = ext3_prepare_failure(file, page, from, to);
+- if (ret2 < 0)
+- return ret2;
++prepare_write_failed:
++ if (ret)
++ ext3_journal_stop(handle);
+ if (ret == -ENOSPC && ext3_should_retry_alloc(inode->i_sb, &retries))
+ goto retry;
+- /* retry number exceeded, or other error like -EDQUOT */
++out:
+ return ret;
+ }
+
+diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
+index a127cc0..0a60ec5 100644
+--- a/fs/ext4/inode.c
++++ b/fs/ext4/inode.c
+@@ -1147,102 +1147,37 @@ static int do_journal_get_write_access(handle_t
*handle,
+ return ext4_journal_get_write_access(handle, bh);
+ }
+
+-/*
+- * The idea of this helper function is following:
+- * if prepare_write has allocated some blocks, but not all of them, the
+- * transaction must include the content of the newly allocated blocks.
+- * This content is expected to be set to zeroes by block_prepare_write().
+- * 2006/10/14 SAW
+- */
+-static int ext4_prepare_failure(struct file *file, struct page *page,
+- unsigned from, unsigned to)
+-{
+- struct address_space *mapping;
+- struct buffer_head *bh, *head, *next;
+- unsigned block_start, block_end;
+- unsigned blocksize;
+- int ret;
+- handle_t *handle = ext4_journal_current_handle();
+-
+- mapping = page->mapping;
+- if (ext4_should_writeback_data(mapping->host)) {
+- /* optimization: no constraints about data */
+-skip:
+- return ext4_journal_stop(handle);
+- }
+-
+- head = page_buffers(page);
+- blocksize = head->b_size;
+- for ( bh = head, block_start = 0;
+- bh != head || !block_start;
+- block_start = block_end, bh = next)
+- {
+- next = bh->b_this_page;
+- block_end = block_start + blocksize;
+- if (block_end <= from)
+- continue;
+- if (block_start >= to) {
+- block_start = to;
+- break;
+- }
+- if (!buffer_mapped(bh))
+- /* prepare_write failed on this bh */
+- break;
+- if (ext4_should_journal_data(mapping->host)) {
+- ret = do_journal_get_write_access(handle, bh);
+- if (ret) {
+- ext4_journal_stop(handle);
+- return ret;
+- }
+- }
+- /*
+- * block_start here becomes the first block where the current iteration
+- * of prepare_write failed.
+- */
+- }
+- if (block_start <= from)
+- goto skip;
+-
+- /* commit allocated and zeroed buffers */
+- return mapping->a_ops->commit_write(file, page, from, block_start);
+-}
+-
+ static int ext4_prepare_write(struct file *file, struct page *page,
+ unsigned from, unsigned to)
+ {
+ struct inode *inode = page->mapping->host;
+- int ret, ret2;
+- int needed_blocks = ext4_writepage_trans_blocks(inode);
++ int ret, needed_blocks = ext4_writepage_trans_blocks(inode);
+ handle_t *handle;
+ int retries = 0;
+
+ retry:
+ handle = ext4_journal_start(inode, needed_blocks);
+- if (IS_ERR(handle))
+- return PTR_ERR(handle);
++ if (IS_ERR(handle)) {
++ ret = PTR_ERR(handle);
++ goto out;
++ }
+ if (test_opt(inode->i_sb, NOBH) && ext4_should_writeback_data(inode))
+ ret = nobh_prepare_write(page, from, to, ext4_get_block);
+ else
+ ret = block_prepare_write(page, from, to, ext4_get_block);
+ if (ret)
+- goto failure;
++ goto prepare_write_failed;
+
+ if (ext4_should_journal_data(inode)) {
+ ret = walk_page_buffers(handle, page_buffers(page),
+ from, to, NULL, do_journal_get_write_access);
+- if (ret)
+- /* fatal error, just put the handle and return */
+- ext4_journal_stop(handle);
+ }
+- return ret;
+-
+-failure:
+- ret2 = ext4_prepare_failure(file, page, from, to);
+- if (ret2 < 0)
+- return ret2;
++prepare_write_failed:
++ if (ret)
++ ext4_journal_stop(handle);
+ if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
+ goto retry;
+- /* retry number exceeded, or other error like -EDQUOT */
++out:
+ return ret;
+ }
+
+diff --git a/fs/nfsd/nfs3xdr.c b/fs/nfsd/nfs3xdr.c
+index e695660..c1ba275 100644
+--- a/fs/nfsd/nfs3xdr.c
++++ b/fs/nfsd/nfs3xdr.c
+@@ -844,8 +844,8 @@ compose_entry_fh(struct nfsd3_readdirres *cd, struct
svc_fh *fhp,
+ #define NFS3_ENTRY_BAGGAGE (2 + 1 + 2 + 1)
+ #define NFS3_ENTRYPLUS_BAGGAGE (1 + 21 + 1 + (NFS3_FHSIZE >> 2))
+ static int
+-encode_entry(struct readdir_cd *ccd, const char *name,
+- int namlen, off_t offset, ino_t ino, unsigned int d_type, int plus)
++encode_entry(struct readdir_cd *ccd, const char *name, int namlen,
++ loff_t offset, ino_t ino, unsigned int d_type, int plus)
+ {
+ struct nfsd3_readdirres *cd = container_of(ccd, struct nfsd3_readdirres,
+ common);
+@@ -865,7 +865,7 @@ encode_entry(struct readdir_cd *ccd, const char *name,
+ *cd->offset1 = htonl(offset64 & 0xffffffff);
+ cd->offset1 = NULL;
+ } else {
+- xdr_encode_hyper(cd->offset, (u64) offset);
++ xdr_encode_hyper(cd->offset, offset64);
+ }
+ }
+
+diff --git a/include/linux/ide.h b/include/linux/ide.h
+index 3808698..63e111e 100644
+--- a/include/linux/ide.h
++++ b/include/linux/ide.h
+@@ -607,6 +607,7 @@ typedef struct ide_drive_s {
+ u8 init_speed; /* transfer rate set at boot */
+ u8 pio_speed; /* unused by core, used by some drivers for
fallback from DMA */
+ u8 current_speed; /* current transfer rate set */
++ u8 desired_speed; /* desired transfer rate set */
+ u8 dn; /* now wide spread use */
+ u8 wcache; /* status of write cache */
+ u8 acoustic; /* acoustic management */
+diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
+index 4ff3940..82f43ad 100644
+--- a/include/linux/skbuff.h
++++ b/include/linux/skbuff.h
+@@ -188,7 +188,7 @@ enum {
+ * @sk: Socket we are owned by
+ * @tstamp: Time we arrived
+ * @dev: Device we arrived on/are leaving by
+- * @input_dev: Device we arrived on
++ * @iif: ifindex of device we arrived on
+ * @h: Transport layer header
+ * @nh: Network layer header
+ * @mac: Link layer header
+@@ -235,7 +235,8 @@ struct sk_buff {
+ struct sock *sk;
+ struct skb_timeval tstamp;
+ struct net_device *dev;
+- struct net_device *input_dev;
++ int iif;
++ /* 4 byte hole on 64 bit*/
+
+ union {
+ struct tcphdr *th;
+diff --git a/include/net/pkt_cls.h b/include/net/pkt_cls.h
+index b902d24..02647fe 100644
+--- a/include/net/pkt_cls.h
++++ b/include/net/pkt_cls.h
+@@ -352,10 +352,13 @@ tcf_change_indev(struct tcf_proto *tp, char *indev,
struct rtattr *indev_tlv)
+ static inline int
+ tcf_match_indev(struct sk_buff *skb, char *indev)
+ {
++ struct net_device *dev;
++
+ if (indev[0]) {
+- if (!skb->input_dev)
++ if (!skb->iif)
+ return 0;
+- if (strcmp(indev, skb->input_dev->name))
++ dev = __dev_get_by_index(skb->iif);
++ if (!dev || strcmp(indev, dev->name))
+ return 0;
+ }
+
+diff --git a/net/core/dev.c b/net/core/dev.c
+index 295f8f9..2a587b8 100644
+--- a/net/core/dev.c
++++ b/net/core/dev.c
+@@ -1741,8 +1741,8 @@ static int ing_filter(struct sk_buff *skb)
+ if (dev->qdisc_ingress) {
+ __u32 ttl = (__u32) G_TC_RTTL(skb->tc_verd);
+ if (MAX_RED_LOOP < ttl++) {
+- printk(KERN_WARNING "Redir loop detected Dropping
packet (%s->%s)\n",
+- skb->input_dev->name, skb->dev->name);
++ printk(KERN_WARNING "Redir loop detected Dropping
packet (%d->%d)\n",
++ skb->iif, skb->dev->ifindex);
+ return TC_ACT_SHOT;
+ }
+
+@@ -1775,8 +1775,8 @@ int netif_receive_skb(struct sk_buff *skb)
+ if (!skb->tstamp.off_sec)
+ net_timestamp(skb);
+
+- if (!skb->input_dev)
+- skb->input_dev = skb->dev;
++ if (!skb->iif)
++ skb->iif = skb->dev->ifindex;
+
+ orig_dev = skb_bond(skb);
+
+diff --git a/net/core/skbuff.c b/net/core/skbuff.c
+index 5299083..ba94969 100644
+--- a/net/core/skbuff.c
++++ b/net/core/skbuff.c
+@@ -497,7 +497,7 @@ struct sk_buff *skb_clone(struct sk_buff *skb, gfp_t
gfp_mask)
+ n->tc_verd = SET_TC_VERD(skb->tc_verd,0);
+ n->tc_verd = CLR_TC_OK2MUNGE(n->tc_verd);
+ n->tc_verd = CLR_TC_MUNGED(n->tc_verd);
+- C(input_dev);
++ C(iif);
+ #endif
+ skb_copy_secmark(n, skb);
+ #endif
+diff --git a/net/ieee80211/softmac/ieee80211softmac_wx.c
b/net/ieee80211/softmac/ieee80211softmac_wx.c
+index fa2f7da..fb58e03 100644
+--- a/net/ieee80211/softmac/ieee80211softmac_wx.c
++++ b/net/ieee80211/softmac/ieee80211softmac_wx.c
+@@ -265,6 +265,12 @@ ieee80211softmac_wx_get_rate(struct net_device *net_dev,
+ int err = -EINVAL;
+
+ spin_lock_irqsave(&mac->lock, flags);
++
++ if (unlikely(!mac->running)) {
++ err = -ENODEV;
++ goto out_unlock;
++ }
++
+ switch (mac->txrates.default_rate) {
+ case IEEE80211_CCK_RATE_1MB:
+ data->bitrate.value = 1000000;
+diff --git a/net/ipv4/netfilter/ipt_CLUSTERIP.c
b/net/ipv4/netfilter/ipt_CLUSTERIP.c
+index b1c1116..9a37db2 100644
+--- a/net/ipv4/netfilter/ipt_CLUSTERIP.c
++++ b/net/ipv4/netfilter/ipt_CLUSTERIP.c
+@@ -409,12 +409,10 @@ checkentry(const char *tablename,
+ "has invalid config pointer!\n");
+ return 0;
+ }
+- clusterip_config_entry_get(cipinfo->config);
+ } else {
+ /* Case B: This is a new rule referring to an existing
+ * clusterip config. */
+ cipinfo->config = config;
+- clusterip_config_entry_get(cipinfo->config);
+ }
+ } else {
+ /* Case C: This is a completely new clusterip config */
+diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c
+index 1951eaa..340bcdd 100644
+--- a/net/ipv4/tcp_output.c
++++ b/net/ipv4/tcp_output.c
+@@ -943,7 +943,8 @@ static void tcp_cwnd_validate(struct sock *sk, struct
tcp_sock *tp)
+ if (tp->packets_out > tp->snd_cwnd_used)
+ tp->snd_cwnd_used = tp->packets_out;
+
+- if ((s32)(tcp_time_stamp - tp->snd_cwnd_stamp) >=
inet_csk(sk)->icsk_rto)
++ if (sysctl_tcp_slow_start_after_idle &&
++ (s32)(tcp_time_stamp - tp->snd_cwnd_stamp) >=
inet_csk(sk)->icsk_rto)
+ tcp_cwnd_application_limited(sk);
+ }
+ }
+@@ -1607,6 +1608,9 @@ u32 __tcp_select_window(struct sock *sk)
+ */
+ if (window <= free_space - mss || window > free_space)
+ window = (free_space/mss)*mss;
++ else if (mss == full_space &&
++ free_space > window + full_space/2)
++ window = free_space;
+ }
+
+ return window;
+diff --git a/net/ipv6/raw.c b/net/ipv6/raw.c
+index 4ae1b19..9479fbd 100644
+--- a/net/ipv6/raw.c
++++ b/net/ipv6/raw.c
+@@ -688,9 +688,9 @@ static int rawv6_sendmsg(struct kiocb *iocb, struct sock
*sk,
+ int err;
+
+ /* Rough check on arithmetic overflow,
+- better check is made in ip6_build_xmit
++ better check is made in ip6_append_data().
+ */
+- if (len < 0)
++ if (len > INT_MAX)
+ return -EMSGSIZE;
+
+ /* Mirror BSD error message compatibility */
+diff --git a/net/ipv6/udp.c b/net/ipv6/udp.c
+index f52a5c3..b5dc5db 100644
+--- a/net/ipv6/udp.c
++++ b/net/ipv6/udp.c
+@@ -616,7 +616,7 @@ do_udp_sendmsg:
+ return udp_sendmsg(iocb, sk, msg, len);
+
+ /* Rough check on arithmetic overflow,
+- better check is made in ip6_build_xmit
++ better check is made in ip6_append_data().
+ */
+ if (len > INT_MAX - sizeof(struct udphdr))
+ return -EMSGSIZE;
+diff --git a/net/sched/act_mirred.c b/net/sched/act_mirred.c
+index 4838972..7263a2e 100644
+--- a/net/sched/act_mirred.c
++++ b/net/sched/act_mirred.c
+@@ -199,7 +199,7 @@ bad_mirred:
+ skb2->tc_verd = SET_TC_FROM(skb2->tc_verd, at);
+
+ skb2->dev = dev;
+- skb2->input_dev = skb->dev;
++ skb2->iif = skb->dev->ifindex;
+ dev_queue_xmit(skb2);
+ spin_unlock(&m->tcf_lock);
+ return m->tcf_action;
+diff --git a/net/sched/cls_tcindex.c b/net/sched/cls_tcindex.c
+index 5af8a59..49bb504 100644
+--- a/net/sched/cls_tcindex.c
++++ b/net/sched/cls_tcindex.c
+@@ -245,9 +245,9 @@ tcindex_set_parms(struct tcf_proto *tp, unsigned long
base, u32 handle,
+ }
+
+ if (tb[TCA_TCINDEX_SHIFT-1]) {
+- if (RTA_PAYLOAD(tb[TCA_TCINDEX_SHIFT-1]) < sizeof(u16))
++ if (RTA_PAYLOAD(tb[TCA_TCINDEX_SHIFT-1]) < sizeof(int))
+ goto errout;
+- cp.shift = *(u16 *) RTA_DATA(tb[TCA_TCINDEX_SHIFT-1]);
++ cp.shift = *(int *) RTA_DATA(tb[TCA_TCINDEX_SHIFT-1]);
+ }
+
+ err = -EBUSY;
+diff --git a/net/xfrm/xfrm_state.c b/net/xfrm/xfrm_state.c
+index f0f2c1a..7cd0f3c 100644
+--- a/net/xfrm/xfrm_state.c
++++ b/net/xfrm/xfrm_state.c
+@@ -1220,7 +1220,8 @@ int xfrm_replay_check(struct xfrm_state *x, __be32
net_seq)
+ return 0;
+
+ diff = x->replay.seq - seq;
+- if (diff >= x->props.replay_window) {
++ if (diff >= min_t(unsigned int, x->props.replay_window,
++ sizeof(x->replay.bitmap) * 8)) {
+ x->stats.replay_window++;
+ return -EINVAL;
+ }
+diff --git a/scripts/basic/fixdep.c b/scripts/basic/fixdep.c
+index 668a11a..6bc7e7c 100644
+--- a/scripts/basic/fixdep.c
++++ b/scripts/basic/fixdep.c
+@@ -28,9 +28,11 @@
+ * the dependency on linux/autoconf.h by a dependency on every config
+ * option which is mentioned in any of the listed prequisites.
+ *
+- * To be exact, split-include populates a tree in include/config/,
+- * e.g. include/config/his/driver.h, which contains the #define/#undef
+- * for the CONFIG_HIS_DRIVER option.
++ * kconfig populates a tree in include/config/ with an empty file
++ * for each config symbol and when the configuration is updated
++ * the files representing changed config options are touched
++ * which then let make pick up the changes and the files that use
++ * the config symbols are rebuilt.
+ *
+ * So if the user changes his CONFIG_HIS_DRIVER option, only the objects
+ * which depend on "include/linux/config/his/driver.h" will be rebuilt,
+@@ -245,6 +247,8 @@ void parse_config_file(char *map, size_t len)
+ continue;
+
+ found:
++ if (!memcmp(q - 7, "_MODULE", 7))
++ q -= 7;
+ use_config(p+7, q-p-7);
+ }
+ }
Modified: dists/sid/linux-2.6/debian/patches/series/2
==============================================================================
--- dists/sid/linux-2.6/debian/patches/series/2 (original)
+++ dists/sid/linux-2.6/debian/patches/series/2 Sat Apr 14 15:46:17 2007
@@ -1 +1,2 @@
- features/mips/sb1-duart.patch
++ bugfix/all/stable/2.6.20.7.patch
_______________________________________________
Kernel-svn-changes mailing list
[EMAIL PROTECTED]
http://lists.alioth.debian.org/mailman/listinfo/kernel-svn-changes
