Magellan Linux

  • Back to homepage
    • /[pkg-src]/trunk/kernel26-alx/patches-2.6.27-r3/0150-2.6.27.51-all-fixes.patch

    Contents of /trunk/kernel26-alx/patches-2.6.27-r3/0150-2.6.27.51-all-fixes.patch

    Parent Directory Parent Directory | Revision Log Revision Log

    Revision 1176 - (show annotations) (download)
    Thu Oct 14 15:11:06 2010 UTC (13 years, 6 months ago) by niro
    File size: 14882 byte(s) 
    -2.6.27-alx-r3: new magellan 0.5.2 kernel
    1 diff --git a/arch/x86/xen/enlighten.c b/arch/x86/xen/enlighten.c
    2 index 001c099..07e27f7 100644
    3 --- a/arch/x86/xen/enlighten.c
    4 +++ b/arch/x86/xen/enlighten.c
    5 @@ -1179,7 +1179,7 @@ static const struct pv_time_ops xen_time_ops __initdata = {
    6 .set_wallclock = xen_set_wallclock,
    7 .get_wallclock = xen_get_wallclock,
    8 .get_tsc_khz = xen_tsc_khz,
    9 - .sched_clock = xen_sched_clock,
    10 + .sched_clock = xen_clocksource_read,
    11 };
    12
    13 static const struct pv_cpu_ops xen_cpu_ops __initdata = {
    14 diff --git a/arch/x86/xen/time.c b/arch/x86/xen/time.c
    15 index 685b774..d0f176e 100644
    16 --- a/arch/x86/xen/time.c
    17 +++ b/arch/x86/xen/time.c
    18 @@ -30,8 +30,6 @@
    19 #define TIMER_SLOP 100000
    20 #define NS_PER_TICK (1000000000LL / HZ)
    21
    22 -static cycle_t xen_clocksource_read(void);
    23 -
    24 /* runstate info updated by Xen */
    25 static DEFINE_PER_CPU(struct vcpu_runstate_info, runstate);
    26
    27 @@ -158,45 +156,6 @@ static void do_stolen_accounting(void)
    28 account_steal_time(idle_task(smp_processor_id()), ticks);
    29 }
    30
    31 -/*
    32 - * Xen sched_clock implementation. Returns the number of unstolen
    33 - * nanoseconds, which is nanoseconds the VCPU spent in RUNNING+BLOCKED
    34 - * states.
    35 - */
    36 -unsigned long long xen_sched_clock(void)
    37 -{
    38 - struct vcpu_runstate_info state;
    39 - cycle_t now;
    40 - u64 ret;
    41 - s64 offset;
    42 -
    43 - /*
    44 - * Ideally sched_clock should be called on a per-cpu basis
    45 - * anyway, so preempt should already be disabled, but that's
    46 - * not current practice at the moment.
    47 - */
    48 - preempt_disable();
    49 -
    50 - now = xen_clocksource_read();
    51 -
    52 - get_runstate_snapshot(&state);
    53 -
    54 - WARN_ON(state.state != RUNSTATE_running);
    55 -
    56 - offset = now - state.state_entry_time;
    57 - if (offset < 0)
    58 - offset = 0;
    59 -
    60 - ret = state.time[RUNSTATE_blocked] +
    61 - state.time[RUNSTATE_running] +
    62 - offset;
    63 -
    64 - preempt_enable();
    65 -
    66 - return ret;
    67 -}
    68 -
    69 -
    70 /* Get the TSC speed from Xen */
    71 unsigned long xen_tsc_khz(void)
    72 {
    73 @@ -213,7 +172,7 @@ unsigned long xen_tsc_khz(void)
    74 return xen_khz;
    75 }
    76
    77 -static cycle_t xen_clocksource_read(void)
    78 +cycle_t xen_clocksource_read(void)
    79 {
    80 struct pvclock_vcpu_time_info *src;
    81 cycle_t ret;
    82 diff --git a/arch/x86/xen/xen-ops.h b/arch/x86/xen/xen-ops.h
    83 index dd3c231..8a3c823 100644
    84 --- a/arch/x86/xen/xen-ops.h
    85 +++ b/arch/x86/xen/xen-ops.h
    86 @@ -3,6 +3,7 @@
    87
    88 #include <linux/init.h>
    89 #include <linux/irqreturn.h>
    90 +#include <linux/clocksource.h>
    91 #include <xen/xen-ops.h>
    92
    93 /* These are code, but not functions. Defined in entry.S */
    94 @@ -37,7 +38,7 @@ unsigned long xen_tsc_khz(void);
    95 void __init xen_time_init(void);
    96 unsigned long xen_get_wallclock(void);
    97 int xen_set_wallclock(unsigned long time);
    98 -unsigned long long xen_sched_clock(void);
    99 +cycle_t xen_clocksource_read(void);
    100
    101 irqreturn_t xen_debug_interrupt(int irq, void *dev_id);
    102
    103 diff --git a/drivers/char/nvram.c b/drivers/char/nvram.c
    104 index 39f6357..1a5d40d 100644
    105 --- a/drivers/char/nvram.c
    106 +++ b/drivers/char/nvram.c
    107 @@ -265,10 +265,16 @@ nvram_write(struct file *file, const char __user *buf, size_t count, loff_t *ppo
    108 unsigned char contents[NVRAM_BYTES];
    109 unsigned i = *ppos;
    110 unsigned char *tmp;
    111 - int len;
    112
    113 - len = (NVRAM_BYTES - i) < count ? (NVRAM_BYTES - i) : count;
    114 - if (copy_from_user(contents, buf, len))
    115 + if (i >= NVRAM_BYTES)
    116 + return 0; /* Past EOF */
    117 +
    118 + if (count > NVRAM_BYTES - i)
    119 + count = NVRAM_BYTES - i;
    120 + if (count > NVRAM_BYTES)
    121 + return -EFAULT; /* Can't happen, but prove it to gcc */
    122 +
    123 + if (copy_from_user(contents, buf, count))
    124 return -EFAULT;
    125
    126 spin_lock_irq(&rtc_lock);
    127 @@ -276,7 +282,7 @@ nvram_write(struct file *file, const char __user *buf, size_t count, loff_t *ppo
    128 if (!__nvram_check_checksum())
    129 goto checksum_err;
    130
    131 - for (tmp = contents; count-- > 0 && i < NVRAM_BYTES; ++i, ++tmp)
    132 + for (tmp = contents; count--; ++i, ++tmp)
    133 __nvram_write_byte(*tmp, i);
    134
    135 __nvram_set_checksum();
    136 diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
    137 index dbf51e9..6fcedbe 100644
    138 --- a/drivers/md/raid10.c
    139 +++ b/drivers/md/raid10.c
    140 @@ -818,11 +818,29 @@ static int make_request(struct request_queue *q, struct bio * bio)
    141 */
    142 bp = bio_split(bio, bio_split_pool,
    143 chunk_sects - (bio->bi_sector & (chunk_sects - 1)) );
    144 +
    145 + /* Each of these 'make_request' calls will call 'wait_barrier'.
    146 + * If the first succeeds but the second blocks due to the resync
    147 + * thread raising the barrier, we will deadlock because the
    148 + * IO to the underlying device will be queued in generic_make_request
    149 + * and will never complete, so will never reduce nr_pending.
    150 + * So increment nr_waiting here so no new raise_barriers will
    151 + * succeed, and so the second wait_barrier cannot block.
    152 + */
    153 + spin_lock_irq(&conf->resync_lock);
    154 + conf->nr_waiting++;
    155 + spin_unlock_irq(&conf->resync_lock);
    156 +
    157 if (make_request(q, &bp->bio1))
    158 generic_make_request(&bp->bio1);
    159 if (make_request(q, &bp->bio2))
    160 generic_make_request(&bp->bio2);
    161
    162 + spin_lock_irq(&conf->resync_lock);
    163 + conf->nr_waiting--;
    164 + wake_up(&conf->wait_barrier);
    165 + spin_unlock_irq(&conf->resync_lock);
    166 +
    167 bio_pair_release(bp);
    168 return 0;
    169 bad_map:
    170 diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c
    171 index 5368689..e09684e 100644
    172 --- a/drivers/pci/quirks.c
    173 +++ b/drivers/pci/quirks.c
    174 @@ -1833,6 +1833,7 @@ DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_ATI, PCI_DEVICE_ID_ATI_RS480, quirk_disabl
    175 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_VT3336, quirk_disable_all_msi);
    176 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_VT3351, quirk_disable_all_msi);
    177 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_VT3364, quirk_disable_all_msi);
    178 +DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_VIA, PCI_DEVICE_ID_VIA_8380_0, quirk_disable_all_msi);
    179
    180 /* Disable MSI on chipsets that are known to not support it */
    181 static void __devinit quirk_disable_msi(struct pci_dev *dev)
    182 diff --git a/fs/ecryptfs/file.c b/fs/ecryptfs/file.c
    183 index bbc723a..45cb94c 100644
    184 --- a/fs/ecryptfs/file.c
    185 +++ b/fs/ecryptfs/file.c
    186 @@ -199,7 +199,7 @@ static int ecryptfs_open(struct inode *inode, struct file *file)
    187 "the persistent file for the dentry with name "
    188 "[%s]; rc = [%d]\n", __func__,
    189 ecryptfs_dentry->d_name.name, rc);
    190 - goto out;
    191 + goto out_free;
    192 }
    193 }
    194 if ((ecryptfs_inode_to_private(inode)->lower_file->f_flags & O_RDONLY)
    195 @@ -207,7 +207,7 @@ static int ecryptfs_open(struct inode *inode, struct file *file)
    196 rc = -EPERM;
    197 printk(KERN_WARNING "%s: Lower persistent file is RO; eCryptfs "
    198 "file must hence be opened RO\n", __func__);
    199 - goto out;
    200 + goto out_free;
    201 }
    202 ecryptfs_set_file_lower(
    203 file, ecryptfs_inode_to_private(inode)->lower_file);
    204 @@ -303,12 +303,40 @@ static int ecryptfs_fasync(int fd, struct file *file, int flag)
    205 return rc;
    206 }
    207
    208 -static int ecryptfs_ioctl(struct inode *inode, struct file *file,
    209 - unsigned int cmd, unsigned long arg);
    210 +static long
    211 +ecryptfs_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
    212 +{
    213 + struct file *lower_file = NULL;
    214 + long rc = -ENOTTY;
    215 +
    216 + if (ecryptfs_file_to_private(file))
    217 + lower_file = ecryptfs_file_to_lower(file);
    218 + if (lower_file && lower_file->f_op && lower_file->f_op->unlocked_ioctl)
    219 + rc = lower_file->f_op->unlocked_ioctl(lower_file, cmd, arg);
    220 + return rc;
    221 +}
    222 +
    223 +#ifdef CONFIG_COMPAT
    224 +static long
    225 +ecryptfs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
    226 +{
    227 + struct file *lower_file = NULL;
    228 + long rc = -ENOIOCTLCMD;
    229 +
    230 + if (ecryptfs_file_to_private(file))
    231 + lower_file = ecryptfs_file_to_lower(file);
    232 + if (lower_file && lower_file->f_op && lower_file->f_op->compat_ioctl)
    233 + rc = lower_file->f_op->compat_ioctl(lower_file, cmd, arg);
    234 + return rc;
    235 +}
    236 +#endif
    237
    238 const struct file_operations ecryptfs_dir_fops = {
    239 .readdir = ecryptfs_readdir,
    240 - .ioctl = ecryptfs_ioctl,
    241 + .unlocked_ioctl = ecryptfs_unlocked_ioctl,
    242 +#ifdef CONFIG_COMPAT
    243 + .compat_ioctl = ecryptfs_compat_ioctl,
    244 +#endif
    245 .mmap = generic_file_mmap,
    246 .open = ecryptfs_open,
    247 .flush = ecryptfs_flush,
    248 @@ -325,7 +353,10 @@ const struct file_operations ecryptfs_main_fops = {
    249 .write = do_sync_write,
    250 .aio_write = generic_file_aio_write,
    251 .readdir = ecryptfs_readdir,
    252 - .ioctl = ecryptfs_ioctl,
    253 + .unlocked_ioctl = ecryptfs_unlocked_ioctl,
    254 +#ifdef CONFIG_COMPAT
    255 + .compat_ioctl = ecryptfs_compat_ioctl,
    256 +#endif
    257 .mmap = generic_file_mmap,
    258 .open = ecryptfs_open,
    259 .flush = ecryptfs_flush,
    260 @@ -334,20 +365,3 @@ const struct file_operations ecryptfs_main_fops = {
    261 .fasync = ecryptfs_fasync,
    262 .splice_read = generic_file_splice_read,
    263 };
    264 -
    265 -static int
    266 -ecryptfs_ioctl(struct inode *inode, struct file *file, unsigned int cmd,
    267 - unsigned long arg)
    268 -{
    269 - int rc = 0;
    270 - struct file *lower_file = NULL;
    271 -
    272 - if (ecryptfs_file_to_private(file))
    273 - lower_file = ecryptfs_file_to_lower(file);
    274 - if (lower_file && lower_file->f_op && lower_file->f_op->ioctl)
    275 - rc = lower_file->f_op->ioctl(ecryptfs_inode_to_lower(inode),
    276 - lower_file, cmd, arg);
    277 - else
    278 - rc = -ENOTTY;
    279 - return rc;
    280 -}
    281 diff --git a/fs/jfs/xattr.c b/fs/jfs/xattr.c
    282 index 9b7f2cd..f35a40b 100644
    283 --- a/fs/jfs/xattr.c
    284 +++ b/fs/jfs/xattr.c
    285 @@ -85,46 +85,25 @@ struct ea_buffer {
    286 #define EA_MALLOC 0x0008
    287
    288
    289 +static int is_known_namespace(const char *name)
    290 +{
    291 + if (strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN) &&
    292 + strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN) &&
    293 + strncmp(name, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) &&
    294 + strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN))
    295 + return false;
    296 +
    297 + return true;
    298 +}
    299 +
    300 /*
    301 * These three routines are used to recognize on-disk extended attributes
    302 * that are in a recognized namespace. If the attribute is not recognized,
    303 * "os2." is prepended to the name
    304 */
    305 -static inline int is_os2_xattr(struct jfs_ea *ea)
    306 +static int is_os2_xattr(struct jfs_ea *ea)
    307 {
    308 - /*
    309 - * Check for "system."
    310 - */
    311 - if ((ea->namelen >= XATTR_SYSTEM_PREFIX_LEN) &&
    312 - !strncmp(ea->name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN))
    313 - return false;
    314 - /*
    315 - * Check for "user."
    316 - */
    317 - if ((ea->namelen >= XATTR_USER_PREFIX_LEN) &&
    318 - !strncmp(ea->name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN))
    319 - return false;
    320 - /*
    321 - * Check for "security."
    322 - */
    323 - if ((ea->namelen >= XATTR_SECURITY_PREFIX_LEN) &&
    324 - !strncmp(ea->name, XATTR_SECURITY_PREFIX,
    325 - XATTR_SECURITY_PREFIX_LEN))
    326 - return false;
    327 - /*
    328 - * Check for "trusted."
    329 - */
    330 - if ((ea->namelen >= XATTR_TRUSTED_PREFIX_LEN) &&
    331 - !strncmp(ea->name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN))
    332 - return false;
    333 - /*
    334 - * Add any other valid namespace prefixes here
    335 - */
    336 -
    337 - /*
    338 - * We assume it's OS/2's flat namespace
    339 - */
    340 - return true;
    341 + return !is_known_namespace(ea->name);
    342 }
    343
    344 static inline int name_size(struct jfs_ea *ea)
    345 @@ -768,13 +747,23 @@ static int can_set_xattr(struct inode *inode, const char *name,
    346 if (!strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN))
    347 return can_set_system_xattr(inode, name, value, value_len);
    348
    349 + if (!strncmp(name, XATTR_OS2_PREFIX, XATTR_OS2_PREFIX_LEN)) {
    350 + /*
    351 + * This makes sure that we aren't trying to set an
    352 + * attribute in a different namespace by prefixing it
    353 + * with "os2."
    354 + */
    355 + if (is_known_namespace(name + XATTR_OS2_PREFIX_LEN))
    356 + return -EOPNOTSUPP;
    357 + return 0;
    358 + }
    359 +
    360 /*
    361 * Don't allow setting an attribute in an unknown namespace.
    362 */
    363 if (strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN) &&
    364 strncmp(name, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) &&
    365 - strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN) &&
    366 - strncmp(name, XATTR_OS2_PREFIX, XATTR_OS2_PREFIX_LEN))
    367 + strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN))
    368 return -EOPNOTSUPP;
    369
    370 return 0;
    371 @@ -956,19 +945,8 @@ ssize_t __jfs_getxattr(struct inode *inode, const char *name, void *data,
    372 int xattr_size;
    373 ssize_t size;
    374 int namelen = strlen(name);
    375 - char *os2name = NULL;
    376 char *value;
    377
    378 - if (strncmp(name, XATTR_OS2_PREFIX, XATTR_OS2_PREFIX_LEN) == 0) {
    379 - os2name = kmalloc(namelen - XATTR_OS2_PREFIX_LEN + 1,
    380 - GFP_KERNEL);
    381 - if (!os2name)
    382 - return -ENOMEM;
    383 - strcpy(os2name, name + XATTR_OS2_PREFIX_LEN);
    384 - name = os2name;
    385 - namelen -= XATTR_OS2_PREFIX_LEN;
    386 - }
    387 -
    388 down_read(&JFS_IP(inode)->xattr_sem);
    389
    390 xattr_size = ea_get(inode, &ea_buf, 0);
    391 @@ -1006,8 +984,6 @@ ssize_t __jfs_getxattr(struct inode *inode, const char *name, void *data,
    392 out:
    393 up_read(&JFS_IP(inode)->xattr_sem);
    394
    395 - kfree(os2name);
    396 -
    397 return size;
    398 }
    399
    400 @@ -1016,6 +992,19 @@ ssize_t jfs_getxattr(struct dentry *dentry, const char *name, void *data,
    401 {
    402 int err;
    403
    404 + if (strncmp(name, XATTR_OS2_PREFIX, XATTR_OS2_PREFIX_LEN) == 0) {
    405 + /*
    406 + * skip past "os2." prefix
    407 + */
    408 + name += XATTR_OS2_PREFIX_LEN;
    409 + /*
    410 + * Don't allow retrieving properly prefixed attributes
    411 + * by prepending them with "os2."
    412 + */
    413 + if (is_known_namespace(name))
    414 + return -EOPNOTSUPP;
    415 + }
    416 +
    417 err = __jfs_getxattr(dentry->d_inode, name, data, buf_size);
    418
    419 return err;
    420 diff --git a/fs/signalfd.c b/fs/signalfd.c
    421 index b07565c..d98bea8 100644
    422 --- a/fs/signalfd.c
    423 +++ b/fs/signalfd.c
    424 @@ -87,6 +87,7 @@ static int signalfd_copyinfo(struct signalfd_siginfo __user *uinfo,
    425 err |= __put_user(kinfo->si_tid, &uinfo->ssi_tid);
    426 err |= __put_user(kinfo->si_overrun, &uinfo->ssi_overrun);
    427 err |= __put_user((long) kinfo->si_ptr, &uinfo->ssi_ptr);
    428 + err |= __put_user(kinfo->si_int, &uinfo->ssi_int);
    429 break;
    430 case __SI_POLL:
    431 err |= __put_user(kinfo->si_band, &uinfo->ssi_band);
    432 @@ -110,6 +111,7 @@ static int signalfd_copyinfo(struct signalfd_siginfo __user *uinfo,
    433 err |= __put_user(kinfo->si_pid, &uinfo->ssi_pid);
    434 err |= __put_user(kinfo->si_uid, &uinfo->ssi_uid);
    435 err |= __put_user((long) kinfo->si_ptr, &uinfo->ssi_ptr);
    436 + err |= __put_user(kinfo->si_int, &uinfo->ssi_int);
    437 break;
    438 default:
    439 /*
    440 diff --git a/fs/splice.c b/fs/splice.c
    441 index 2f2d8c1..4e1ea5e 100644
    442 --- a/fs/splice.c
    443 +++ b/fs/splice.c
    444 @@ -366,17 +366,7 @@ __generic_file_splice_read(struct file *in, loff_t *ppos,
    445 * If the page isn't uptodate, we may need to start io on it
    446 */
    447 if (!PageUptodate(page)) {
    448 - /*
    449 - * If in nonblock mode then dont block on waiting
    450 - * for an in-flight io page
    451 - */
    452 - if (flags & SPLICE_F_NONBLOCK) {
    453 - if (!trylock_page(page)) {
    454 - error = -EAGAIN;
    455 - break;
    456 - }
    457 - } else
    458 - lock_page(page);
    459 + lock_page(page);
    460
    461 /*
    462 * Page was truncated, or invalidated by the
    463 diff --git a/mm/backing-dev.c b/mm/backing-dev.c
    464 index f2e574d..801c08b 100644
    465 --- a/mm/backing-dev.c
    466 +++ b/mm/backing-dev.c
    467 @@ -176,6 +176,9 @@ int bdi_register(struct backing_dev_info *bdi, struct device *parent,
    468 int ret = 0;
    469 struct device *dev;
    470
    471 + if (bdi->dev) /* The driver needs to use separate queues per device */
    472 + goto exit;
    473 +
    474 va_start(args, fmt);
    475 dev = device_create_vargs(bdi_class, parent, MKDEV(0, 0), bdi, fmt, args);
    476 va_end(args);