Merge branch 'master' of /home/greg/linux/git/torvalds-2.6/
authorGreg Kroah-Hartman <gregkh@suse.de>
Sun, 6 Aug 2006 22:44:39 +0000 (15:44 -0700)
committerGreg Kroah-Hartman <gregkh@suse.de>
Sun, 6 Aug 2006 22:44:39 +0000 (15:44 -0700)
36 files changed:
Documentation/sysctl/kernel.txt
MAINTAINERS
Makefile
arch/sh/kernel/cpu/sh4/sq.c
arch/x86_64/kernel/smp.c
drivers/acpi/acpi_memhotplug.c
drivers/char/hvsi.c
drivers/char/hw_random/omap-rng.c
drivers/edac/edac_mc.h
drivers/i2c/busses/scx200_acb.c
drivers/ieee1394/sbp2.c
drivers/isdn/hardware/eicon/divasync.h
drivers/md/linear.c
drivers/pnp/pnpacpi/rsparser.c
drivers/video/aty/aty128fb.c
drivers/video/au1100fb.c
fs/befs/linuxvfs.c
fs/reiserfs/file.c
fs/reiserfs/inode.c
fs/reiserfs/ioctl.c
fs/udf/ialloc.c
fs/ufs/balloc.c
fs/ufs/util.c
include/linux/debug_locks.h
include/linux/sched.h
include/linux/vmstat.h
kernel/fork.c
kernel/futex.c
kernel/futex_compat.c
kernel/power/process.c
kernel/printk.c
kernel/resource.c
lib/spinlock_debug.c
mm/fadvise.c
mm/memory_hotplug.c
net/sunrpc/cache.c

index b0c7ab93dcb92db3423690382d5d4f8fc4507849..7345c338080a6548dcaf765b7e7423431ea47cdd 100644 (file)
@@ -211,9 +211,8 @@ Controls the kernel's behaviour when an oops or BUG is encountered.
 
 0: try to continue operation
 
-1: delay a few seconds (to give klogd time to record the oops output) and
-   then panic.  If the `panic' sysctl is also non-zero then the machine will
-   be rebooted.
+1: panic immediatly.  If the `panic' sysctl is also non-zero then the
+   machine will be rebooted.
 
 ==============================================================
 
index b6c3c544df8991709d991a93f7e7b4b5f7586de8..e3e1515ba5a9065308e588b5fa2e480bcd039132 100644 (file)
@@ -2648,6 +2648,14 @@ M:       dbrownell@users.sourceforge.net
 L:     spi-devel-general@lists.sourceforge.net
 S:     Maintained
 
+STABLE BRANCH:
+P:     Greg Kroah-Hartman
+M:     greg@kroah.com
+P:     Chris Wright
+M:     chrisw@sous-sol.org
+L:     stable@kernel.org
+S:     Maintained
+
 TPM DEVICE DRIVER
 P:     Kylene Hall
 M:     kjhall@us.ibm.com
index 110db856e966a046abfe85268563b866298cb75b..c2f78a5a549390223a5dd76ee0543f1a5d36a55c 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -1,7 +1,7 @@
 VERSION = 2
 PATCHLEVEL = 6
 SUBLEVEL = 18
-EXTRAVERSION = -rc3
+EXTRAVERSION = -rc4
 NAME=Crazed Snow-Weasel
 
 # *DOCUMENTATION*
index 781dbb11c03894b56e04668a0311a63c99fbb47b..b09805f3ee23799e8a78379856211d2b967a30f0 100644 (file)
@@ -421,18 +421,22 @@ static struct miscdevice sq_dev = {
 
 static int __init sq_api_init(void)
 {
+       int ret;
        printk(KERN_NOTICE "sq: Registering store queue API.\n");
 
-#ifdef CONFIG_PROC_FS
        create_proc_read_entry("sq_mapping", 0, 0, sq_mapping_read_proc, 0);
-#endif
 
-       return misc_register(&sq_dev);
+       ret = misc_register(&sq_dev);
+       if (ret)
+               remove_proc_entry("sq_mapping", NULL);
+
+       return ret;
 }
 
 static void __exit sq_api_exit(void)
 {
        misc_deregister(&sq_dev);
+       remove_proc_entry("sq_mapping", NULL);
 }
 
 module_init(sq_api_init);
index 5a1c0a3bf87262c027c327773628e93e58194188..06af6ca601295e8253b95b999435710fdc8672e2 100644 (file)
@@ -203,7 +203,7 @@ int __cpuinit init_smp_flush(void)
 {
        int i;
        for_each_cpu_mask(i, cpu_possible_map) {
-               spin_lock_init(&per_cpu(flush_state.tlbstate_lock, i));
+               spin_lock_init(&per_cpu(flush_state, i).tlbstate_lock);
        }
        return 0;
 }
index 81e970adeab3b3cc6d5e47d32e69381693240943..b0d4b147b19eab7155452c818e5947716bf4b0bd 100644 (file)
@@ -129,11 +129,15 @@ acpi_memory_get_device_resources(struct acpi_memory_device *mem_device)
        struct acpi_memory_info *info, *n;
 
 
+       if (!list_empty(&mem_device->res_list))
+               return 0;
+
        status = acpi_walk_resources(mem_device->device->handle, METHOD_NAME__CRS,
                                     acpi_memory_get_resource, mem_device);
        if (ACPI_FAILURE(status)) {
                list_for_each_entry_safe(info, n, &mem_device->res_list, list)
                        kfree(info);
+               INIT_LIST_HEAD(&mem_device->res_list);
                return -EINVAL;
        }
 
@@ -230,17 +234,10 @@ static int acpi_memory_enable_device(struct acpi_memory_device *mem_device)
         * (i.e. memory-hot-remove function)
         */
        list_for_each_entry(info, &mem_device->res_list, list) {
-               u64 start_pfn, end_pfn;
-
-               start_pfn = info->start_addr >> PAGE_SHIFT;
-               end_pfn = (info->start_addr + info->length - 1) >> PAGE_SHIFT;
-
-               if (pfn_valid(start_pfn) || pfn_valid(end_pfn)) {
-                       /* already enabled. try next area */
+               if (info->enabled) { /* just sanity check...*/
                        num_enabled++;
                        continue;
                }
-
                result = add_memory(node, info->start_addr, info->length);
                if (result)
                        continue;
index 41db8060e8f791502c51bb559ffbfa4881327e5c..017f755632a3455d1a2223d2b1cd01006477d990 100644 (file)
@@ -311,7 +311,8 @@ static void hvsi_recv_control(struct hvsi_struct *hp, uint8_t *packet,
                                /* CD went away; no more connection */
                                pr_debug("hvsi%i: CD dropped\n", hp->index);
                                hp->mctrl &= TIOCM_CD;
-                               if (!(hp->tty->flags & CLOCAL))
+                               /* If userland hasn't done an open(2) yet, hp->tty is NULL. */
+                               if (hp->tty && !(hp->tty->flags & CLOCAL))
                                        *to_hangup = hp->tty;
                        }
                        break;
@@ -986,10 +987,7 @@ static void hvsi_write_worker(void *arg)
                start_j = 0;
 #endif /* DEBUG */
                wake_up_all(&hp->emptyq);
-               if (test_bit(TTY_DO_WRITE_WAKEUP, &hp->tty->flags)
-                               && hp->tty->ldisc.write_wakeup)
-                       hp->tty->ldisc.write_wakeup(hp->tty);
-               wake_up_interruptible(&hp->tty->write_wait);
+               tty_wakeup(hp->tty);
        }
 
 out:
index 819516b35a79394deb31eb419e5be7d8d0524575..a01d796d1eeb3624a4f55537d604cc9dba1cb1e3 100644 (file)
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/random.h>
+#include <linux/clk.h>
 #include <linux/err.h>
-#include <linux/device.h>
+#include <linux/platform_device.h>
 #include <linux/hw_random.h>
 
 #include <asm/io.h>
-#include <asm/hardware/clock.h>
 
 #define RNG_OUT_REG            0x00            /* Output register */
 #define RNG_STAT_REG           0x04            /* Status register
@@ -52,7 +52,7 @@
 
 static void __iomem *rng_base;
 static struct clk *rng_ick;
-static struct device *rng_dev;
+static struct platform_device *rng_dev;
 
 static u32 omap_rng_read_reg(int reg)
 {
@@ -83,9 +83,8 @@ static struct hwrng omap_rng_ops = {
        .data_read      = omap_rng_data_read,
 };
 
-static int __init omap_rng_probe(struct device *dev)
+static int __init omap_rng_probe(struct platform_device *pdev)
 {
-       struct platform_device *pdev = to_platform_device(dev);
        struct resource *res, *mem;
        int ret;
 
@@ -95,16 +94,14 @@ static int __init omap_rng_probe(struct device *dev)
         */
        BUG_ON(rng_dev);
 
-       if (cpu_is_omap24xx()) {
+       if (cpu_is_omap24xx()) {
                rng_ick = clk_get(NULL, "rng_ick");
                if (IS_ERR(rng_ick)) {
-                       dev_err(dev, "Could not get rng_ick\n");
+                       dev_err(&pdev->dev, "Could not get rng_ick\n");
                        ret = PTR_ERR(rng_ick);
                        return ret;
-               }
-               else {
-                       clk_use(rng_ick);
-               }
+               } else
+                       clk_enable(rng_ick);
        }
 
        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
@@ -117,7 +114,7 @@ static int __init omap_rng_probe(struct device *dev)
        if (mem == NULL)
                return -EBUSY;
 
-       dev_set_drvdata(dev, mem);
+       dev_set_drvdata(&pdev->dev, mem);
        rng_base = (u32 __iomem *)io_p2v(res->start);
 
        ret = hwrng_register(&omap_rng_ops);
@@ -127,25 +124,25 @@ static int __init omap_rng_probe(struct device *dev)
                return ret;
        }
 
-       dev_info(dev, "OMAP Random Number Generator ver. %02x\n",
+       dev_info(&pdev->dev, "OMAP Random Number Generator ver. %02x\n",
                omap_rng_read_reg(RNG_REV_REG));
        omap_rng_write_reg(RNG_MASK_REG, 0x1);
 
-       rng_dev = dev;
+       rng_dev = pdev;
 
        return 0;
 }
 
-static int __exit omap_rng_remove(struct device *dev)
+static int __exit omap_rng_remove(struct platform_device *pdev)
 {
-       struct resource *mem = dev_get_drvdata(dev);
+       struct resource *mem = dev_get_drvdata(&pdev->dev);
 
        hwrng_unregister(&omap_rng_ops);
 
        omap_rng_write_reg(RNG_MASK_REG, 0x0);
 
        if (cpu_is_omap24xx()) {
-               clk_unuse(rng_ick);
+               clk_disable(rng_ick);
                clk_put(rng_ick);
        }
 
@@ -157,18 +154,16 @@ static int __exit omap_rng_remove(struct device *dev)
 
 #ifdef CONFIG_PM
 
-static int omap_rng_suspend(struct device *dev, pm_message_t message, u32 level)
+static int omap_rng_suspend(struct platform_device *pdev, pm_message_t message)
 {
        omap_rng_write_reg(RNG_MASK_REG, 0x0);
-
        return 0;
 }
 
-static int omap_rng_resume(struct device *dev, pm_message_t message, u32 level)
+static int omap_rng_resume(struct platform_device *pdev)
 {
        omap_rng_write_reg(RNG_MASK_REG, 0x1);
-
-       return 1;
+       return 0;
 }
 
 #else
@@ -179,9 +174,11 @@ static int omap_rng_resume(struct device *dev, pm_message_t message, u32 level)
 #endif
 
 
-static struct device_driver omap_rng_driver = {
-       .name           = "omap_rng",
-       .bus            = &platform_bus_type,
+static struct platform_driver omap_rng_driver = {
+       .driver = {
+               .name           = "omap_rng",
+               .owner          = THIS_MODULE,
+       },
        .probe          = omap_rng_probe,
        .remove         = __exit_p(omap_rng_remove),
        .suspend        = omap_rng_suspend,
@@ -193,12 +190,12 @@ static int __init omap_rng_init(void)
        if (!cpu_is_omap16xx() && !cpu_is_omap24xx())
                return -ENODEV;
 
-       return driver_register(&omap_rng_driver);
+       return platform_driver_register(&omap_rng_driver);
 }
 
 static void __exit omap_rng_exit(void)
 {
-       driver_unregister(&omap_rng_driver);
+       platform_driver_unregister(&omap_rng_driver);
 }
 
 module_init(omap_rng_init);
index bf6ab8a8d5ed8700dce391de101a03b60ee72987..a1cfd4e3c97df8e3454112bda619446b69623b9a 100644 (file)
@@ -29,6 +29,7 @@
 #include <linux/rcupdate.h>
 #include <linux/completion.h>
 #include <linux/kobject.h>
+#include <linux/platform_device.h>
 
 #define EDAC_MC_LABEL_LEN      31
 #define MC_PROC_NAME_MAX_LEN 7
index ced309ff056fa123d3a0022dfcc7d7530b60d491..eae9e81be375acecb2a697fd23b7afdcab944b6a 100644 (file)
@@ -232,7 +232,7 @@ static void scx200_acb_poll(struct scx200_acb_iface *iface)
        unsigned long timeout;
 
        timeout = jiffies + POLL_TIMEOUT;
-       while (time_before(jiffies, timeout)) {
+       while (1) {
                status = inb(ACBST);
 
                /* Reset the status register to avoid the hang */
@@ -242,7 +242,10 @@ static void scx200_acb_poll(struct scx200_acb_iface *iface)
                        scx200_acb_machine(iface, status);
                        return;
                }
-               yield();
+               if (time_after(jiffies, timeout))
+                       break;
+               cpu_relax();
+               cond_resched();
        }
 
        dev_err(&iface->adapter.dev, "timeout in state %s\n",
index aaa74f293aaf4279353c77404ba9f38ac2c98663..b08755e2e68f31115ff11920f598835001ea0bd3 100644 (file)
@@ -2515,6 +2515,9 @@ static int sbp2scsi_slave_configure(struct scsi_device *sdev)
                sdev->skip_ms_page_8 = 1;
        if (scsi_id->workarounds & SBP2_WORKAROUND_FIX_CAPACITY)
                sdev->fix_capacity = 1;
+       if (scsi_id->ne->guid_vendor_id == 0x0010b9 && /* Maxtor's OUI */
+           (sdev->type == TYPE_DISK || sdev->type == TYPE_RBC))
+               sdev->allow_restart = 1;
        return 0;
 }
 
index 0a5be7f969f212e494912f8e1a6db7b0bdaec58e..af3eb9e795b500faba4eaa15eca11152b54c8872 100644 (file)
@@ -256,7 +256,6 @@ typedef struct
 #define NO_ORDER_CHECK_MASK 0x00000010
 #define LOW_CHANNEL_MASK 0x00000020
 #define NO_HSCX30_MASK  0x00000040
-#define MODE_MASK   0x00000080
 #define SET_BOARD   0x00001000
 #define SET_CRC4   0x00030000
 #define SET_L1_TRISTATE  0x00040000
index ff83c9b5979e5feb0c433b4e3a118344e479a5cc..b99c19c7eb2237e6f6583530c849bcfcaa2887c2 100644 (file)
@@ -162,7 +162,7 @@ static linear_conf_t *linear_conf(mddev_t *mddev, int raid_disks)
                goto out;
        }
 
-       min_spacing = mddev->array_size;
+       min_spacing = conf->array_size;
        sector_div(min_spacing, PAGE_SIZE/sizeof(struct dev_info *));
 
        /* min_spacing is the minimum spacing that will fit the hash
@@ -171,7 +171,7 @@ static linear_conf_t *linear_conf(mddev_t *mddev, int raid_disks)
         * that is larger than min_spacing as use the size of that as
         * the actual spacing
         */
-       conf->hash_spacing = mddev->array_size;
+       conf->hash_spacing = conf->array_size;
        for (i=0; i < cnt-1 ; i++) {
                sector_t sz = 0;
                int j;
@@ -228,7 +228,7 @@ static linear_conf_t *linear_conf(mddev_t *mddev, int raid_disks)
        curr_offset = 0;
        i = 0;
        for (curr_offset = 0;
-            curr_offset < mddev->array_size;
+            curr_offset < conf->array_size;
             curr_offset += conf->hash_spacing) {
 
                while (i < mddev->raid_disks-1 &&
index 21226888185789f24d112b32ab78d1b76e63d458..dc79b0a0059f6206c22dd6a611c591d62b83aa7a 100644 (file)
@@ -173,6 +173,9 @@ pnpacpi_parse_allocated_address_space(struct pnp_resource_table *res_table,
                return;
        }
 
+       if (p->producer_consumer == ACPI_PRODUCER)
+               return;
+
        if (p->resource_type == ACPI_MEMORY_RANGE)
                pnpacpi_parse_allocated_memresource(res_table,
                                p->minimum, p->address_length);
@@ -252,9 +255,14 @@ static acpi_status pnpacpi_allocated_resource(struct acpi_resource *res,
                break;
 
        case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
+               if (res->data.ext_address64.producer_consumer == ACPI_PRODUCER)
+                       return AE_OK;
                break;
 
        case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
+               if (res->data.extended_irq.producer_consumer == ACPI_PRODUCER)
+                       return AE_OK;
+
                for (i = 0; i < res->data.extended_irq.interrupt_count; i++) {
                        pnpacpi_parse_allocated_irqresource(res_table,
                                res->data.extended_irq.interrupts[i],
index 8b08121b390bf979a9272792725fd4efb8ada9a6..3e827e04a2aab4de2c3081486ff07ef89dbecea0 100644 (file)
@@ -1913,9 +1913,6 @@ static int __devinit aty128_init(struct pci_dev *pdev, const struct pci_device_i
        u8 chip_rev;
        u32 dac;
 
-       if (!par->vram_size)    /* may have already been probed */
-               par->vram_size = aty_ld_le32(CONFIG_MEMSIZE) & 0x03FFFFFF;
-
        /* Get the chip revision */
        chip_rev = (aty_ld_le32(CONFIG_CNTL) >> 16) & 0x1F;
 
@@ -2028,9 +2025,6 @@ static int __devinit aty128_init(struct pci_dev *pdev, const struct pci_device_i
 
        aty128_init_engine(par);
 
-       if (register_framebuffer(info) < 0)
-               return 0;
-
        par->pm_reg = pci_find_capability(pdev, PCI_CAP_ID_PM);
        par->pdev = pdev;
        par->asleep = 0;
@@ -2040,6 +2034,9 @@ static int __devinit aty128_init(struct pci_dev *pdev, const struct pci_device_i
        aty128_bl_init(par);
 #endif
 
+       if (register_framebuffer(info) < 0)
+               return 0;
+
        printk(KERN_INFO "fb%d: %s frame buffer device on %s\n",
               info->node, info->fix.id, video_card);
 
@@ -2089,7 +2086,6 @@ static int __devinit aty128_probe(struct pci_dev *pdev, const struct pci_device_
        par = info->par;
 
        info->pseudo_palette = par->pseudo_palette;
-       info->fix = aty128fb_fix;
 
        /* Virtualize mmio region */
        info->fix.mmio_start = reg_addr;
index a92a91fef16fc303d0aa393c4af607a063e305a2..f25d5d648333cb6665529154aeaec90184da02b5 100644 (file)
@@ -156,7 +156,7 @@ int au1100fb_setmode(struct au1100fb_device *fbdev)
 
                        info->fix.visual = FB_VISUAL_TRUECOLOR;
                        info->fix.line_length = info->var.xres_virtual << 1; /* depth=16 */
-       }
+               }
        } else {
                /* mono */
                info->fix.visual = FB_VISUAL_MONO10;
@@ -164,20 +164,16 @@ int au1100fb_setmode(struct au1100fb_device *fbdev)
        }
 
        info->screen_size = info->fix.line_length * info->var.yres_virtual;
+       info->var.rotate = ((fbdev->panel->control_base&LCD_CONTROL_SM_MASK) \
+                               >> LCD_CONTROL_SM_BIT) * 90;
 
        /* Determine BPP mode and format */
-       fbdev->regs->lcd_control = fbdev->panel->control_base |
-                           ((info->var.rotate/90) << LCD_CONTROL_SM_BIT);
-
-       fbdev->regs->lcd_intenable = 0;
-       fbdev->regs->lcd_intstatus = 0;
-
+       fbdev->regs->lcd_control = fbdev->panel->control_base;
        fbdev->regs->lcd_horztiming = fbdev->panel->horztiming;
-
        fbdev->regs->lcd_verttiming = fbdev->panel->verttiming;
-
        fbdev->regs->lcd_clkcontrol = fbdev->panel->clkcontrol_base;
-
+       fbdev->regs->lcd_intenable = 0;
+       fbdev->regs->lcd_intstatus = 0;
        fbdev->regs->lcd_dmaaddr0 = LCD_DMA_SA_N(fbdev->fb_phys);
 
        if (panel_is_dual(fbdev->panel)) {
@@ -206,6 +202,8 @@ int au1100fb_setmode(struct au1100fb_device *fbdev)
 
        /* Resume controller */
        fbdev->regs->lcd_control |= LCD_CONTROL_GO;
+       mdelay(10);
+       au1100fb_fb_blank(VESA_NO_BLANKING, info);
 
        return 0;
 }
index fcaeead9696b135f6481ff93afd7829980d53e5e..50cfca5c7efd570588d549a5f23f9f5650fd360d 100644 (file)
@@ -512,7 +512,11 @@ befs_utf2nls(struct super_block *sb, const char *in,
        wchar_t uni;
        int unilen, utflen;
        char *result;
-       int maxlen = in_len; /* The utf8->nls conversion can't make more chars */
+       /* The utf8->nls conversion won't make the final nls string bigger
+        * than the utf one, but if the string is pure ascii they'll have the
+        * same width and an extra char is needed to save the additional \0
+        */
+       int maxlen = in_len + 1;
 
        befs_debug(sb, "---> utf2nls()");
 
@@ -588,7 +592,10 @@ befs_nls2utf(struct super_block *sb, const char *in,
        wchar_t uni;
        int unilen, utflen;
        char *result;
-       int maxlen = 3 * in_len;
+       /* There're nls characters that will translate to 3-chars-wide UTF-8
+        * characters, a additional byte is needed to save the final \0
+        * in special cases */
+       int maxlen = (3 * in_len) + 1;
 
        befs_debug(sb, "---> nls2utf()\n");
 
index f318b58510fd896b2b68c04fadb5ca6af5daa3fc..1627edd50810b94df2f4003479092022c9952d9d 100644 (file)
@@ -48,8 +48,8 @@ static int reiserfs_file_release(struct inode *inode, struct file *filp)
                return 0;
        }
 
-       reiserfs_write_lock(inode->i_sb);
        mutex_lock(&inode->i_mutex);
+       reiserfs_write_lock(inode->i_sb);
        /* freeing preallocation only involves relogging blocks that
         * are already in the current transaction.  preallocation gets
         * freed at the end of each transaction, so it is impossible for
index 12dfdcfbee3dfb8666712f81fb8ca28f203568cb..52f1e2136546f215f7bd13ea403735222a621e46 100644 (file)
@@ -39,14 +39,10 @@ void reiserfs_delete_inode(struct inode *inode)
 
        /* The = 0 happens when we abort creating a new inode for some reason like lack of space.. */
        if (!(inode->i_state & I_NEW) && INODE_PKEY(inode)->k_objectid != 0) {  /* also handles bad_inode case */
-               mutex_lock(&inode->i_mutex);
-
                reiserfs_delete_xattrs(inode);
 
-               if (journal_begin(&th, inode->i_sb, jbegin_count)) {
-                       mutex_unlock(&inode->i_mutex);
+               if (journal_begin(&th, inode->i_sb, jbegin_count))
                        goto out;
-               }
                reiserfs_update_inode_transaction(inode);
 
                err = reiserfs_delete_object(&th, inode);
@@ -57,12 +53,8 @@ void reiserfs_delete_inode(struct inode *inode)
                if (!err) 
                        DQUOT_FREE_INODE(inode);
 
-               if (journal_end(&th, inode->i_sb, jbegin_count)) {
-                       mutex_unlock(&inode->i_mutex);
+               if (journal_end(&th, inode->i_sb, jbegin_count))
                        goto out;
-               }
-
-               mutex_unlock(&inode->i_mutex);
 
                /* check return value from reiserfs_delete_object after
                 * ending the transaction
@@ -2348,6 +2340,7 @@ static int reiserfs_write_full_page(struct page *page,
        unsigned long end_index = inode->i_size >> PAGE_CACHE_SHIFT;
        int error = 0;
        unsigned long block;
+       sector_t last_block;
        struct buffer_head *head, *bh;
        int partial = 0;
        int nr = 0;
@@ -2395,10 +2388,19 @@ static int reiserfs_write_full_page(struct page *page,
        }
        bh = head;
        block = page->index << (PAGE_CACHE_SHIFT - s->s_blocksize_bits);
+       last_block = (i_size_read(inode) - 1) >> inode->i_blkbits;
        /* first map all the buffers, logging any direct items we find */
        do {
-               if ((checked || buffer_dirty(bh)) && (!buffer_mapped(bh) ||
-                                                     (buffer_mapped(bh)
+               if (block > last_block) {
+                       /*
+                        * This can happen when the block size is less than
+                        * the page size.  The corresponding bytes in the page
+                        * were zero filled above
+                        */
+                       clear_buffer_dirty(bh);
+                       set_buffer_uptodate(bh);
+               } else if ((checked || buffer_dirty(bh)) &&
+                          (!buffer_mapped(bh) || (buffer_mapped(bh)
                                                       && bh->b_blocknr ==
                                                       0))) {
                        /* not mapped yet, or it points to a direct item, search
index 745c8810089512e0b9a77d6f3847ea7683500037..a986b5e1e288c8dd47eca5ea525c9cfe2fc26b77 100644 (file)
@@ -116,12 +116,12 @@ static int reiserfs_unpack(struct inode *inode, struct file *filp)
        if (REISERFS_I(inode)->i_flags & i_nopack_mask) {
                return 0;
        }
-       reiserfs_write_lock(inode->i_sb);
 
        /* we need to make sure nobody is changing the file size beneath
         ** us
         */
        mutex_lock(&inode->i_mutex);
+       reiserfs_write_lock(inode->i_sb);
 
        write_from = inode->i_size & (blocksize - 1);
        /* if we are on a block boundary, we are already unpacked.  */
index 3873c672cb4c0ce09b63a5d06801ddeba029b800..33323473e3c43edfbd53a16014f3bf313d580ac4 100644 (file)
@@ -75,6 +75,12 @@ struct inode * udf_new_inode (struct inode *dir, int mode, int * err)
        }
        *err = -ENOSPC;
 
+       UDF_I_UNIQUE(inode) = 0;
+       UDF_I_LENEXTENTS(inode) = 0;
+       UDF_I_NEXT_ALLOC_BLOCK(inode) = 0;
+       UDF_I_NEXT_ALLOC_GOAL(inode) = 0;
+       UDF_I_STRAT4096(inode) = 0;
+
        block = udf_new_block(dir->i_sb, NULL, UDF_I_LOCATION(dir).partitionReferenceNum,
                start, err);
        if (*err)
@@ -84,11 +90,6 @@ struct inode * udf_new_inode (struct inode *dir, int mode, int * err)
        }
 
        mutex_lock(&sbi->s_alloc_mutex);
-       UDF_I_UNIQUE(inode) = 0;
-       UDF_I_LENEXTENTS(inode) = 0;
-       UDF_I_NEXT_ALLOC_BLOCK(inode) = 0;
-       UDF_I_NEXT_ALLOC_GOAL(inode) = 0;
-       UDF_I_STRAT4096(inode) = 0;
        if (UDF_SB_LVIDBH(sb))
        {
                struct logicalVolHeaderDesc *lvhd;
index b01804baa120f630c1fe2480a970086e96e58cde..b82381475779b59ecdd52685eafc05db391d6bb2 100644 (file)
@@ -248,7 +248,7 @@ static void ufs_change_blocknr(struct inode *inode, unsigned int baseblk,
 
                if (likely(cur_index != index)) {
                        page = ufs_get_locked_page(mapping, index);
-                       if (IS_ERR(page))
+                       if (!page || IS_ERR(page)) /* it was truncated or EIO */
                                continue;
                } else
                        page = locked_page;
index 337cf2c46d109f1e9c9cef3492ed2dd26bffe07e..22f820a9b15c782dace5e86fc2a6bf9d9ad74ab0 100644 (file)
@@ -251,12 +251,12 @@ struct page *ufs_get_locked_page(struct address_space *mapping,
 {
        struct page *page;
 
-try_again:
        page = find_lock_page(mapping, index);
        if (!page) {
                page = read_cache_page(mapping, index,
                                       (filler_t*)mapping->a_ops->readpage,
                                       NULL);
+
                if (IS_ERR(page)) {
                        printk(KERN_ERR "ufs_change_blocknr: "
                               "read_cache_page error: ino %lu, index: %lu\n",
@@ -266,6 +266,14 @@ try_again:
 
                lock_page(page);
 
+               if (unlikely(page->mapping == NULL)) {
+                       /* Truncate got there first */
+                       unlock_page(page);
+                       page_cache_release(page);
+                       page = NULL;
+                       goto out;
+               }
+
                if (!PageUptodate(page) || PageError(page)) {
                        unlock_page(page);
                        page_cache_release(page);
@@ -275,15 +283,8 @@ try_again:
                               mapping->host->i_ino, index);
 
                        page = ERR_PTR(-EIO);
-                       goto out;
                }
        }
-
-       if (unlikely(!page->mapping || !page_has_buffers(page))) {
-               unlock_page(page);
-               page_cache_release(page);
-               goto try_again;/*we really need these buffers*/
-       }
 out:
        return page;
 }
index 6a7047851e48b8174ffa0360e95e056a5d9921fa..88dafa246d87a968b61163ad500dd7da2d5bb812 100644 (file)
@@ -1,6 +1,8 @@
 #ifndef __LINUX_DEBUG_LOCKING_H
 #define __LINUX_DEBUG_LOCKING_H
 
+struct task_struct;
+
 extern int debug_locks;
 extern int debug_locks_silent;
 
index 6afa72e080cb7665bc4be600db1b4fe382460ccd..6674fc1e51bf3dfe0677633e489231a91c271dac 100644 (file)
@@ -1557,6 +1557,14 @@ static inline void freeze(struct task_struct *p)
        p->flags |= PF_FREEZE;
 }
 
+/*
+ * Sometimes we may need to cancel the previous 'freeze' request
+ */
+static inline void do_not_freeze(struct task_struct *p)
+{
+       p->flags &= ~PF_FREEZE;
+}
+
 /*
  * Wake up a frozen process
  */
index 1ab806c47514e5e6a468063f37fa4fcb1ce9c038..2d9b1b60798aca15f99c9fe46afe5587f1605b6e 100644 (file)
@@ -41,23 +41,23 @@ DECLARE_PER_CPU(struct vm_event_state, vm_event_states);
 
 static inline void __count_vm_event(enum vm_event_item item)
 {
-       __get_cpu_var(vm_event_states.event[item])++;
+       __get_cpu_var(vm_event_states).event[item]++;
 }
 
 static inline void count_vm_event(enum vm_event_item item)
 {
-       get_cpu_var(vm_event_states.event[item])++;
+       get_cpu_var(vm_event_states).event[item]++;
        put_cpu();
 }
 
 static inline void __count_vm_events(enum vm_event_item item, long delta)
 {
-       __get_cpu_var(vm_event_states.event[item]) += delta;
+       __get_cpu_var(vm_event_states).event[item] += delta;
 }
 
 static inline void count_vm_events(enum vm_event_item item, long delta)
 {
-       get_cpu_var(vm_event_states.event[item]) += delta;
+       get_cpu_var(vm_event_states).event[item] += delta;
        put_cpu();
 }
 
index 1b0f7b1e088189a53d531e038b1dce75ad3f7a6a..aa36c43783cc01f296eb1c755cc4f17b51b55ccc 100644 (file)
@@ -1387,8 +1387,10 @@ long do_fork(unsigned long clone_flags,
 
                if (clone_flags & CLONE_VFORK) {
                        wait_for_completion(&vfork);
-                       if (unlikely (current->ptrace & PT_TRACE_VFORK_DONE))
+                       if (unlikely (current->ptrace & PT_TRACE_VFORK_DONE)) {
+                               current->ptrace_message = nr;
                                ptrace_notify ((PTRACE_EVENT_VFORK_DONE << 8) | SIGTRAP);
+                       }
                }
        } else {
                free_pid(pid);
index dda2049692a23dff47633c7e0394526ff0398289..c2b2e0b83abf520a5a170252e8d56e4659443448 100644 (file)
@@ -948,6 +948,7 @@ static int unqueue_me(struct futex_q *q)
        /* In the common case we don't take the spinlock, which is nice. */
  retry:
        lock_ptr = q->lock_ptr;
+       barrier();
        if (lock_ptr != 0) {
                spin_lock(lock_ptr);
                /*
index d1aab1a452ccd338f12d325e681e6010ddab7dd9..c5cca3f65cb776f2757e4bd5eeb167a4f84f6ffd 100644 (file)
@@ -39,7 +39,7 @@ void compat_exit_robust_list(struct task_struct *curr)
 {
        struct compat_robust_list_head __user *head = curr->compat_robust_list;
        struct robust_list __user *entry, *pending;
-       unsigned int limit = ROBUST_LIST_LIMIT, pi;
+       unsigned int limit = ROBUST_LIST_LIMIT, pi, pip;
        compat_uptr_t uentry, upending;
        compat_long_t futex_offset;
 
@@ -59,10 +59,10 @@ void compat_exit_robust_list(struct task_struct *curr)
         * if it exists:
         */
        if (fetch_robust_entry(&upending, &pending,
-                              &head->list_op_pending, &pi))
+                              &head->list_op_pending, &pip))
                return;
        if (upending)
-               handle_futex_death((void *)pending + futex_offset, curr, pi);
+               handle_futex_death((void *)pending + futex_offset, curr, pip);
 
        while (compat_ptr(uentry) != &head->list) {
                /*
index b2a5f671d6cd3f2d164e44ad20ad7780a7e00377..72e72d2c61e6e412106c2e58733087b9ba16ac81 100644 (file)
@@ -66,13 +66,25 @@ static inline void freeze_process(struct task_struct *p)
        }
 }
 
+static void cancel_freezing(struct task_struct *p)
+{
+       unsigned long flags;
+
+       if (freezing(p)) {
+               pr_debug("  clean up: %s\n", p->comm);
+               do_not_freeze(p);
+               spin_lock_irqsave(&p->sighand->siglock, flags);
+               recalc_sigpending_tsk(p);
+               spin_unlock_irqrestore(&p->sighand->siglock, flags);
+       }
+}
+
 /* 0 = success, else # of processes that we failed to stop */
 int freeze_processes(void)
 {
        int todo, nr_user, user_frozen;
        unsigned long start_time;
        struct task_struct *g, *p;
-       unsigned long flags;
 
        printk( "Stopping tasks: " );
        start_time = jiffies;
@@ -85,6 +97,10 @@ int freeze_processes(void)
                                continue;
                        if (frozen(p))
                                continue;
+                       if (p->state == TASK_TRACED && frozen(p->parent)) {
+                               cancel_freezing(p);
+                               continue;
+                       }
                        if (p->mm && !(p->flags & PF_BORROWED_MM)) {
                                /* The task is a user-space one.
                                 * Freeze it unless there's a vfork completion
@@ -126,13 +142,7 @@ int freeze_processes(void)
                do_each_thread(g, p) {
                        if (freezeable(p) && !frozen(p))
                                printk(KERN_ERR "  %s\n", p->comm);
-                       if (freezing(p)) {
-                               pr_debug("  clean up: %s\n", p->comm);
-                               p->flags &= ~PF_FREEZE;
-                               spin_lock_irqsave(&p->sighand->siglock, flags);
-                               recalc_sigpending_tsk(p);
-                               spin_unlock_irqrestore(&p->sighand->siglock, flags);
-                       }
+                       cancel_freezing(p);
                } while_each_thread(g, p);
                read_unlock(&tasklist_lock);
                return todo;
index 65ca0688f86f1b78fafd144671a17015b2fd1525..1149365e989edee40639bda0cd6865204e05cc89 100644 (file)
@@ -799,6 +799,9 @@ void release_console_sem(void)
                up(&secondary_console_sem);
                return;
        }
+
+       console_may_schedule = 0;
+
        for ( ; ; ) {
                spin_lock_irqsave(&logbuf_lock, flags);
                wake_klogd |= log_start - log_end;
@@ -812,7 +815,6 @@ void release_console_sem(void)
                local_irq_restore(flags);
        }
        console_locked = 0;
-       console_may_schedule = 0;
        up(&console_sem);
        spin_unlock_irqrestore(&logbuf_lock, flags);
        if (wake_klogd && !oops_in_progress && waitqueue_active(&log_wait)) {
index 0dd3a857579e4fe1b9aae9463aac4717e149eaa9..46286434af8066af359143df81244e0c3024de19 100644 (file)
@@ -244,6 +244,7 @@ int find_next_system_ram(struct resource *res)
 
        start = res->start;
        end = res->end;
+       BUG_ON(start >= end);
 
        read_lock(&resource_lock);
        for (p = iomem_resource.child; p ; p = p->sibling) {
@@ -254,15 +255,17 @@ int find_next_system_ram(struct resource *res)
                        p = NULL;
                        break;
                }
-               if (p->start >= start)
+               if ((p->end >= start) && (p->start < end))
                        break;
        }
        read_unlock(&resource_lock);
        if (!p)
                return -1;
        /* copy data */
-       res->start = p->start;
-       res->end = p->end;
+       if (res->start < p->start)
+               res->start = p->start;
+       if (res->end > p->end)
+               res->end = p->end;
        return 0;
 }
 #endif
index 3d9c4dc965ed5d3f90173eff828da22fac0ccb4b..58c577dd82e5240e551d151b73ea31c55de8c309 100644 (file)
@@ -162,6 +162,7 @@ static void rwlock_bug(rwlock_t *lock, const char *msg)
 
 #define RWLOCK_BUG_ON(cond, lock, msg) if (unlikely(cond)) rwlock_bug(lock, msg)
 
+#if 0          /* __write_lock_debug() can lock up - maybe this can too? */
 static void __read_lock_debug(rwlock_t *lock)
 {
        int print_once = 1;
@@ -184,12 +185,12 @@ static void __read_lock_debug(rwlock_t *lock)
                }
        }
 }
+#endif
 
 void _raw_read_lock(rwlock_t *lock)
 {
        RWLOCK_BUG_ON(lock->magic != RWLOCK_MAGIC, lock, "bad magic");
-       if (unlikely(!__raw_read_trylock(&lock->raw_lock)))
-               __read_lock_debug(lock);
+       __raw_read_lock(&lock->raw_lock);
 }
 
 int _raw_read_trylock(rwlock_t *lock)
@@ -235,6 +236,7 @@ static inline void debug_write_unlock(rwlock_t *lock)
        lock->owner_cpu = -1;
 }
 
+#if 0          /* This can cause lockups */
 static void __write_lock_debug(rwlock_t *lock)
 {
        int print_once = 1;
@@ -257,12 +259,12 @@ static void __write_lock_debug(rwlock_t *lock)
                }
        }
 }
+#endif
 
 void _raw_write_lock(rwlock_t *lock)
 {
        debug_write_lock_before(lock);
-       if (unlikely(!__raw_write_trylock(&lock->raw_lock)))
-               __write_lock_debug(lock);
+       __raw_write_lock(&lock->raw_lock);
        debug_write_lock_after(lock);
 }
 
index 60a5d55e51d949588cc60fb5ed8f138b37f372ad..168c78a121bb0f67835dabcae5e3f4edb74e8e7d 100644 (file)
@@ -73,7 +73,6 @@ asmlinkage long sys_fadvise64_64(int fd, loff_t offset, loff_t len, int advice)
                file->f_ra.ra_pages = bdi->ra_pages * 2;
                break;
        case POSIX_FADV_WILLNEED:
-       case POSIX_FADV_NOREUSE:
                if (!mapping->a_ops->readpage) {
                        ret = -EINVAL;
                        break;
@@ -94,6 +93,8 @@ asmlinkage long sys_fadvise64_64(int fd, loff_t offset, loff_t len, int advice)
                if (ret > 0)
                        ret = 0;
                break;
+       case POSIX_FADV_NOREUSE:
+               break;
        case POSIX_FADV_DONTNEED:
                if (!bdi_write_congested(mapping->backing_dev_info))
                        filemap_flush(mapping);
index 01c9fb97c619135edce3431d265e397f49113b58..c37319542b700a92339fdfc4427a5fc4d6fa2ee4 100644 (file)
@@ -52,6 +52,9 @@ static int __add_section(struct zone *zone, unsigned long phys_start_pfn)
        int nr_pages = PAGES_PER_SECTION;
        int ret;
 
+       if (pfn_valid(phys_start_pfn))
+               return -EEXIST;
+
        ret = sparse_add_one_section(zone, phys_start_pfn, nr_pages);
 
        if (ret < 0)
@@ -76,15 +79,22 @@ int __add_pages(struct zone *zone, unsigned long phys_start_pfn,
 {
        unsigned long i;
        int err = 0;
+       int start_sec, end_sec;
+       /* during initialize mem_map, align hot-added range to section */
+       start_sec = pfn_to_section_nr(phys_start_pfn);
+       end_sec = pfn_to_section_nr(phys_start_pfn + nr_pages - 1);
 
-       for (i = 0; i < nr_pages; i += PAGES_PER_SECTION) {
-               err = __add_section(zone, phys_start_pfn + i);
+       for (i = start_sec; i <= end_sec; i++) {
+               err = __add_section(zone, i << PFN_SECTION_SHIFT);
 
-               /* We want to keep adding the rest of the
-                * sections if the first ones already exist
+               /*
+                * EEXIST is finally dealed with by ioresource collision
+                * check. see add_memory() => register_memory_resource()
+                * Warning will be printed if there is collision.
                 */
                if (err && (err != -EEXIST))
                        break;
+               err = 0;
        }
 
        return err;
@@ -156,7 +166,7 @@ int online_pages(unsigned long pfn, unsigned long nr_pages)
        res.flags = IORESOURCE_MEM; /* we just need system ram */
        section_end = res.end;
 
-       while (find_next_system_ram(&res) >= 0) {
+       while ((res.start < res.end) && (find_next_system_ram(&res) >= 0)) {
                start_pfn = (unsigned long)(res.start >> PAGE_SHIFT);
                nr_pages = (unsigned long)
                            ((res.end + 1 - res.start) >> PAGE_SHIFT);
@@ -213,10 +223,9 @@ static void rollback_node_hotadd(int nid, pg_data_t *pgdat)
 }
 
 /* add this memory to iomem resource */
-static void register_memory_resource(u64 start, u64 size)
+static struct resource *register_memory_resource(u64 start, u64 size)
 {
        struct resource *res;
-
        res = kzalloc(sizeof(struct resource), GFP_KERNEL);
        BUG_ON(!res);
 
@@ -228,7 +237,18 @@ static void register_memory_resource(u64 start, u64 size)
                printk("System RAM resource %llx - %llx cannot be added\n",
                (unsigned long long)res->start, (unsigned long long)res->end);
                kfree(res);
+               res = NULL;
        }
+       return res;
+}
+
+static void release_memory_resource(struct resource *res)
+{
+       if (!res)
+               return;
+       release_resource(res);
+       kfree(res);
+       return;
 }
 
 
@@ -237,8 +257,13 @@ int add_memory(int nid, u64 start, u64 size)
 {
        pg_data_t *pgdat = NULL;
        int new_pgdat = 0;
+       struct resource *res;
        int ret;
 
+       res = register_memory_resource(start, size);
+       if (!res)
+               return -EEXIST;
+
        if (!node_online(nid)) {
                pgdat = hotadd_new_pgdat(nid, start);
                if (!pgdat)
@@ -268,14 +293,13 @@ int add_memory(int nid, u64 start, u64 size)
                BUG_ON(ret);
        }
 
-       /* register this memory as resource */
-       register_memory_resource(start, size);
-
        return ret;
 error:
        /* rollback pgdat allocation and others */
        if (new_pgdat)
                rollback_node_hotadd(nid, pgdat);
+       if (res)
+               release_memory_resource(res);
 
        return ret;
 }
index 7026b0866b7b0d50b0003b15bb14fde24a569a65..00cb388ece032cec8aeba948bb97c0e653eede5e 100644 (file)
@@ -71,7 +71,12 @@ struct cache_head *sunrpc_cache_lookup(struct cache_detail *detail,
        new = detail->alloc();
        if (!new)
                return NULL;
+       /* must fully initialise 'new', else
+        * we might get lose if we need to
+        * cache_put it soon.
+        */
        cache_init(new);
+       detail->init(new, key);
 
        write_lock(&detail->hash_lock);
 
@@ -85,7 +90,6 @@ struct cache_head *sunrpc_cache_lookup(struct cache_detail *detail,
                        return tmp;
                }
        }
-       detail->init(new, key);
        new->next = *head;
        *head = new;
        detail->entries++;