From: Greg Kroah-Hartman Date: Tue, 13 Dec 2011 23:23:53 +0000 (-0800) Subject: 3.0 patches X-Git-Tag: v3.0.14~8 X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=168dc274b72df9bbf0662689033cc7e1ecb51040;p=thirdparty%2Fkernel%2Fstable-queue.git 3.0 patches added patches: hwmon-coretemp-fix-oops-on-cpu-offlining.patch xfs-avoid-synchronous-transactions-when-deleting-attr-blocks.patch xfs-fix-nfs-export-of-64-bit-inodes-numbers-on-32-bit-kernels.patch --- diff --git a/queue-3.0/fix-apparmor-dereferencing-potentially-freed-dentry-sanitize-__d_path-api.patch b/queue-3.0/fix-apparmor-dereferencing-potentially-freed-dentry-sanitize-__d_path-api.patch index 2d01496a6b0..7f4a0273112 100644 --- a/queue-3.0/fix-apparmor-dereferencing-potentially-freed-dentry-sanitize-__d_path-api.patch +++ b/queue-3.0/fix-apparmor-dereferencing-potentially-freed-dentry-sanitize-__d_path-api.patch @@ -61,8 +61,8 @@ Signed-off-by: Greg Kroah-Hartman include/linux/dcache.h | 3 + include/linux/fs.h | 1 security/apparmor/path.c | 65 ++++++++++++++++++++++++----------------- - security/tomoyo/realpath.c | 3 - - 7 files changed, 100 insertions(+), 69 deletions(-) + security/tomoyo/realpath.c | 9 +++-- + 7 files changed, 105 insertions(+), 70 deletions(-) --- a/fs/dcache.c +++ b/fs/dcache.c @@ -442,12 +442,18 @@ Signed-off-by: Greg Kroah-Hartman char *pos; buf_len <<= 1; kfree(buf); -@@ -129,7 +128,7 @@ char *tomoyo_realpath_from_path(struct p +@@ -128,8 +127,12 @@ char *tomoyo_realpath_from_path(struct p + /* If we don't have a vfsmount, we can't calculate. */ if (!path->mnt) break; - /* go to whatever namespace root we are under */ +- /* go to whatever namespace root we are under */ - pos = __d_path(path, &ns_root, buf, buf_len); -+ pos = d_absolute_path(path, buffer, buflen - 1); ++ pos = d_absolute_path(path, buf, buf_len - 1); ++ /* If path is disconnected, use "[unknown]" instead. */ ++ if (pos == ERR_PTR(-EINVAL)) { ++ name = tomoyo_encode("[unknown]"); ++ break; ++ } /* Prepend "/proc" prefix if using internal proc vfs mount. */ if (!IS_ERR(pos) && (path->mnt->mnt_flags & MNT_INTERNAL) && (path->mnt->mnt_sb->s_magic == PROC_SUPER_MAGIC)) { diff --git a/queue-3.0/hwmon-coretemp-fix-oops-on-cpu-offlining.patch b/queue-3.0/hwmon-coretemp-fix-oops-on-cpu-offlining.patch new file mode 100644 index 00000000000..87f3d06fa58 --- /dev/null +++ b/queue-3.0/hwmon-coretemp-fix-oops-on-cpu-offlining.patch @@ -0,0 +1,35 @@ +From khali@linux-fr.org Tue Dec 13 14:30:57 2011 +From: Jean Delvare +Date: Tue, 13 Dec 2011 10:45:55 +0100 +Subject: hwmon: (coretemp) Fix oops on CPU offlining +To: stable@kernel.org +Cc: Guenter Roeck , Greg KH +Message-ID: <20111213104555.648b3cdf@endymion.delvare> + +This is for stable kernel branch 3.0 only. Previous and later versions +have different code paths and are not affected by this bug. + +This is the same fix as "hwmon: (coretemp) Fix oops on driver load" +but for the CPU offlining case. Sorry for missing it at first. + +Signed-off-by: Jean Delvare +Cc: Durgadoss R +Acked-by: Guenter Roeck +Cc: Fenghua Yu +Signed-off-by: Greg Kroah-Hartman + +--- + drivers/hwmon/coretemp.c | 2 ++ + 1 file changed, 2 insertions(+) + +--- a/drivers/hwmon/coretemp.c ++++ b/drivers/hwmon/coretemp.c +@@ -747,6 +747,8 @@ static void __cpuinit put_core_offline(u + return; + + pdata = platform_get_drvdata(pdev); ++ if (!pdata) ++ return; + + indx = TO_ATTR_NO(cpu); + diff --git a/queue-3.0/series b/queue-3.0/series index d6b006b85d6..7e39bc1ae2e 100644 --- a/queue-3.0/series +++ b/queue-3.0/series @@ -27,3 +27,6 @@ x86-hpet-immediately-disable-hpet-timer-1-if-rtc-irq-is-masked.patch jbd-jbd2-validate-sb-s_first-in-journal_get_superblock.patch make-taskstats-require-root-access.patch hfs-fix-hfs_find_init-sb-ext_tree-null-ptr-oops.patch +hwmon-coretemp-fix-oops-on-cpu-offlining.patch +xfs-fix-nfs-export-of-64-bit-inodes-numbers-on-32-bit-kernels.patch +xfs-avoid-synchronous-transactions-when-deleting-attr-blocks.patch diff --git a/queue-3.0/xfs-avoid-synchronous-transactions-when-deleting-attr-blocks.patch b/queue-3.0/xfs-avoid-synchronous-transactions-when-deleting-attr-blocks.patch new file mode 100644 index 00000000000..7f1afda6ba5 --- /dev/null +++ b/queue-3.0/xfs-avoid-synchronous-transactions-when-deleting-attr-blocks.patch @@ -0,0 +1,98 @@ +From hch@infradead.org Tue Dec 13 14:31:52 2011 +From: Christoph Hellwig +Date: Mon, 12 Dec 2011 17:22:46 -0500 +Subject: xfs: avoid synchronous transactions when deleting attr blocks +To: stable@vger.kernel.org, xfs@oss.sgi.com +Message-ID: <20111212222246.GC16123@infradead.org> +Content-Disposition: inline + +From: Christoph Hellwig + +commit 859f57ca00805e6c482eef1a7ab073097d02c8ca upstream. + +[slightly different from the upstream version because of a previous cleanup] + +Currently xfs_attr_inactive causes a synchronous transactions if we are +removing a file that has any extents allocated to the attribute fork, and +thus makes XFS extremely slow at removing files with out of line extended +attributes. The code looks a like a relict from the days before the busy +extent list, but with the busy extent list we avoid reusing data and attr +extents that have been freed but not commited yet, so this code is just +as superflous as the synchronous transactions for data blocks. + +Signed-off-by: Christoph Hellwig +Reported-by: Bernd Schubert +Reviewed-by: Dave Chinner +Signed-off-by: Alex Elder +Signed-off-by: Greg Kroah-Hartman + +--- + fs/xfs/xfs_attr.c | 14 +++----------- + fs/xfs/xfs_bmap.c | 10 +--------- + fs/xfs/xfs_inode.c | 8 -------- + 3 files changed, 4 insertions(+), 28 deletions(-) + +--- a/fs/xfs/xfs_attr.c ++++ b/fs/xfs/xfs_attr.c +@@ -822,17 +822,9 @@ xfs_attr_inactive(xfs_inode_t *dp) + error = xfs_attr_root_inactive(&trans, dp); + if (error) + goto out; +- /* +- * signal synchronous inactive transactions unless this +- * is a synchronous mount filesystem in which case we +- * know that we're here because we've been called out of +- * xfs_inactive which means that the last reference is gone +- * and the unlink transaction has already hit the disk so +- * async inactive transactions are safe. +- */ +- if ((error = xfs_itruncate_finish(&trans, dp, 0LL, XFS_ATTR_FORK, +- (!(mp->m_flags & XFS_MOUNT_WSYNC) +- ? 1 : 0)))) ++ ++ error = xfs_itruncate_finish(&trans, dp, 0LL, XFS_ATTR_FORK, 0); ++ if (error) + goto out; + + /* +--- a/fs/xfs/xfs_bmap.c ++++ b/fs/xfs/xfs_bmap.c +@@ -3785,19 +3785,11 @@ xfs_bmap_compute_maxlevels( + * Routine to be called at transaction's end by xfs_bmapi, xfs_bunmapi + * caller. Frees all the extents that need freeing, which must be done + * last due to locking considerations. We never free any extents in +- * the first transaction. This is to allow the caller to make the first +- * transaction a synchronous one so that the pointers to the data being +- * broken in this transaction will be permanent before the data is actually +- * freed. This is necessary to prevent blocks from being reallocated +- * and written to before the free and reallocation are actually permanent. +- * We do not just make the first transaction synchronous here, because +- * there are more efficient ways to gain the same protection in some cases +- * (see the file truncation code). ++ * the first transaction. + * + * Return 1 if the given transaction was committed and a new one + * started, and 0 otherwise in the committed parameter. + */ +-/*ARGSUSED*/ + int /* error */ + xfs_bmap_finish( + xfs_trans_t **tp, /* transaction pointer addr */ +--- a/fs/xfs/xfs_inode.c ++++ b/fs/xfs/xfs_inode.c +@@ -1528,15 +1528,7 @@ xfs_itruncate_finish( + xfs_trans_log_inode(ntp, ip, XFS_ILOG_CORE); + } + } +- } else if (sync) { +- ASSERT(!(mp->m_flags & XFS_MOUNT_WSYNC)); +- if (ip->i_d.di_anextents > 0) +- xfs_trans_set_sync(ntp); + } +- ASSERT(fork == XFS_DATA_FORK || +- (fork == XFS_ATTR_FORK && +- ((sync && !(mp->m_flags & XFS_MOUNT_WSYNC)) || +- (sync == 0 && (mp->m_flags & XFS_MOUNT_WSYNC))))); + + /* + * Since it is possible for space to become allocated beyond diff --git a/queue-3.0/xfs-fix-nfs-export-of-64-bit-inodes-numbers-on-32-bit-kernels.patch b/queue-3.0/xfs-fix-nfs-export-of-64-bit-inodes-numbers-on-32-bit-kernels.patch new file mode 100644 index 00000000000..1b1f5307bf8 --- /dev/null +++ b/queue-3.0/xfs-fix-nfs-export-of-64-bit-inodes-numbers-on-32-bit-kernels.patch @@ -0,0 +1,57 @@ +From hch@infradead.org Tue Dec 13 14:31:25 2011 +From: Christoph Hellwig +Date: Mon, 12 Dec 2011 17:22:29 -0500 +Subject: xfs: fix nfs export of 64-bit inodes numbers on 32-bit kernels +To: stable@vger.kernel.org, xfs@oss.sgi.com +Message-ID: <20111212222229.GB16123@infradead.org> +Content-Disposition: inline + +From: Christoph Hellwig + +commit c29f7d457ac63311feb11928a866efd2fe153d74 upstream. + +The i_ino field in the VFS inode is of type unsigned long and thus can't +hold the full 64-bit inode number on 32-bit kernels. We have the full +inode number in the XFS inode, so use that one for nfs exports. Note +that I've also switched the 32-bit file handles types to it, just to make +the code more consistent and copy & paste errors less likely to happen. + +Reported-by: Guoquan Yang +Reported-by: Hank Peng +Signed-off-by: Christoph Hellwig +Signed-off-by: Ben Myers +Signed-off-by: Greg Kroah-Hartman + +--- + fs/xfs/linux-2.6/xfs_export.c | 8 ++++---- + 1 file changed, 4 insertions(+), 4 deletions(-) + +--- a/fs/xfs/linux-2.6/xfs_export.c ++++ b/fs/xfs/linux-2.6/xfs_export.c +@@ -98,22 +98,22 @@ xfs_fs_encode_fh( + switch (fileid_type) { + case FILEID_INO32_GEN_PARENT: + spin_lock(&dentry->d_lock); +- fid->i32.parent_ino = dentry->d_parent->d_inode->i_ino; ++ fid->i32.parent_ino = XFS_I(dentry->d_parent->d_inode)->i_ino; + fid->i32.parent_gen = dentry->d_parent->d_inode->i_generation; + spin_unlock(&dentry->d_lock); + /*FALLTHRU*/ + case FILEID_INO32_GEN: +- fid->i32.ino = inode->i_ino; ++ fid->i32.ino = XFS_I(inode)->i_ino; + fid->i32.gen = inode->i_generation; + break; + case FILEID_INO32_GEN_PARENT | XFS_FILEID_TYPE_64FLAG: + spin_lock(&dentry->d_lock); +- fid64->parent_ino = dentry->d_parent->d_inode->i_ino; ++ fid64->parent_ino = XFS_I(dentry->d_parent->d_inode)->i_ino; + fid64->parent_gen = dentry->d_parent->d_inode->i_generation; + spin_unlock(&dentry->d_lock); + /*FALLTHRU*/ + case FILEID_INO32_GEN | XFS_FILEID_TYPE_64FLAG: +- fid64->ino = inode->i_ino; ++ fid64->ino = XFS_I(inode)->i_ino; + fid64->gen = inode->i_generation; + break; + }