debian-packaging
/
linux
8
0
Fork 0
Code Releases Activity

Add stable releases 2.6.23.2 to 2.6.23.8. 

* debian/changelog: Update.
* debian/patches/bugfix/all/stable/2.6.23.2.patch,
  debian/patches/bugfix/all/stable/2.6.23.3.patch,
  debian/patches/bugfix/all/stable/2.6.23.4.patch,
  debian/patches/bugfix/all/stable/2.6.23.5.patch,
  debian/patches/bugfix/all/stable/2.6.23.6.patch,
  debian/patches/bugfix/all/stable/2.6.23.7.patch,
  debian/patches/bugfix/all/stable/2.6.23.8.patch: Add.
* debian/patches/series/1~experimental.1: Update.

svn path=/dists/trunk/linux-2.6/; revision=9725
This commit is contained in:
Bastian Blank 2007-11-16 22:04:51 +00:00
parent 1541a0b3e6
commit ae74dcceb7
9 changed files with 5427 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

128
debian/changelog vendored
View File

@ -111,7 +111,133 @@ linux-2.6 (2.6.23-1~experimental.1) UNRELEASED; urgency=low
* [ia64] Re-enable various unintentionally disabled config options
* Enable hugetlbfs on i386, amd64, sparc64 and powerpc64. Closes: #450939
-- dann frazier <dannf@debian.org> Mon, 12 Nov 2007 22:23:32 -0700
[ Bastian Blank ]
* Add stable release 2.6.23.2:
- BLOCK: Fix bad sharing of tag busy list on queues with shared tag maps
- fix tmpfs BUG and AOP_WRITEPAGE_ACTIVATE
- Fix compat futex hangs.
- sched: keep utime/stime monotonic
- fix the softlockup watchdog to actually work
- splice: fix double kunmap() in vmsplice copy path
- writeback: don't propagate AOP_WRITEPAGE_ACTIVATE
- SLUB: Fix memory leak by not reusing cpu_slab
- HOWTO: update ja_JP/HOWTO with latest changes
- fix param_sysfs_builtin name length check
- param_sysfs_builtin memchr argument fix
- Remove broken ptrace() special-case code from file mapping
- locks: fix possible infinite loop in posix deadlock detection
- lockdep: fix mismatched lockdep_depth/curr_chain_hash
* Add stable release 2.6.23.3:
- revert "x86_64: allocate sparsemem memmap above 4G"
- x86: fix TSC clock source calibration error
- x86 setup: sizeof() is unsigned, unbreak comparisons
- x86 setup: handle boot loaders which set up the stack incorrectly
- x86: fix global_flush_tlb() bug
- xfs: eagerly remove vmap mappings to avoid upsetting Xen
- xen: fix incorrect vcpu_register_vcpu_info hypercall argument
- xen: deal with stale cr3 values when unpinning pagetables
- xen: add batch completion callbacks
- UML - kill subprocesses on exit
- UML - stop using libc asm/user.h
- UML - Fix kernel vs libc symbols clash
- UML - Stop using libc asm/page.h
- POWERPC: Make sure to of_node_get() the result of pci_device_to_OF_node()
- POWERPC: Fix handling of stfiwx math emulation
- MIPS: R1: Fix hazard barriers to make kernels work on R2 also.
- MIPS: MT: Fix bug in multithreaded kernels.
- Fix sparc64 MAP_FIXED handling of framebuffer mmaps
- Fix sparc64 niagara optimized RAID xor asm
* Add stable release 2.6.23.4:
- mac80211: make ieee802_11_parse_elems return void
- mac80211: only honor IW_SCAN_THIS_ESSID in STA, IBSS, and AP modes
- mac80211: honor IW_SCAN_THIS_ESSID in siwscan ioctl
- mac80211: store SSID in sta_bss_list
- mac80211: store channel info in sta_bss_list
- mac80211: reorder association debug output
- ieee80211: fix TKIP QoS bug
- NETFILTER: nf_conntrack_tcp: fix connection reopening
- Fix netlink timeouts.
- Fix crypto_alloc_comp() error checking.
- Fix SET_VLAN_INGRESS_PRIORITY_CMD error return.
- Fix VLAN address syncing.
- Fix endianness bug in U32 classifier.
- Fix TEQL oops.
- Fix error returns in sys_socketpair()
- softmac: fix wext MLME request reason code endianness
- Fix kernel_accept() return handling.
- TCP: Fix size calculation in sk_stream_alloc_pskb
- Fix SKB_WITH_OVERHEAD calculations.
- Fix 9P protocol build
- Fix advertised packet scheduler timer resolution
- Add get_unaligned to ieee80211_get_radiotap_len
- mac80211: Improve sanity checks on injected packets
- mac80211: filter locally-originated multicast frames
* Add stable release 2.6.23.5:
- zd1211rw, fix oops when ejecting install media
- rtl8187: Fix more frag bit checking, rts duration calc
- ipw2100: send WEXT scan events
- zd1201: avoid null ptr access of skb->dev
- sky2: fix power settings on Yukon XL
- sky2: ethtool register reserved area blackout
- sky2: status ring race fix
- skge: XM PHY handling fixes
- Fix L2TP oopses.
- TG3: Fix performance regression on 5705.
- forcedeth: add MCP77 device IDs
- forcedeth msi bugfix
- ehea: 64K page kernel support fix
- libertas: fix endianness breakage
- libertas: more endianness breakage
* Add stable release 2.6.23.6:
- ACPI: suspend: Wrong order of GPE restore.
- ACPI: sleep: Fix GPE suspend cleanup
- libata: backport ATA_FLAG_NO_SRST and ATA_FLAG_ASSUME_ATA, part 2
- libata: backport ATA_FLAG_NO_SRST and ATA_FLAG_ASSUME_ATA
- libata: add HTS542525K9SA00 to NCQ blacklist
- radeon: set the address to access the GART table on the CPU side correctly
- Char: moxa, fix and optimise empty timer
- Char: rocket, fix dynamic_dev tty
- hptiop: avoid buffer overflow when returning sense data
- ide: Fix cs5535 driver accessing beyond array boundary
- ide: Fix siimage driver accessing beyond array boundary
- ide: Add ide_get_paired_drive() helper
- ide: fix serverworks.c UDMA regression
- i4l: fix random freezes with AVM B1 drivers
- i4l: Fix random hard freeze with AVM c4 card
- ALSA: hda-codec - Add array terminator for dmic in STAC codec
- USB: usbserial - fix potential deadlock between write() and IRQ
- USB: add URB_FREE_BUFFER to permissible flags
- USB: mutual exclusion for EHCI init and port resets
- usb-gadget-ether: prevent oops caused by error interrupt race
- USB: remove USB_QUIRK_NO_AUTOSUSPEND
- MSI: Use correct data offset for 32-bit MSI in read_msi_msg()
- md: raid5: fix clearing of biofill operations
- md: fix an unsigned compare to allow creation of bitmaps with v1.0 metadata
- dm: fix thaw_bdev
- dm delay: fix status
- libata: sync NCQ blacklist with upstream
- ALSA: hdsp - Fix zero division
- ALSA: emu10k1 - Fix memory corruption
- ALSA: Fix build error without CONFIG_HAS_DMA
- ALSA: fix selector unit bug affecting some USB speakerphones
- ALSA: hda-codec - Avoid zero NID in line_out_pins[] of STAC codecs
- IB/mthca: Use mmiowb() to avoid firmware commands getting jumbled up
- IB/uverbs: Fix checking of userspace object ownership
- hwmon/lm87: Disable VID when it should be
- hwmon/lm87: Fix a division by zero
- hwmon/w83627hf: Don't assume bank 0
- hwmon/w83627hf: Fix setting fan min right after driver load
- i915: fix vbl swap allocation size.
- POWERPC: Fix platinumfb framebuffer
* Add stable release 2.6.23.7:
- NFS: Fix a writeback race...
- ocfs2: fix write() performance regression
- minixfs: limit minixfs printks on corrupted dir i_size (CVE-2006-6058)
* Add stable release 2.6.23.8:
- wait_task_stopped: Check p->exit_state instead of TASK_TRACED (CVE-2007-5500)
- TCP: Make sure write_queue_from does not begin with NULL ptr (CVE-2007-5501)
-- Bastian Blank <waldi@debian.org> Fri, 16 Nov 2007 23:01:31 +0100
linux-2.6 (2.6.22-6) unstable; urgency=low

693
debian/patches/bugfix/all/stable/2.6.23.2.patch vendored Normal file
View File

@ -0,0 +1,693 @@
diff --git a/Documentation/ja_JP/HOWTO b/Documentation/ja_JP/HOWTO
index 9f08dab..d9d832c 100644
--- a/Documentation/ja_JP/HOWTO
+++ b/Documentation/ja_JP/HOWTO
@@ -1,4 +1,4 @@
-<2D>ｿNOTE:
+NOTE:
This is a version of Documentation/HOWTO translated into Japanese.
This document is maintained by Tsugikazu Shibata <tshibata@ab.jp.nec.com>
and the JF Project team <www.linux.or.jp/JF>.
@@ -11,14 +11,14 @@ for non English (read: Japanese) speakers and is not intended as a
fork. So if you have any comments or updates for this file, please try
to update the original English file first.
-Last Updated: 2007/07/18
+Last Updated: 2007/09/23
==================================
縺薙ｌ縺ｯ縲<EFBDAF>
-linux-2.6.22/Documentation/HOWTO
+linux-2.6.23/Documentation/HOWTO
縺ｮ蜥瑚ｨｳ縺ｧ縺吶€<E590B6>
鄙ｻ險ｳ蝗｣菴難ｼ<E99BA3> JF 繝励Ο繧ｸ繧ｧ繧ｯ繝<EFBDAF> < http://www.linux.or.jp/JF/ >
-鄙ｻ險ｳ譌･<E8AD8C><EFBDA5> 2007/07/16
+鄙ｻ險ｳ譌･<E8AD8C><EFBDA5> 2007/09/19
鄙ｻ險ｳ閠<EFBDB3>ｼ<EFBFBD> Tsugikazu Shibata <tshibata at ab dot jp dot nec dot com>
譬｡豁｣閠<EFBDA3>ｼ<EFBFBD> 譚ｾ蛟峨＆繧<EFBC86> <nbh--mats at nifty dot com>
蟆乗棊 髮<><E9ABAE>縺輔ｓ (Masanori Kobayasi) <zap03216 at nifty dot ne dot jp>
@@ -27,6 +27,7 @@ linux-2.6.22/Documentation/HOWTO
驥主哨縺輔ｓ (Kenji Noguchi) <tokyo246 at gmail dot com>
豐ｳ蜀<EFBDB3>＆繧<EFBC86> (Takayoshi Kochi) <t-kochi at bq dot jp dot nec dot com>
蟯ｩ譛ｬ縺輔ｓ (iwamoto) <iwamoto.kn at ncos dot nec dot co dot jp>
+ 蜀<>伐縺輔ｓ (Satoshi Uchida) <s-uchida at ap dot jp dot nec dot com>
==================================
Linux 繧ｫ繝ｼ繝阪Ν髢狗匱縺ｮ繧<EFBDAE>ｊ譁ｹ
@@ -40,7 +41,7 @@ Linux 繧ｫ繝ｼ繝阪Ν髢狗匱繧ｳ繝溘Η繝九ユ繧｣縺ｨ蜈ｱ縺ｫ豢ｻ蜍輔☆繧九ｄ繧頑婿繧貞ｭｦ縺
謇句勧縺代↓縺ｪ繧翫∪縺吶€<E590B6>
繧ゅ＠縲√％縺ｮ繝峨く繝･繝｡繝ｳ繝医<E7B99D>縺ｩ縺薙°縺悟商縺上↑縺｣縺ｦ縺<EFBDA6>◆蝣ｴ蜷医↓縺ｯ縲√％縺ｮ繝峨く繝･繝｡繝ｳ
-繝医<E7B99D>譛€蠕後↓繝ｪ繧ｹ繝医＠縺溘Γ繝ｳ繝<EFBDB3>リ繝ｼ縺ｫ繝代ャ繝√ｒ騾√▲縺ｦ縺上□縺輔＞縲<EFBC9E>
+繝医<E7B99D>譛€蠕後↓繝ｪ繧ｹ繝医＠縺溘Γ繝ｳ繝<EFBDB3>リ縺ｫ繝代ャ繝√ｒ騾√▲縺ｦ縺上□縺輔＞縲<EFBC9E>
縺ｯ縺倥ａ縺ｫ
---------
@@ -59,7 +60,7 @@ Linux 繧ｫ繝ｼ繝阪Ν髢狗匱繧ｳ繝溘Η繝九ユ繧｣縺ｨ蜈ｱ縺ｫ豢ｻ蜍輔☆繧九ｄ繧頑婿繧貞ｭｦ縺
繝阪Ν髢狗匱閠<E58CB1>↓縺ｯ蠢<EFBDAF>ｦ√〒縺吶€ゅい繝ｼ繧ｭ繝<EFBDAD>け繝√Ε蜷代￠縺ｮ菴弱Ξ繝吶Ν驛ｨ蛻<EFBDA8><E89BBB>髢狗匱繧偵☆繧九<E7B9A7>
縺ｧ縺ｪ縺代ｌ縺ｰ縲<EFBDB0>(縺ｩ繧薙↑繧｢繝ｼ繧ｭ繝<EFBDAD>け繝√Ε縺ｧ繧<EFBDA7>)繧｢繧ｻ繝ｳ繝悶Μ(險ｳ豕ｨ: 險€隱<C280>)縺ｯ蠢<EFBDAF>ｦ√≠繧<E289A0>
縺ｾ縺帙ｓ縲ゆｻ･荳九<E88DB3>譛ｬ縺ｯ縲， 險€隱槭<E99AB1>蜊∝<E89C8A>縺ｪ遏･隴倥ｄ菴募ｹｴ繧ゅ<E7B9A7>邨碁ｨ薙↓蜿悶▲縺ｦ莉｣繧上ｋ繧ゅ<E7B9A7>
-縺ｧ縺ｯ縺ゅｊ縺ｾ縺帙ｓ縺後€∝ｰ代↑縺上→繧ゅΜ繝輔ぃ繝ｬ繝ｳ繧ｹ縺ｨ縺励※縺ｯ縺<EFBDAF>＞譛ｬ縺ｧ縺吶€<E590B6>
+縺ｧ縺ｯ縺ゅｊ縺ｾ縺帙ｓ縺後€∝ｰ代↑縺上→繧ゅΜ繝輔ぃ繝ｬ繝ｳ繧ｹ縺ｨ縺励※縺ｯ濶ｯ縺<EFBDAF>悽縺ｧ縺吶€<E590B6>
- "The C Programming Language" by Kernighan and Ritchie [Prentice Hall]
-縲弱<E7B8B2>繝ｭ繧ｰ繝ｩ繝溘Φ繧ｰ險€隱橸ｼ｣隨ｬ2迚医€<E58CBB>(B.W. 繧ｫ繝ｼ繝九ワ繝ｳ/D.M. 繝ｪ繝<EFBDAA>メ繝ｼ闡<EFBDBC> 遏ｳ逕ｰ譎ｴ荵<EFBDB4>ｨｳ) [蜈ｱ遶句<E981B6>迚<EFBFBD>
- "Practical C Programming" by Steve Oualline [O'Reilly]
@@ -76,7 +77,7 @@ Linux 繧ｫ繝ｼ繝阪Ν髢狗匱繧ｳ繝溘Η繝九ユ繧｣縺ｨ蜈ｱ縺ｫ豢ｻ蜍輔☆繧九ｄ繧頑婿繧貞ｭｦ縺
縺ｨ縺阪←縺阪€√き繝ｼ繝阪Ν縺後ヤ繝ｼ繝ｫ繝√ぉ繧､繝ｳ繧<EFBDB3> C 險€隱樊僑蠑ｵ縺ｫ鄂ｮ縺<EFBDAE>※縺<E280BB>ｋ蜑肴署縺後←縺<E28690>
縺ｪ縺｣縺ｦ縺<EFBDA6>ｋ縺ｮ縺九ｏ縺九ｊ縺ｫ縺上＞縺薙→縺後≠繧翫€√∪縺溘€∵ｮ句ｿｵ縺ｪ縺薙→縺ｫ豎ｺ螳夂噪縺ｪ繝ｪ繝輔ぃ
繝ｬ繝ｳ繧ｹ縺ｯ蟄伜惠縺励∪縺帙ｓ縲よュ蝣ｱ繧貞ｾ励ｋ縺ｫ縺ｯ縲“cc 縺ｮ info 繝壹<E7B99D>繧ｸ( info gcc )繧<>
-縺ｿ縺ｦ縺上□縺輔＞縲<EFBC9E>
+隕九※縺上□縺輔＞縲<EFBC9E>
縺ゅ↑縺溘<E7B8BA>譌｢蟄倥<E89F84>髢狗匱繧ｳ繝溘Η繝九ユ繧｣縺ｨ荳€邱偵↓菴懈･ｭ縺吶ｋ譁ｹ豕輔ｒ蟄ｦ縺ｼ縺<EFBDBC>→縺励※縺<E280BB>ｋ縺<EFBD8B>
縺ｨ縺ｫ逡呎э縺励※縺上□縺輔＞縲ゅ◎縺ｮ繧ｳ繝溘Η繝九ユ繧｣縺ｯ縲√さ繝ｼ繝<EFBDBC>ぅ繝ｳ繧ｰ縲√せ繧ｿ繧､繝ｫ縲<EFBDAB>
@@ -92,7 +93,7 @@ Linux 繧ｫ繝ｼ繝阪Ν髢狗匱繧ｳ繝溘Η繝九ユ繧｣縺ｨ蜈ｱ縺ｫ豢ｻ蜍輔☆繧九ｄ繧頑婿繧貞ｭｦ縺
Linux 繧ｫ繝ｼ繝阪Ν縺ｮ繧ｽ繝ｼ繧ｹ繧ｳ繝ｼ繝峨<E7B99D> GPL 繝ｩ繧､繧ｻ繝ｳ繧ｹ縺ｮ荳九〒繝ｪ繝ｪ繝ｼ繧ｹ縺輔ｌ縺ｦ縺<EFBDA6>∪
縺吶€ゅΛ繧､繧ｻ繝ｳ繧ｹ縺ｮ隧ｳ邏ｰ縺ｫ縺､縺<EFBDA4>※縺ｯ縲√た繝ｼ繧ｹ繝<EFBDB9>Μ繝ｼ縺ｮ繝｡繧､繝ｳ繝<EFBDB3>ぅ繝ｬ繧ｯ繝医Μ縺ｫ蟄伜惠
-縺吶ｋ縲，OPYING 縺ｮ繝輔ぃ繧､繝ｫ繧偵∩縺ｦ縺上□縺輔＞縲ゅｂ縺励Λ繧､繧ｻ繝ｳ繧ｹ縺ｫ縺､縺<EFBDA4>※縺輔ｉ縺ｫ雉ｪ
+縺吶ｋ縲，OPYING 縺ｮ繝輔ぃ繧､繝ｫ繧定ｦ九※縺上□縺輔＞縲ゅｂ縺励Λ繧､繧ｻ繝ｳ繧ｹ縺ｫ縺､縺<EFBDA4>※縺輔ｉ縺ｫ雉ｪ
蝠上′縺ゅｌ縺ｰ縲´inux Kernel 繝｡繝ｼ繝ｪ繝ｳ繧ｰ繝ｪ繧ｹ繝医↓雉ｪ蝠上☆繧九<E7B9A7>縺ｧ縺ｯ縺ｪ縺上€√←縺<E28690>◇
豕募ｾ句ｮｶ縺ｫ逶ｸ隲<EFBDB8>＠縺ｦ縺上□縺輔＞縲ゅΓ繝ｼ繝ｪ繝ｳ繧ｰ繝ｪ繧ｹ繝医<E7B99D>莠ｺ驕斐<E9A995>豕募ｾ句ｮｶ縺ｧ縺ｯ縺ｪ縺上€∵ｳ慕噪
蝠城｡後↓縺､縺<EFBDA4>※縺ｯ蠖ｼ繧峨<E7B9A7>螢ｰ譏弱<E8AD8F>縺ゅ※縺ｫ縺吶ｋ縺ｹ縺阪〒縺ｯ縺ゅｊ縺ｾ縺帙ｓ縲<EFBD93>
@@ -109,7 +110,8 @@ Linux 繧ｫ繝ｼ繝阪Ν繧ｽ繝ｼ繧ｹ繝<EFBDB9>Μ繝ｼ縺ｯ蟷<EFBDAF>ｺ<EFBFBD>＞遽<EFBC9E>峇縺ｮ繝峨く繝･繝｡繝ｳ繝医ｒ蜷
譁ｰ縺励＞繝峨く繝･繝｡繝ｳ繝医ヵ繧｡繧､繝ｫ繧りｿｽ蜉<EFBDBD>縺吶ｋ縺薙→繧貞匡繧√∪縺吶€<E590B6>
繧ｫ繝ｼ繝阪Ν縺ｮ螟画峩縺後€√き繝ｼ繝阪Ν縺後Θ繝ｼ繧ｶ遨ｺ髢薙↓蜈ｬ髢九＠縺ｦ縺<EFBDA6>ｋ繧､繝ｳ繧ｿ繝ｼ繝輔ぉ繧､繧ｹ縺ｮ
螟画峩繧貞ｼ輔″襍ｷ縺薙☆蝣ｴ蜷医€√◎縺ｮ螟画峩繧定ｪｬ譏弱☆繧九<E7B9A7>繝九Η繧｢繝ｫ繝壹<E7B99D>繧ｸ縺ｮ繝代ャ繝√ｄ諠<EFBD84><E8ABA0>ｱ
-繧偵<E7B9A7>繝九Η繧｢繝ｫ繝壹<E7B99D>繧ｸ縺ｮ繝｡繝ｳ繝<EFBDB3>リ mtk-manpages@gmx.net 縺ｫ騾√ｋ縺薙→繧貞匡繧√∪縺吶€<E590B6>
+繧偵<E7B9A7>繝九Η繧｢繝ｫ繝壹<E7B99D>繧ｸ縺ｮ繝｡繝ｳ繝<EFBDB3>リ mtk-manpages@gmx.net 縺ｫ騾√ｋ縺薙→繧貞匡繧√∪
+縺吶€<E590B6>
莉･荳九<E88DB3>繧ｫ繝ｼ繝阪Ν繧ｽ繝ｼ繧ｹ繝<EFBDB9>Μ繝ｼ縺ｫ蜷ｫ縺ｾ繧後※縺<E280BB>ｋ隱ｭ繧薙〒縺翫￥縺ｹ縺阪ヵ繧｡繧､繝ｫ縺ｮ荳€隕ｧ縺ｧ
縺<>-
@@ -117,7 +119,7 @@ Linux 繧ｫ繝ｼ繝阪Ν繧ｽ繝ｼ繧ｹ繝<EFBDB9>Μ繝ｼ縺ｯ蟷<EFBDAF>ｺ<EFBFBD>＞遽<EFBC9E>峇縺ｮ繝峨く繝･繝｡繝ｳ繝医ｒ蜷
README
縺薙<E7B8BA>繝輔ぃ繧､繝ｫ縺ｯ Linux繧ｫ繝ｼ繝阪Ν縺ｮ邁｡蜊倥↑閭梧勹縺ｨ繧ｫ繝ｼ繝阪Ν繧定ｨｭ螳<EFBDAD>(險ｳ豕ｨ
configure )縺励€∫函謌<E587BD>(險ｳ豕ｨ build )縺吶ｋ縺溘ａ縺ｫ蠢<EFBDAB>ｦ√↑縺薙→縺ｯ菴輔°縺梧嶌縺九ｌ
- 縺ｦ縺<EFBDA6>∪縺吶€ゅき繝ｼ繝阪Ν縺ｫ髢｢縺励※蛻昴ａ縺ｦ縺ｮ莠ｺ縺ｯ縺薙％縺九ｉ繧ｹ繧ｿ繝ｼ繝医☆繧九→繧医＞縺ｧ
+ 縺ｦ縺<EFBDA6>∪縺吶€ゅき繝ｼ繝阪Ν縺ｫ髢｢縺励※蛻昴ａ縺ｦ縺ｮ莠ｺ縺ｯ縺薙％縺九ｉ繧ｹ繧ｿ繝ｼ繝医☆繧九→濶ｯ縺<EFBDAF>〒
縺励ｇ縺<EFBD87>€<EFBFBD>
Documentation/Changes
@@ -128,7 +130,7 @@ Linux 繧ｫ繝ｼ繝阪Ν繧ｽ繝ｼ繧ｹ繝<EFBDB9>Μ繝ｼ縺ｯ蟷<EFBDAF>ｺ<EFBFBD>＞遽<EFBC9E>峇縺ｮ繝峨く繝･繝｡繝ｳ繝医ｒ蜷
Documentation/CodingStyle
縺薙ｌ縺ｯ Linux 繧ｫ繝ｼ繝阪Ν縺ｮ繧ｳ繝ｼ繝<EFBDBC>ぅ繝ｳ繧ｰ繧ｹ繧ｿ繧､繝ｫ縺ｨ閭梧勹縺ｫ縺ゅｋ逅<EFBD8B>罰繧定ｨ倩ｿｰ
縺励※縺<E280BB>∪縺吶€ょ<C280>縺ｦ縺ｮ譁ｰ縺励＞繧ｳ繝ｼ繝峨<E7B99D>縺薙<E7B8BA>繝峨く繝･繝｡繝ｳ繝医↓縺ゅｋ繧ｬ繧､繝峨Λ繧､繝ｳ
- 縺ｫ蠕薙▲縺ｦ縺<EFBDA6>ｋ縺薙→繧呈悄蠕<E68284>＆繧後※縺<E280BB>∪縺吶€ょ､ｧ驛ｨ蛻<EFBDA8><E89BBB>繝｡繝ｳ繝<EFBDB3>リ繝ｼ縺ｯ縺薙ｌ繧峨<E7B9A7>繝ｫ繝ｼ
+ 縺ｫ蠕薙▲縺ｦ縺<EFBDA6>ｋ縺薙→繧呈悄蠕<E68284>＆繧後※縺<E280BB>∪縺吶€ょ､ｧ驛ｨ蛻<EFBDA8><E89BBB>繝｡繝ｳ繝<EFBDB3>リ縺ｯ縺薙ｌ繧峨<E7B9A7>繝ｫ繝ｼ
繝ｫ縺ｫ蠕薙▲縺ｦ縺<EFBDA6>ｋ繧ゅ<E7B9A7>縺<EFBFBD>縺代ｒ蜿励￠莉倥￠縲∝､壹￥縺ｮ莠ｺ縺ｯ豁｣縺励＞繧ｹ繧ｿ繧､繝ｫ縺ｮ繧ｳ繝ｼ繝<EFBDBC>
縺<>縺代ｒ繝ｬ繝薙Η繝ｼ縺励∪縺吶€<E590B6>
@@ -168,16 +170,16 @@ Linux 繧ｫ繝ｼ繝阪Ν繧ｽ繝ｼ繧ｹ繝<EFBDB9>Μ繝ｼ縺ｯ蟷<EFBDAF>ｺ<EFBFBD>＞遽<EFBC9E>峇縺ｮ繝峨く繝･繝｡繝ｳ繝医ｒ蜷
謾ｯ謠ｴ縺励※縺上□縺輔＞縲<EFBC9E>
Documentation/ManagementStyle
- 縺薙<E7B8BA>繝峨く繝･繝｡繝ｳ繝医<E7B99D> Linux 繧ｫ繝ｼ繝阪Ν縺ｮ繝｡繝ｳ繝<EFBDB3>リ繝ｼ驕斐′縺ｩ縺<EFBDA9>｡悟虚縺吶ｋ縺九€<E4B99D>
+ 縺薙<E7B8BA>繝峨く繝･繝｡繝ｳ繝医<E7B99D> Linux 繧ｫ繝ｼ繝阪Ν縺ｮ繝｡繝ｳ繝<EFBDB3>リ驕斐′縺ｩ縺<EFBDA9>｡悟虚縺吶ｋ縺九€<E4B99D>
蠖ｼ繧峨<E7B9A7>謇区ｳ輔<EFBDB3>閭梧勹縺ｫ縺ゅｋ蜈ｱ譛峨＆繧後※縺<E280BB>ｋ邊ｾ逾槭↓縺､縺<EFBDA4>※險倩ｿｰ縺励※縺<E280BB>∪縺吶€ゅ％
繧後<E7B9A7>繧ｫ繝ｼ繝阪Ν髢狗匱縺ｮ蛻晏ｿ<E6998F>€<EFBFBD>↑繧会ｼ医ｂ縺励￥縺ｯ縲∝腰縺ｫ闊亥袖縺後≠繧九□縺代<E7B8BA>莠ｺ縺ｧ繧ゑｼ<E38291>
- 驥崎ｦ√〒縺吶€ゅ↑縺懊↑繧峨％縺ｮ繝峨く繝･繝｡繝ｳ繝医<E7B99D>縲√き繝ｼ繝阪Ν繝｡繝ｳ繝<EFBDB3>リ繝ｼ驕斐<E9A995>迢ｬ迚ｹ縺ｪ
+ 驥崎ｦ√〒縺吶€ゅ↑縺懊↑繧峨％縺ｮ繝峨く繝･繝｡繝ｳ繝医<E7B99D>縲√き繝ｼ繝阪Ν繝｡繝ｳ繝<EFBDB3>リ驕斐<E9A995>迢ｬ迚ｹ縺ｪ
陦悟虚縺ｫ縺､縺<EFBDA4>※縺ｮ螟壹￥縺ｮ隱､隗｣繧<EFBDA3>ｷｷ荵ｱ繧定ｧ｣豸医☆繧九°繧峨〒縺吶€<E590B6>
Documentation/stable_kernel_rules.txt
縺薙<E7B8BA>繝輔ぃ繧､繝ｫ縺ｯ縺ｩ縺ｮ繧医≧縺ｫ stable 繧ｫ繝ｼ繝阪Ν縺ｮ繝ｪ繝ｪ繝ｼ繧ｹ縺瑚｡後ｏ繧後ｋ縺九<E7B8BA>繝ｫ繝ｼ
繝ｫ縺瑚ｨ倩ｿｰ縺輔ｌ縺ｦ縺<EFBDA6>∪縺吶€ゅ◎縺励※縺薙ｌ繧峨<E7B9A7>繝ｪ繝ｪ繝ｼ繧ｹ縺ｮ荳ｭ縺ｮ縺ｩ縺薙°縺ｧ螟画峩繧貞叙
- 繧雁<E7B9A7>繧後※繧ゅｉ縺<EFBD89>◆縺<E29786><E7B8BA>ｴ蜷医↓菴輔ｒ縺吶ｌ縺ｰ縺<EFBDB0>＞縺九′遉ｺ縺輔ｌ縺ｦ縺<EFBDA6>∪縺吶€<E590B6>
+ 繧雁<E7B9A7>繧後※繧ゅｉ縺<EFBD89>◆縺<E29786><E7B8BA>ｴ蜷医↓菴輔ｒ縺吶ｌ縺ｰ濶ｯ縺<EFBDAF>°縺檎､ｺ縺輔ｌ縺ｦ縺<EFBDA6>∪縺吶€<E590B6>
Documentation/kernel-docs.txt
縲€縲€繧ｫ繝ｼ繝阪Ν髢狗匱縺ｫ莉倬囂縺吶ｋ螟夜Κ繝峨く繝･繝｡繝ｳ繝医<E7B99D>繝ｪ繧ｹ繝医〒縺吶€ゅｂ縺励≠縺ｪ縺溘′
@@ -218,9 +220,9 @@ web 繧ｵ繧､繝医↓縺ｯ縲√さ繝ｼ繝峨<E7B99D>讒区<E8AE92>縲√し繝悶す繧ｹ繝<EFBDB9>Β縲∫樟蝨ｨ蟄伜惠縺吶
縺薙％縺ｫ縺ｯ縲√∪縺溘€√き繝ｼ繝阪Ν縺ｮ繧ｳ繝ｳ繝代う繝ｫ縺ｮ繧<EFBDAE>ｊ譁ｹ繧<EFBDB9>ヱ繝<E383B1>メ縺ｮ蠖薙※譁ｹ縺ｪ縺ｩ縺ｮ髢捺磁
逧<>↑蝓ｺ譛ｬ諠<EFBDAC><E8ABA0>ｱ繧りｨ倩ｿｰ縺輔ｌ縺ｦ縺<EFBDA6>∪縺吶€<E590B6>
-縺ゅ↑縺溘′縺ｩ縺薙°繧峨せ繧ｿ繝ｼ繝医＠縺ｦ繧医＞縺九ｏ縺九ｉ縺ｪ縺<EFBDAA>′縲´inux 繧ｫ繝ｼ繝阪Ν髢狗匱繧ｳ繝溘Η
+縺ゅ↑縺溘′縺ｩ縺薙°繧峨せ繧ｿ繝ｼ繝医＠縺ｦ濶ｯ縺<EFBDAF>°繧上°繧峨↑縺<E28691>′縲´inux 繧ｫ繝ｼ繝阪Ν髢狗匱繧ｳ繝溘Η
繝九ユ繧｣縺ｫ蜿ょ刈縺励※菴輔°縺吶ｋ縺薙→繧偵＆縺後＠縺ｦ縺<EFBDA6>ｋ蝣ｴ蜷医↓縺ｯ縲´inux kernel
-Janitor's 繝励Ο繧ｸ繧ｧ繧ｯ繝医↓縺<E28693>￠縺ｰ繧医＞縺ｧ縺励ｇ縺<EFBD87> -
+Janitor's 繝励Ο繧ｸ繧ｧ繧ｯ繝医↓縺<E28693>￠縺ｰ濶ｯ縺<EFBDAF>〒縺励ｇ縺<EFBD87> -
http://janitor.kernelnewbies.org/
縺薙％縺ｯ縺昴<E7B8BA>繧医≧縺ｪ繧ｹ繧ｿ繝ｼ繝医ｒ縺吶ｋ縺ｮ縺ｫ縺<EFBDAB>▲縺ｦ縺､縺代<E7B8BA>蝣ｴ謇€縺ｧ縺吶€ゅ％縺薙↓縺ｯ縲<EFBDAF>
Linux 繧ｫ繝ｼ繝阪Ν繧ｽ繝ｼ繧ｹ繝<EFBDB9>Μ繝ｼ縺ｮ荳ｭ縺ｫ蜷ｫ縺ｾ繧後ｋ縲√″繧後＞縺ｫ縺励€∽ｿｮ豁｣縺励↑縺代ｌ縺ｰ縺ｪ
@@ -243,7 +245,7 @@ Linux 繧ｫ繝ｼ繝阪Ν繧ｽ繝ｼ繧ｹ繝<EFBDB9>Μ繝ｼ縺ｮ荳ｭ縺ｫ蜷ｫ縺ｾ繧後ｋ縲√″繧後＞縺ｫ縺励€∽ｿ
閾ｪ蟾ｱ蜿ら<E89CBF>譁ｹ蠑上〒縲∫ｴ｢蠑輔′縺､縺<EFBDA4>◆ web 蠖｢蠑上〒縲√た繝ｼ繧ｹ繧ｳ繝ｼ繝峨ｒ蜿ら<E89CBF>縺吶ｋ縺薙→縺<E28692>
縺ｧ縺阪∪縺吶€ゅ％縺ｮ譛€譁ｰ縺ｮ邏<EFBDAE>譎ｴ縺励＞繧ｫ繝ｼ繝阪Ν繧ｳ繝ｼ繝峨<E7B99D>繝ｪ繝昴ず繝医Μ縺ｯ莉･荳九〒隕九▽縺九ｊ
縺ｾ縺<EFBDBE>-
- http://sosdg.org/~coywolf/lxr/
+ http://sosdg.org/~qiyong/lxr/
髢狗匱繝励Ο繧ｻ繧ｹ
-----------------------
@@ -265,9 +267,9 @@ Linux 繧ｫ繝ｼ繝阪Ν縺ｮ髢狗匱繝励Ο繧ｻ繧ｹ縺ｯ迴ｾ蝨ｨ蟷ｾ縺､縺九<E7B8BA>逡ｰ縺ｪ繧九Γ繧､繝ｳ繧
莉･荳九<E88DB3>縺ｨ縺翫ｊ-
- 譁ｰ縺励＞繧ｫ繝ｼ繝阪Ν縺後Μ繝ｪ繝ｼ繧ｹ縺輔ｌ縺溽峩蠕後↓縲<E28693>2騾ｱ髢薙<E9ABA2>迚ｹ蛻･譛滄俣縺瑚ｨｭ縺代ｉ繧後€<E5BE8C>
- 縺薙<E7B8BA>譛滄俣荳ｭ縺ｫ縲√Γ繝ｳ繝<EFBDB3>リ繝ｼ驕斐<E9A995> Linus 縺ｫ螟ｧ縺阪↑蟾ｮ蛻<EFBDAE>ｒ騾√ｋ縺薙→縺後〒縺阪∪
- 縺吶€ゅ％縺ｮ繧医≧縺ｪ蟾ｮ蛻<EFBDAE><E89BBB>騾壼ｸｸ -mm 繧ｫ繝ｼ繝阪Ν縺ｫ謨ｰ騾ｱ髢灘性縺ｾ繧後※縺阪◆繝代ャ繝√〒
- 縺吶€<E590B6> 螟ｧ縺阪↑螟画峩縺ｯ git(繧ｫ繝ｼ繝阪Ν縺ｮ繧ｽ繝ｼ繧ｹ邂｡逅<EFBDA1>ヤ繝ｼ繝ｫ縲∬ｩｳ邏ｰ縺ｯ
+ 縺薙<E7B8BA>譛滄俣荳ｭ縺ｫ縲√Γ繝ｳ繝<EFBDB3>リ驕斐<E9A995> Linus 縺ｫ螟ｧ縺阪↑蟾ｮ蛻<EFBDAE>ｒ騾√ｋ縺薙→縺後〒縺阪∪縺吶€<E590B6>
+ 縺薙<E7B8BA>繧医≧縺ｪ蟾ｮ蛻<EFBDAE><E89BBB>騾壼ｸｸ -mm 繧ｫ繝ｼ繝阪Ν縺ｫ謨ｰ騾ｱ髢灘性縺ｾ繧後※縺阪◆繝代ャ繝√〒縺吶€<E590B6>
+ 螟ｧ縺阪↑螟画峩縺ｯ git(繧ｫ繝ｼ繝阪Ν縺ｮ繧ｽ繝ｼ繧ｹ邂｡逅<EFBDA1>ヤ繝ｼ繝ｫ縲∬ｩｳ邏ｰ縺ｯ
http://git.or.cz/ 蜿ら<E89CBF>) 繧剃ｽｿ縺｣縺ｦ騾√ｋ縺ｮ縺悟･ｽ縺ｾ縺励＞繧<EFBC9E>ｊ譁ｹ縺ｧ縺吶′縲√ヱ繝<E383B1>
繝√ヵ繧｡繧､繝ｫ縺ｮ蠖｢蠑上<E8A091>縺ｾ縺ｾ騾√ｋ縺ｮ縺ｧ繧ょ香蛻<E9A699>〒縺吶€<E590B6>
@@ -285,6 +287,10 @@ Linux 繧ｫ繝ｼ繝阪Ν縺ｮ髢狗匱繝励Ο繧ｻ繧ｹ縺ｯ迴ｾ蝨ｨ蟷ｾ縺､縺九<E7B8BA>逡ｰ縺ｪ繧九Γ繧､繝ｳ繧
縺ｫ螳牙ｮ壹＠縺溽憾諷九↓縺ゅｋ縺ｨ蛻､譁ｭ縺励◆縺ｨ縺阪↓繝ｪ繝ｪ繝ｼ繧ｹ縺輔ｌ縺ｾ縺吶€ら岼讓吶<E8AE93>豈朱€ｱ譁ｰ
縺励＞ -rc 繧ｫ繝ｼ繝阪Ν繧偵Μ繝ｪ繝ｼ繧ｹ縺吶ｋ縺薙→縺ｧ縺吶€<E590B6>
+ - 莉･荳九<E88DB3> URL 縺ｧ蜷<EFBDA7> -rc 繝ｪ繝ｪ繝ｼ繧ｹ縺ｫ蟄伜惠縺吶ｋ譌｢遏･縺ｮ蠕梧綾繧雁撫鬘後<E9AC98>繝ｪ繧ｹ繝<EFBDB9>
+ 縺瑚ｿｽ霍｡縺輔ｌ縺ｾ縺<EFBDBE>-
+ http://kernelnewbies.org/known_regressions
+
- 縺薙<E7B8BA>繝励Ο繧ｻ繧ｹ縺ｯ繧ｫ繝ｼ繝阪Ν縺<CE9D> 縲梧ｺ門ｙ縺後〒縺阪◆縲阪→閠<E28692>∴繧峨ｌ繧九∪縺ｧ邯咏ｶ壹＠縺ｾ
縺吶€ゅ％縺ｮ繝励Ο繧ｻ繧ｹ縺ｯ縺<EFBDAF>縺<EFBFBD>◆縺<E29786> 6騾ｱ髢鍋ｶ咏ｶ壹＠縺ｾ縺吶€<E590B6>
@@ -331,8 +337,8 @@ Andrew 縺ｯ蛟句挨縺ｮ繧ｵ繝悶す繧ｹ繝<EFBDB9>Β繧ｫ繝ｼ繝阪Ν繝<CE9D>Μ繝ｼ縺ｨ繝代ャ繝√ｒ蜈ｨ縺ｦ<E7B8BA>
linux-kernel 繝｡繝ｼ繝ｪ繝ｳ繧ｰ繝ｪ繧ｹ繝医〒蜿朱寔縺輔ｌ縺溷､壽焚縺ｮ繝代ャ繝√→蜷梧凾縺ｫ荳€縺､縺ｫ縺ｾ
縺ｨ繧√∪縺吶€<E590B6>
縺薙<E7B8BA>繝<EFBFBD>Μ繝ｼ縺ｯ譁ｰ讖溯<E8AE96>縺ｨ繝代ャ繝√′讀懆ｨｼ縺輔ｌ繧句<E7B9A7>ｴ縺ｨ縺ｪ繧翫∪縺吶€ゅ≠繧区悄髢薙<E9ABA2>髢薙ヱ繝<E383B1>メ
-縺<> -mm 縺ｫ蜈･縺｣縺ｦ萓｡蛟､繧定ｨｼ譏弱＆繧後◆繧峨€、ndrew 繧<>し繝悶す繧ｹ繝<EFBDB9>Β繝｡繝ｳ繝<EFBDB3>リ縺後€√Γ
-繧､繝ｳ繝ｩ繧､繝ｳ縺ｸ蜈･繧後ｋ繧医≧縺ｫ Linus 縺ｫ繝励ャ繧ｷ繝･縺励∪縺吶€<E590B6>
+縺<> -mm 縺ｫ蜈･縺｣縺ｦ萓｡蛟､繧定ｨｼ譏弱＆繧後◆繧峨€、ndrew 繧<>し繝悶す繧ｹ繝<EFBDB9>Β繝｡繝ｳ繝<EFBDB3>リ縺後€<E5BE8C>
+繝｡繧､繝ｳ繝ｩ繧､繝ｳ縺ｸ蜈･繧後ｋ繧医≧縺ｫ Linus 縺ｫ繝励ャ繧ｷ繝･縺励∪縺吶€<E590B6>
繝｡繧､繝ｳ繧ｫ繝ｼ繝阪Ν繝<CE9D>Μ繝ｼ縺ｫ蜷ｫ繧√ｋ縺溘ａ縺ｫ Linus 縺ｫ騾√ｋ蜑阪↓縲√☆縺ｹ縺ｦ縺ｮ譁ｰ縺励＞繝代ャ
繝√′ -mm 繝<>Μ繝ｼ縺ｧ繝<EFBDA7>せ繝医＆繧後ｋ縺薙→縺悟ｼｷ縺乗耳螂ｨ縺輔ｌ縺ｾ縺吶€<E590B6>
@@ -460,7 +466,7 @@ MAINTAINERS 繝輔ぃ繧､繝ｫ縺ｫ繝ｪ繧ｹ繝医′縺ゅｊ縺ｾ縺吶<E7B8BA>縺ｧ蜿ら<E89CBF>縺励※縺上□縺輔<E7B8BA>
縺帙ｓ-
蠖ｼ繧峨<E7B9A7>縺ゅ↑縺溘<E7B8BA>繝代ャ繝√<E7B99D>陦梧ｯ弱↓繧ｳ繝｡繝ｳ繝医ｒ蜈･繧後◆縺<E29786><E7B8BA>縺ｧ縲√◎縺ｮ縺溘ａ縺ｫ縺ｯ縺昴≧縺<E289A7>
繧九＠縺九≠繧翫∪縺帙ｓ縲ゅ≠縺ｪ縺溘<E7B8BA>繝｡繝ｼ繝ｫ繝励Ο繧ｰ繝ｩ繝<EFBDA9>縺檎ｩｺ逋ｽ繧<EFBDBD>ち繝悶ｒ蝨ｧ邵ｮ縺励↑縺<E28691>ｈ縺<EFBD88>
-縺ｫ遒ｺ隱阪＠縺滓婿縺後＞縺<EFBC9E>〒縺吶€よ怙蛻昴<E89BBB>濶ｯ縺<EFBDAF>ユ繧ｹ繝医→縺励※縺ｯ縲∬<E7B8B2>蛻<EFBFBD>↓繝｡繝ｼ繝ｫ繧帝€√▲縺ｦ
+縺ｫ遒ｺ隱阪＠縺滓婿縺瑚憶縺<E686B6>〒縺吶€よ怙蛻昴<E89BBB>濶ｯ縺<EFBDAF>ユ繧ｹ繝医→縺励※縺ｯ縲∬<E7B8B2>蛻<EFBFBD>↓繝｡繝ｼ繝ｫ繧帝€√▲縺ｦ
縺ｿ縺ｦ縲√◎縺ｮ繝代ャ繝√ｒ閾ｪ蛻<EFBDAA>〒蠖薙※縺ｦ縺ｿ繧九％縺ｨ縺ｧ縺吶€ゅｂ縺励◎繧後′縺<E280B2>∪縺剰｡後°縺ｪ縺<EFBDAA>↑
繧峨€√≠縺ｪ縺溘<E7B8BA>繝｡繝ｼ繝ｫ繝励Ο繧ｰ繝ｩ繝<EFBDA9>繧堤峩縺励※繧ゅｉ縺<EFBD89>°縲∵ｭ｣縺励￥蜍輔￥繧医≧縺ｫ螟峨∴繧九∋
縺阪〒縺吶€<E590B6>
@@ -507,14 +513,14 @@ MAINTAINERS 繝輔ぃ繧､繝ｫ縺ｫ繝ｪ繧ｹ繝医′縺ゅｊ縺ｾ縺吶<E7B8BA>縺ｧ蜿ら<E89CBF>縺励※縺上□縺輔<E7B8BA>
縺ｨ繧よ勸騾壹<E9A8BE>縺薙→縺ｧ縺吶€ゅ％繧後<E7B9A7>縺ゅ↑縺溘<E7B8BA>繝代ャ繝√′蜿励￠蜈･繧後ｉ繧後↑縺<E28691>→縺<E28692>≧縺薙→縺ｧ
縺ｯ *縺ゅｊ縺ｾ縺帙ｓ*縲√◎縺励※縺ゅ↑縺溯<E7B8BA>霄ｫ縺ｫ蜿榊ｯｾ縺吶ｋ縺薙→繧呈э蜻ｳ縺吶ｋ縺ｮ縺ｧ繧<EFBDA7> *縺ゅｊ縺ｾ
縺帙ｓ*縲ょ腰縺ｫ閾ｪ蛻<EFBDAA><E89BBB>繝代ャ繝√↓蟇ｾ縺励※謖<E280BB>遭縺輔ｌ縺溷撫鬘後ｒ蜈ｨ縺ｦ菫ｮ豁｣縺励※蜀埼€√☆繧後<E7B9A7>
-縺<>＞縺ｮ縺ｧ縺吶€<E590B6>
+濶ｯ縺<EFBDAF><E7B8BA>縺ｧ縺吶€<E590B6>
繧ｫ繝ｼ繝阪Ν繧ｳ繝溘Η繝九ユ繧｣縺ｨ莨∵･ｭ邨<EFBDAD>ｹ斐<EFBDB9>縺｡縺後＞
-----------------------------------------------------------------
繧ｫ繝ｼ繝阪Ν繧ｳ繝溘Η繝九ユ繧｣縺ｯ螟ｧ驛ｨ蛻<EFBDA8><E89BBB>莨晉ｵｱ逧<EFBDB1>↑莨夂､ｾ縺ｮ髢狗匱迺ｰ蠅<EFBDB0>→縺ｯ逡ｰ縺｣縺溘ｄ繧頑婿縺ｧ
-蜍輔＞縺ｦ縺<EFBDA6>∪縺吶€ゆｻ･荳九<E88DB3>蝠城｡後ｒ驕ｿ縺代ｋ縺溘ａ縺ｫ縺ｧ縺阪ｋ縺ｨ繧医＞縺薙→縺ｮ縺ｮ繝ｪ繧ｹ繝医〒縺<E38092>-
+蜍輔＞縺ｦ縺<EFBDA6>∪縺吶€ゆｻ･荳九<E88DB3>蝠城｡後ｒ驕ｿ縺代ｋ縺溘ａ縺ｫ縺ｧ縺阪ｋ縺ｨ濶ｯ縺<EFBDAF>％縺ｨ縺ｮ繝ｪ繧ｹ繝医〒縺<E38092>-
縺ゅ↑縺溘<E7B8BA>謠先｡医☆繧句､画峩縺ｫ縺､縺<EFBDA4>※險€縺<C280>→縺阪<E7B8BA>縺<EFBFBD>∪縺<E288AA>ｨ€縺<C280>婿<EFBFBD><E5A9BF>
@@ -525,7 +531,7 @@ MAINTAINERS 繝輔ぃ繧､繝ｫ縺ｫ繝ｪ繧ｹ繝医′縺ゅｊ縺ｾ縺吶<E7B8BA>縺ｧ蜿ら<E89CBF>縺励※縺上□縺輔<E7B8BA>
- "莉･荳九<E88DB3>荳€騾｣縺ｮ蟆上＆縺ｪ繝代ャ繝∫ｾ､縺ｧ縺吶′..."
- "縺薙ｌ縺ｯ蜈ｸ蝙狗噪縺ｪ繝槭す繝ｳ縺ｧ縺ｮ諤ｧ閭ｽ繧貞髄荳翫＆縺帙∪縺<E288AA>.."
- 繧<>ａ縺滓婿縺後＞縺<EFBC9E>が縺<E3818C>ｨ€縺<C280>婿<EFBFBD><E5A9BF>
+ 繧<>ａ縺滓婿縺瑚憶縺<E686B6>が縺<E3818C>ｨ€縺<C280>婿<EFBFBD><E5A9BF>
- 縺薙<E7B8BA>繧<EFBFBD>ｊ譁ｹ縺ｧ AIX/ptx/Solaris 縺ｧ縺ｯ縺ｧ縺阪◆縺ｮ縺ｧ縲√〒縺阪ｋ縺ｯ縺壹□
- 遘√<E98198>縺薙ｌ繧<EFBD8C>20蟷ｴ繧ゅ<E7B9A7>髢薙ｄ縺｣縺ｦ縺阪◆縲√□縺九ｉ
@@ -575,10 +581,10 @@ Linux 繧ｫ繝ｼ繝阪Ν繧ｳ繝溘Η繝九ユ繧｣縺ｯ縲∽ｸ€蠎ｦ縺ｫ螟ｧ驥上<E9A9A5>繧ｳ繝ｼ繝峨<E7B99D>蝪翫ｒ蝟
1) 蟆上＆縺<EFBC86>ヱ繝<E383B1>メ縺ｯ縺ゅ↑縺溘<E7B8BA>繝代ャ繝√′驕ｩ逕ｨ縺輔ｌ繧玖ｦ玖ｾｼ縺ｿ繧貞､ｧ縺阪￥縺励∪縺吶€√き繝ｼ
繝阪Ν縺ｮ莠ｺ驕斐<E9A995>繝代ャ繝√′豁｣縺励＞縺九←縺<E28690>°繧堤｢ｺ隱阪☆繧区凾髢薙ｄ蜉ｴ蜉帙ｒ縺九￠縺ｪ縺<EFBDAA>°
- 繧峨〒縺吶€<E590B6>5陦後<E999A6>繝代ャ繝√<E7B99D>繝｡繝ｳ繝<EFBDB3>リ縺後◆縺｣縺<EFBDA3>1遘定ｦ九ｋ縺<EFBD8B>縺代〒驕ｩ逕ｨ縺ｧ縺阪∪縺吶€ゅ＠
- 縺九＠縲<EFBCA0>500陦後<E999A6>繝代ャ繝√<E7B99D>縲∵ｭ｣縺励＞縺薙→繧偵Ξ繝薙Η繝ｼ縺吶ｋ縺ｮ縺ｫ謨ｰ譎る俣縺九°繧九°繧<C2B0>
- 縺励ｌ縺ｾ縺帙ｓ(譎る俣縺ｯ繝代ャ繝√<E7B99D>繧ｵ繧､繧ｺ縺ｪ縺ｩ縺ｫ繧医ｊ謖<EFBD8A>焚髢｢謨ｰ縺ｫ豈比ｾ九＠縺ｦ縺九°繧翫∪
- 縺<>)
+ 繧峨〒縺吶€<E590B6>5陦後<E999A6>繝代ャ繝√<E7B99D>繝｡繝ｳ繝<EFBDB3>リ縺後◆縺｣縺<EFBDA3>1遘定ｦ九ｋ縺<EFBD8B>縺代〒驕ｩ逕ｨ縺ｧ縺阪∪縺吶€<E590B6>
+ 縺励°縺励€<E58AB1>500陦後<E999A6>繝代ャ繝√<E7B99D>縲∵ｭ｣縺励＞縺薙→繧偵Ξ繝薙Η繝ｼ縺吶ｋ縺ｮ縺ｫ謨ｰ譎る俣縺九°繧九°
+ 繧ゅ＠繧後∪縺帙ｓ(譎る俣縺ｯ繝代ャ繝√<E7B99D>繧ｵ繧､繧ｺ縺ｪ縺ｩ縺ｫ繧医ｊ謖<EFBD8A>焚髢｢謨ｰ縺ｫ豈比ｾ九＠縺ｦ縺九°繧<C2B0>
+ 縺ｾ縺<EFBDBE>)
蟆上＆縺<EFBC86>ヱ繝<E383B1>メ縺ｯ菴輔°縺ゅ▲縺溘→縺阪↓繝<E28693>ヰ繝<E383B0>げ繧ゅ→縺ｦ繧らｰ｡蜊倥↓縺ｪ繧翫∪縺吶€ゅヱ繝<E383B1>
繝√ｒ1蛟<31>1蛟句叙繧企勁縺上<E7B8BA>縺ｯ縲√→縺ｦ繧ょ､ｧ縺阪↑繝代ャ繝√ｒ蠖薙※縺溷ｾ後↓(縺九▽縲∽ｽ輔°縺<C2B0>
@@ -587,23 +593,23 @@ Linux 繧ｫ繝ｼ繝阪Ν繧ｳ繝溘Η繝九ユ繧｣縺ｯ縲∽ｸ€蠎ｦ縺ｫ螟ｧ驥上<E9A9A5>繧ｳ繝ｼ繝峨<E7B99D>蝪翫ｒ蝟
2) 蟆上＆縺<EFBC86>ヱ繝<E383B1>メ繧帝€√ｋ縺<EFBD8B>縺代〒縺ｪ縺上€<E4B88A>€√ｋ縺ｾ縺医↓縲∵嶌縺咲峩縺励※縲√す繝ｳ繝励Ν縺ｫ縺<EFBDAB>
繧<>(繧ゅ＠縺上<E7B8BA>縲∝腰縺ｫ鬆<EFBDAB>分繧貞､峨∴繧九□縺代〒繧<E38092>)縺薙→繧ゅ€√→縺ｦ繧る㍾隕√〒縺吶€<E590B6>
-莉･荳九<E88DB3>繧ｫ繝ｼ繝阪Ν髢狗匱閠<E58CB1><E996A0> Al Viro 縺ｮ縺溘→縺郁ｩｱ縺励〒縺呻ｼ<E591BB>
+莉･荳九<E88DB3>繧ｫ繝ｼ繝阪Ν髢狗匱閠<E58CB1><E996A0> Al Viro 縺ｮ縺溘→縺郁ｩｱ縺ｧ縺呻ｼ<E591BB>
"逕溷ｾ偵<EFBDBE>謨ｰ蟄ｦ縺ｮ螳ｿ鬘後ｒ謗｡轤ｹ縺吶ｋ蜈育函縺ｮ縺薙→繧定€<E5AE9A>∴縺ｦ縺ｿ縺ｦ縺上□縺輔＞縲∝<E7B8B2>
- 逕溘<E98095>逕溷ｾ偵′隗｣縺ｫ蛻ｰ驕斐☆繧九∪縺ｧ縺ｮ隧ｦ陦碁険隱､繧偵∩縺溘＞縺ｨ縺ｯ諤昴ｏ縺ｪ縺<EFBDAA>〒縺励ｇ
- 縺<>€ょ<C280>逕溘<E98095>邁｡貎斐↑譛€鬮倥<E9ACAE>隗｣繧偵∩縺溘＞縺ｮ縺ｧ縺吶€り憶縺<E686B6>函蠕偵<E8A095>縺薙ｌ繧堤衍縺｣縺ｦ
+ 逕溘<E98095>逕溷ｾ偵′隗｣縺ｫ蛻ｰ驕斐☆繧九∪縺ｧ縺ｮ隧ｦ陦碁険隱､繧定ｦ九◆縺<E29786>→縺ｯ諤昴ｏ縺ｪ縺<EFBDAA>〒縺励ｇ
+ 縺<>€ょ<C280>逕溘<E98095>邁｡貎斐↑譛€鬮倥<E9ACAE>隗｣繧定ｦ九◆縺<E29786><E7B8BA>縺ｧ縺吶€り憶縺<E686B6>函蠕偵<E8A095>縺薙ｌ繧堤衍縺｣縺ｦ
縺翫ｊ縲√◎縺励※譛€邨りｧ｣縺ｮ蜑阪<E89C91>荳ｭ髢謎ｽ懈･ｭ繧呈署蜃ｺ縺吶ｋ縺薙→縺ｯ豎ｺ縺励※縺ｪ縺<EFBDAA><E7B8BA>縺ｧ
縺<>"
- 繧ｫ繝ｼ繝阪Ν髢狗匱縺ｧ繧ゅ％繧後<E7B9A7>蜷後§縺ｧ縺吶€ゅΓ繝ｳ繝<EFBDB3>リ繝ｼ驕斐→繝ｬ繝薙Η繝ｼ繧｢驕斐<E9A995>縲<EFBFBD>
- 蝠城｡後ｒ隗｣豎ｺ縺吶ｋ隗｣縺ｮ閭悟ｾ後↓縺ｪ繧区€晁€<E69981><C280>繝ｭ繧ｻ繧ｹ繧偵∩縺溘＞縺ｨ縺ｯ諤昴＞縺ｾ縺帙ｓ縲<EFBD93>
- 蠖ｼ繧峨<E7B9A7>蜊倡ｴ斐〒縺ゅ＊繧<EFBC8A>°縺ｪ隗｣豎ｺ譁ｹ豕輔ｒ縺ｿ縺溘＞縺ｮ縺ｧ縺吶€<E590B6>
+ 繧ｫ繝ｼ繝阪Ν髢狗匱縺ｧ繧ゅ％繧後<E7B9A7>蜷後§縺ｧ縺吶€ゅΓ繝ｳ繝<EFBDB3>リ驕斐→繝ｬ繝薙Η繝ｼ繧｢驕斐<E9A995>縲<EFBFBD>
+ 蝠城｡後ｒ隗｣豎ｺ縺吶ｋ隗｣縺ｮ閭悟ｾ後↓縺ｪ繧区€晁€<E69981><C280>繝ｭ繧ｻ繧ｹ繧定ｦ九◆縺<E29786>→縺ｯ諤昴＞縺ｾ縺帙ｓ縲<EFBD93>
+ 蠖ｼ繧峨<E7B9A7>蜊倡ｴ斐〒縺ゅ＊繧<EFBC8A>°縺ｪ隗｣豎ｺ譁ｹ豕輔ｒ隕九◆縺<E29786><E7B8BA>縺ｧ縺吶€<E590B6>
縺ゅ＊繧<EFBC8A>°縺ｪ隗｣繧定ｪｬ譏弱☆繧九<E7B9A7>縺ｨ縲√さ繝溘Η繝九ユ繧｣縺ｨ蜈ｱ縺ｫ莉穂ｺ九ｒ縺励€∵悴隗｣豎ｺ縺ｮ莉穂ｺ九ｒ
隴ｰ隲悶☆繧九％縺ｨ縺ｮ繝舌Λ繝ｳ繧ｹ繧偵く繝ｼ繝励☆繧九<E7B9A7>縺ｯ髮｣縺励＞縺九ｂ縺励ｌ縺ｾ縺帙ｓ縲<EFBD93>
縺ｧ縺吶°繧峨€<E5B3A8>幕逋ｺ繝励Ο繧ｻ繧ｹ縺ｮ譌ｩ譛滓ｮｵ髫弱〒謾ｹ蝟<EFBDB9><E89D9F>縺溘ａ縺ｮ繝輔ぅ繝ｼ繝峨ヰ繝<E383B0>け繧偵ｂ繧峨≧繧<E289A7>
-縺<>↓縺吶ｋ縺ｮ繧ゅ＞縺<EFBC9E>〒縺吶′縲∝､画峩轤ｹ繧貞ｰ上＆縺<EFBC86>Κ蛻<CE9A>↓蛻<E28693>牡縺励※蜈ｨ菴薙〒縺ｯ縺ｾ縺<EFBDBE>螳梧<E89EB3>縺<EFBFBD>
-縺ｦ縺<EFBDA6>↑縺<E28691>ｻ穂ｺ九ｒ(驛ｨ蛻<EFBDA8>噪縺ｫ)蜿悶ｊ霎ｼ繧薙〒繧ゅｉ縺医ｋ繧医≧縺ｫ縺吶ｋ縺薙→繧ゅ＞縺<EFBC9E>％縺ｨ縺ｧ縺吶€<E590B6>
+縺<>↓縺吶ｋ縺ｮ繧り憶縺<E686B6>〒縺吶′縲∝､画峩轤ｹ繧貞ｰ上＆縺<EFBC86>Κ蛻<CE9A>↓蛻<E28693>牡縺励※蜈ｨ菴薙〒縺ｯ縺ｾ縺<EFBDBE>螳梧<E89EB3>縺<EFBFBD>
+縺ｦ縺<EFBDA6>↑縺<E28691>ｻ穂ｺ九ｒ(驛ｨ蛻<EFBDA8>噪縺ｫ)蜿悶ｊ霎ｼ繧薙〒繧ゅｉ縺医ｋ繧医≧縺ｫ縺吶ｋ縺薙→繧り憶縺<E686B6>％縺ｨ縺ｧ縺吶€<E590B6>
縺ｾ縺溘€√〒縺堺ｸ翫′縺｣縺ｦ縺<EFBDA6>↑縺<E28691>ｂ縺ｮ繧<EFBDAE>€<EFBFBD>"蟆<>擂逶ｴ縺<EFBDB4>" 繧医≧縺ｪ繝代ャ繝√ｒ縲∵悽豬√↓蜷ｫ繧<EFBDAB>
縺ｦ繧ゅｉ縺<EFBD89>ｈ縺<EFBD88>↓騾√▲縺ｦ繧ゅ€√◎繧後<E7B9A7>蜿励￠莉倥￠繧峨ｌ縺ｪ縺<EFBDAA>％縺ｨ繧堤炊隗｣縺励※縺上□縺輔＞縲<EFBC9E>
@@ -629,7 +635,7 @@ Linux 繧ｫ繝ｼ繝阪Ν繧ｳ繝溘Η繝九ユ繧｣縺ｯ縲∽ｸ€蠎ｦ縺ｫ螟ｧ驥上<E9A9A5>繧ｳ繝ｼ繝峨<E7B99D>蝪翫ｒ蝟
- 繝<>せ繝育ｵ先棡
縺薙ｌ縺ｫ縺､縺<EFBDA4>※蜈ｨ縺ｦ縺後←縺ｮ繧医≧縺ｫ縺ゅｋ縺ｹ縺阪°縺ｫ縺､縺<EFBDA4>※縺ｮ隧ｳ邏ｰ縺ｯ縲∽ｻ･荳九<E88DB3>繝峨く繝･繝｡
-繝ｳ繝医<E7B99D> ChangeLog 繧ｻ繧ｯ繧ｷ繝ｧ繝ｳ繧偵∩縺ｦ縺上□縺輔＞-
+繝ｳ繝医<E7B99D> ChangeLog 繧ｻ繧ｯ繧ｷ繝ｧ繝ｳ繧定ｦ九※縺上□縺輔＞-
"The Perfect Patch"
http://www.zip.com.au/~akpm/linux/patches/stuff/tpp.txt
diff --git a/Makefile b/Makefile
index c244a02..c6d545c 100644
diff --git a/block/ll_rw_blk.c b/block/ll_rw_blk.c
index ed39313..026cf24 100644
--- a/block/ll_rw_blk.c
+++ b/block/ll_rw_blk.c
@@ -819,7 +819,6 @@ static int __blk_free_tags(struct blk_queue_tag *bqt)
retval = atomic_dec_and_test(&bqt->refcnt);
if (retval) {
BUG_ON(bqt->busy);
- BUG_ON(!list_empty(&bqt->busy_list));
kfree(bqt->tag_index);
bqt->tag_index = NULL;
@@ -931,7 +930,6 @@ static struct blk_queue_tag *__blk_queue_init_tags(struct request_queue *q,
if (init_tag_map(q, tags, depth))
goto fail;
- INIT_LIST_HEAD(&tags->busy_list);
tags->busy = 0;
atomic_set(&tags->refcnt, 1);
return tags;
@@ -982,6 +980,7 @@ int blk_queue_init_tags(struct request_queue *q, int depth,
*/
q->queue_tags = tags;
q->queue_flags |= (1 << QUEUE_FLAG_QUEUED);
+ INIT_LIST_HEAD(&q->tag_busy_list);
return 0;
fail:
kfree(tags);
@@ -1152,7 +1151,7 @@ int blk_queue_start_tag(struct request_queue *q, struct request *rq)
rq->tag = tag;
bqt->tag_index[tag] = rq;
blkdev_dequeue_request(rq);
- list_add(&rq->queuelist, &bqt->busy_list);
+ list_add(&rq->queuelist, &q->tag_busy_list);
bqt->busy++;
return 0;
}
@@ -1173,11 +1172,10 @@ EXPORT_SYMBOL(blk_queue_start_tag);
**/
void blk_queue_invalidate_tags(struct request_queue *q)
{
- struct blk_queue_tag *bqt = q->queue_tags;
struct list_head *tmp, *n;
struct request *rq;
- list_for_each_safe(tmp, n, &bqt->busy_list) {
+ list_for_each_safe(tmp, n, &q->tag_busy_list) {
rq = list_entry_rq(tmp);
if (rq->tag == -1) {
diff --git a/fs/locks.c b/fs/locks.c
index c795eaa..494f250 100644
--- a/fs/locks.c
+++ b/fs/locks.c
@@ -694,11 +694,20 @@ EXPORT_SYMBOL(posix_test_lock);
* Note: the above assumption may not be true when handling lock requests
* from a broken NFS client. But broken NFS clients have a lot more to
* worry about than proper deadlock detection anyway... --okir
+ *
+ * However, the failure of this assumption (also possible in the case of
+ * multiple tasks sharing the same open file table) also means there's no
+ * guarantee that the loop below will terminate. As a hack, we give up
+ * after a few iterations.
*/
+
+#define MAX_DEADLK_ITERATIONS 10
+
static int posix_locks_deadlock(struct file_lock *caller_fl,
struct file_lock *block_fl)
{
struct list_head *tmp;
+ int i = 0;
next_task:
if (posix_same_owner(caller_fl, block_fl))
@@ -706,6 +715,8 @@ next_task:
list_for_each(tmp, &blocked_list) {
struct file_lock *fl = list_entry(tmp, struct file_lock, fl_link);
if (posix_same_owner(fl, block_fl)) {
+ if (i++ > MAX_DEADLK_ITERATIONS)
+ return 0;
fl = fl->fl_next;
block_fl = fl;
goto next_task;
diff --git a/fs/proc/array.c b/fs/proc/array.c
index ee4814d..20d7ae4 100644
--- a/fs/proc/array.c
+++ b/fs/proc/array.c
@@ -351,7 +351,8 @@ static cputime_t task_utime(struct task_struct *p)
}
utime = (clock_t)temp;
- return clock_t_to_cputime(utime);
+ p->prev_utime = max(p->prev_utime, clock_t_to_cputime(utime));
+ return p->prev_utime;
}
static cputime_t task_stime(struct task_struct *p)
@@ -366,7 +367,8 @@ static cputime_t task_stime(struct task_struct *p)
stime = nsec_to_clock_t(p->se.sum_exec_runtime) -
cputime_to_clock_t(task_utime(p));
- return clock_t_to_cputime(stime);
+ p->prev_stime = max(p->prev_stime, clock_t_to_cputime(stime));
+ return p->prev_stime;
}
#endif
diff --git a/fs/splice.c b/fs/splice.c
index e95a362..02c39ae 100644
--- a/fs/splice.c
+++ b/fs/splice.c
@@ -1390,10 +1390,10 @@ static int pipe_to_user(struct pipe_inode_info *pipe, struct pipe_buffer *buf,
if (copy_to_user(sd->u.userptr, src + buf->offset, sd->len))
ret = -EFAULT;
+ buf->ops->unmap(pipe, buf, src);
out:
if (ret > 0)
sd->u.userptr += ret;
- buf->ops->unmap(pipe, buf, src);
return ret;
}
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index b126c6f..d26bbb0 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -356,7 +356,6 @@ enum blk_queue_state {
struct blk_queue_tag {
struct request **tag_index; /* map of busy tags */
unsigned long *tag_map; /* bit map of free/busy tags */
- struct list_head busy_list; /* fifo list of busy tags */
int busy; /* current depth */
int max_depth; /* what we will send to device */
int real_max_depth; /* what the array can hold */
@@ -451,6 +450,7 @@ struct request_queue
unsigned int dma_alignment;
struct blk_queue_tag *queue_tags;
+ struct list_head tag_busy_list;
unsigned int nr_sorted;
unsigned int in_flight;
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 313c6b6..f509fbd 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -1022,6 +1022,7 @@ struct task_struct {
unsigned int rt_priority;
cputime_t utime, stime;
+ cputime_t prev_utime, prev_stime;
unsigned long nvcsw, nivcsw; /* context switch counts */
struct timespec start_time; /* monotonic time */
struct timespec real_start_time; /* boot based time */
diff --git a/kernel/fork.c b/kernel/fork.c
index 33f12f4..f299d45 100644
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -1045,6 +1045,8 @@ static struct task_struct *copy_process(unsigned long clone_flags,
p->utime = cputime_zero;
p->stime = cputime_zero;
+ p->prev_utime = cputime_zero;
+ p->prev_stime = cputime_zero;
#ifdef CONFIG_TASK_XACCT
p->rchar = 0; /* I/O counter: bytes read */
diff --git a/kernel/futex_compat.c b/kernel/futex_compat.c
index 2c2e295..f938c23 100644
--- a/kernel/futex_compat.c
+++ b/kernel/futex_compat.c
@@ -29,6 +29,15 @@ fetch_robust_entry(compat_uptr_t *uentry, struct robust_list __user **entry,
return 0;
}
+static void __user *futex_uaddr(struct robust_list *entry,
+ compat_long_t futex_offset)
+{
+ compat_uptr_t base = ptr_to_compat(entry);
+ void __user *uaddr = compat_ptr(base + futex_offset);
+
+ return uaddr;
+}
+
/*
* Walk curr->robust_list (very carefully, it's a userspace list!)
* and mark any locks found there dead, and notify any waiters.
@@ -75,11 +84,13 @@ void compat_exit_robust_list(struct task_struct *curr)
* A pending lock might already be on the list, so
* dont process it twice:
*/
- if (entry != pending)
- if (handle_futex_death((void __user *)entry + futex_offset,
- curr, pi))
- return;
+ if (entry != pending) {
+ void __user *uaddr = futex_uaddr(entry,
+ futex_offset);
+ if (handle_futex_death(uaddr, curr, pi))
+ return;
+ }
if (rc)
return;
uentry = next_uentry;
@@ -93,9 +104,11 @@ void compat_exit_robust_list(struct task_struct *curr)
cond_resched();
}
- if (pending)
- handle_futex_death((void __user *)pending + futex_offset,
- curr, pip);
+ if (pending) {
+ void __user *uaddr = futex_uaddr(pending, futex_offset);
+
+ handle_futex_death(uaddr, curr, pip);
+ }
}
asmlinkage long
diff --git a/kernel/lockdep.c b/kernel/lockdep.c
index 734da57..42ae4a5 100644
--- a/kernel/lockdep.c
+++ b/kernel/lockdep.c
@@ -1521,7 +1521,7 @@ cache_hit:
}
static int validate_chain(struct task_struct *curr, struct lockdep_map *lock,
- struct held_lock *hlock, int chain_head)
+ struct held_lock *hlock, int chain_head, u64 chain_key)
{
/*
* Trylock needs to maintain the stack of held locks, but it
@@ -1534,7 +1534,7 @@ static int validate_chain(struct task_struct *curr, struct lockdep_map *lock,
* graph_lock for us)
*/
if (!hlock->trylock && (hlock->check == 2) &&
- lookup_chain_cache(curr->curr_chain_key, hlock->class)) {
+ lookup_chain_cache(chain_key, hlock->class)) {
/*
* Check whether last held lock:
*
@@ -1576,7 +1576,7 @@ static int validate_chain(struct task_struct *curr, struct lockdep_map *lock,
#else
static inline int validate_chain(struct task_struct *curr,
struct lockdep_map *lock, struct held_lock *hlock,
- int chain_head)
+ int chain_head, u64 chain_key)
{
return 1;
}
@@ -2450,11 +2450,11 @@ static int __lock_acquire(struct lockdep_map *lock, unsigned int subclass,
chain_head = 1;
}
chain_key = iterate_chain_key(chain_key, id);
- curr->curr_chain_key = chain_key;
- if (!validate_chain(curr, lock, hlock, chain_head))
+ if (!validate_chain(curr, lock, hlock, chain_head, chain_key))
return 0;
+ curr->curr_chain_key = chain_key;
curr->lockdep_depth++;
check_chain_key(curr);
#ifdef CONFIG_DEBUG_LOCKDEP
diff --git a/kernel/params.c b/kernel/params.c
index 4e57732..5e5651f 100644
--- a/kernel/params.c
+++ b/kernel/params.c
@@ -595,13 +595,16 @@ static void __init param_sysfs_builtin(void)
for (i=0; i < __stop___param - __start___param; i++) {
char *dot;
+ size_t max_name_len;
kp = &__start___param[i];
+ max_name_len =
+ min_t(size_t, MAX_KBUILD_MODNAME, strlen(kp->name));
- /* We do not handle args without periods. */
- dot = memchr(kp->name, '.', MAX_KBUILD_MODNAME);
+ dot = memchr(kp->name, '.', max_name_len);
if (!dot) {
- DEBUGP("couldn't find period in %s\n", kp->name);
+ DEBUGP("couldn't find period in first %d characters "
+ "of %s\n", MAX_KBUILD_MODNAME, kp->name);
continue;
}
name_len = dot - kp->name;
diff --git a/kernel/softlockup.c b/kernel/softlockup.c
index 708d488..e557c44 100644
--- a/kernel/softlockup.c
+++ b/kernel/softlockup.c
@@ -80,10 +80,11 @@ void softlockup_tick(void)
print_timestamp = per_cpu(print_timestamp, this_cpu);
/* report at most once a second */
- if (print_timestamp < (touch_timestamp + 1) ||
- did_panic ||
- !per_cpu(watchdog_task, this_cpu))
+ if ((print_timestamp >= touch_timestamp &&
+ print_timestamp < (touch_timestamp + 1)) ||
+ did_panic || !per_cpu(watchdog_task, this_cpu)) {
return;
+ }
/* do not print during early bootup: */
if (unlikely(system_state != SYSTEM_RUNNING)) {
diff --git a/mm/filemap.c b/mm/filemap.c
index 15c8413..14ca63f 100644
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -1312,7 +1312,7 @@ int filemap_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
size = (i_size_read(inode) + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
if (vmf->pgoff >= size)
- goto outside_data_content;
+ return VM_FAULT_SIGBUS;
/* If we don't want any read-ahead, don't bother */
if (VM_RandomReadHint(vma))
@@ -1389,7 +1389,7 @@ retry_find:
if (unlikely(vmf->pgoff >= size)) {
unlock_page(page);
page_cache_release(page);
- goto outside_data_content;
+ return VM_FAULT_SIGBUS;
}
/*
@@ -1400,15 +1400,6 @@ retry_find:
vmf->page = page;
return ret | VM_FAULT_LOCKED;
-outside_data_content:
- /*
- * An external ptracer can access pages that normally aren't
- * accessible..
- */
- if (vma->vm_mm == current->mm)
- return VM_FAULT_SIGBUS;
-
- /* Fall through to the non-read-ahead case */
no_cached_page:
/*
* We're only likely to ever get here if MADV_RANDOM is in
diff --git a/mm/page-writeback.c b/mm/page-writeback.c
index 4472036..97ddc58 100644
--- a/mm/page-writeback.c
+++ b/mm/page-writeback.c
@@ -672,8 +672,10 @@ retry:
ret = (*writepage)(page, wbc, data);
- if (unlikely(ret == AOP_WRITEPAGE_ACTIVATE))
+ if (unlikely(ret == AOP_WRITEPAGE_ACTIVATE)) {
unlock_page(page);
+ ret = 0;
+ }
if (ret || (--(wbc->nr_to_write) <= 0))
done = 1;
if (wbc->nonblocking && bdi_write_congested(bdi)) {
diff --git a/mm/shmem.c b/mm/shmem.c
index fcd19d3..95558e4 100644
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -916,6 +916,21 @@ static int shmem_writepage(struct page *page, struct writeback_control *wbc)
struct inode *inode;
BUG_ON(!PageLocked(page));
+ /*
+ * shmem_backing_dev_info's capabilities prevent regular writeback or
+ * sync from ever calling shmem_writepage; but a stacking filesystem
+ * may use the ->writepage of its underlying filesystem, in which case
+ * we want to do nothing when that underlying filesystem is tmpfs
+ * (writing out to swap is useful as a response to memory pressure, but
+ * of no use to stabilize the data) - just redirty the page, unlock it
+ * and claim success in this case. AOP_WRITEPAGE_ACTIVATE, and the
+ * page_mapped check below, must be avoided unless we're in reclaim.
+ */
+ if (!wbc->for_reclaim) {
+ set_page_dirty(page);
+ unlock_page(page);
+ return 0;
+ }
BUG_ON(page_mapped(page));
mapping = page->mapping;
diff --git a/mm/slub.c b/mm/slub.c
index addb20a..c1f2fda 100644
--- a/mm/slub.c
+++ b/mm/slub.c
@@ -1501,28 +1501,8 @@ new_slab:
page = new_slab(s, gfpflags, node);
if (page) {
cpu = smp_processor_id();
- if (s->cpu_slab[cpu]) {
- /*
- * Someone else populated the cpu_slab while we
- * enabled interrupts, or we have gotten scheduled
- * on another cpu. The page may not be on the
- * requested node even if __GFP_THISNODE was
- * specified. So we need to recheck.
- */
- if (node == -1 ||
- page_to_nid(s->cpu_slab[cpu]) == node) {
- /*
- * Current cpuslab is acceptable and we
- * want the current one since its cache hot
- */
- discard_slab(s, page);
- page = s->cpu_slab[cpu];
- slab_lock(page);
- goto load_freelist;
- }
- /* New slab does not fit our expectations */
+ if (s->cpu_slab[cpu])
flush_slab(s, s->cpu_slab[cpu], cpu);
- }
slab_lock(page);
SetSlabFrozen(page);
s->cpu_slab[cpu] = page;

1001
debian/patches/bugfix/all/stable/2.6.23.3.patch vendored Normal file
View File

File diff suppressed because it is too large Load Diff

875
debian/patches/bugfix/all/stable/2.6.23.4.patch vendored Normal file
View File

@ -0,0 +1,875 @@
diff --git a/Makefile b/Makefile
index b0c2c32..0c34409 100644
diff --git a/include/linux/netlink.h b/include/linux/netlink.h
index 83d8239..63af986 100644
--- a/include/linux/netlink.h
+++ b/include/linux/netlink.h
@@ -175,7 +175,7 @@ extern int netlink_unregister_notifier(struct notifier_block *nb);
/* finegrained unicast helpers: */
struct sock *netlink_getsockbyfilp(struct file *filp);
int netlink_attachskb(struct sock *sk, struct sk_buff *skb, int nonblock,
- long timeo, struct sock *ssk);
+ long *timeo, struct sock *ssk);
void netlink_detachskb(struct sock *sk, struct sk_buff *skb);
int netlink_sendskb(struct sock *sk, struct sk_buff *skb, int protocol);
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index a656cec..ed2c458 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -41,8 +41,7 @@
#define SKB_DATA_ALIGN(X) (((X) + (SMP_CACHE_BYTES - 1)) & \
~(SMP_CACHE_BYTES - 1))
#define SKB_WITH_OVERHEAD(X) \
- (((X) - sizeof(struct skb_shared_info)) & \
- ~(SMP_CACHE_BYTES - 1))
+ ((X) - SKB_DATA_ALIGN(sizeof(struct skb_shared_info)))
#define SKB_MAX_ORDER(X, ORDER) \
SKB_WITH_OVERHEAD((PAGE_SIZE << (ORDER)) - (X))
#define SKB_MAX_HEAD(X) (SKB_MAX_ORDER((X), 0))
diff --git a/include/net/9p/9p.h b/include/net/9p/9p.h
index 88884d3..7726ff4 100644
--- a/include/net/9p/9p.h
+++ b/include/net/9p/9p.h
@@ -412,6 +412,18 @@ int p9_idpool_check(int id, struct p9_idpool *p);
int p9_error_init(void);
int p9_errstr2errno(char *, int);
+
+#ifdef CONFIG_SYSCTL
int __init p9_sysctl_register(void);
void __exit p9_sysctl_unregister(void);
+#else
+static inline int p9_sysctl_register(void)
+{
+ return 0;
+}
+static inline void p9_sysctl_unregister(void)
+{
+}
+#endif
+
#endif /* NET_9P_H */
diff --git a/include/net/sock.h b/include/net/sock.h
index dfeb8b1..bdd9ebe 100644
--- a/include/net/sock.h
+++ b/include/net/sock.h
@@ -1199,14 +1199,16 @@ static inline struct sk_buff *sk_stream_alloc_pskb(struct sock *sk,
gfp_t gfp)
{
struct sk_buff *skb;
- int hdr_len;
- hdr_len = SKB_DATA_ALIGN(sk->sk_prot->max_header);
- skb = alloc_skb_fclone(size + hdr_len, gfp);
+ skb = alloc_skb_fclone(size + sk->sk_prot->max_header, gfp);
if (skb) {
skb->truesize += mem;
if (sk_stream_wmem_schedule(sk, skb->truesize)) {
- skb_reserve(skb, hdr_len);
+ /*
+ * Make sure that we have exactly size bytes
+ * available to the caller, no more, no less.
+ */
+ skb_reserve(skb, skb_tailroom(skb) - size);
return skb;
}
__kfree_skb(skb);
diff --git a/ipc/mqueue.c b/ipc/mqueue.c
index 145d5a0..1c0de2c 100644
--- a/ipc/mqueue.c
+++ b/ipc/mqueue.c
@@ -1014,6 +1014,8 @@ asmlinkage long sys_mq_notify(mqd_t mqdes,
return -EINVAL;
}
if (notification.sigev_notify == SIGEV_THREAD) {
+ long timeo;
+
/* create the notify skb */
nc = alloc_skb(NOTIFY_COOKIE_LEN, GFP_KERNEL);
ret = -ENOMEM;
@@ -1042,8 +1044,8 @@ retry:
goto out;
}
- ret = netlink_attachskb(sock, nc, 0,
- MAX_SCHEDULE_TIMEOUT, NULL);
+ timeo = MAX_SCHEDULE_TIMEOUT;
+ ret = netlink_attachskb(sock, nc, 0, &timeo, NULL);
if (ret == 1)
goto retry;
if (ret) {
diff --git a/net/8021q/vlan.c b/net/8021q/vlan.c
index 2a54691..ef3f789 100644
--- a/net/8021q/vlan.c
+++ b/net/8021q/vlan.c
@@ -629,6 +629,10 @@ static int vlan_device_event(struct notifier_block *unused, unsigned long event,
if (!vlandev)
continue;
+ flgs = vlandev->flags;
+ if (!(flgs & IFF_UP))
+ continue;
+
vlan_sync_address(dev, vlandev);
}
break;
@@ -740,6 +744,7 @@ static int vlan_ioctl_handler(void __user *arg)
vlan_dev_set_ingress_priority(dev,
args.u.skb_priority,
args.vlan_qos);
+ err = 0;
break;
case SET_VLAN_EGRESS_PRIORITY_CMD:
diff --git a/net/ieee80211/ieee80211_crypt_tkip.c b/net/ieee80211/ieee80211_crypt_tkip.c
index 5a48d8e..7f11dd9 100644
--- a/net/ieee80211/ieee80211_crypt_tkip.c
+++ b/net/ieee80211/ieee80211_crypt_tkip.c
@@ -584,7 +584,7 @@ static void michael_mic_hdr(struct sk_buff *skb, u8 * hdr)
if (stype & IEEE80211_STYPE_QOS_DATA) {
const struct ieee80211_hdr_3addrqos *qoshdr =
(struct ieee80211_hdr_3addrqos *)skb->data;
- hdr[12] = qoshdr->qos_ctl & cpu_to_le16(IEEE80211_QCTL_TID);
+ hdr[12] = le16_to_cpu(qoshdr->qos_ctl) & IEEE80211_QCTL_TID;
} else
hdr[12] = 0; /* priority */
diff --git a/net/ieee80211/softmac/ieee80211softmac_wx.c b/net/ieee80211/softmac/ieee80211softmac_wx.c
index 5742dc8..2b0b4c7 100644
--- a/net/ieee80211/softmac/ieee80211softmac_wx.c
+++ b/net/ieee80211/softmac/ieee80211softmac_wx.c
@@ -469,7 +469,7 @@ ieee80211softmac_wx_set_mlme(struct net_device *dev,
{
struct ieee80211softmac_device *mac = ieee80211_priv(dev);
struct iw_mlme *mlme = (struct iw_mlme *)extra;
- u16 reason = cpu_to_le16(mlme->reason_code);
+ u16 reason = mlme->reason_code;
struct ieee80211softmac_network *net;
int err = -EINVAL;
diff --git a/net/ipv4/ipcomp.c b/net/ipv4/ipcomp.c
index e787044..a8a9f13 100644
--- a/net/ipv4/ipcomp.c
+++ b/net/ipv4/ipcomp.c
@@ -17,6 +17,7 @@
#include <asm/scatterlist.h>
#include <asm/semaphore.h>
#include <linux/crypto.h>
+#include <linux/err.h>
#include <linux/pfkeyv2.h>
#include <linux/percpu.h>
#include <linux/smp.h>
@@ -355,7 +356,7 @@ static struct crypto_comp **ipcomp_alloc_tfms(const char *alg_name)
for_each_possible_cpu(cpu) {
struct crypto_comp *tfm = crypto_alloc_comp(alg_name, 0,
CRYPTO_ALG_ASYNC);
- if (!tfm)
+ if (IS_ERR(tfm))
goto error;
*per_cpu_ptr(tfms, cpu) = tfm;
}
diff --git a/net/ipv6/ipcomp6.c b/net/ipv6/ipcomp6.c
index 473f165..9dd1ebc 100644
--- a/net/ipv6/ipcomp6.c
+++ b/net/ipv6/ipcomp6.c
@@ -37,6 +37,7 @@
#include <asm/scatterlist.h>
#include <asm/semaphore.h>
#include <linux/crypto.h>
+#include <linux/err.h>
#include <linux/pfkeyv2.h>
#include <linux/random.h>
#include <linux/percpu.h>
@@ -366,7 +367,7 @@ static struct crypto_comp **ipcomp6_alloc_tfms(const char *alg_name)
for_each_possible_cpu(cpu) {
struct crypto_comp *tfm = crypto_alloc_comp(alg_name, 0,
CRYPTO_ALG_ASYNC);
- if (!tfm)
+ if (IS_ERR(tfm))
goto error;
*per_cpu_ptr(tfms, cpu) = tfm;
}
diff --git a/net/mac80211/ieee80211.c b/net/mac80211/ieee80211.c
index ff2172f..9e0da6e 100644
--- a/net/mac80211/ieee80211.c
+++ b/net/mac80211/ieee80211.c
@@ -350,7 +350,7 @@ static int ieee80211_get_radiotap_len(struct sk_buff *skb)
struct ieee80211_radiotap_header *hdr =
(struct ieee80211_radiotap_header *) skb->data;
- return le16_to_cpu(hdr->it_len);
+ return le16_to_cpu(get_unaligned(&hdr->it_len));
}
#ifdef CONFIG_MAC80211_LOWTX_FRAME_DUMP
@@ -1680,46 +1680,54 @@ int ieee80211_monitor_start_xmit(struct sk_buff *skb,
struct ieee80211_tx_packet_data *pkt_data;
struct ieee80211_radiotap_header *prthdr =
(struct ieee80211_radiotap_header *)skb->data;
- u16 len;
+ u16 len_rthdr;
- /*
- * there must be a radiotap header at the
- * start in this case
- */
- if (unlikely(prthdr->it_version)) {
- /* only version 0 is supported */
- dev_kfree_skb(skb);
- return NETDEV_TX_OK;
- }
+ /* check for not even having the fixed radiotap header part */
+ if (unlikely(skb->len < sizeof(struct ieee80211_radiotap_header)))
+ goto fail; /* too short to be possibly valid */
+
+ /* is it a header version we can trust to find length from? */
+ if (unlikely(prthdr->it_version))
+ goto fail; /* only version 0 is supported */
+
+ /* then there must be a radiotap header with a length we can use */
+ len_rthdr = ieee80211_get_radiotap_len(skb);
+
+ /* does the skb contain enough to deliver on the alleged length? */
+ if (unlikely(skb->len < len_rthdr))
+ goto fail; /* skb too short for claimed rt header extent */
skb->dev = local->mdev;
pkt_data = (struct ieee80211_tx_packet_data *)skb->cb;
memset(pkt_data, 0, sizeof(*pkt_data));
+ /* needed because we set skb device to master */
pkt_data->ifindex = dev->ifindex;
+
pkt_data->mgmt_iface = 0;
pkt_data->do_not_encrypt = 1;
- /* above needed because we set skb device to master */
-
/*
* fix up the pointers accounting for the radiotap
* header still being in there. We are being given
* a precooked IEEE80211 header so no need for
* normal processing
*/
- len = le16_to_cpu(get_unaligned(&prthdr->it_len));
- skb_set_mac_header(skb, len);
- skb_set_network_header(skb, len + sizeof(struct ieee80211_hdr));
- skb_set_transport_header(skb, len + sizeof(struct ieee80211_hdr));
-
+ skb_set_mac_header(skb, len_rthdr);
/*
- * pass the radiotap header up to
- * the next stage intact
+ * these are just fixed to the end of the rt area since we
+ * don't have any better information and at this point, nobody cares
*/
- dev_queue_xmit(skb);
+ skb_set_network_header(skb, len_rthdr);
+ skb_set_transport_header(skb, len_rthdr);
+ /* pass the radiotap header up to the next stage intact */
+ dev_queue_xmit(skb);
return NETDEV_TX_OK;
+
+fail:
+ dev_kfree_skb(skb);
+ return NETDEV_TX_OK; /* meaning, we dealt with the skb */
}
@@ -2836,9 +2844,10 @@ ieee80211_rx_h_data(struct ieee80211_txrx_data *rx)
memcpy(dst, hdr->addr1, ETH_ALEN);
memcpy(src, hdr->addr3, ETH_ALEN);
- if (sdata->type != IEEE80211_IF_TYPE_STA) {
+ if (sdata->type != IEEE80211_IF_TYPE_STA ||
+ (is_multicast_ether_addr(dst) &&
+ !compare_ether_addr(src, dev->dev_addr)))
return TXRX_DROP;
- }
break;
case 0:
/* DA SA BSSID */
diff --git a/net/mac80211/ieee80211_ioctl.c b/net/mac80211/ieee80211_ioctl.c
index e7904db..7b5b801 100644
--- a/net/mac80211/ieee80211_ioctl.c
+++ b/net/mac80211/ieee80211_ioctl.c
@@ -687,10 +687,11 @@ static int ieee80211_ioctl_giwap(struct net_device *dev,
static int ieee80211_ioctl_siwscan(struct net_device *dev,
struct iw_request_info *info,
- struct iw_point *data, char *extra)
+ union iwreq_data *wrqu, char *extra)
{
struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
+ struct iw_scan_req *req = NULL;
u8 *ssid = NULL;
size_t ssid_len = 0;
@@ -715,6 +716,14 @@ static int ieee80211_ioctl_siwscan(struct net_device *dev,
return -EOPNOTSUPP;
}
+ /* if SSID was specified explicitly then use that */
+ if (wrqu->data.length == sizeof(struct iw_scan_req) &&
+ wrqu->data.flags & IW_SCAN_THIS_ESSID) {
+ req = (struct iw_scan_req *)extra;
+ ssid = req->essid;
+ ssid_len = req->essid_len;
+ }
+
return ieee80211_sta_req_scan(dev, ssid, ssid_len);
}
diff --git a/net/mac80211/ieee80211_sta.c b/net/mac80211/ieee80211_sta.c
index 0d99b68..73d39e1 100644
--- a/net/mac80211/ieee80211_sta.c
+++ b/net/mac80211/ieee80211_sta.c
@@ -12,7 +12,6 @@
*/
/* TODO:
- * BSS table: use <BSSID,SSID> as the key to support multi-SSID APs
* order BSS list by RSSI(?) ("quality of AP")
* scan result table filtering (by capability (privacy, IBSS/BSS, WPA/RSN IE,
* SSID)
@@ -61,7 +60,8 @@
static void ieee80211_send_probe_req(struct net_device *dev, u8 *dst,
u8 *ssid, size_t ssid_len);
static struct ieee80211_sta_bss *
-ieee80211_rx_bss_get(struct net_device *dev, u8 *bssid);
+ieee80211_rx_bss_get(struct net_device *dev, u8 *bssid, int channel,
+ u8 *ssid, u8 ssid_len);
static void ieee80211_rx_bss_put(struct net_device *dev,
struct ieee80211_sta_bss *bss);
static int ieee80211_sta_find_ibss(struct net_device *dev,
@@ -108,15 +108,11 @@ struct ieee802_11_elems {
u8 wmm_param_len;
};
-typedef enum { ParseOK = 0, ParseUnknown = 1, ParseFailed = -1 } ParseRes;
-
-
-static ParseRes ieee802_11_parse_elems(u8 *start, size_t len,
- struct ieee802_11_elems *elems)
+static void ieee802_11_parse_elems(u8 *start, size_t len,
+ struct ieee802_11_elems *elems)
{
size_t left = len;
u8 *pos = start;
- int unknown = 0;
memset(elems, 0, sizeof(*elems));
@@ -127,15 +123,8 @@ static ParseRes ieee802_11_parse_elems(u8 *start, size_t len,
elen = *pos++;
left -= 2;
- if (elen > left) {
-#if 0
- if (net_ratelimit())
- printk(KERN_DEBUG "IEEE 802.11 element parse "
- "failed (id=%d elen=%d left=%d)\n",
- id, elen, left);
-#endif
- return ParseFailed;
- }
+ if (elen > left)
+ return;
switch (id) {
case WLAN_EID_SSID:
@@ -202,28 +191,15 @@ static ParseRes ieee802_11_parse_elems(u8 *start, size_t len,
elems->ext_supp_rates_len = elen;
break;
default:
-#if 0
- printk(KERN_DEBUG "IEEE 802.11 element parse ignored "
- "unknown element (id=%d elen=%d)\n",
- id, elen);
-#endif
- unknown++;
break;
}
left -= elen;
pos += elen;
}
-
- /* Do not trigger error if left == 1 as Apple Airport base stations
- * send AssocResps that are one spurious byte too long. */
-
- return unknown ? ParseUnknown : ParseOK;
}
-
-
static int ecw2cw(int ecw)
{
int cw = 1;
@@ -387,6 +363,7 @@ static void ieee80211_set_associated(struct net_device *dev,
struct ieee80211_if_sta *ifsta, int assoc)
{
union iwreq_data wrqu;
+ struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
if (ifsta->associated == assoc)
@@ -401,7 +378,9 @@ static void ieee80211_set_associated(struct net_device *dev,
if (sdata->type != IEEE80211_IF_TYPE_STA)
return;
- bss = ieee80211_rx_bss_get(dev, ifsta->bssid);
+ bss = ieee80211_rx_bss_get(dev, ifsta->bssid,
+ local->hw.conf.channel,
+ ifsta->ssid, ifsta->ssid_len);
if (bss) {
if (bss->has_erp_value)
ieee80211_handle_erp_ie(dev, bss->erp_value);
@@ -543,7 +522,8 @@ static void ieee80211_send_assoc(struct net_device *dev,
capab |= WLAN_CAPABILITY_SHORT_SLOT_TIME |
WLAN_CAPABILITY_SHORT_PREAMBLE;
}
- bss = ieee80211_rx_bss_get(dev, ifsta->bssid);
+ bss = ieee80211_rx_bss_get(dev, ifsta->bssid, local->hw.conf.channel,
+ ifsta->ssid, ifsta->ssid_len);
if (bss) {
if (bss->capability & WLAN_CAPABILITY_PRIVACY)
capab |= WLAN_CAPABILITY_PRIVACY;
@@ -695,6 +675,7 @@ static void ieee80211_send_disassoc(struct net_device *dev,
static int ieee80211_privacy_mismatch(struct net_device *dev,
struct ieee80211_if_sta *ifsta)
{
+ struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
struct ieee80211_sta_bss *bss;
int res = 0;
@@ -702,7 +683,8 @@ static int ieee80211_privacy_mismatch(struct net_device *dev,
ifsta->key_mgmt != IEEE80211_KEY_MGMT_NONE)
return 0;
- bss = ieee80211_rx_bss_get(dev, ifsta->bssid);
+ bss = ieee80211_rx_bss_get(dev, ifsta->bssid, local->hw.conf.channel,
+ ifsta->ssid, ifsta->ssid_len);
if (!bss)
return 0;
@@ -901,12 +883,7 @@ static void ieee80211_auth_challenge(struct net_device *dev,
printk(KERN_DEBUG "%s: replying to auth challenge\n", dev->name);
pos = mgmt->u.auth.variable;
- if (ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems)
- == ParseFailed) {
- printk(KERN_DEBUG "%s: failed to parse Auth(challenge)\n",
- dev->name);
- return;
- }
+ ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);
if (!elems.challenge) {
printk(KERN_DEBUG "%s: no challenge IE in shared key auth "
"frame\n", dev->name);
@@ -1174,15 +1151,11 @@ static void ieee80211_rx_mgmt_assoc_resp(struct net_device *dev,
capab_info = le16_to_cpu(mgmt->u.assoc_resp.capab_info);
status_code = le16_to_cpu(mgmt->u.assoc_resp.status_code);
aid = le16_to_cpu(mgmt->u.assoc_resp.aid);
- if ((aid & (BIT(15) | BIT(14))) != (BIT(15) | BIT(14)))
- printk(KERN_DEBUG "%s: invalid aid value %d; bits 15:14 not "
- "set\n", dev->name, aid);
- aid &= ~(BIT(15) | BIT(14));
printk(KERN_DEBUG "%s: RX %sssocResp from " MAC_FMT " (capab=0x%x "
"status=%d aid=%d)\n",
dev->name, reassoc ? "Rea" : "A", MAC_ARG(mgmt->sa),
- capab_info, status_code, aid);
+ capab_info, status_code, aid & ~(BIT(15) | BIT(14)));
if (status_code != WLAN_STATUS_SUCCESS) {
printk(KERN_DEBUG "%s: AP denied association (code=%d)\n",
@@ -1192,13 +1165,13 @@ static void ieee80211_rx_mgmt_assoc_resp(struct net_device *dev,
return;
}
+ if ((aid & (BIT(15) | BIT(14))) != (BIT(15) | BIT(14)))
+ printk(KERN_DEBUG "%s: invalid aid value %d; bits 15:14 not "
+ "set\n", dev->name, aid);
+ aid &= ~(BIT(15) | BIT(14));
+
pos = mgmt->u.assoc_resp.variable;
- if (ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems)
- == ParseFailed) {
- printk(KERN_DEBUG "%s: failed to parse AssocResp\n",
- dev->name);
- return;
- }
+ ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);
if (!elems.supp_rates) {
printk(KERN_DEBUG "%s: no SuppRates element in AssocResp\n",
@@ -1210,7 +1183,9 @@ static void ieee80211_rx_mgmt_assoc_resp(struct net_device *dev,
* update our stored copy */
if (elems.erp_info && elems.erp_info_len >= 1) {
struct ieee80211_sta_bss *bss
- = ieee80211_rx_bss_get(dev, ifsta->bssid);
+ = ieee80211_rx_bss_get(dev, ifsta->bssid,
+ local->hw.conf.channel,
+ ifsta->ssid, ifsta->ssid_len);
if (bss) {
bss->erp_value = elems.erp_info[0];
bss->has_erp_value = 1;
@@ -1240,7 +1215,9 @@ static void ieee80211_rx_mgmt_assoc_resp(struct net_device *dev,
" AP\n", dev->name);
return;
}
- bss = ieee80211_rx_bss_get(dev, ifsta->bssid);
+ bss = ieee80211_rx_bss_get(dev, ifsta->bssid,
+ local->hw.conf.channel,
+ ifsta->ssid, ifsta->ssid_len);
if (bss) {
sta->last_rssi = bss->rssi;
sta->last_signal = bss->signal;
@@ -1321,7 +1298,8 @@ static void __ieee80211_rx_bss_hash_del(struct net_device *dev,
static struct ieee80211_sta_bss *
-ieee80211_rx_bss_add(struct net_device *dev, u8 *bssid)
+ieee80211_rx_bss_add(struct net_device *dev, u8 *bssid, int channel,
+ u8 *ssid, u8 ssid_len)
{
struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
struct ieee80211_sta_bss *bss;
@@ -1332,6 +1310,11 @@ ieee80211_rx_bss_add(struct net_device *dev, u8 *bssid)
atomic_inc(&bss->users);
atomic_inc(&bss->users);
memcpy(bss->bssid, bssid, ETH_ALEN);
+ bss->channel = channel;
+ if (ssid && ssid_len <= IEEE80211_MAX_SSID_LEN) {
+ memcpy(bss->ssid, ssid, ssid_len);
+ bss->ssid_len = ssid_len;
+ }
spin_lock_bh(&local->sta_bss_lock);
/* TODO: order by RSSI? */
@@ -1343,7 +1326,8 @@ ieee80211_rx_bss_add(struct net_device *dev, u8 *bssid)
static struct ieee80211_sta_bss *
-ieee80211_rx_bss_get(struct net_device *dev, u8 *bssid)
+ieee80211_rx_bss_get(struct net_device *dev, u8 *bssid, int channel,
+ u8 *ssid, u8 ssid_len)
{
struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
struct ieee80211_sta_bss *bss;
@@ -1351,7 +1335,10 @@ ieee80211_rx_bss_get(struct net_device *dev, u8 *bssid)
spin_lock_bh(&local->sta_bss_lock);
bss = local->sta_bss_hash[STA_HASH(bssid)];
while (bss) {
- if (memcmp(bss->bssid, bssid, ETH_ALEN) == 0) {
+ if (!memcmp(bss->bssid, bssid, ETH_ALEN) &&
+ bss->channel == channel &&
+ bss->ssid_len == ssid_len &&
+ (ssid_len == 0 || !memcmp(bss->ssid, ssid, ssid_len))) {
atomic_inc(&bss->users);
break;
}
@@ -1413,7 +1400,7 @@ static void ieee80211_rx_bss_info(struct net_device *dev,
struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
struct ieee802_11_elems elems;
size_t baselen;
- int channel, invalid = 0, clen;
+ int channel, clen;
struct ieee80211_sta_bss *bss;
struct sta_info *sta;
struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
@@ -1457,9 +1444,7 @@ static void ieee80211_rx_bss_info(struct net_device *dev,
#endif /* CONFIG_MAC80211_IBSS_DEBUG */
}
- if (ieee802_11_parse_elems(mgmt->u.beacon.variable, len - baselen,
- &elems) == ParseFailed)
- invalid = 1;
+ ieee802_11_parse_elems(mgmt->u.beacon.variable, len - baselen, &elems);
if (sdata->type == IEEE80211_IF_TYPE_IBSS && elems.supp_rates &&
memcmp(mgmt->bssid, sdata->u.sta.bssid, ETH_ALEN) == 0 &&
@@ -1519,9 +1504,11 @@ static void ieee80211_rx_bss_info(struct net_device *dev,
else
channel = rx_status->channel;
- bss = ieee80211_rx_bss_get(dev, mgmt->bssid);
+ bss = ieee80211_rx_bss_get(dev, mgmt->bssid, channel,
+ elems.ssid, elems.ssid_len);
if (!bss) {
- bss = ieee80211_rx_bss_add(dev, mgmt->bssid);
+ bss = ieee80211_rx_bss_add(dev, mgmt->bssid, channel,
+ elems.ssid, elems.ssid_len);
if (!bss)
return;
} else {
@@ -1547,10 +1534,6 @@ static void ieee80211_rx_bss_info(struct net_device *dev,
bss->beacon_int = le16_to_cpu(mgmt->u.beacon.beacon_int);
bss->capability = le16_to_cpu(mgmt->u.beacon.capab_info);
- if (elems.ssid && elems.ssid_len <= IEEE80211_MAX_SSID_LEN) {
- memcpy(bss->ssid, elems.ssid, elems.ssid_len);
- bss->ssid_len = elems.ssid_len;
- }
bss->supp_rates_len = 0;
if (elems.supp_rates) {
@@ -1621,7 +1604,6 @@ static void ieee80211_rx_bss_info(struct net_device *dev,
bss->hw_mode = rx_status->phymode;
- bss->channel = channel;
bss->freq = rx_status->freq;
if (channel != rx_status->channel &&
(bss->hw_mode == MODE_IEEE80211G ||
@@ -1681,9 +1663,7 @@ static void ieee80211_rx_mgmt_beacon(struct net_device *dev,
if (baselen > len)
return;
- if (ieee802_11_parse_elems(mgmt->u.beacon.variable, len - baselen,
- &elems) == ParseFailed)
- return;
+ ieee802_11_parse_elems(mgmt->u.beacon.variable, len - baselen, &elems);
if (elems.erp_info && elems.erp_info_len >= 1)
ieee80211_handle_erp_ie(dev, elems.erp_info[0]);
@@ -2332,7 +2312,7 @@ static int ieee80211_sta_create_ibss(struct net_device *dev,
{
struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
struct ieee80211_sta_bss *bss;
- struct ieee80211_sub_if_data *sdata;
+ struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
struct ieee80211_hw_mode *mode;
u8 bssid[ETH_ALEN], *pos;
int i;
@@ -2354,18 +2334,17 @@ static int ieee80211_sta_create_ibss(struct net_device *dev,
printk(KERN_DEBUG "%s: Creating new IBSS network, BSSID " MAC_FMT "\n",
dev->name, MAC_ARG(bssid));
- bss = ieee80211_rx_bss_add(dev, bssid);
+ bss = ieee80211_rx_bss_add(dev, bssid, local->hw.conf.channel,
+ sdata->u.sta.ssid, sdata->u.sta.ssid_len);
if (!bss)
return -ENOMEM;
- sdata = IEEE80211_DEV_TO_SUB_IF(dev);
mode = local->oper_hw_mode;
if (local->hw.conf.beacon_int == 0)
local->hw.conf.beacon_int = 100;
bss->beacon_int = local->hw.conf.beacon_int;
bss->hw_mode = local->hw.conf.phymode;
- bss->channel = local->hw.conf.channel;
bss->freq = local->hw.conf.freq;
bss->last_update = jiffies;
bss->capability = WLAN_CAPABILITY_IBSS;
@@ -2425,7 +2404,8 @@ static int ieee80211_sta_find_ibss(struct net_device *dev,
MAC_FMT "\n", MAC_ARG(bssid), MAC_ARG(ifsta->bssid));
#endif /* CONFIG_MAC80211_IBSS_DEBUG */
if (found && memcmp(ifsta->bssid, bssid, ETH_ALEN) != 0 &&
- (bss = ieee80211_rx_bss_get(dev, bssid))) {
+ (bss = ieee80211_rx_bss_get(dev, bssid, local->hw.conf.channel,
+ ifsta->ssid, ifsta->ssid_len))) {
printk(KERN_DEBUG "%s: Selected IBSS BSSID " MAC_FMT
" based on configured SSID\n",
dev->name, MAC_ARG(bssid));
diff --git a/net/netfilter/nf_conntrack_proto_tcp.c b/net/netfilter/nf_conntrack_proto_tcp.c
index eb3fe74..70c5b7d 100644
--- a/net/netfilter/nf_conntrack_proto_tcp.c
+++ b/net/netfilter/nf_conntrack_proto_tcp.c
@@ -831,6 +831,22 @@ static int tcp_packet(struct nf_conn *conntrack,
tuple = &conntrack->tuplehash[dir].tuple;
switch (new_state) {
+ case TCP_CONNTRACK_SYN_SENT:
+ if (old_state < TCP_CONNTRACK_TIME_WAIT)
+ break;
+ if ((conntrack->proto.tcp.seen[!dir].flags &
+ IP_CT_TCP_FLAG_CLOSE_INIT)
+ || (conntrack->proto.tcp.last_dir == dir
+ && conntrack->proto.tcp.last_index == TCP_RST_SET)) {
+ /* Attempt to reopen a closed/aborted connection.
+ * Delete this connection and look up again. */
+ write_unlock_bh(&tcp_lock);
+ if (del_timer(&conntrack->timeout))
+ conntrack->timeout.function((unsigned long)
+ conntrack);
+ return -NF_REPEAT;
+ }
+ /* Fall through */
case TCP_CONNTRACK_IGNORE:
/* Ignored packets:
*
@@ -879,27 +895,6 @@ static int tcp_packet(struct nf_conn *conntrack,
nf_log_packet(pf, 0, skb, NULL, NULL, NULL,
"nf_ct_tcp: invalid state ");
return -NF_ACCEPT;
- case TCP_CONNTRACK_SYN_SENT:
- if (old_state < TCP_CONNTRACK_TIME_WAIT)
- break;
- if ((conntrack->proto.tcp.seen[dir].flags &
- IP_CT_TCP_FLAG_CLOSE_INIT)
- || after(ntohl(th->seq),
- conntrack->proto.tcp.seen[dir].td_end)) {
- /* Attempt to reopen a closed connection.
- * Delete this connection and look up again. */
- write_unlock_bh(&tcp_lock);
- if (del_timer(&conntrack->timeout))
- conntrack->timeout.function((unsigned long)
- conntrack);
- return -NF_REPEAT;
- } else {
- write_unlock_bh(&tcp_lock);
- if (LOG_INVALID(IPPROTO_TCP))
- nf_log_packet(pf, 0, skb, NULL, NULL,
- NULL, "nf_ct_tcp: invalid SYN");
- return -NF_ACCEPT;
- }
case TCP_CONNTRACK_CLOSE:
if (index == TCP_RST_SET
&& ((test_bit(IPS_SEEN_REPLY_BIT, &conntrack->status)
@@ -932,6 +927,7 @@ static int tcp_packet(struct nf_conn *conntrack,
in_window:
/* From now on we have got in-window packets */
conntrack->proto.tcp.last_index = index;
+ conntrack->proto.tcp.last_dir = dir;
pr_debug("tcp_conntracks: ");
NF_CT_DUMP_TUPLE(tuple);
diff --git a/net/netlink/af_netlink.c b/net/netlink/af_netlink.c
index 5681ce3..1a0fcc5 100644
--- a/net/netlink/af_netlink.c
+++ b/net/netlink/af_netlink.c
@@ -744,7 +744,7 @@ struct sock *netlink_getsockbyfilp(struct file *filp)
* 1: repeat lookup - reference dropped while waiting for socket memory.
*/
int netlink_attachskb(struct sock *sk, struct sk_buff *skb, int nonblock,
- long timeo, struct sock *ssk)
+ long *timeo, struct sock *ssk)
{
struct netlink_sock *nlk;
@@ -753,7 +753,7 @@ int netlink_attachskb(struct sock *sk, struct sk_buff *skb, int nonblock,
if (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf ||
test_bit(0, &nlk->state)) {
DECLARE_WAITQUEUE(wait, current);
- if (!timeo) {
+ if (!*timeo) {
if (!ssk || nlk_sk(ssk)->pid == 0)
netlink_overrun(sk);
sock_put(sk);
@@ -767,7 +767,7 @@ int netlink_attachskb(struct sock *sk, struct sk_buff *skb, int nonblock,
if ((atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf ||
test_bit(0, &nlk->state)) &&
!sock_flag(sk, SOCK_DEAD))
- timeo = schedule_timeout(timeo);
+ *timeo = schedule_timeout(*timeo);
__set_current_state(TASK_RUNNING);
remove_wait_queue(&nlk->wait, &wait);
@@ -775,7 +775,7 @@ int netlink_attachskb(struct sock *sk, struct sk_buff *skb, int nonblock,
if (signal_pending(current)) {
kfree_skb(skb);
- return sock_intr_errno(timeo);
+ return sock_intr_errno(*timeo);
}
return 1;
}
@@ -839,7 +839,7 @@ retry:
kfree_skb(skb);
return PTR_ERR(sk);
}
- err = netlink_attachskb(sk, skb, nonblock, timeo, ssk);
+ err = netlink_attachskb(sk, skb, nonblock, &timeo, ssk);
if (err == 1)
goto retry;
if (err)
diff --git a/net/sched/cls_u32.c b/net/sched/cls_u32.c
index d4d5d2f..fceb75b 100644
--- a/net/sched/cls_u32.c
+++ b/net/sched/cls_u32.c
@@ -91,7 +91,7 @@ static struct tc_u_common *u32_list;
static __inline__ unsigned u32_hash_fold(u32 key, struct tc_u32_sel *sel, u8 fshift)
{
- unsigned h = (key & sel->hmask)>>fshift;
+ unsigned h = ntohl(key & sel->hmask)>>fshift;
return h;
}
@@ -615,7 +615,7 @@ static int u32_change(struct tcf_proto *tp, unsigned long base, u32 handle,
n->handle = handle;
{
u8 i = 0;
- u32 mask = s->hmask;
+ u32 mask = ntohl(s->hmask);
if (mask) {
while (!(mask & 1)) {
i++;
diff --git a/net/sched/sch_api.c b/net/sched/sch_api.c
index dee0d5f..8f1bcf6 100644
--- a/net/sched/sch_api.c
+++ b/net/sched/sch_api.c
@@ -1225,10 +1225,13 @@ EXPORT_SYMBOL(tcf_destroy_chain);
#ifdef CONFIG_PROC_FS
static int psched_show(struct seq_file *seq, void *v)
{
+ struct timespec ts;
+
+ hrtimer_get_res(CLOCK_MONOTONIC, &ts);
seq_printf(seq, "%08x %08x %08x %08x\n",
(u32)NSEC_PER_USEC, (u32)PSCHED_US2NS(1),
1000000,
- (u32)NSEC_PER_SEC/(u32)ktime_to_ns(KTIME_MONOTONIC_RES));
+ (u32)NSEC_PER_SEC/(u32)ktime_to_ns(timespec_to_ktime(ts)));
return 0;
}
diff --git a/net/sched/sch_teql.c b/net/sched/sch_teql.c
index 0968184..cb5754b 100644
--- a/net/sched/sch_teql.c
+++ b/net/sched/sch_teql.c
@@ -249,6 +249,9 @@ __teql_resolve(struct sk_buff *skb, struct sk_buff *skb_res, struct net_device *
static __inline__ int
teql_resolve(struct sk_buff *skb, struct sk_buff *skb_res, struct net_device *dev)
{
+ if (dev->qdisc == &noop_qdisc)
+ return -ENODEV;
+
if (dev->hard_header == NULL ||
skb->dst == NULL ||
skb->dst->neighbour == NULL)
diff --git a/net/socket.c b/net/socket.c
index b09eb90..8e5be74 100644
--- a/net/socket.c
+++ b/net/socket.c
@@ -1245,11 +1245,14 @@ asmlinkage long sys_socketpair(int family, int type, int protocol,
goto out_release_both;
fd1 = sock_alloc_fd(&newfile1);
- if (unlikely(fd1 < 0))
+ if (unlikely(fd1 < 0)) {
+ err = fd1;
goto out_release_both;
+ }
fd2 = sock_alloc_fd(&newfile2);
if (unlikely(fd2 < 0)) {
+ err = fd2;
put_filp(newfile1);
put_unused_fd(fd1);
goto out_release_both;
@@ -2230,6 +2233,7 @@ int kernel_accept(struct socket *sock, struct socket **newsock, int flags)
err = sock->ops->accept(sock, *newsock, flags);
if (err < 0) {
sock_release(*newsock);
+ *newsock = NULL;
goto done;
}

951
debian/patches/bugfix/all/stable/2.6.23.5.patch vendored Normal file
View File

@ -0,0 +1,951 @@
diff --git a/Makefile b/Makefile
index 0c34409..e11814e 100644
diff --git a/drivers/net/ehea/ehea_qmr.c b/drivers/net/ehea/ehea_qmr.c
index c82e245..329a252 100644
--- a/drivers/net/ehea/ehea_qmr.c
+++ b/drivers/net/ehea/ehea_qmr.c
@@ -563,8 +563,7 @@ int ehea_destroy_qp(struct ehea_qp *qp)
int ehea_create_busmap( void )
{
u64 vaddr = EHEA_BUSMAP_START;
- unsigned long abs_max_pfn = 0;
- unsigned long sec_max_pfn;
+ unsigned long high_section_index = 0;
int i;
/*
@@ -574,14 +573,10 @@ int ehea_create_busmap( void )
ehea_bmap.valid_sections = 0;
for (i = 0; i < NR_MEM_SECTIONS; i++)
- if (valid_section_nr(i)) {
- sec_max_pfn = section_nr_to_pfn(i);
- if (sec_max_pfn > abs_max_pfn)
- abs_max_pfn = sec_max_pfn;
- ehea_bmap.valid_sections++;
- }
+ if (valid_section_nr(i))
+ high_section_index = i;
- ehea_bmap.entries = abs_max_pfn / EHEA_PAGES_PER_SECTION + 1;
+ ehea_bmap.entries = high_section_index + 1;
ehea_bmap.vaddr = vmalloc(ehea_bmap.entries * sizeof(*ehea_bmap.vaddr));
if (!ehea_bmap.vaddr)
@@ -593,6 +588,7 @@ int ehea_create_busmap( void )
if (pfn_valid(pfn)) {
ehea_bmap.vaddr[i] = vaddr;
vaddr += EHEA_SECTSIZE;
+ ehea_bmap.valid_sections++;
} else
ehea_bmap.vaddr[i] = 0;
}
@@ -637,7 +633,7 @@ int ehea_reg_kernel_mr(struct ehea_adapter *adapter, struct ehea_mr *mr)
mr_len = ehea_bmap.valid_sections * EHEA_SECTSIZE;
- pt = kzalloc(EHEA_MAX_RPAGE * sizeof(u64), GFP_KERNEL);
+ pt = kzalloc(PAGE_SIZE, GFP_KERNEL);
if (!pt) {
ehea_error("no mem");
ret = -ENOMEM;
@@ -660,8 +656,8 @@ int ehea_reg_kernel_mr(struct ehea_adapter *adapter, struct ehea_mr *mr)
void *sectbase = __va(i << SECTION_SIZE_BITS);
unsigned long k = 0;
- for (j = 0; j < (PAGES_PER_SECTION / EHEA_MAX_RPAGE);
- j++) {
+ for (j = 0; j < (EHEA_PAGES_PER_SECTION /
+ EHEA_MAX_RPAGE); j++) {
for (m = 0; m < EHEA_MAX_RPAGE; m++) {
pg = sectbase + ((k++) * EHEA_PAGESIZE);
diff --git a/drivers/net/ehea/ehea_qmr.h b/drivers/net/ehea/ehea_qmr.h
index b71f845..352cb38 100644
--- a/drivers/net/ehea/ehea_qmr.h
+++ b/drivers/net/ehea/ehea_qmr.h
@@ -39,7 +39,7 @@
#define EHEA_PAGESHIFT 12
#define EHEA_PAGESIZE (1UL << EHEA_PAGESHIFT)
#define EHEA_SECTSIZE (1UL << 24)
-#define EHEA_PAGES_PER_SECTION (EHEA_SECTSIZE >> PAGE_SHIFT)
+#define EHEA_PAGES_PER_SECTION (EHEA_SECTSIZE >> EHEA_PAGESHIFT)
#if (1UL << SECTION_SIZE_BITS) < EHEA_SECTSIZE
#error eHEA module can't work if kernel sectionsize < ehea sectionsize
diff --git a/drivers/net/forcedeth.c b/drivers/net/forcedeth.c
index 1938d6d..d68796e 100644
--- a/drivers/net/forcedeth.c
+++ b/drivers/net/forcedeth.c
@@ -988,7 +988,7 @@ static void nv_enable_irq(struct net_device *dev)
if (np->msi_flags & NV_MSI_X_ENABLED)
enable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_ALL].vector);
else
- enable_irq(dev->irq);
+ enable_irq(np->pci_dev->irq);
} else {
enable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_RX].vector);
enable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_TX].vector);
@@ -1004,7 +1004,7 @@ static void nv_disable_irq(struct net_device *dev)
if (np->msi_flags & NV_MSI_X_ENABLED)
disable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_ALL].vector);
else
- disable_irq(dev->irq);
+ disable_irq(np->pci_dev->irq);
} else {
disable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_RX].vector);
disable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_TX].vector);
@@ -1601,7 +1601,7 @@ static void nv_do_rx_refill(unsigned long data)
if (np->msi_flags & NV_MSI_X_ENABLED)
disable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_ALL].vector);
else
- disable_irq(dev->irq);
+ disable_irq(np->pci_dev->irq);
} else {
disable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_RX].vector);
}
@@ -1619,7 +1619,7 @@ static void nv_do_rx_refill(unsigned long data)
if (np->msi_flags & NV_MSI_X_ENABLED)
enable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_ALL].vector);
else
- enable_irq(dev->irq);
+ enable_irq(np->pci_dev->irq);
} else {
enable_irq(np->msi_x_entry[NV_MSI_X_VECTOR_RX].vector);
}
@@ -3557,10 +3557,12 @@ static int nv_request_irq(struct net_device *dev, int intr_test)
if (ret != 0 && np->msi_flags & NV_MSI_CAPABLE) {
if ((ret = pci_enable_msi(np->pci_dev)) == 0) {
np->msi_flags |= NV_MSI_ENABLED;
+ dev->irq = np->pci_dev->irq;
if (request_irq(np->pci_dev->irq, handler, IRQF_SHARED, dev->name, dev) != 0) {
printk(KERN_INFO "forcedeth: request_irq failed %d\n", ret);
pci_disable_msi(np->pci_dev);
np->msi_flags &= ~NV_MSI_ENABLED;
+ dev->irq = np->pci_dev->irq;
goto out_err;
}
@@ -3623,7 +3625,7 @@ static void nv_do_nic_poll(unsigned long data)
if (np->msi_flags & NV_MSI_X_ENABLED)
disable_irq_lockdep(np->msi_x_entry[NV_MSI_X_VECTOR_ALL].vector);
else
- disable_irq_lockdep(dev->irq);
+ disable_irq_lockdep(np->pci_dev->irq);
mask = np->irqmask;
} else {
if (np->nic_poll_irq & NVREG_IRQ_RX_ALL) {
@@ -3641,6 +3643,8 @@ static void nv_do_nic_poll(unsigned long data)
}
np->nic_poll_irq = 0;
+ /* disable_irq() contains synchronize_irq, thus no irq handler can run now */
+
if (np->recover_error) {
np->recover_error = 0;
printk(KERN_INFO "forcedeth: MAC in recoverable error state\n");
@@ -3677,7 +3681,6 @@ static void nv_do_nic_poll(unsigned long data)
}
}
- /* FIXME: Do we need synchronize_irq(dev->irq) here? */
writel(mask, base + NvRegIrqMask);
pci_push(base);
@@ -3690,7 +3693,7 @@ static void nv_do_nic_poll(unsigned long data)
if (np->msi_flags & NV_MSI_X_ENABLED)
enable_irq_lockdep(np->msi_x_entry[NV_MSI_X_VECTOR_ALL].vector);
else
- enable_irq_lockdep(dev->irq);
+ enable_irq_lockdep(np->pci_dev->irq);
} else {
if (np->nic_poll_irq & NVREG_IRQ_RX_ALL) {
nv_nic_irq_rx(0, dev);
@@ -4943,7 +4946,7 @@ static int nv_close(struct net_device *dev)
np->in_shutdown = 1;
spin_unlock_irq(&np->lock);
netif_poll_disable(dev);
- synchronize_irq(dev->irq);
+ synchronize_irq(np->pci_dev->irq);
del_timer_sync(&np->oom_kick);
del_timer_sync(&np->nic_poll);
@@ -5563,6 +5566,22 @@ static struct pci_device_id pci_tbl[] = {
PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_31),
.driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_HIGH_DMA|DEV_HAS_POWER_CNTRL|DEV_HAS_MSI|DEV_HAS_PAUSEFRAME_TX|DEV_HAS_STATISTICS_V2|DEV_HAS_TEST_EXTENDED|DEV_HAS_MGMT_UNIT|DEV_HAS_CORRECT_MACADDR,
},
+ { /* MCP77 Ethernet Controller */
+ PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_32),
+ .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA|DEV_HAS_MSI|DEV_HAS_POWER_CNTRL|DEV_HAS_PAUSEFRAME_TX|DEV_HAS_STATISTICS_V2|DEV_HAS_TEST_EXTENDED|DEV_HAS_MGMT_UNIT,
+ },
+ { /* MCP77 Ethernet Controller */
+ PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_33),
+ .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA|DEV_HAS_MSI|DEV_HAS_POWER_CNTRL|DEV_HAS_PAUSEFRAME_TX|DEV_HAS_STATISTICS_V2|DEV_HAS_TEST_EXTENDED|DEV_HAS_MGMT_UNIT,
+ },
+ { /* MCP77 Ethernet Controller */
+ PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_34),
+ .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA|DEV_HAS_MSI|DEV_HAS_POWER_CNTRL|DEV_HAS_PAUSEFRAME_TX|DEV_HAS_STATISTICS_V2|DEV_HAS_TEST_EXTENDED|DEV_HAS_MGMT_UNIT,
+ },
+ { /* MCP77 Ethernet Controller */
+ PCI_DEVICE(PCI_VENDOR_ID_NVIDIA, PCI_DEVICE_ID_NVIDIA_NVENET_35),
+ .driver_data = DEV_NEED_TIMERIRQ|DEV_NEED_LINKTIMER|DEV_HAS_CHECKSUM|DEV_HAS_HIGH_DMA|DEV_HAS_MSI|DEV_HAS_POWER_CNTRL|DEV_HAS_PAUSEFRAME_TX|DEV_HAS_STATISTICS_V2|DEV_HAS_TEST_EXTENDED|DEV_HAS_MGMT_UNIT,
+ },
{0,},
};
diff --git a/drivers/net/pppol2tp.c b/drivers/net/pppol2tp.c
index abe91cb..7da0d07 100644
--- a/drivers/net/pppol2tp.c
+++ b/drivers/net/pppol2tp.c
@@ -487,7 +487,7 @@ static int pppol2tp_recv_core(struct sock *sock, struct sk_buff *skb)
{
struct pppol2tp_session *session = NULL;
struct pppol2tp_tunnel *tunnel;
- unsigned char *ptr;
+ unsigned char *ptr, *optr;
u16 hdrflags;
u16 tunnel_id, session_id;
int length;
@@ -495,7 +495,7 @@ static int pppol2tp_recv_core(struct sock *sock, struct sk_buff *skb)
tunnel = pppol2tp_sock_to_tunnel(sock);
if (tunnel == NULL)
- goto error;
+ goto no_tunnel;
/* UDP always verifies the packet length. */
__skb_pull(skb, sizeof(struct udphdr));
@@ -508,7 +508,7 @@ static int pppol2tp_recv_core(struct sock *sock, struct sk_buff *skb)
}
/* Point to L2TP header */
- ptr = skb->data;
+ optr = ptr = skb->data;
/* Get L2TP header flags */
hdrflags = ntohs(*(__be16*)ptr);
@@ -636,12 +636,14 @@ static int pppol2tp_recv_core(struct sock *sock, struct sk_buff *skb)
/* If offset bit set, skip it. */
if (hdrflags & L2TP_HDRFLAG_O) {
offset = ntohs(*(__be16 *)ptr);
- skb->transport_header += 2 + offset;
- if (!pskb_may_pull(skb, skb_transport_offset(skb) + 2))
- goto discard;
+ ptr += 2 + offset;
}
- __skb_pull(skb, skb_transport_offset(skb));
+ offset = ptr - optr;
+ if (!pskb_may_pull(skb, offset))
+ goto discard;
+
+ __skb_pull(skb, offset);
/* Skip PPP header, if present. In testing, Microsoft L2TP clients
* don't send the PPP header (PPP header compression enabled), but
@@ -651,6 +653,9 @@ static int pppol2tp_recv_core(struct sock *sock, struct sk_buff *skb)
* Note that skb->data[] isn't dereferenced from a u16 ptr here since
* the field may be unaligned.
*/
+ if (!pskb_may_pull(skb, 2))
+ goto discard;
+
if ((skb->data[0] == 0xff) && (skb->data[1] == 0x03))
skb_pull(skb, 2);
@@ -708,6 +713,10 @@ discard:
return 0;
error:
+ /* Put UDP header back */
+ __skb_push(skb, sizeof(struct udphdr));
+
+no_tunnel:
return 1;
}
@@ -1049,6 +1058,8 @@ static int pppol2tp_xmit(struct ppp_channel *chan, struct sk_buff *skb)
/* Get routing info from the tunnel socket */
dst_release(skb->dst);
skb->dst = sk_dst_get(sk_tun);
+ skb_orphan(skb);
+ skb->sk = sk_tun;
/* Queue the packet to IP for output */
len = skb->len;
diff --git a/drivers/net/skge.c b/drivers/net/skge.c
index e3d8520..b3d4728 100644
--- a/drivers/net/skge.c
+++ b/drivers/net/skge.c
@@ -57,7 +57,7 @@
#define TX_WATCHDOG (5 * HZ)
#define NAPI_WEIGHT 64
#define BLINK_MS 250
-#define LINK_HZ (HZ/2)
+#define LINK_HZ HZ
MODULE_DESCRIPTION("SysKonnect Gigabit Ethernet driver");
MODULE_AUTHOR("Stephen Hemminger <shemminger@linux-foundation.org>");
@@ -992,19 +992,15 @@ static void xm_link_down(struct skge_hw *hw, int port)
{
struct net_device *dev = hw->dev[port];
struct skge_port *skge = netdev_priv(dev);
- u16 cmd, msk;
+ u16 cmd = xm_read16(hw, port, XM_MMU_CMD);
- if (hw->phy_type == SK_PHY_XMAC) {
- msk = xm_read16(hw, port, XM_IMSK);
- msk |= XM_IS_INP_ASS | XM_IS_LIPA_RC | XM_IS_RX_PAGE | XM_IS_AND;
- xm_write16(hw, port, XM_IMSK, msk);
- }
+ xm_write16(hw, port, XM_IMSK, XM_IMSK_DISABLE);
- cmd = xm_read16(hw, port, XM_MMU_CMD);
cmd &= ~(XM_MMU_ENA_RX | XM_MMU_ENA_TX);
xm_write16(hw, port, XM_MMU_CMD, cmd);
+
/* dummy read to ensure writing */
- (void) xm_read16(hw, port, XM_MMU_CMD);
+ xm_read16(hw, port, XM_MMU_CMD);
if (netif_carrier_ok(dev))
skge_link_down(skge);
@@ -1100,7 +1096,7 @@ static void genesis_reset(struct skge_hw *hw, int port)
/* reset the statistics module */
xm_write32(hw, port, XM_GP_PORT, XM_GP_RES_STAT);
- xm_write16(hw, port, XM_IMSK, 0xffff); /* disable XMAC IRQs */
+ xm_write16(hw, port, XM_IMSK, XM_IMSK_DISABLE);
xm_write32(hw, port, XM_MODE, 0); /* clear Mode Reg */
xm_write16(hw, port, XM_TX_CMD, 0); /* reset TX CMD Reg */
xm_write16(hw, port, XM_RX_CMD, 0); /* reset RX CMD Reg */
@@ -1138,7 +1134,7 @@ static void bcom_check_link(struct skge_hw *hw, int port)
u16 status;
/* read twice because of latch */
- (void) xm_phy_read(hw, port, PHY_BCOM_STAT);
+ xm_phy_read(hw, port, PHY_BCOM_STAT);
status = xm_phy_read(hw, port, PHY_BCOM_STAT);
if ((status & PHY_ST_LSYNC) == 0) {
@@ -1339,7 +1335,7 @@ static void xm_phy_init(struct skge_port *skge)
mod_timer(&skge->link_timer, jiffies + LINK_HZ);
}
-static void xm_check_link(struct net_device *dev)
+static int xm_check_link(struct net_device *dev)
{
struct skge_port *skge = netdev_priv(dev);
struct skge_hw *hw = skge->hw;
@@ -1347,25 +1343,25 @@ static void xm_check_link(struct net_device *dev)
u16 status;
/* read twice because of latch */
- (void) xm_phy_read(hw, port, PHY_XMAC_STAT);
+ xm_phy_read(hw, port, PHY_XMAC_STAT);
status = xm_phy_read(hw, port, PHY_XMAC_STAT);
if ((status & PHY_ST_LSYNC) == 0) {
xm_link_down(hw, port);
- return;
+ return 0;
}
if (skge->autoneg == AUTONEG_ENABLE) {
u16 lpa, res;
if (!(status & PHY_ST_AN_OVER))
- return;
+ return 0;
lpa = xm_phy_read(hw, port, PHY_XMAC_AUNE_LP);
if (lpa & PHY_B_AN_RF) {
printk(KERN_NOTICE PFX "%s: remote fault\n",
dev->name);
- return;
+ return 0;
}
res = xm_phy_read(hw, port, PHY_XMAC_RES_ABI);
@@ -1381,7 +1377,7 @@ static void xm_check_link(struct net_device *dev)
default:
printk(KERN_NOTICE PFX "%s: duplex mismatch\n",
dev->name);
- return;
+ return 0;
}
/* We are using IEEE 802.3z/D5.0 Table 37-4 */
@@ -1405,11 +1401,14 @@ static void xm_check_link(struct net_device *dev)
if (!netif_carrier_ok(dev))
genesis_link_up(skge);
+ return 1;
}
/* Poll to check for link coming up.
+ *
* Since internal PHY is wired to a level triggered pin, can't
- * get an interrupt when carrier is detected.
+ * get an interrupt when carrier is detected, need to poll for
+ * link coming up.
*/
static void xm_link_timer(unsigned long arg)
{
@@ -1417,29 +1416,35 @@ static void xm_link_timer(unsigned long arg)
struct net_device *dev = skge->netdev;
struct skge_hw *hw = skge->hw;
int port = skge->port;
+ int i;
+ unsigned long flags;
if (!netif_running(dev))
return;
- if (netif_carrier_ok(dev)) {
+ spin_lock_irqsave(&hw->phy_lock, flags);
+
+ /*
+ * Verify that the link by checking GPIO register three times.
+ * This pin has the signal from the link_sync pin connected to it.
+ */
+ for (i = 0; i < 3; i++) {
+ if (xm_read16(hw, port, XM_GP_PORT) & XM_GP_INP_ASS)
+ goto link_down;
+ }
+
+ /* Re-enable interrupt to detect link down */
+ if (xm_check_link(dev)) {
+ u16 msk = xm_read16(hw, port, XM_IMSK);
+ msk &= ~XM_IS_INP_ASS;
+ xm_write16(hw, port, XM_IMSK, msk);
xm_read16(hw, port, XM_ISRC);
- if (!(xm_read16(hw, port, XM_ISRC) & XM_IS_INP_ASS))
- goto nochange;
} else {
- if (xm_read32(hw, port, XM_GP_PORT) & XM_GP_INP_ASS)
- goto nochange;
- xm_read16(hw, port, XM_ISRC);
- if (xm_read16(hw, port, XM_ISRC) & XM_IS_INP_ASS)
- goto nochange;
+link_down:
+ mod_timer(&skge->link_timer,
+ round_jiffies(jiffies + LINK_HZ));
}
-
- spin_lock(&hw->phy_lock);
- xm_check_link(dev);
- spin_unlock(&hw->phy_lock);
-
-nochange:
- if (netif_running(dev))
- mod_timer(&skge->link_timer, jiffies + LINK_HZ);
+ spin_unlock_irqrestore(&hw->phy_lock, flags);
}
static void genesis_mac_init(struct skge_hw *hw, int port)
@@ -1683,14 +1688,16 @@ static void genesis_mac_intr(struct skge_hw *hw, int port)
printk(KERN_DEBUG PFX "%s: mac interrupt status 0x%x\n",
skge->netdev->name, status);
- if (hw->phy_type == SK_PHY_XMAC &&
- (status & (XM_IS_INP_ASS | XM_IS_LIPA_RC)))
- xm_link_down(hw, port);
+ if (hw->phy_type == SK_PHY_XMAC && (status & XM_IS_INP_ASS)) {
+ xm_link_down(hw, port);
+ mod_timer(&skge->link_timer, jiffies + 1);
+ }
if (status & XM_IS_TXF_UR) {
xm_write32(hw, port, XM_MODE, XM_MD_FTF);
++skge->net_stats.tx_fifo_errors;
}
+
if (status & XM_IS_RXF_OV) {
xm_write32(hw, port, XM_MODE, XM_MD_FRF);
++skge->net_stats.rx_fifo_errors;
@@ -1750,11 +1757,12 @@ static void genesis_link_up(struct skge_port *skge)
}
xm_write32(hw, port, XM_MODE, mode);
- msk = XM_DEF_MSK;
- if (hw->phy_type != SK_PHY_XMAC)
- msk |= XM_IS_INP_ASS; /* disable GP0 interrupt bit */
+ /* Turn on detection of Tx underrun, Rx overrun */
+ msk = xm_read16(hw, port, XM_IMSK);
+ msk &= ~(XM_IS_RXF_OV | XM_IS_TXF_UR);
xm_write16(hw, port, XM_IMSK, msk);
+
xm_read16(hw, port, XM_ISRC);
/* get MMU Command Reg. */
@@ -2185,7 +2193,7 @@ static void yukon_mac_intr(struct skge_hw *hw, int port)
u8 status = skge_read8(hw, SK_REG(port, GMAC_IRQ_SRC));
if (netif_msg_intr(skge))
- printk(KERN_DEBUG PFX "%s: mac interrupt status 0x%x\n",
+ printk(KERN_DEBUG PFX "%s: yukon mac interrupt status 0x%x\n",
dev->name, status);
if (status & GM_IS_RX_FF_OR) {
diff --git a/drivers/net/skge.h b/drivers/net/skge.h
index edd7146..323d6c6 100644
--- a/drivers/net/skge.h
+++ b/drivers/net/skge.h
@@ -2193,11 +2193,9 @@ enum {
XM_IS_TXF_UR = 1<<2, /* Bit 2: Transmit FIFO Underrun */
XM_IS_TX_COMP = 1<<1, /* Bit 1: Frame Tx Complete */
XM_IS_RX_COMP = 1<<0, /* Bit 0: Frame Rx Complete */
-};
-
-#define XM_DEF_MSK (~(XM_IS_INP_ASS | XM_IS_LIPA_RC | \
- XM_IS_RXF_OV | XM_IS_TXF_UR))
+ XM_IMSK_DISABLE = 0xffff,
+};
/* XM_HW_CFG 16 bit r/w Hardware Config Register */
enum {
diff --git a/drivers/net/sky2.c b/drivers/net/sky2.c
index ea117fc..2575077 100644
--- a/drivers/net/sky2.c
+++ b/drivers/net/sky2.c
@@ -603,21 +603,22 @@ static void sky2_phy_init(struct sky2_hw *hw, unsigned port)
static void sky2_phy_power(struct sky2_hw *hw, unsigned port, int onoff)
{
u32 reg1;
- static const u32 phy_power[]
- = { PCI_Y2_PHY1_POWD, PCI_Y2_PHY2_POWD };
-
- /* looks like this XL is back asswards .. */
- if (hw->chip_id == CHIP_ID_YUKON_XL && hw->chip_rev > 1)
- onoff = !onoff;
+ static const u32 phy_power[] = { PCI_Y2_PHY1_POWD, PCI_Y2_PHY2_POWD };
+ static const u32 coma_mode[] = { PCI_Y2_PHY1_COMA, PCI_Y2_PHY2_COMA };
sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_ON);
reg1 = sky2_pci_read32(hw, PCI_DEV_REG1);
+
if (onoff)
/* Turn off phy power saving */
reg1 &= ~phy_power[port];
else
reg1 |= phy_power[port];
+ if (onoff && hw->chip_id == CHIP_ID_YUKON_XL && hw->chip_rev > 1)
+ reg1 |= coma_mode[port];
+
+
sky2_pci_write32(hw, PCI_DEV_REG1, reg1);
sky2_pci_read32(hw, PCI_DEV_REG1);
sky2_write8(hw, B2_TST_CTRL1, TST_CFG_WRITE_OFF);
@@ -2246,20 +2247,26 @@ static int sky2_status_intr(struct sky2_hw *hw, int to_do)
while (hw->st_idx != hwidx) {
struct sky2_port *sky2;
struct sky2_status_le *le = hw->st_le + hw->st_idx;
- unsigned port = le->css & CSS_LINK_BIT;
+ unsigned port;
struct net_device *dev;
struct sk_buff *skb;
u32 status;
u16 length;
+ u8 opcode = le->opcode;
+
+ if (!(opcode & HW_OWNER))
+ break;
hw->st_idx = RING_NEXT(hw->st_idx, STATUS_RING_SIZE);
+ port = le->css & CSS_LINK_BIT;
dev = hw->dev[port];
sky2 = netdev_priv(dev);
length = le16_to_cpu(le->length);
status = le32_to_cpu(le->status);
- switch (le->opcode & ~HW_OWNER) {
+ le->opcode = 0;
+ switch (opcode & ~HW_OWNER) {
case OP_RXSTAT:
++rx[port];
skb = sky2_receive(dev, length, status);
@@ -2352,7 +2359,7 @@ static int sky2_status_intr(struct sky2_hw *hw, int to_do)
default:
if (net_ratelimit())
printk(KERN_WARNING PFX
- "unknown status opcode 0x%x\n", le->opcode);
+ "unknown status opcode 0x%x\n", opcode);
}
}
@@ -3564,20 +3571,64 @@ static void sky2_get_regs(struct net_device *dev, struct ethtool_regs *regs,
{
const struct sky2_port *sky2 = netdev_priv(dev);
const void __iomem *io = sky2->hw->regs;
+ unsigned int b;
regs->version = 1;
- memset(p, 0, regs->len);
- memcpy_fromio(p, io, B3_RAM_ADDR);
-
- /* skip diagnostic ram region */
- memcpy_fromio(p + B3_RI_WTO_R1, io + B3_RI_WTO_R1, 0x2000 - B3_RI_WTO_R1);
+ for (b = 0; b < 128; b++) {
+ /* This complicated switch statement is to make sure and
+ * only access regions that are unreserved.
+ * Some blocks are only valid on dual port cards.
+ * and block 3 has some special diagnostic registers that
+ * are poison.
+ */
+ switch (b) {
+ case 3:
+ /* skip diagnostic ram region */
+ memcpy_fromio(p + 0x10, io + 0x10, 128 - 0x10);
+ break;
- /* copy GMAC registers */
- memcpy_fromio(p + BASE_GMAC_1, io + BASE_GMAC_1, 0x1000);
- if (sky2->hw->ports > 1)
- memcpy_fromio(p + BASE_GMAC_2, io + BASE_GMAC_2, 0x1000);
+ /* dual port cards only */
+ case 5: /* Tx Arbiter 2 */
+ case 9: /* RX2 */
+ case 14 ... 15: /* TX2 */
+ case 17: case 19: /* Ram Buffer 2 */
+ case 22 ... 23: /* Tx Ram Buffer 2 */
+ case 25: /* Rx MAC Fifo 1 */
+ case 27: /* Tx MAC Fifo 2 */
+ case 31: /* GPHY 2 */
+ case 40 ... 47: /* Pattern Ram 2 */
+ case 52: case 54: /* TCP Segmentation 2 */
+ case 112 ... 116: /* GMAC 2 */
+ if (sky2->hw->ports == 1)
+ goto reserved;
+ /* fall through */
+ case 0: /* Control */
+ case 2: /* Mac address */
+ case 4: /* Tx Arbiter 1 */
+ case 7: /* PCI express reg */
+ case 8: /* RX1 */
+ case 12 ... 13: /* TX1 */
+ case 16: case 18:/* Rx Ram Buffer 1 */
+ case 20 ... 21: /* Tx Ram Buffer 1 */
+ case 24: /* Rx MAC Fifo 1 */
+ case 26: /* Tx MAC Fifo 1 */
+ case 28 ... 29: /* Descriptor and status unit */
+ case 30: /* GPHY 1*/
+ case 32 ... 39: /* Pattern Ram 1 */
+ case 48: case 50: /* TCP Segmentation 1 */
+ case 56 ... 60: /* PCI space */
+ case 80 ... 84: /* GMAC 1 */
+ memcpy_fromio(p, io, 128);
+ break;
+ default:
+reserved:
+ memset(p, 0, 128);
+ }
+ p += 128;
+ io += 128;
+ }
}
/* In order to do Jumbo packets on these chips, need to turn off the
diff --git a/drivers/net/tg3.c b/drivers/net/tg3.c
index 9034a05..f80721e 100644
--- a/drivers/net/tg3.c
+++ b/drivers/net/tg3.c
@@ -64,8 +64,8 @@
#define DRV_MODULE_NAME "tg3"
#define PFX DRV_MODULE_NAME ": "
-#define DRV_MODULE_VERSION "3.81"
-#define DRV_MODULE_RELDATE "September 5, 2007"
+#define DRV_MODULE_VERSION "3.81.1"
+#define DRV_MODULE_RELDATE "October 18, 2007"
#define TG3_DEF_MAC_MODE 0
#define TG3_DEF_RX_MODE 0
@@ -4874,6 +4874,12 @@ static void tg3_restore_pci_state(struct tg3 *tp)
pci_write_config_dword(tp->pdev, TG3PCI_COMMAND, tp->pci_cmd);
+ if (!(tp->tg3_flags2 & TG3_FLG2_PCI_EXPRESS)) {
+ pci_write_config_byte(tp->pdev, PCI_CACHE_LINE_SIZE,
+ tp->pci_cacheline_sz);
+ pci_write_config_byte(tp->pdev, PCI_LATENCY_TIMER,
+ tp->pci_lat_timer);
+ }
/* Make sure PCI-X relaxed ordering bit is clear. */
pci_read_config_dword(tp->pdev, TG3PCI_X_CAPS, &val);
val &= ~PCIX_CAPS_RELAXED_ORDERING;
diff --git a/drivers/net/wireless/ipw2100.c b/drivers/net/wireless/ipw2100.c
index 8990585..e690609 100644
--- a/drivers/net/wireless/ipw2100.c
+++ b/drivers/net/wireless/ipw2100.c
@@ -2102,12 +2102,46 @@ static void isr_indicate_rf_kill(struct ipw2100_priv *priv, u32 status)
queue_delayed_work(priv->workqueue, &priv->rf_kill, round_jiffies(HZ));
}
+static void send_scan_event(void *data)
+{
+ struct ipw2100_priv *priv = data;
+ union iwreq_data wrqu;
+
+ wrqu.data.length = 0;
+ wrqu.data.flags = 0;
+ wireless_send_event(priv->net_dev, SIOCGIWSCAN, &wrqu, NULL);
+}
+
+static void ipw2100_scan_event_later(struct work_struct *work)
+{
+ send_scan_event(container_of(work, struct ipw2100_priv,
+ scan_event_later.work));
+}
+
+static void ipw2100_scan_event_now(struct work_struct *work)
+{
+ send_scan_event(container_of(work, struct ipw2100_priv,
+ scan_event_now));
+}
+
static void isr_scan_complete(struct ipw2100_priv *priv, u32 status)
{
IPW_DEBUG_SCAN("scan complete\n");
/* Age the scan results... */
priv->ieee->scans++;
priv->status &= ~STATUS_SCANNING;
+
+ /* Only userspace-requested scan completion events go out immediately */
+ if (!priv->user_requested_scan) {
+ if (!delayed_work_pending(&priv->scan_event_later))
+ queue_delayed_work(priv->workqueue,
+ &priv->scan_event_later,
+ round_jiffies(msecs_to_jiffies(4000)));
+ } else {
+ priv->user_requested_scan = 0;
+ cancel_delayed_work(&priv->scan_event_later);
+ queue_work(priv->workqueue, &priv->scan_event_now);
+ }
}
#ifdef CONFIG_IPW2100_DEBUG
@@ -4376,6 +4410,7 @@ static void ipw2100_kill_workqueue(struct ipw2100_priv *priv)
cancel_delayed_work(&priv->wx_event_work);
cancel_delayed_work(&priv->hang_check);
cancel_delayed_work(&priv->rf_kill);
+ cancel_delayed_work(&priv->scan_event_later);
destroy_workqueue(priv->workqueue);
priv->workqueue = NULL;
}
@@ -6118,6 +6153,8 @@ static struct net_device *ipw2100_alloc_device(struct pci_dev *pci_dev,
INIT_DELAYED_WORK(&priv->wx_event_work, ipw2100_wx_event_work);
INIT_DELAYED_WORK(&priv->hang_check, ipw2100_hang_check);
INIT_DELAYED_WORK(&priv->rf_kill, ipw2100_rf_kill);
+ INIT_WORK(&priv->scan_event_now, ipw2100_scan_event_now);
+ INIT_DELAYED_WORK(&priv->scan_event_later, ipw2100_scan_event_later);
tasklet_init(&priv->irq_tasklet, (void (*)(unsigned long))
ipw2100_irq_tasklet, (unsigned long)priv);
@@ -7427,6 +7464,8 @@ static int ipw2100_wx_set_scan(struct net_device *dev,
}
IPW_DEBUG_WX("Initiating scan...\n");
+
+ priv->user_requested_scan = 1;
if (ipw2100_set_scan_options(priv) || ipw2100_start_scan(priv)) {
IPW_DEBUG_WX("Start scan failed.\n");
diff --git a/drivers/net/wireless/ipw2100.h b/drivers/net/wireless/ipw2100.h
index de7d384..1ee3348 100644
--- a/drivers/net/wireless/ipw2100.h
+++ b/drivers/net/wireless/ipw2100.h
@@ -588,6 +588,10 @@ struct ipw2100_priv {
struct delayed_work wx_event_work;
struct delayed_work hang_check;
struct delayed_work rf_kill;
+ struct work_struct scan_event_now;
+ struct delayed_work scan_event_later;
+
+ int user_requested_scan;
u32 interrupts;
int tx_interrupts;
diff --git a/drivers/net/wireless/libertas/11d.c b/drivers/net/wireless/libertas/11d.c
index 4cf0ff7..0560270 100644
--- a/drivers/net/wireless/libertas/11d.c
+++ b/drivers/net/wireless/libertas/11d.c
@@ -562,7 +562,7 @@ int libertas_cmd_802_11d_domain_info(wlan_private * priv,
nr_subband * sizeof(struct ieeetypes_subbandset));
cmd->size = cpu_to_le16(sizeof(pdomaininfo->action) +
- domain->header.len +
+ le16_to_cpu(domain->header.len) +
sizeof(struct mrvlietypesheader) +
S_DS_GEN);
} else {
diff --git a/drivers/net/wireless/libertas/cmd.c b/drivers/net/wireless/libertas/cmd.c
index 4a8f5dc..86fff8d 100644
--- a/drivers/net/wireless/libertas/cmd.c
+++ b/drivers/net/wireless/libertas/cmd.c
@@ -185,14 +185,12 @@ static int wlan_cmd_802_11_set_wep(wlan_private * priv,
switch (pkey->len) {
case KEY_LEN_WEP_40:
- wep->keytype[i] =
- cpu_to_le16(cmd_type_wep_40_bit);
+ wep->keytype[i] = cmd_type_wep_40_bit;
memmove(&wep->keymaterial[i], pkey->key,
pkey->len);
break;
case KEY_LEN_WEP_104:
- wep->keytype[i] =
- cpu_to_le16(cmd_type_wep_104_bit);
+ wep->keytype[i] = cmd_type_wep_104_bit;
memmove(&wep->keymaterial[i], pkey->key,
pkey->len);
break;
diff --git a/drivers/net/wireless/libertas/wext.c b/drivers/net/wireless/libertas/wext.c
index 2fcc3bf..873c405 100644
--- a/drivers/net/wireless/libertas/wext.c
+++ b/drivers/net/wireless/libertas/wext.c
@@ -973,7 +973,7 @@ static struct iw_statistics *wlan_get_wireless_stats(struct net_device *dev)
/* Quality by TX errors */
priv->wstats.discard.retries = priv->stats.tx_errors;
- tx_retries = le16_to_cpu(adapter->logmsg.retry);
+ tx_retries = le32_to_cpu(adapter->logmsg.retry);
if (tx_retries > 75)
tx_qual = (90 - tx_retries) * POOR / 15;
@@ -989,10 +989,10 @@ static struct iw_statistics *wlan_get_wireless_stats(struct net_device *dev)
(PERFECT - VERY_GOOD) / 50 + VERY_GOOD;
quality = min(quality, tx_qual);
- priv->wstats.discard.code = le16_to_cpu(adapter->logmsg.wepundecryptable);
- priv->wstats.discard.fragment = le16_to_cpu(adapter->logmsg.rxfrag);
+ priv->wstats.discard.code = le32_to_cpu(adapter->logmsg.wepundecryptable);
+ priv->wstats.discard.fragment = le32_to_cpu(adapter->logmsg.rxfrag);
priv->wstats.discard.retries = tx_retries;
- priv->wstats.discard.misc = le16_to_cpu(adapter->logmsg.ackfailure);
+ priv->wstats.discard.misc = le32_to_cpu(adapter->logmsg.ackfailure);
/* Calculate quality */
priv->wstats.qual.qual = max(quality, (u32)100);
diff --git a/drivers/net/wireless/rtl8187_dev.c b/drivers/net/wireless/rtl8187_dev.c
index e61c6d5..66704b8 100644
--- a/drivers/net/wireless/rtl8187_dev.c
+++ b/drivers/net/wireless/rtl8187_dev.c
@@ -78,7 +78,8 @@ static int rtl8187_tx(struct ieee80211_hw *dev, struct sk_buff *skb,
struct rtl8187_tx_hdr *hdr;
struct rtl8187_tx_info *info;
struct urb *urb;
- u32 tmp;
+ __le16 rts_dur = 0;
+ u32 flags;
urb = usb_alloc_urb(0, GFP_ATOMIC);
if (!urb) {
@@ -86,24 +87,24 @@ static int rtl8187_tx(struct ieee80211_hw *dev, struct sk_buff *skb,
return 0;
}
- hdr = (struct rtl8187_tx_hdr *)skb_push(skb, sizeof(*hdr));
- tmp = skb->len - sizeof(*hdr);
- tmp |= RTL8187_TX_FLAG_NO_ENCRYPT;
- tmp |= control->rts_cts_rate << 19;
- tmp |= control->tx_rate << 24;
- if (ieee80211_get_morefrag((struct ieee80211_hdr *)skb))
- tmp |= RTL8187_TX_FLAG_MORE_FRAG;
+ flags = skb->len;
+ flags |= RTL8187_TX_FLAG_NO_ENCRYPT;
+ flags |= control->rts_cts_rate << 19;
+ flags |= control->tx_rate << 24;
+ if (ieee80211_get_morefrag((struct ieee80211_hdr *)skb->data))
+ flags |= RTL8187_TX_FLAG_MORE_FRAG;
if (control->flags & IEEE80211_TXCTL_USE_RTS_CTS) {
- tmp |= RTL8187_TX_FLAG_RTS;
- hdr->rts_duration =
- ieee80211_rts_duration(dev, skb->len, control);
+ flags |= RTL8187_TX_FLAG_RTS;
+ rts_dur = ieee80211_rts_duration(dev, skb->len, control);
}
if (control->flags & IEEE80211_TXCTL_USE_CTS_PROTECT)
- tmp |= RTL8187_TX_FLAG_CTS;
- hdr->flags = cpu_to_le32(tmp);
+ flags |= RTL8187_TX_FLAG_CTS;
+
+ hdr = (struct rtl8187_tx_hdr *)skb_push(skb, sizeof(*hdr));
+ hdr->flags = cpu_to_le32(flags);
hdr->len = 0;
- tmp = control->retry_limit << 8;
- hdr->retry = cpu_to_le32(tmp);
+ hdr->rts_duration = rts_dur;
+ hdr->retry = cpu_to_le32(control->retry_limit << 8);
info = (struct rtl8187_tx_info *)skb->cb;
info->control = kmemdup(control, sizeof(*control), GFP_ATOMIC);
diff --git a/drivers/net/wireless/zd1201.c b/drivers/net/wireless/zd1201.c
index 935b144..d5c0c66 100644
--- a/drivers/net/wireless/zd1201.c
+++ b/drivers/net/wireless/zd1201.c
@@ -327,8 +327,8 @@ static void zd1201_usbrx(struct urb *urb)
memcpy(skb_put(skb, 6), &data[datalen-8], 6);
memcpy(skb_put(skb, 2), &data[datalen-24], 2);
memcpy(skb_put(skb, len), data, len);
- skb->dev->last_rx = jiffies;
skb->protocol = eth_type_trans(skb, zd->dev);
+ skb->dev->last_rx = jiffies;
zd->stats.rx_packets++;
zd->stats.rx_bytes += skb->len;
netif_rx(skb);
@@ -384,8 +384,8 @@ static void zd1201_usbrx(struct urb *urb)
memcpy(skb_put(skb, 2), &data[6], 2);
memcpy(skb_put(skb, len), data+8, len);
}
- skb->dev->last_rx = jiffies;
skb->protocol = eth_type_trans(skb, zd->dev);
+ skb->dev->last_rx = jiffies;
zd->stats.rx_packets++;
zd->stats.rx_bytes += skb->len;
netif_rx(skb);
diff --git a/drivers/net/wireless/zd1211rw/zd_usb.c b/drivers/net/wireless/zd1211rw/zd_usb.c
index a9c339e..5326301 100644
--- a/drivers/net/wireless/zd1211rw/zd_usb.c
+++ b/drivers/net/wireless/zd1211rw/zd_usb.c
@@ -1041,14 +1041,17 @@ error:
static void disconnect(struct usb_interface *intf)
{
struct net_device *netdev = zd_intf_to_netdev(intf);
- struct zd_mac *mac = zd_netdev_mac(netdev);
- struct zd_usb *usb = &mac->chip.usb;
+ struct zd_mac *mac;
+ struct zd_usb *usb;
/* Either something really bad happened, or we're just dealing with
* a DEVICE_INSTALLER. */
if (netdev == NULL)
return;
+ mac = zd_netdev_mac(netdev);
+ usb = &mac->chip.usb;
+
dev_dbg_f(zd_usb_dev(usb), "\n");
zd_netdev_disconnect(netdev);
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index 55f307f..85d434b 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -1233,6 +1233,10 @@
#define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP67_IDE 0x0560
#define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP73_IDE 0x056C
#define PCI_DEVICE_ID_NVIDIA_NFORCE_MCP77_IDE 0x0759
+#define PCI_DEVICE_ID_NVIDIA_NVENET_32 0x0760
+#define PCI_DEVICE_ID_NVIDIA_NVENET_33 0x0761
+#define PCI_DEVICE_ID_NVIDIA_NVENET_34 0x0762
+#define PCI_DEVICE_ID_NVIDIA_NVENET_35 0x0763
#define PCI_VENDOR_ID_IMS 0x10e0
#define PCI_DEVICE_ID_IMS_TT128 0x9128

1597
debian/patches/bugfix/all/stable/2.6.23.6.patch vendored Normal file
View File

File diff suppressed because it is too large Load Diff

137
debian/patches/bugfix/all/stable/2.6.23.7.patch vendored Normal file
View File

@ -0,0 +1,137 @@
diff --git a/Makefile b/Makefile
index 798ffe9..c0feac2 100644
diff --git a/fs/minix/itree_v1.c b/fs/minix/itree_v1.c
index 1a5f3bf..82d6554 100644
--- a/fs/minix/itree_v1.c
+++ b/fs/minix/itree_v1.c
@@ -23,11 +23,16 @@ static inline block_t *i_data(struct inode *inode)
static int block_to_path(struct inode * inode, long block, int offsets[DEPTH])
{
int n = 0;
+ char b[BDEVNAME_SIZE];
if (block < 0) {
- printk("minix_bmap: block<0\n");
+ printk("MINIX-fs: block_to_path: block %ld < 0 on dev %s\n",
+ block, bdevname(inode->i_sb->s_bdev, b));
} else if (block >= (minix_sb(inode->i_sb)->s_max_size/BLOCK_SIZE)) {
- printk("minix_bmap: block>big\n");
+ if (printk_ratelimit())
+ printk("MINIX-fs: block_to_path: "
+ "block %ld too big on dev %s\n",
+ block, bdevname(inode->i_sb->s_bdev, b));
} else if (block < 7) {
offsets[n++] = block;
} else if ((block -= 7) < 512) {
diff --git a/fs/minix/itree_v2.c b/fs/minix/itree_v2.c
index ad8f0de..f230109 100644
--- a/fs/minix/itree_v2.c
+++ b/fs/minix/itree_v2.c
@@ -23,12 +23,17 @@ static inline block_t *i_data(struct inode *inode)
static int block_to_path(struct inode * inode, long block, int offsets[DEPTH])
{
int n = 0;
+ char b[BDEVNAME_SIZE];
struct super_block *sb = inode->i_sb;
if (block < 0) {
- printk("minix_bmap: block<0\n");
+ printk("MINIX-fs: block_to_path: block %ld < 0 on dev %s\n",
+ block, bdevname(sb->s_bdev, b));
} else if (block >= (minix_sb(inode->i_sb)->s_max_size/sb->s_blocksize)) {
- printk("minix_bmap: block>big\n");
+ if (printk_ratelimit())
+ printk("MINIX-fs: block_to_path: "
+ "block %ld too big on dev %s\n",
+ block, bdevname(sb->s_bdev, b));
} else if (block < 7) {
offsets[n++] = block;
} else if ((block -= 7) < 256) {
diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index 0d7a77c..a2a4865 100644
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -167,8 +167,6 @@ static void nfs_mark_uptodate(struct page *page, unsigned int base, unsigned int
return;
if (count != nfs_page_length(page))
return;
- if (count != PAGE_CACHE_SIZE)
- zero_user_page(page, count, PAGE_CACHE_SIZE - count, KM_USER0);
SetPageUptodate(page);
}
@@ -643,7 +641,8 @@ static struct nfs_page * nfs_update_request(struct nfs_open_context* ctx,
return ERR_PTR(error);
}
spin_unlock(&inode->i_lock);
- return new;
+ req = new;
+ goto zero_page;
}
spin_unlock(&inode->i_lock);
@@ -671,13 +670,23 @@ static struct nfs_page * nfs_update_request(struct nfs_open_context* ctx,
if (offset < req->wb_offset) {
req->wb_offset = offset;
req->wb_pgbase = offset;
- req->wb_bytes = rqend - req->wb_offset;
+ req->wb_bytes = max(end, rqend) - req->wb_offset;
+ goto zero_page;
}
if (end > rqend)
req->wb_bytes = end - req->wb_offset;
return req;
+zero_page:
+ /* If this page might potentially be marked as up to date,
+ * then we need to zero any uninitalised data. */
+ if (req->wb_pgbase == 0 && req->wb_bytes != PAGE_CACHE_SIZE
+ && !PageUptodate(req->wb_page))
+ zero_user_page(req->wb_page, req->wb_bytes,
+ PAGE_CACHE_SIZE - req->wb_bytes,
+ KM_USER0);
+ return req;
}
int nfs_flush_incompatible(struct file *file, struct page *page)
diff --git a/fs/ocfs2/aops.c b/fs/ocfs2/aops.c
index f37f25c..0b5e35f 100644
--- a/fs/ocfs2/aops.c
+++ b/fs/ocfs2/aops.c
@@ -661,6 +661,27 @@ static void ocfs2_clear_page_regions(struct page *page,
}
/*
+ * Nonsparse file systems fully allocate before we get to the write
+ * code. This prevents ocfs2_write() from tagging the write as an
+ * allocating one, which means ocfs2_map_page_blocks() might try to
+ * read-in the blocks at the tail of our file. Avoid reading them by
+ * testing i_size against each block offset.
+ */
+static int ocfs2_should_read_blk(struct inode *inode, struct page *page,
+ unsigned int block_start)
+{
+ u64 offset = page_offset(page) + block_start;
+
+ if (ocfs2_sparse_alloc(OCFS2_SB(inode->i_sb)))
+ return 1;
+
+ if (i_size_read(inode) > offset)
+ return 1;
+
+ return 0;
+}
+
+/*
* Some of this taken from block_prepare_write(). We already have our
* mapping by now though, and the entire write will be allocating or
* it won't, so not much need to use BH_New.
@@ -713,6 +734,7 @@ int ocfs2_map_page_blocks(struct page *page, u64 *p_blkno,
set_buffer_uptodate(bh);
} else if (!buffer_uptodate(bh) && !buffer_delay(bh) &&
!buffer_new(bh) &&
+ ocfs2_should_read_blk(inode, page, block_start) &&
(block_start < from || block_end > to)) {
ll_rw_block(READ, 1, &bh);
*wait_bh++=bh;

39
debian/patches/bugfix/all/stable/2.6.23.8.patch vendored Normal file
View File

@ -0,0 +1,39 @@
diff --git a/Makefile b/Makefile
index c0feac2..435a3d7 100644
diff --git a/kernel/exit.c b/kernel/exit.c
index 993369e..096c27d 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -1362,8 +1362,7 @@ static int wait_task_stopped(struct task_struct *p, int delayed_group_leader,
int why = (p->ptrace & PT_PTRACED) ? CLD_TRAPPED : CLD_STOPPED;
exit_code = p->exit_code;
- if (unlikely(!exit_code) ||
- unlikely(p->state & TASK_TRACED))
+ if (unlikely(!exit_code) || unlikely(p->exit_state))
goto bail_ref;
return wait_noreap_copyout(p, pid, uid,
why, (exit_code << 8) | 0x7f,
diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index f893e90..c9298a7 100644
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -1012,6 +1012,9 @@ tcp_sacktag_write_queue(struct sock *sk, struct sk_buff *ack_skb, u32 prior_snd_
if (before(TCP_SKB_CB(ack_skb)->ack_seq, prior_snd_una - tp->max_window))
return 0;
+ if (!tp->packets_out)
+ goto out;
+
/* SACK fastpath:
* if the only SACK change is the increase of the end_seq of
* the first block then only apply that SACK block
@@ -1280,6 +1283,8 @@ tcp_sacktag_write_queue(struct sock *sk, struct sk_buff *ack_skb, u32 prior_snd_
(!tp->frto_highmark || after(tp->snd_una, tp->frto_highmark)))
tcp_update_reordering(sk, ((tp->fackets_out + 1) - reord), 0);
+out:
+
#if FASTRETRANS_DEBUG > 0
BUG_TRAP((int)tp->sacked_out >= 0);
BUG_TRAP((int)tp->lost_out >= 0);

7
debian/patches/series/1~experimental.1 vendored
View File

@ -50,3 +50,10 @@
+ features/all/e1000e-fixes.patch
+ bugfix/all/2.6.23.1
+ bugfix/arm/disable-scsi_acard.patch
+ bugfix/all/stable/2.6.23.2.patch
+ bugfix/all/stable/2.6.23.3.patch
+ bugfix/all/stable/2.6.23.4.patch
+ bugfix/all/stable/2.6.23.5.patch
+ bugfix/all/stable/2.6.23.6.patch
+ bugfix/all/stable/2.6.23.7.patch
+ bugfix/all/stable/2.6.23.8.patch