Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs-2.6
authorLinus Torvalds <torvalds@linux-foundation.org>
Sun, 10 May 2009 17:49:08 +0000 (10:49 -0700)
committerLinus Torvalds <torvalds@linux-foundation.org>
Sun, 10 May 2009 17:49:08 +0000 (10:49 -0700)
* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs-2.6: (22 commits)
  Fix the race between capifs remount and node creation
  Fix races around the access to ->s_options
  switch ufs directories to ufs_sync_file()
  Switch open_exec() and sys_uselib() to do_open_filp()
  Make open_exec() and sys_uselib() use may_open(), instead of duplicating its parts
  Reduce path_lookup() abuses
  Make checkpatch.pl shut up on fs/inode.c
  NULL noise in fs/super.c:kill_bdev_super()
  romfs: cleanup romfs_fs.h
  ROMFS: romfs_dev_read() error ignored
  fs: dcache fix LRU ordering
  ocfs2: Use nd_set_link().
  Fix deadlock in ipathfs ->get_sb()
  Fix a leak in failure exit in 9p ->get_sb()
  Convert obvious places to deactivate_locked_super()
  New helper: deactivate_locked_super()
  reiserfs: remove privroot hiding in lookup
  reiserfs: dont associate security.* with xattr files
  reiserfs: fixup xattr_root caching
  Always lookup priv_root on reiserfs mount and keep it
  ...

47 files changed:
arch/arm/mach-ixp4xx/ixp4xx_npe.c
drivers/media/radio/radio-sf16fmi.c
drivers/media/radio/radio-sf16fmr2.c
drivers/media/video/cafe_ccic.c
drivers/media/video/cx23885/cx23885-dvb.c
drivers/media/video/ivtv/ivtv-driver.c
drivers/media/video/ivtv/ivtv-gpio.c
drivers/media/video/ivtv/ivtv-ioctl.c
drivers/media/video/ivtv/ivtv-irq.c
drivers/media/video/ivtv/ivtv-yuv.c
drivers/media/video/ivtv/ivtvfb.c
drivers/media/video/uvc/uvc_driver.c
drivers/media/video/uvc/uvc_video.c
drivers/media/video/v4l2-ioctl.c
drivers/media/video/zoran/zoran_driver.c
drivers/net/arm/ixp4xx_eth.c
drivers/net/bnx2.c
drivers/net/bonding/bond_main.c
drivers/net/igb/igb_main.c
drivers/net/wan/ixp4xx_hss.c
drivers/net/wireless/iwlwifi/iwl-sta.c
drivers/net/wireless/iwlwifi/iwl3945-base.c
fs/gfs2/glock.c
include/linux/netfilter/xt_LED.h
include/linux/netfilter/xt_cluster.h
include/sound/version.h
net/Kconfig
net/bluetooth/hci_sysfs.c
net/core/skbuff.c
net/ipv4/Kconfig
net/ipv6/netfilter/ip6t_ipv6header.c
net/mac80211/rc80211_minstrel.c
net/mac80211/rc80211_pid_algo.c
net/mac80211/tx.c
net/netfilter/ipvs/ip_vs_conn.c
net/netfilter/ipvs/ip_vs_core.c
net/netfilter/nf_conntrack_netlink.c
net/netfilter/xt_cluster.c
net/sched/sch_fifo.c
net/wimax/op-msg.c
net/wimax/stack.c
net/wireless/reg.c
net/wireless/scan.c
sound/drivers/serial-u16550.c
sound/pci/hda/patch_sigmatel.c
sound/pci/via82xx.c
sound/soc/codecs/wm8990.c

index 252310234903d96147cc737729231cf9c161c392..7bb8e778e4b6eecc286368c90dda2dce0a3d421d 100644 (file)
@@ -714,7 +714,7 @@ static int __init npe_init_module(void)
        }
 
        if (!found)
-               return -ENOSYS;
+               return -ENODEV;
        return 0;
 }
 
index 1dba8f0832a05427aa094683d0be06807955d75e..5cf6c45b91fe4c2559d4764469cd2cf3af160ca9 100644 (file)
@@ -153,7 +153,7 @@ static int vidioc_g_tuner(struct file *file, void *priv,
        mult = (fmi->flags & V4L2_TUNER_CAP_LOW) ? 1 : 1000;
        v->rangelow = RSF16_MINFREQ / mult;
        v->rangehigh = RSF16_MAXFREQ / mult;
-       v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_MODE_STEREO;
+       v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
        v->capability = fmi->flags & V4L2_TUNER_CAP_LOW;
        v->audmode = V4L2_TUNER_MODE_STEREO;
        v->signal = fmi_getsigstr(fmi);
index c09ca8600ea1d0a2e3219bd26e2d511a0b7e9e6f..935ff9bcdfcc6b4775455857bb0a2604fe3d9758 100644 (file)
@@ -233,7 +233,7 @@ static int vidioc_g_tuner(struct file *file, void *priv,
        mult = (fmr2->flags & V4L2_TUNER_CAP_LOW) ? 1 : 1000;
        v->rangelow = RSF16_MINFREQ / mult;
        v->rangehigh = RSF16_MAXFREQ / mult;
-       v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_MODE_STEREO;
+       v->rxsubchans = V4L2_TUNER_SUB_MONO | V4L2_TUNER_SUB_STEREO;
        v->capability = fmr2->flags&V4L2_TUNER_CAP_LOW;
        v->audmode = fmr2->stereo ? V4L2_TUNER_MODE_STEREO:
                                V4L2_TUNER_MODE_MONO;
index 5f582726985d8d39ea773c7ed14149f9d2733e39..c4d181dde1cafb17ebf6ec80d2b20f9125b5cae9 100644 (file)
@@ -774,6 +774,7 @@ static int cafe_cam_init(struct cafe_camera *cam)
        ret = __cafe_cam_reset(cam);
        if (ret)
                goto out;
+       chip.ident = V4L2_IDENT_NONE;
        chip.match.type = V4L2_CHIP_MATCH_I2C_ADDR;
        chip.match.addr = cam->sensor_addr;
        ret = sensor_call(cam, core, g_chip_ident, &chip);
index 0c49a98213c4cab43ed65c67f8c00173e4f54632..1dc070da8652b8bcc5fdca72cfae39760944fe65 100644 (file)
@@ -472,7 +472,7 @@ static int dvb_register(struct cx23885_tsport *port)
                        static struct xc2028_ctrl ctl = {
                                .fname       = XC2028_DEFAULT_FIRMWARE,
                                .max_len     = 64,
-                               .scode_table = XC3028_FE_OREN538,
+                               .demod       = XC3028_FE_OREN538,
                        };
 
                        fe = dvb_attach(xc2028_attach,
index b0195e8ee4d1d45d64ba17792e94a53fd06642f8..db2ac9a99acd68b96f5af3e439acd4206ed3e01a 100644 (file)
@@ -305,14 +305,17 @@ int ivtv_waitq(wait_queue_head_t *waitq)
 /* Generic utility functions */
 int ivtv_msleep_timeout(unsigned int msecs, int intr)
 {
-       int ret;
        int timeout = msecs_to_jiffies(msecs);
 
        do {
                set_current_state(intr ? TASK_INTERRUPTIBLE : TASK_UNINTERRUPTIBLE);
                timeout = schedule_timeout(timeout);
-               if (intr && (ret = signal_pending(current)))
-                       return ret;
+               if (intr) {
+                       int ret = signal_pending(current);
+
+                       if (ret)
+                               return ret;
+               }
        } while (timeout);
        return 0;
 }
index ceb05bdcaf62c80c5cd3ee145e49b70da3c4d5b6..85ac707228e74377a9d4dd81ea5132146f2a07b1 100644 (file)
@@ -190,8 +190,8 @@ static int subdev_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
 
        mask = itv->card->gpio_audio_detect.mask;
        if (mask == 0 || (read_reg(IVTV_REG_GPIO_IN) & mask))
-               vt->rxsubchans = V4L2_TUNER_MODE_STEREO |
-                       V4L2_TUNER_MODE_LANG1 | V4L2_TUNER_MODE_LANG2;
+               vt->rxsubchans = V4L2_TUNER_SUB_STEREO |
+                       V4L2_TUNER_SUB_LANG1 | V4L2_TUNER_SUB_LANG2;
        else
                vt->rxsubchans = V4L2_TUNER_SUB_MONO;
        return 0;
index 4a2d464f055e633e94d39554e346c8d38e2c75c6..c342a9fe983eab8246c912ac60070f25923a48bd 100644 (file)
@@ -180,7 +180,7 @@ int ivtv_set_speed(struct ivtv *itv, int speed)
 
                /* Wait for any DMA to finish */
                prepare_to_wait(&itv->dma_waitq, &wait, TASK_INTERRUPTIBLE);
-               while (itv->i_flags & IVTV_F_I_DMA) {
+               while (test_bit(IVTV_F_I_DMA, &itv->i_flags)) {
                        got_sig = signal_pending(current);
                        if (got_sig)
                                break;
@@ -1710,7 +1710,8 @@ static int ivtv_decoder_ioctls(struct file *filp, unsigned int cmd, void *arg)
                           we are waiting unlock first and later lock again. */
                        mutex_unlock(&itv->serialize_lock);
                        prepare_to_wait(&itv->event_waitq, &wait, TASK_INTERRUPTIBLE);
-                       if ((itv->i_flags & (IVTV_F_I_EV_DEC_STOPPED|IVTV_F_I_EV_VSYNC)) == 0)
+                       if (!test_bit(IVTV_F_I_EV_DEC_STOPPED, &itv->i_flags) &&
+                           !test_bit(IVTV_F_I_EV_VSYNC, &itv->i_flags))
                                schedule();
                        finish_wait(&itv->event_waitq, &wait);
                        mutex_lock(&itv->serialize_lock);
index 01c14d2b381a3111ab9db4389aa8ce09a8dd4757..cd9db0bf33bf078946d08307a2414b901c9c1cde 100644 (file)
@@ -196,7 +196,7 @@ static int stream_enc_dma_append(struct ivtv_stream *s, u32 data[CX2341X_MBOX_MA
                                bytes_needed, s->name);
                return -1;
        }
-       if (rc && !s->buffers_stolen && (s->s_flags & IVTV_F_S_APPL_IO)) {
+       if (rc && !s->buffers_stolen && test_bit(IVTV_F_S_APPL_IO, &s->s_flags)) {
                IVTV_WARN("All %s stream buffers are full. Dropping data.\n", s->name);
                IVTV_WARN("Cause: the application is not reading fast enough.\n");
        }
index 7912ed6b72eec0e70a4028cfefc66efe04dbb1d8..c0875378acc2ffa372426c8ea05ed8497cddd7a8 100644 (file)
@@ -1063,7 +1063,8 @@ static int ivtv_yuv_udma_frame(struct ivtv *itv, struct ivtv_dma_frame *args)
        prepare_to_wait(&itv->dma_waitq, &wait, TASK_INTERRUPTIBLE);
        /* if no UDMA is pending and no UDMA is in progress, then the DMA
           is finished */
-       while (itv->i_flags & (IVTV_F_I_UDMA_PENDING | IVTV_F_I_UDMA)) {
+       while (test_bit(IVTV_F_I_UDMA_PENDING, &itv->i_flags) ||
+              test_bit(IVTV_F_I_UDMA, &itv->i_flags)) {
                /* don't interrupt if the DMA is in progress but break off
                   a still pending DMA. */
                got_sig = signal_pending(current);
index 66e6eb513076a8073831bacdc462e34955c9d885..fa6bb85cb4b06ebf7626f5dd6557b9d345107bee 100644 (file)
@@ -298,7 +298,8 @@ static int ivtvfb_prep_dec_dma_to_device(struct ivtv *itv,
        prepare_to_wait(&itv->dma_waitq, &wait, TASK_INTERRUPTIBLE);
        /* if no UDMA is pending and no UDMA is in progress, then the DMA
           is finished */
-       while (itv->i_flags & (IVTV_F_I_UDMA_PENDING | IVTV_F_I_UDMA)) {
+       while (test_bit(IVTV_F_I_UDMA_PENDING, &itv->i_flags) ||
+              test_bit(IVTV_F_I_UDMA, &itv->i_flags)) {
                /* don't interrupt if the DMA is in progress but break off
                   a still pending DMA. */
                got_sig = signal_pending(current);
index 399412d7f020db9b19278994ff9e826111bd0e23..507dc85646b2312256d7096aff7ea0e536caba3f 100644 (file)
@@ -1726,14 +1726,17 @@ static int uvc_suspend(struct usb_interface *intf, pm_message_t message)
 static int __uvc_resume(struct usb_interface *intf, int reset)
 {
        struct uvc_device *dev = usb_get_intfdata(intf);
-       int ret;
 
        uvc_trace(UVC_TRACE_SUSPEND, "Resuming interface %u\n",
                intf->cur_altsetting->desc.bInterfaceNumber);
 
        if (intf->cur_altsetting->desc.bInterfaceSubClass == SC_VIDEOCONTROL) {
-               if (reset && (ret = uvc_ctrl_resume_device(dev)) < 0)
-                       return ret;
+               if (reset) {
+                       int ret = uvc_ctrl_resume_device(dev);
+
+                       if (ret < 0)
+                               return ret;
+               }
 
                return uvc_status_resume(dev);
        }
index a95e17329c5bb366d6eb7d70039a3328e8dbbc77..6ce974d7362f2d2c442f6d7174693eb1419b9f37 100644 (file)
@@ -742,7 +742,7 @@ static int uvc_alloc_urb_buffers(struct uvc_video_device *video,
 
        /* Buffers are already allocated, bail out. */
        if (video->urb_size)
-               return 0;
+               return video->urb_size / psize;
 
        /* Compute the number of packets. Bulk endpoints might transfer UVC
         * payloads accross multiple URBs.
index 88f10d6cbc92e899fd2c19d7f65797685728e5cd..be64a502ea276e5a49ee3c97bea6d3f9a52a2fec 100644 (file)
                        printk(KERN_DEBUG "%s: " fmt, vfd->name, ## arg);\
                } while (0)
 
+/* Zero out the end of the struct pointed to by p.  Everthing after, but
+ * not including, the specified field is cleared. */
+#define CLEAR_AFTER_FIELD(p, field) \
+       memset((u8 *)(p) + offsetof(typeof(*(p)), field) + sizeof((p)->field), \
+       0, sizeof(*(p)) - offsetof(typeof(*(p)), field) - sizeof((p)->field))
+
 struct std_descr {
        v4l2_std_id std;
        const char *descr;
@@ -544,39 +550,39 @@ static int check_fmt(const struct v4l2_ioctl_ops *ops, enum v4l2_buf_type type)
 
        switch (type) {
        case V4L2_BUF_TYPE_VIDEO_CAPTURE:
-               if (ops->vidioc_try_fmt_vid_cap)
+               if (ops->vidioc_g_fmt_vid_cap)
                        return 0;
                break;
        case V4L2_BUF_TYPE_VIDEO_OVERLAY:
-               if (ops->vidioc_try_fmt_vid_overlay)
+               if (ops->vidioc_g_fmt_vid_overlay)
                        return 0;
                break;
        case V4L2_BUF_TYPE_VIDEO_OUTPUT:
-               if (ops->vidioc_try_fmt_vid_out)
+               if (ops->vidioc_g_fmt_vid_out)
                        return 0;
                break;
        case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
-               if (ops->vidioc_try_fmt_vid_out_overlay)
+               if (ops->vidioc_g_fmt_vid_out_overlay)
                        return 0;
                break;
        case V4L2_BUF_TYPE_VBI_CAPTURE:
-               if (ops->vidioc_try_fmt_vbi_cap)
+               if (ops->vidioc_g_fmt_vbi_cap)
                        return 0;
                break;
        case V4L2_BUF_TYPE_VBI_OUTPUT:
-               if (ops->vidioc_try_fmt_vbi_out)
+               if (ops->vidioc_g_fmt_vbi_out)
                        return 0;
                break;
        case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
-               if (ops->vidioc_try_fmt_sliced_vbi_cap)
+               if (ops->vidioc_g_fmt_sliced_vbi_cap)
                        return 0;
                break;
        case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
-               if (ops->vidioc_try_fmt_sliced_vbi_out)
+               if (ops->vidioc_g_fmt_sliced_vbi_out)
                        return 0;
                break;
        case V4L2_BUF_TYPE_PRIVATE:
-               if (ops->vidioc_try_fmt_type_private)
+               if (ops->vidioc_g_fmt_type_private)
                        return 0;
                break;
        }
@@ -782,44 +788,53 @@ static long __video_do_ioctl(struct file *file,
 
                switch (f->type) {
                case V4L2_BUF_TYPE_VIDEO_CAPTURE:
+                       CLEAR_AFTER_FIELD(f, fmt.pix);
                        v4l_print_pix_fmt(vfd, &f->fmt.pix);
                        if (ops->vidioc_s_fmt_vid_cap)
                                ret = ops->vidioc_s_fmt_vid_cap(file, fh, f);
                        break;
                case V4L2_BUF_TYPE_VIDEO_OVERLAY:
+                       CLEAR_AFTER_FIELD(f, fmt.win);
                        if (ops->vidioc_s_fmt_vid_overlay)
                                ret = ops->vidioc_s_fmt_vid_overlay(file,
                                                                    fh, f);
                        break;
                case V4L2_BUF_TYPE_VIDEO_OUTPUT:
+                       CLEAR_AFTER_FIELD(f, fmt.pix);
                        v4l_print_pix_fmt(vfd, &f->fmt.pix);
                        if (ops->vidioc_s_fmt_vid_out)
                                ret = ops->vidioc_s_fmt_vid_out(file, fh, f);
                        break;
                case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
+                       CLEAR_AFTER_FIELD(f, fmt.win);
                        if (ops->vidioc_s_fmt_vid_out_overlay)
                                ret = ops->vidioc_s_fmt_vid_out_overlay(file,
                                        fh, f);
                        break;
                case V4L2_BUF_TYPE_VBI_CAPTURE:
+                       CLEAR_AFTER_FIELD(f, fmt.vbi);
                        if (ops->vidioc_s_fmt_vbi_cap)
                                ret = ops->vidioc_s_fmt_vbi_cap(file, fh, f);
                        break;
                case V4L2_BUF_TYPE_VBI_OUTPUT:
+                       CLEAR_AFTER_FIELD(f, fmt.vbi);
                        if (ops->vidioc_s_fmt_vbi_out)
                                ret = ops->vidioc_s_fmt_vbi_out(file, fh, f);
                        break;
                case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
+                       CLEAR_AFTER_FIELD(f, fmt.sliced);
                        if (ops->vidioc_s_fmt_sliced_vbi_cap)
                                ret = ops->vidioc_s_fmt_sliced_vbi_cap(file,
                                                                        fh, f);
                        break;
                case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
+                       CLEAR_AFTER_FIELD(f, fmt.sliced);
                        if (ops->vidioc_s_fmt_sliced_vbi_out)
                                ret = ops->vidioc_s_fmt_sliced_vbi_out(file,
                                                                        fh, f);
                        break;
                case V4L2_BUF_TYPE_PRIVATE:
+                       /* CLEAR_AFTER_FIELD(f, fmt.raw_data); <- does nothing */
                        if (ops->vidioc_s_fmt_type_private)
                                ret = ops->vidioc_s_fmt_type_private(file,
                                                                fh, f);
@@ -836,46 +851,55 @@ static long __video_do_ioctl(struct file *file,
                                                v4l2_type_names));
                switch (f->type) {
                case V4L2_BUF_TYPE_VIDEO_CAPTURE:
+                       CLEAR_AFTER_FIELD(f, fmt.pix);
                        if (ops->vidioc_try_fmt_vid_cap)
                                ret = ops->vidioc_try_fmt_vid_cap(file, fh, f);
                        if (!ret)
                                v4l_print_pix_fmt(vfd, &f->fmt.pix);
                        break;
                case V4L2_BUF_TYPE_VIDEO_OVERLAY:
+                       CLEAR_AFTER_FIELD(f, fmt.win);
                        if (ops->vidioc_try_fmt_vid_overlay)
                                ret = ops->vidioc_try_fmt_vid_overlay(file,
                                        fh, f);
                        break;
                case V4L2_BUF_TYPE_VIDEO_OUTPUT:
+                       CLEAR_AFTER_FIELD(f, fmt.pix);
                        if (ops->vidioc_try_fmt_vid_out)
                                ret = ops->vidioc_try_fmt_vid_out(file, fh, f);
                        if (!ret)
                                v4l_print_pix_fmt(vfd, &f->fmt.pix);
                        break;
                case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
+                       CLEAR_AFTER_FIELD(f, fmt.win);
                        if (ops->vidioc_try_fmt_vid_out_overlay)
                                ret = ops->vidioc_try_fmt_vid_out_overlay(file,
                                       fh, f);
                        break;
                case V4L2_BUF_TYPE_VBI_CAPTURE:
+                       CLEAR_AFTER_FIELD(f, fmt.vbi);
                        if (ops->vidioc_try_fmt_vbi_cap)
                                ret = ops->vidioc_try_fmt_vbi_cap(file, fh, f);
                        break;
                case V4L2_BUF_TYPE_VBI_OUTPUT:
+                       CLEAR_AFTER_FIELD(f, fmt.vbi);
                        if (ops->vidioc_try_fmt_vbi_out)
                                ret = ops->vidioc_try_fmt_vbi_out(file, fh, f);
                        break;
                case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
+                       CLEAR_AFTER_FIELD(f, fmt.sliced);
                        if (ops->vidioc_try_fmt_sliced_vbi_cap)
                                ret = ops->vidioc_try_fmt_sliced_vbi_cap(file,
                                                                fh, f);
                        break;
                case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
+                       CLEAR_AFTER_FIELD(f, fmt.sliced);
                        if (ops->vidioc_try_fmt_sliced_vbi_out)
                                ret = ops->vidioc_try_fmt_sliced_vbi_out(file,
                                                                fh, f);
                        break;
                case V4L2_BUF_TYPE_PRIVATE:
+                       /* CLEAR_AFTER_FIELD(f, fmt.raw_data); <- does nothing */
                        if (ops->vidioc_try_fmt_type_private)
                                ret = ops->vidioc_try_fmt_type_private(file,
                                                                fh, f);
@@ -898,6 +922,9 @@ static long __video_do_ioctl(struct file *file,
                if (ret)
                        break;
 
+               if (p->type < V4L2_BUF_TYPE_PRIVATE)
+                       CLEAR_AFTER_FIELD(p, memory);
+
                ret = ops->vidioc_reqbufs(file, fh, p);
                dbgarg(cmd, "count=%d, type=%s, memory=%s\n",
                                p->count,
index 092333b1c34f5c8808a3148c1b36ca52327e691a..643cccaa1aab7fc377df18bbcee4eeee9d40fbb0 100644 (file)
@@ -1863,22 +1863,20 @@ static int zoran_querycap(struct file *file, void *__fh, struct v4l2_capability
 
 static int zoran_enum_fmt(struct zoran *zr, struct v4l2_fmtdesc *fmt, int flag)
 {
-       int num = -1, i;
-
-       for (i = 0; i < NUM_FORMATS; i++) {
-               if (zoran_formats[i].flags & flag)
-                       num++;
-               if (num == fmt->index)
-                       break;
+       unsigned int num, i;
+
+       for (num = i = 0; i < NUM_FORMATS; i++) {
+               if (zoran_formats[i].flags & flag && num++ == fmt->index) {
+                       strncpy(fmt->description, zoran_formats[i].name,
+                               sizeof(fmt->description) - 1);
+                       /* fmt struct pre-zeroed, so adding '\0' not neeed */
+                       fmt->pixelformat = zoran_formats[i].fourcc;
+                       if (zoran_formats[i].flags & ZORAN_FORMAT_COMPRESSED)
+                               fmt->flags |= V4L2_FMT_FLAG_COMPRESSED;
+                       return 0;
+               }
        }
-       if (fmt->index < 0 /* late, but not too late */  || i == NUM_FORMATS)
-               return -EINVAL;
-
-       strncpy(fmt->description, zoran_formats[i].name, sizeof(fmt->description)-1);
-       fmt->pixelformat = zoran_formats[i].fourcc;
-       if (zoran_formats[i].flags & ZORAN_FORMAT_COMPRESSED)
-               fmt->flags |= V4L2_FMT_FLAG_COMPRESSED;
-       return 0;
+       return -EINVAL;
 }
 
 static int zoran_enum_fmt_vid_cap(struct file *file, void *__fh,
index 448487e22fa3ed3fad9837c2e0bb41bb76b9c2a2..a740053d3af34c00c25a23e9223d8a9d5d0667c9 100644 (file)
@@ -338,12 +338,12 @@ static int ixp4xx_mdio_register(void)
        if (cpu_is_ixp43x()) {
                /* IXP43x lacks NPE-B and uses NPE-C for MII PHY access */
                if (!(ixp4xx_read_feature_bits() & IXP4XX_FEATURE_NPEC_ETH))
-                       return -ENOSYS;
+                       return -ENODEV;
                mdio_regs = (struct eth_regs __iomem *)IXP4XX_EthC_BASE_VIRT;
        } else {
                /* All MII PHY accesses use NPE-B Ethernet registers */
                if (!(ixp4xx_read_feature_bits() & IXP4XX_FEATURE_NPEB_ETH0))
-                       return -ENOSYS;
+                       return -ENODEV;
                mdio_regs = (struct eth_regs __iomem *)IXP4XX_EthB_BASE_VIRT;
        }
 
@@ -1174,7 +1174,7 @@ static int __devinit eth_init_one(struct platform_device *pdev)
                regs_phys  = IXP4XX_EthC_BASE_PHYS;
                break;
        default:
-               err = -ENOSYS;
+               err = -ENODEV;
                goto err_free;
        }
 
@@ -1189,15 +1189,10 @@ static int __devinit eth_init_one(struct platform_device *pdev)
                goto err_free;
        }
 
-       if (register_netdev(dev)) {
-               err = -EIO;
-               goto err_npe_rel;
-       }
-
        port->mem_res = request_mem_region(regs_phys, REGS_SIZE, dev->name);
        if (!port->mem_res) {
                err = -EBUSY;
-               goto err_unreg;
+               goto err_npe_rel;
        }
 
        port->plat = plat;
@@ -1215,20 +1210,25 @@ static int __devinit eth_init_one(struct platform_device *pdev)
        snprintf(phy_id, BUS_ID_SIZE, PHY_ID_FMT, "0", plat->phy);
        port->phydev = phy_connect(dev, phy_id, &ixp4xx_adjust_link, 0,
                                   PHY_INTERFACE_MODE_MII);
-       if (IS_ERR(port->phydev)) {
-               printk(KERN_ERR "%s: Could not attach to PHY\n", dev->name);
-               return PTR_ERR(port->phydev);
-       }
+       if ((err = IS_ERR(port->phydev)))
+               goto err_free_mem;
 
        port->phydev->irq = PHY_POLL;
 
+       if ((err = register_netdev(dev)))
+               goto err_phy_dis;
+
        printk(KERN_INFO "%s: MII PHY %i on %s\n", dev->name, plat->phy,
               npe_name(port->npe));
 
        return 0;
 
-err_unreg:
-       unregister_netdev(dev);
+err_phy_dis:
+       phy_disconnect(port->phydev);
+err_free_mem:
+       npe_port_tab[NPE_ID(port->id)] = NULL;
+       platform_set_drvdata(pdev, NULL);
+       release_resource(port->mem_res);
 err_npe_rel:
        npe_release(port->npe);
 err_free:
@@ -1242,6 +1242,7 @@ static int __devexit eth_remove_one(struct platform_device *pdev)
        struct port *port = netdev_priv(dev);
 
        unregister_netdev(dev);
+       phy_disconnect(port->phydev);
        npe_port_tab[NPE_ID(port->id)] = NULL;
        platform_set_drvdata(pdev, NULL);
        npe_release(port->npe);
index d47839184a0680cbd51440afdc5d85fbd6c60a48..b0cb29d4cc01e735b7855e99f7e3a7c81650d3db 100644 (file)
@@ -54,8 +54,8 @@
 
 #define DRV_MODULE_NAME                "bnx2"
 #define PFX DRV_MODULE_NAME    ": "
-#define DRV_MODULE_VERSION     "2.0.0"
-#define DRV_MODULE_RELDATE     "April 2, 2009"
+#define DRV_MODULE_VERSION     "2.0.1"
+#define DRV_MODULE_RELDATE     "May 6, 2009"
 #define FW_MIPS_FILE_06                "bnx2/bnx2-mips-06-4.6.16.fw"
 #define FW_RV2P_FILE_06                "bnx2/bnx2-rv2p-06-4.6.16.fw"
 #define FW_MIPS_FILE_09                "bnx2/bnx2-mips-09-4.6.17.fw"
@@ -2600,6 +2600,7 @@ bnx2_get_hw_tx_cons(struct bnx2_napi *bnapi)
        /* Tell compiler that status block fields can change. */
        barrier();
        cons = *bnapi->hw_tx_cons_ptr;
+       barrier();
        if (unlikely((cons & MAX_TX_DESC_CNT) == MAX_TX_DESC_CNT))
                cons++;
        return cons;
@@ -2879,6 +2880,7 @@ bnx2_get_hw_rx_cons(struct bnx2_napi *bnapi)
        /* Tell compiler that status block fields can change. */
        barrier();
        cons = *bnapi->hw_rx_cons_ptr;
+       barrier();
        if (unlikely((cons & MAX_RX_DESC_CNT) == MAX_RX_DESC_CNT))
                cons++;
        return cons;
index 2188a96fc090a644594ca17406acd8d041566982..74824028f85c988b370f587e7934828f03c4d6bc 100644 (file)
@@ -5181,7 +5181,6 @@ static int __init bonding_init(void)
 {
        int i;
        int res;
-       struct bonding *bond;
 
        printk(KERN_INFO "%s", version);
 
@@ -5212,13 +5211,6 @@ static int __init bonding_init(void)
 
        goto out;
 err:
-       list_for_each_entry(bond, &bond_dev_list, bond_list) {
-               bond_work_cancel_all(bond);
-               destroy_workqueue(bond->wq);
-       }
-
-       bond_destroy_sysfs();
-
        rtnl_lock();
        bond_free_all();
        rtnl_unlock();
index 08c801490c7250e3708e835d9039abe47899c33e..e25343588fc77466380039a46728ba4bfd8ecd34 100644 (file)
@@ -2006,7 +2006,7 @@ static void igb_setup_rctl(struct igb_adapter *adapter)
        struct e1000_hw *hw = &adapter->hw;
        u32 rctl;
        u32 srrctl = 0;
-       int i, j;
+       int i;
 
        rctl = rd32(E1000_RCTL);
 
@@ -2071,8 +2071,6 @@ static void igb_setup_rctl(struct igb_adapter *adapter)
        if (adapter->vfs_allocated_count) {
                u32 vmolr;
 
-               j = adapter->rx_ring[0].reg_idx;
-
                /* set all queue drop enable bits */
                wr32(E1000_QDE, ALL_QUEUES);
                srrctl |= E1000_SRRCTL_DROP_EN;
@@ -2080,16 +2078,16 @@ static void igb_setup_rctl(struct igb_adapter *adapter)
                /* disable queue 0 to prevent tail write w/o re-config */
                wr32(E1000_RXDCTL(0), 0);
 
-               vmolr = rd32(E1000_VMOLR(j));
+               vmolr = rd32(E1000_VMOLR(adapter->vfs_allocated_count));
                if (rctl & E1000_RCTL_LPE)
                        vmolr |= E1000_VMOLR_LPE;
-               if (adapter->num_rx_queues > 0)
+               if (adapter->num_rx_queues > 1)
                        vmolr |= E1000_VMOLR_RSSE;
-               wr32(E1000_VMOLR(j), vmolr);
+               wr32(E1000_VMOLR(adapter->vfs_allocated_count), vmolr);
        }
 
        for (i = 0; i < adapter->num_rx_queues; i++) {
-               j = adapter->rx_ring[i].reg_idx;
+               int j = adapter->rx_ring[i].reg_idx;
                wr32(E1000_SRRCTL(j), srrctl);
        }
 
index 3bf7d3f447db83002e3e7929e864eeb35303a272..765a7f5d6aa4c7b0ee17dd3d58e970b6d59e2798 100644 (file)
@@ -1249,7 +1249,7 @@ static int __devinit hss_init_one(struct platform_device *pdev)
                return -ENOMEM;
 
        if ((port->npe = npe_request(0)) == NULL) {
-               err = -ENOSYS;
+               err = -ENODEV;
                goto err_free;
        }
 
@@ -1311,7 +1311,7 @@ static int __init hss_init_module(void)
        if ((ixp4xx_read_feature_bits() &
             (IXP4XX_FEATURE_HDLC | IXP4XX_FEATURE_HSS)) !=
            (IXP4XX_FEATURE_HDLC | IXP4XX_FEATURE_HSS))
-               return -ENOSYS;
+               return -ENODEV;
 
        spin_lock_init(&npe_lock);
 
index 5798fe49c771d97d45d8e12e07fac4ad5bf6f492..44ab03a12e40e353014fe56e67e0fd18f815585d 100644 (file)
@@ -719,6 +719,14 @@ static int iwl_set_tkip_dynamic_key_info(struct iwl_priv *priv,
 {
        unsigned long flags;
        int ret = 0;
+       __le16 key_flags = 0;
+
+       key_flags |= (STA_KEY_FLG_TKIP | STA_KEY_FLG_MAP_KEY_MSK);
+       key_flags |= cpu_to_le16(keyconf->keyidx << STA_KEY_FLG_KEYID_POS);
+       key_flags &= ~STA_KEY_FLG_INVALID;
+
+       if (sta_id == priv->hw_params.bcast_sta_id)
+               key_flags |= STA_KEY_MULTICAST_MSK;
 
        keyconf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
        keyconf->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
@@ -738,6 +746,9 @@ static int iwl_set_tkip_dynamic_key_info(struct iwl_priv *priv,
        WARN(priv->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET,
                "no space for a new key");
 
+       priv->stations[sta_id].sta.key.key_flags = key_flags;
+
+
        /* This copy is acutally not needed: we get the key with each TX */
        memcpy(priv->stations[sta_id].keyinfo.key, keyconf->key, 16);
 
@@ -754,9 +765,7 @@ void iwl_update_tkip_key(struct iwl_priv *priv,
 {
        u8 sta_id = IWL_INVALID_STATION;
        unsigned long flags;
-       __le16 key_flags = 0;
        int i;
-       DECLARE_MAC_BUF(mac);
 
        sta_id = iwl_find_station(priv, addr);
        if (sta_id == IWL_INVALID_STATION) {
@@ -771,16 +780,8 @@ void iwl_update_tkip_key(struct iwl_priv *priv,
                return;
        }
 
-       key_flags |= (STA_KEY_FLG_TKIP | STA_KEY_FLG_MAP_KEY_MSK);
-       key_flags |= cpu_to_le16(keyconf->keyidx << STA_KEY_FLG_KEYID_POS);
-       key_flags &= ~STA_KEY_FLG_INVALID;
-
-       if (sta_id == priv->hw_params.bcast_sta_id)
-               key_flags |= STA_KEY_MULTICAST_MSK;
-
        spin_lock_irqsave(&priv->sta_lock, flags);
 
-       priv->stations[sta_id].sta.key.key_flags = key_flags;
        priv->stations[sta_id].sta.key.tkip_rx_tsc_byte2 = (u8) iv32;
 
        for (i = 0; i < 5; i++)
index 70a00c8ee42eeb5a05de6f7f96ff06108370e70f..4cce66133500a04087084ab8eec0979160b7262f 100644 (file)
@@ -1744,7 +1744,6 @@ static void iwl3945_rx_queue_free(struct iwl_priv *priv, struct iwl_rx_queue *rx
        rxq->bd = NULL;
        rxq->rb_stts  = NULL;
 }
-EXPORT_SYMBOL(iwl3945_rx_queue_free);
 
 
 /* Convert linear signal-to-noise ratio into dB */
index 1afd9f26bcb118287bf008355439ea8aba5597fc..ff49810904897788465263af146bcb1ead719567 100644 (file)
@@ -1304,6 +1304,7 @@ static int gfs2_shrink_glock_memory(int nr, gfp_t gfp_mask)
                                nr--;
                                if (queue_delayed_work(glock_workqueue, &gl->gl_work, 0) == 0)
                                        gfs2_glock_put(gl);
+                               got_ref = 0;
                        }
                        spin_lock(&lru_lock);
                        if (may_demote)
index 4c91a0d770d0f90aa08b31ddb7d4a7e79bf653f7..f5509e7524d3c80b96420ae54c21a3528925e036 100644 (file)
@@ -1,6 +1,8 @@
 #ifndef _XT_LED_H
 #define _XT_LED_H
 
+#include <linux/types.h>
+
 struct xt_led_info {
        char id[27];        /* Unique ID for this trigger in the LED class */
        __u8 always_blink;  /* Blink even if the LED is already on */
index 5e0a0d07b526d47e8026440a2d41cab1a45bd00b..886682656f098db6df2dd5cd0327cd5a76c5b6c1 100644 (file)
@@ -12,4 +12,6 @@ struct xt_cluster_match_info {
        u_int32_t               flags;
 };
 
+#define XT_CLUSTER_NODES_MAX   32
+
 #endif /* _XT_CLUSTER_MATCH_H */
index a7e74e23ad2ee92255530f011ad1df12de03e73c..456f1359e1c0f03a2a4c368f82286046e3e04bf2 100644 (file)
@@ -1,3 +1,3 @@
 /* include/version.h */
-#define CONFIG_SND_VERSION "1.0.19"
+#define CONFIG_SND_VERSION "1.0.20"
 #define CONFIG_SND_DATE ""
index ce77db4fcec8c0a5a34a1bb3f918531941e66733..c19f549c8e74c874d3a35f3ae8ba0cfa78a13592 100644 (file)
@@ -119,12 +119,6 @@ menuconfig NETFILTER
          <file:Documentation/Changes> under "iptables" for the location of
          these packages.
 
-         Make sure to say N to "Fast switching" below if you intend to say Y
-         here, as Fast switching currently bypasses netfilter.
-
-         Chances are that you should say Y here if you compile a kernel which
-         will run as a router and N for regular hosts. If unsure, say N.
-
 if NETFILTER
 
 config NETFILTER_DEBUG
index 582d8877078c9894876bf448561fe17804874711..a05d45eb3ba115c16447e108b2781645e4fa85d3 100644 (file)
@@ -88,10 +88,13 @@ static struct device_type bt_link = {
 static void add_conn(struct work_struct *work)
 {
        struct hci_conn *conn = container_of(work, struct hci_conn, work_add);
+       struct hci_dev *hdev = conn->hdev;
 
        /* ensure previous del is complete */
        flush_work(&conn->work_del);
 
+       dev_set_name(&conn->dev, "%s:%d", hdev->name, conn->handle);
+
        if (device_add(&conn->dev) < 0) {
                BT_ERR("Failed to register connection device");
                return;
@@ -154,12 +157,8 @@ void hci_conn_init_sysfs(struct hci_conn *conn)
 
 void hci_conn_add_sysfs(struct hci_conn *conn)
 {
-       struct hci_dev *hdev = conn->hdev;
-
        BT_DBG("conn %p", conn);
 
-       dev_set_name(&conn->dev, "%s:%d", hdev->name, conn->handle);
-
        queue_work(bt_workq, &conn->work_add);
 }
 
index f091a5a845c11c332ee408e452e4e1b89da251e2..d152394b2611e27d9533e7663972d2e3cccc4ea5 100644 (file)
@@ -502,7 +502,9 @@ int skb_recycle_check(struct sk_buff *skb, int skb_size)
        shinfo->gso_segs = 0;
        shinfo->gso_type = 0;
        shinfo->ip6_frag_id = 0;
+       shinfo->tx_flags.flags = 0;
        shinfo->frag_list = NULL;
+       memset(&shinfo->hwtstamps, 0, sizeof(shinfo->hwtstamps));
 
        memset(skb, 0, offsetof(struct sk_buff, tail));
        skb->data = skb->head + NET_SKB_PAD;
index b2cf91e4ccaa11fd140af7ece0c7b11b820e048c..9d26a3da37e5696dfaf385bb0a4474dda239ff14 100644 (file)
@@ -407,7 +407,7 @@ config INET_XFRM_MODE_BEET
          If unsure, say Y.
 
 config INET_LRO
-       tristate "Large Receive Offload (ipv4/tcp)"
+       bool "Large Receive Offload (ipv4/tcp)"
 
        ---help---
          Support for Large Receive Offload (ipv4/tcp).
index 14e6724d5672a7ff291ced4de556da7a7d920d29..91490ad9302ccc692c23fd6f37a7f8e9f78bdb7e 100644 (file)
@@ -50,14 +50,14 @@ ipv6header_mt6(const struct sk_buff *skb, const struct xt_match_param *par)
                struct ipv6_opt_hdr _hdr;
                int hdrlen;
 
-               /* Is there enough space for the next ext header? */
-               if (len < (int)sizeof(struct ipv6_opt_hdr))
-                       return false;
                /* No more exthdr -> evaluate */
                if (nexthdr == NEXTHDR_NONE) {
                        temp |= MASK_NONE;
                        break;
                }
+               /* Is there enough space for the next ext header? */
+               if (len < (int)sizeof(struct ipv6_opt_hdr))
+                       return false;
                /* ESP -> evaluate */
                if (nexthdr == NEXTHDR_ESP) {
                        temp |= MASK_ESP;
index 3824990d340bdb75f5357088740438d8658e6f75..70df3dcc3cf6444ff56d20b6b851cd6cc70b1c7d 100644 (file)
@@ -476,7 +476,7 @@ minstrel_alloc_sta(void *priv, struct ieee80211_sta *sta, gfp_t gfp)
                return NULL;
 
        for (i = 0; i < IEEE80211_NUM_BANDS; i++) {
-               sband = hw->wiphy->bands[hw->conf.channel->band];
+               sband = hw->wiphy->bands[i];
                if (sband->n_bitrates > max_rates)
                        max_rates = sband->n_bitrates;
        }
index b16801cde06f41825b6f0db7fd2f4188ebdbcbf8..01d59a8e334ce832445c1c64ea3136c0bd373636 100644 (file)
@@ -317,13 +317,44 @@ rate_control_pid_rate_init(void *priv, struct ieee80211_supported_band *sband,
                           struct ieee80211_sta *sta, void *priv_sta)
 {
        struct rc_pid_sta_info *spinfo = priv_sta;
+       struct rc_pid_info *pinfo = priv;
+       struct rc_pid_rateinfo *rinfo = pinfo->rinfo;
        struct sta_info *si;
+       int i, j, tmp;
+       bool s;
 
        /* TODO: This routine should consider using RSSI from previous packets
         * as we need to have IEEE 802.1X auth succeed immediately after assoc..
         * Until that method is implemented, we will use the lowest supported
         * rate as a workaround. */
 
+       /* Sort the rates. This is optimized for the most common case (i.e.
+        * almost-sorted CCK+OFDM rates). Kind of bubble-sort with reversed
+        * mapping too. */
+       for (i = 0; i < sband->n_bitrates; i++) {
+               rinfo[i].index = i;
+               rinfo[i].rev_index = i;
+               if (RC_PID_FAST_START)
+                       rinfo[i].diff = 0;
+               else
+                       rinfo[i].diff = i * pinfo->norm_offset;
+       }
+       for (i = 1; i < sband->n_bitrates; i++) {
+               s = 0;
+               for (j = 0; j < sband->n_bitrates - i; j++)
+                       if (unlikely(sband->bitrates[rinfo[j].index].bitrate >
+                                    sband->bitrates[rinfo[j + 1].index].bitrate)) {
+                               tmp = rinfo[j].index;
+                               rinfo[j].index = rinfo[j + 1].index;
+                               rinfo[j + 1].index = tmp;
+                               rinfo[rinfo[j].index].rev_index = j;
+                               rinfo[rinfo[j + 1].index].rev_index = j + 1;
+                               s = 1;
+                       }
+               if (!s)
+                       break;
+       }
+
        spinfo->txrate_idx = rate_lowest_index(sband, sta);
        /* HACK */
        si = container_of(sta, struct sta_info, sta);
@@ -336,21 +367,22 @@ static void *rate_control_pid_alloc(struct ieee80211_hw *hw,
        struct rc_pid_info *pinfo;
        struct rc_pid_rateinfo *rinfo;
        struct ieee80211_supported_band *sband;
-       int i, j, tmp;
-       bool s;
+       int i, max_rates = 0;
 #ifdef CONFIG_MAC80211_DEBUGFS
        struct rc_pid_debugfs_entries *de;
 #endif
 
-       sband = hw->wiphy->bands[hw->conf.channel->band];
-
        pinfo = kmalloc(sizeof(*pinfo), GFP_ATOMIC);
        if (!pinfo)
                return NULL;
 
-       /* We can safely assume that sband won't change unless we get
-        * reinitialized. */
-       rinfo = kmalloc(sizeof(*rinfo) * sband->n_bitrates, GFP_ATOMIC);
+       for (i = 0; i < IEEE80211_NUM_BANDS; i++) {
+               sband = hw->wiphy->bands[i];
+               if (sband->n_bitrates > max_rates)
+                       max_rates = sband->n_bitrates;
+       }
+
+       rinfo = kmalloc(sizeof(*rinfo) * max_rates, GFP_ATOMIC);
        if (!rinfo) {
                kfree(pinfo);
                return NULL;
@@ -368,33 +400,6 @@ static void *rate_control_pid_alloc(struct ieee80211_hw *hw,
        pinfo->rinfo = rinfo;
        pinfo->oldrate = 0;
 
-       /* Sort the rates. This is optimized for the most common case (i.e.
-        * almost-sorted CCK+OFDM rates). Kind of bubble-sort with reversed
-        * mapping too. */
-       for (i = 0; i < sband->n_bitrates; i++) {
-               rinfo[i].index = i;
-               rinfo[i].rev_index = i;
-               if (RC_PID_FAST_START)
-                       rinfo[i].diff = 0;
-               else
-                       rinfo[i].diff = i * pinfo->norm_offset;
-       }
-       for (i = 1; i < sband->n_bitrates; i++) {
-               s = 0;
-               for (j = 0; j < sband->n_bitrates - i; j++)
-                       if (unlikely(sband->bitrates[rinfo[j].index].bitrate >
-                                    sband->bitrates[rinfo[j + 1].index].bitrate)) {
-                               tmp = rinfo[j].index;
-                               rinfo[j].index = rinfo[j + 1].index;
-                               rinfo[j + 1].index = tmp;
-                               rinfo[rinfo[j].index].rev_index = j;
-                               rinfo[rinfo[j + 1].index].rev_index = j + 1;
-                               s = 1;
-                       }
-               if (!s)
-                       break;
-       }
-
 #ifdef CONFIG_MAC80211_DEBUGFS
        de = &pinfo->dentries;
        de->target = debugfs_create_u32("target_pf", S_IRUSR | S_IWUSR,
index 3fb04a86444d959d980f5e7d3e0ce1a2c779a63a..63656266d567e50f5b2d82bc4580d7abdfbf65b4 100644 (file)
@@ -772,7 +772,7 @@ ieee80211_tx_h_fragment(struct ieee80211_tx_data *tx)
        hdrlen = ieee80211_hdrlen(hdr->frame_control);
 
        /* internal error, why is TX_FRAGMENTED set? */
-       if (WARN_ON(skb->len <= frag_threshold))
+       if (WARN_ON(skb->len + FCS_LEN <= frag_threshold))
                return TX_DROP;
 
        /*
index 60aba45023ff7e9d687d356c1aaf4edfebde7e2d..77bfdfeb966e99c0e0212271319fbe4c7eafbe98 100644 (file)
@@ -260,7 +260,10 @@ struct ip_vs_conn *ip_vs_ct_in_get
        list_for_each_entry(cp, &ip_vs_conn_tab[hash], c_list) {
                if (cp->af == af &&
                    ip_vs_addr_equal(af, s_addr, &cp->caddr) &&
-                   ip_vs_addr_equal(af, d_addr, &cp->vaddr) &&
+                   /* protocol should only be IPPROTO_IP if
+                    * d_addr is a fwmark */
+                   ip_vs_addr_equal(protocol == IPPROTO_IP ? AF_UNSPEC : af,
+                                    d_addr, &cp->vaddr) &&
                    s_port == cp->cport && d_port == cp->vport &&
                    cp->flags & IP_VS_CONN_F_TEMPLATE &&
                    protocol == cp->protocol) {
@@ -698,7 +701,9 @@ ip_vs_conn_new(int af, int proto, const union nf_inet_addr *caddr, __be16 cport,
        cp->cport          = cport;
        ip_vs_addr_copy(af, &cp->vaddr, vaddr);
        cp->vport          = vport;
-       ip_vs_addr_copy(af, &cp->daddr, daddr);
+       /* proto should only be IPPROTO_IP if d_addr is a fwmark */
+       ip_vs_addr_copy(proto == IPPROTO_IP ? AF_UNSPEC : af,
+                       &cp->daddr, daddr);
        cp->dport          = dport;
        cp->flags          = flags;
        spin_lock_init(&cp->lock);
index cb3e031335ebc4af9a95e5a359c10c3805c8754d..8dddb17a947a7be424d28e4f987939a02ff5dc54 100644 (file)
@@ -278,7 +278,7 @@ ip_vs_sched_persist(struct ip_vs_service *svc,
                 */
                if (svc->fwmark) {
                        union nf_inet_addr fwmark = {
-                               .all = { 0, 0, 0, htonl(svc->fwmark) }
+                               .ip = htonl(svc->fwmark)
                        };
 
                        ct = ip_vs_ct_in_get(svc->af, IPPROTO_IP, &snet, 0,
@@ -306,7 +306,7 @@ ip_vs_sched_persist(struct ip_vs_service *svc,
                         */
                        if (svc->fwmark) {
                                union nf_inet_addr fwmark = {
-                                       .all = { 0, 0, 0, htonl(svc->fwmark) }
+                                       .ip = htonl(svc->fwmark)
                                };
 
                                ct = ip_vs_conn_new(svc->af, IPPROTO_IP,
index f13fc57e1ecbe14b1a479b00117305b82f1c5702..c523f0b8cee53bd9e304af4db77a4a474c44bcbe 100644 (file)
@@ -1186,28 +1186,6 @@ ctnetlink_change_conntrack(struct nf_conn *ct, struct nlattr *cda[])
        return 0;
 }
 
-static inline void
-ctnetlink_event_report(struct nf_conn *ct, u32 pid, int report)
-{
-       unsigned int events = 0;
-
-       if (test_bit(IPS_EXPECTED_BIT, &ct->status))
-               events |= IPCT_RELATED;
-       else
-               events |= IPCT_NEW;
-
-       nf_conntrack_event_report(IPCT_STATUS |
-                                 IPCT_HELPER |
-                                 IPCT_REFRESH |
-                                 IPCT_PROTOINFO |
-                                 IPCT_NATSEQADJ |
-                                 IPCT_MARK |
-                                 events,
-                                 ct,
-                                 pid,
-                                 report);
-}
-
 static struct nf_conn *
 ctnetlink_create_conntrack(struct nlattr *cda[],
                           struct nf_conntrack_tuple *otuple,
@@ -1373,6 +1351,7 @@ ctnetlink_new_conntrack(struct sock *ctnl, struct sk_buff *skb,
                err = -ENOENT;
                if (nlh->nlmsg_flags & NLM_F_CREATE) {
                        struct nf_conn *ct;
+                       enum ip_conntrack_events events;
 
                        ct = ctnetlink_create_conntrack(cda, &otuple,
                                                        &rtuple, u3);
@@ -1383,9 +1362,18 @@ ctnetlink_new_conntrack(struct sock *ctnl, struct sk_buff *skb,
                        err = 0;
                        nf_conntrack_get(&ct->ct_general);
                        spin_unlock_bh(&nf_conntrack_lock);
-                       ctnetlink_event_report(ct,
-                                              NETLINK_CB(skb).pid,
-                                              nlmsg_report(nlh));
+                       if (test_bit(IPS_EXPECTED_BIT, &ct->status))
+                               events = IPCT_RELATED;
+                       else
+                               events = IPCT_NEW;
+
+                       nf_conntrack_event_report(IPCT_STATUS |
+                                                 IPCT_HELPER |
+                                                 IPCT_PROTOINFO |
+                                                 IPCT_NATSEQADJ |
+                                                 IPCT_MARK | events,
+                                                 ct, NETLINK_CB(skb).pid,
+                                                 nlmsg_report(nlh));
                        nf_ct_put(ct);
                } else
                        spin_unlock_bh(&nf_conntrack_lock);
@@ -1404,9 +1392,13 @@ ctnetlink_new_conntrack(struct sock *ctnl, struct sk_buff *skb,
                if (err == 0) {
                        nf_conntrack_get(&ct->ct_general);
                        spin_unlock_bh(&nf_conntrack_lock);
-                       ctnetlink_event_report(ct,
-                                              NETLINK_CB(skb).pid,
-                                              nlmsg_report(nlh));
+                       nf_conntrack_event_report(IPCT_STATUS |
+                                                 IPCT_HELPER |
+                                                 IPCT_PROTOINFO |
+                                                 IPCT_NATSEQADJ |
+                                                 IPCT_MARK,
+                                                 ct, NETLINK_CB(skb).pid,
+                                                 nlmsg_report(nlh));
                        nf_ct_put(ct);
                } else
                        spin_unlock_bh(&nf_conntrack_lock);
index 6c4847662b8541ff1e808d0269518248930ed7f3..69a639f354031ffa3288e1e8c6a7929fce784762 100644 (file)
@@ -135,7 +135,13 @@ static bool xt_cluster_mt_checkentry(const struct xt_mtchk_param *par)
 {
        struct xt_cluster_match_info *info = par->matchinfo;
 
-       if (info->node_mask >= (1 << info->total_nodes)) {
+       if (info->total_nodes > XT_CLUSTER_NODES_MAX) {
+               printk(KERN_ERR "xt_cluster: you have exceeded the maximum "
+                               "number of cluster nodes (%u > %u)\n",
+                               info->total_nodes, XT_CLUSTER_NODES_MAX);
+               return false;
+       }
+       if (info->node_mask >= (1ULL << info->total_nodes)) {
                printk(KERN_ERR "xt_cluster: this node mask cannot be "
                                "higher than the total number of nodes\n");
                return false;
index 92cfc9d7e3b93486a718bea3712a983814d605f0..69188e8358b4cd6c73e1861bacbea27c6564f7bd 100644 (file)
@@ -51,7 +51,7 @@ static int fifo_init(struct Qdisc *sch, struct nlattr *opt)
                u32 limit = qdisc_dev(sch)->tx_queue_len ? : 1;
 
                if (sch->ops == &bfifo_qdisc_ops)
-                       limit *= qdisc_dev(sch)->mtu;
+                       limit *= psched_mtu(qdisc_dev(sch));
 
                q->limit = limit;
        } else {
index 5d149c1b5f0dee96280e854e38304682afdfbd9d..9ad4d893a566b6e8e8b535a8e4fc0784c13c7098 100644 (file)
@@ -149,7 +149,8 @@ struct sk_buff *wimax_msg_alloc(struct wimax_dev *wimax_dev,
        }
        result = nla_put(skb, WIMAX_GNL_MSG_DATA, size, msg);
        if (result < 0) {
-               dev_err(dev, "no memory to add payload in attribute\n");
+               dev_err(dev, "no memory to add payload (msg %p size %zu) in "
+                       "attribute: %d\n", msg, size, result);
                goto error_nla_put;
        }
        genlmsg_end(skb, genl_msg);
@@ -299,10 +300,10 @@ int wimax_msg(struct wimax_dev *wimax_dev, const char *pipe_name,
        struct sk_buff *skb;
 
        skb = wimax_msg_alloc(wimax_dev, pipe_name, buf, size, gfp_flags);
-       if (skb == NULL)
-               goto error_msg_new;
-       result = wimax_msg_send(wimax_dev, skb);
-error_msg_new:
+       if (IS_ERR(skb))
+               result = PTR_ERR(skb);
+       else
+               result = wimax_msg_send(wimax_dev, skb);
        return result;
 }
 EXPORT_SYMBOL_GPL(wimax_msg);
index a0ee76b525109241fe037721545274c1bda57262..933e1422b09f98de1939347fb4dbb92a963ea36e 100644 (file)
@@ -338,8 +338,21 @@ out:
  */
 void wimax_state_change(struct wimax_dev *wimax_dev, enum wimax_st new_state)
 {
+       /*
+        * A driver cannot take the wimax_dev out of the
+        * __WIMAX_ST_NULL state unless by calling wimax_dev_add(). If
+        * the wimax_dev's state is still NULL, we ignore any request
+        * to change its state because it means it hasn't been yet
+        * registered.
+        *
+        * There is no need to complain about it, as routines that
+        * call this might be shared from different code paths that
+        * are called before or after wimax_dev_add() has done its
+        * job.
+        */
        mutex_lock(&wimax_dev->mutex);
-       __wimax_state_change(wimax_dev, new_state);
+       if (wimax_dev->state > __WIMAX_ST_NULL)
+               __wimax_state_change(wimax_dev, new_state);
        mutex_unlock(&wimax_dev->mutex);
        return;
 }
@@ -376,7 +389,7 @@ EXPORT_SYMBOL_GPL(wimax_state_get);
 void wimax_dev_init(struct wimax_dev *wimax_dev)
 {
        INIT_LIST_HEAD(&wimax_dev->id_table_node);
-       __wimax_state_set(wimax_dev, WIMAX_ST_UNINITIALIZED);
+       __wimax_state_set(wimax_dev, __WIMAX_ST_NULL);
        mutex_init(&wimax_dev->mutex);
        mutex_init(&wimax_dev->mutex_reset);
 }
index 6c1993d99902aaa41d676ea72cf1f1a625892b61..08265ca157853c525a74512306bbe7ac055b72c3 100644 (file)
@@ -907,6 +907,7 @@ EXPORT_SYMBOL(freq_reg_info);
 int freq_reg_info(struct wiphy *wiphy, u32 center_freq, u32 *bandwidth,
                         const struct ieee80211_reg_rule **reg_rule)
 {
+       assert_cfg80211_lock();
        return freq_reg_info_regd(wiphy, center_freq,
                bandwidth, reg_rule, NULL);
 }
@@ -1133,7 +1134,8 @@ static bool reg_is_world_roaming(struct wiphy *wiphy)
        if (is_world_regdom(cfg80211_regdomain->alpha2) ||
            (wiphy->regd && is_world_regdom(wiphy->regd->alpha2)))
                return true;
-       if (last_request->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
+       if (last_request &&
+           last_request->initiator != NL80211_REGDOM_SET_BY_COUNTRY_IE &&
            wiphy->custom_regulatory)
                return true;
        return false;
@@ -1142,6 +1144,12 @@ static bool reg_is_world_roaming(struct wiphy *wiphy)
 /* Reap the advantages of previously found beacons */
 static void reg_process_beacons(struct wiphy *wiphy)
 {
+       /*
+        * Means we are just firing up cfg80211, so no beacons would
+        * have been processed yet.
+        */
+       if (!last_request)
+               return;
        if (!reg_is_world_roaming(wiphy))
                return;
        wiphy_update_beacon_reg(wiphy);
@@ -1176,6 +1184,8 @@ static void handle_channel_custom(struct wiphy *wiphy,
        struct ieee80211_supported_band *sband;
        struct ieee80211_channel *chan;
 
+       assert_cfg80211_lock();
+
        sband = wiphy->bands[band];
        BUG_ON(chan_idx >= sband->n_channels);
        chan = &sband->channels[chan_idx];
@@ -1214,10 +1224,13 @@ void wiphy_apply_custom_regulatory(struct wiphy *wiphy,
                                   const struct ieee80211_regdomain *regd)
 {
        enum ieee80211_band band;
+
+       mutex_lock(&cfg80211_mutex);
        for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
                if (wiphy->bands[band])
                        handle_band_custom(wiphy, band, regd);
        }
+       mutex_unlock(&cfg80211_mutex);
 }
 EXPORT_SYMBOL(wiphy_apply_custom_regulatory);
 
@@ -1423,7 +1436,7 @@ new_request:
        return call_crda(last_request->alpha2);
 }
 
-/* This currently only processes user and driver regulatory hints */
+/* This processes *all* regulatory hints */
 static void reg_process_hint(struct regulatory_request *reg_request)
 {
        int r = 0;
index 2ae65b39b529fd64fd1bde0c88c1570e9ed4fbc4..1f260c40b6ca478954e6a67e8b65cdfb33a2666c 100644 (file)
@@ -395,6 +395,7 @@ cfg80211_bss_update(struct cfg80211_registered_device *dev,
                                        memcpy(ies, res->pub.information_elements, ielen);
                                        found->ies_allocated = true;
                                        found->pub.information_elements = ies;
+                                       found->pub.len_information_elements = ielen;
                                }
                        }
                }
index b2b6d50c942559fcb14474ff1e8281ae947e4db4..a25fb7b1f4414c883a4a0e071f26099f389085b1 100644 (file)
@@ -963,16 +963,11 @@ static int __devinit snd_serial_probe(struct platform_device *devptr)
        if (err < 0)
                goto _err;
 
-       sprintf(card->longname, "%s at 0x%lx, irq %d speed %d div %d outs %d ins %d adaptor %s droponfull %d",
+       sprintf(card->longname, "%s [%s] at %#lx, irq %d",
                card->shortname,
-               uart->base,
-               uart->irq,
-               uart->speed,
-               (int)uart->divisor,
-               outs[dev],
-               ins[dev],
                adaptor_names[uart->adaptor],
-               uart->drop_on_full);
+               uart->base,
+               uart->irq);
 
        snd_card_set_dev(card, &devptr->dev);
 
index 917bc5d3ac2c7f223bb86a56a1027e8a3708a9eb..03b3646018a1a5e7f1cb710780d1e29999a57ac7 100644 (file)
@@ -4079,7 +4079,12 @@ static int stac92xx_init(struct hda_codec *codec)
                                pinctl = snd_hda_codec_read(codec, nid, 0,
                                        AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
                                /* if PINCTL already set then skip */
-                               if (!(pinctl & AC_PINCTL_IN_EN)) {
+                               /* Also, if both INPUT and OUTPUT are set,
+                                * it must be a BIOS bug; need to override, too
+                                */
+                               if (!(pinctl & AC_PINCTL_IN_EN) ||
+                                   (pinctl & AC_PINCTL_OUT_EN)) {
+                                       pinctl &= ~AC_PINCTL_OUT_EN;
                                        pinctl |= AC_PINCTL_IN_EN;
                                        stac92xx_auto_set_pinctl(codec, nid,
                                                                 pinctl);
index 809b233dd4a3add8cb7ef357ae6291a8ad3f083a..1ef58c51c21343c6d7721b5dedfa6c91ddc4071c 100644 (file)
@@ -1687,7 +1687,7 @@ static int snd_via8233_pcmdxs_volume_put(struct snd_kcontrol *kcontrol,
        return change;
 }
 
-static const DECLARE_TLV_DB_SCALE(db_scale_dxs, -9450, 150, 1);
+static const DECLARE_TLV_DB_SCALE(db_scale_dxs, -4650, 150, 1);
 
 static struct snd_kcontrol_new snd_via8233_pcmdxs_volume_control __devinitdata = {
        .name = "PCM Playback Volume",
index c518c3e5aa3f8e10409dc16da5b9640610060c17..40cd274eb1ef51f60588ffaf7ba09e6c44f10a1f 100644 (file)
@@ -729,7 +729,7 @@ SND_SOC_DAPM_MIXER_E("INMIXL", WM8990_INTDRIVBITS, WM8990_INMIXL_PWR_BIT, 0,
        inmixer_event, SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
 
 /* AINLMUX */
-SND_SOC_DAPM_MUX_E("AILNMUX", WM8990_INTDRIVBITS, WM8990_AINLMUX_PWR_BIT, 0,
+SND_SOC_DAPM_MUX_E("AINLMUX", WM8990_INTDRIVBITS, WM8990_AINLMUX_PWR_BIT, 0,
        &wm8990_dapm_ainlmux_controls, inmixer_event,
        SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
 
@@ -740,7 +740,7 @@ SND_SOC_DAPM_MIXER_E("INMIXR", WM8990_INTDRIVBITS, WM8990_INMIXR_PWR_BIT, 0,
        inmixer_event, SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
 
 /* AINRMUX */
-SND_SOC_DAPM_MUX_E("AIRNMUX", WM8990_INTDRIVBITS, WM8990_AINRMUX_PWR_BIT, 0,
+SND_SOC_DAPM_MUX_E("AINRMUX", WM8990_INTDRIVBITS, WM8990_AINRMUX_PWR_BIT, 0,
        &wm8990_dapm_ainrmux_controls, inmixer_event,
        SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
 
@@ -848,40 +848,40 @@ static const struct snd_soc_dapm_route audio_map[] = {
        {"LIN12 PGA", "LIN2 Switch", "LIN2"},
        /* LIN34 PGA */
        {"LIN34 PGA", "LIN3 Switch", "LIN3"},
-       {"LIN34 PGA", "LIN4 Switch", "LIN4"},
+       {"LIN34 PGA", "LIN4 Switch", "LIN4/RXN"},
        /* INMIXL */
        {"INMIXL", "Record Left Volume", "LOMIX"},
        {"INMIXL", "LIN2 Volume", "LIN2"},
        {"INMIXL", "LINPGA12 Switch", "LIN12 PGA"},
        {"INMIXL", "LINPGA34 Switch", "LIN34 PGA"},
-       /* AILNMUX */
-       {"AILNMUX", "INMIXL Mix", "INMIXL"},
-       {"AILNMUX", "DIFFINL Mix", "LIN12PGA"},
-       {"AILNMUX", "DIFFINL Mix", "LIN34PGA"},
-       {"AILNMUX", "RXVOICE Mix", "LIN4/RXN"},
-       {"AILNMUX", "RXVOICE Mix", "RIN4/RXP"},
+       /* AINLMUX */
+       {"AINLMUX", "INMIXL Mix", "INMIXL"},
+       {"AINLMUX", "DIFFINL Mix", "LIN12 PGA"},
+       {"AINLMUX", "DIFFINL Mix", "LIN34 PGA"},
+       {"AINLMUX", "RXVOICE Mix", "LIN4/RXN"},
+       {"AINLMUX", "RXVOICE Mix", "RIN4/RXP"},
        /* ADC */
-       {"Left ADC", NULL, "AILNMUX"},
+       {"Left ADC", NULL, "AINLMUX"},
 
        /* RIN12 PGA */
        {"RIN12 PGA", "RIN1 Switch", "RIN1"},
        {"RIN12 PGA", "RIN2 Switch", "RIN2"},
        /* RIN34 PGA */
        {"RIN34 PGA", "RIN3 Switch", "RIN3"},
-       {"RIN34 PGA", "RIN4 Switch", "RIN4"},
+       {"RIN34 PGA", "RIN4 Switch", "RIN4/RXP"},
        /* INMIXL */
        {"INMIXR", "Record Right Volume", "ROMIX"},
        {"INMIXR", "RIN2 Volume", "RIN2"},
        {"INMIXR", "RINPGA12 Switch", "RIN12 PGA"},
        {"INMIXR", "RINPGA34 Switch", "RIN34 PGA"},
-       /* AIRNMUX */
-       {"AIRNMUX", "INMIXR Mix", "INMIXR"},
-       {"AIRNMUX", "DIFFINR Mix", "RIN12PGA"},
-       {"AIRNMUX", "DIFFINR Mix", "RIN34PGA"},
-       {"AIRNMUX", "RXVOICE Mix", "RIN4/RXN"},
-       {"AIRNMUX", "RXVOICE Mix", "RIN4/RXP"},
+       /* AINRMUX */
+       {"AINRMUX", "INMIXR Mix", "INMIXR"},
+       {"AINRMUX", "DIFFINR Mix", "RIN12 PGA"},
+       {"AINRMUX", "DIFFINR Mix", "RIN34 PGA"},
+       {"AINRMUX", "RXVOICE Mix", "LIN4/RXN"},
+       {"AINRMUX", "RXVOICE Mix", "RIN4/RXP"},
        /* ADC */
-       {"Right ADC", NULL, "AIRNMUX"},
+       {"Right ADC", NULL, "AINRMUX"},
 
        /* LOMIX */
        {"LOMIX", "LOMIX RIN3 Bypass Switch", "RIN3"},
@@ -922,7 +922,7 @@ static const struct snd_soc_dapm_route audio_map[] = {
        {"LOPMIX", "LOPMIX Left Mixer PGA Switch", "LOPGA"},
 
        /* OUT3MIX */
-       {"OUT3MIX", "OUT3MIX LIN4/RXP Bypass Switch", "LIN4/RXP"},
+       {"OUT3MIX", "OUT3MIX LIN4/RXP Bypass Switch", "LIN4/RXN"},
        {"OUT3MIX", "OUT3MIX Left Out PGA Switch", "LOPGA"},
 
        /* OUT4MIX */
@@ -949,7 +949,7 @@ static const struct snd_soc_dapm_route audio_map[] = {
        /* Output Pins */
        {"LON", NULL, "LONMIX"},
        {"LOP", NULL, "LOPMIX"},
-       {"OUT", NULL, "OUT3MIX"},
+       {"OUT3", NULL, "OUT3MIX"},
        {"LOUT", NULL, "LOUT PGA"},
        {"SPKN", NULL, "SPKMIX"},
        {"ROUT", NULL, "ROUT PGA"},