From: Greg Kroah-Hartman Date: Mon, 6 Aug 2012 21:45:56 +0000 (-0700) Subject: 3.5-stable patches X-Git-Tag: v3.5.1~14 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=76444e31d5a571b2a83fd93b91346cd3fc887aae;p=thirdparty%2Fkernel%2Fstable-queue.git 3.5-stable patches added patches: dm-thin-fix-memory-leak-in-process_prepared_mapping-error-paths.patch dm-thin-reduce-endio_hook-pool-size.patch ext4-don-t-let-i_reserved_meta_blocks-go-negative.patch ext4-fix-hole-punch-failure-when-depth-is-greater-than-0.patch ext4-fix-overhead-calculation-used-by-ext4_statfs.patch ext4-pass-a-char-to-ext4_count_free-instead-of-a-buffer_head-ptr.patch ext4-undo-ext4_calc_metadata_amount-if-we-fail-to-claim-space.patch nfsd4-fix-cr_principal-comparison-check-in-same_creds.patch nfsd4-our-filesystems-are-normally-case-sensitive.patch nfs-fix-a-number-of-bugs-in-the-idmapper.patch nfs-skip-commit-in-releasepage-if-we-re-freeing-memory-for-fs-related-reasons.patch nouveau-fix-alignment-requirements-on-src-and-dst-addresses.patch --- diff --git a/queue-3.5/dm-thin-fix-memory-leak-in-process_prepared_mapping-error-paths.patch b/queue-3.5/dm-thin-fix-memory-leak-in-process_prepared_mapping-error-paths.patch new file mode 100644 index 00000000000..14760b0ac8f --- /dev/null +++ b/queue-3.5/dm-thin-fix-memory-leak-in-process_prepared_mapping-error-paths.patch @@ -0,0 +1,50 @@ +From 905386f82d08f66726912f303f3e6605248c60a3 Mon Sep 17 00:00:00 2001 +From: Joe Thornber +Date: Fri, 27 Jul 2012 15:08:05 +0100 +Subject: dm thin: fix memory leak in process_prepared_mapping error paths + +From: Joe Thornber + +commit 905386f82d08f66726912f303f3e6605248c60a3 upstream. + +Fix memory leak in process_prepared_mapping by always freeing +the dm_thin_new_mapping structs from the mapping_pool mempool on +the error paths. + +Signed-off-by: Joe Thornber +Signed-off-by: Mike Snitzer +Signed-off-by: Alasdair G Kergon +Signed-off-by: Greg Kroah-Hartman + +--- + drivers/md/dm-thin.c | 5 +++-- + 1 file changed, 3 insertions(+), 2 deletions(-) + +--- a/drivers/md/dm-thin.c ++++ b/drivers/md/dm-thin.c +@@ -859,7 +859,7 @@ static void process_prepared_mapping(str + + if (m->err) { + cell_error(m->cell); +- return; ++ goto out; + } + + /* +@@ -871,7 +871,7 @@ static void process_prepared_mapping(str + if (r) { + DMERR("dm_thin_insert_block() failed"); + cell_error(m->cell); +- return; ++ goto out; + } + + /* +@@ -886,6 +886,7 @@ static void process_prepared_mapping(str + } else + cell_defer(tc, m->cell, m->data_block); + ++out: + list_del(&m->list); + mempool_free(m, tc->pool->mapping_pool); + } diff --git a/queue-3.5/dm-thin-reduce-endio_hook-pool-size.patch b/queue-3.5/dm-thin-reduce-endio_hook-pool-size.patch new file mode 100644 index 00000000000..1aaadb942e3 --- /dev/null +++ b/queue-3.5/dm-thin-reduce-endio_hook-pool-size.patch @@ -0,0 +1,35 @@ +From 7768ed33ccdc02801c4483fc5682dc66ace14aea Mon Sep 17 00:00:00 2001 +From: Alasdair G Kergon +Date: Fri, 27 Jul 2012 15:07:57 +0100 +Subject: dm thin: reduce endio_hook pool size + +From: Alasdair G Kergon + +commit 7768ed33ccdc02801c4483fc5682dc66ace14aea upstream. + +Reduce the slab size used for the dm_thin_endio_hook mempool. + +Allocation has been seen to fail on machines with smaller amounts +of memory due to fragmentation. + + lvm: page allocation failure. order:5, mode:0xd0 + device-mapper: table: 253:38: thin-pool: Error creating pool's endio_hook mempool + +Signed-off-by: Alasdair G Kergon +Signed-off-by: Greg Kroah-Hartman + +--- + drivers/md/dm-thin.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +--- a/drivers/md/dm-thin.c ++++ b/drivers/md/dm-thin.c +@@ -19,7 +19,7 @@ + /* + * Tunable constants + */ +-#define ENDIO_HOOK_POOL_SIZE 10240 ++#define ENDIO_HOOK_POOL_SIZE 1024 + #define DEFERRED_SET_SIZE 64 + #define MAPPING_POOL_SIZE 1024 + #define PRISON_CELLS 1024 diff --git a/queue-3.5/ext4-don-t-let-i_reserved_meta_blocks-go-negative.patch b/queue-3.5/ext4-don-t-let-i_reserved_meta_blocks-go-negative.patch new file mode 100644 index 00000000000..8381d51df54 --- /dev/null +++ b/queue-3.5/ext4-don-t-let-i_reserved_meta_blocks-go-negative.patch @@ -0,0 +1,53 @@ +From 97795d2a5b8d3c8dc4365d4bd3404191840453ba Mon Sep 17 00:00:00 2001 +From: Brian Foster +Date: Sun, 22 Jul 2012 23:59:40 -0400 +Subject: ext4: don't let i_reserved_meta_blocks go negative + +From: Brian Foster + +commit 97795d2a5b8d3c8dc4365d4bd3404191840453ba upstream. + +If we hit a condition where we have allocated metadata blocks that +were not appropriately reserved, we risk underflow of +ei->i_reserved_meta_blocks. In turn, this can throw +sbi->s_dirtyclusters_counter significantly out of whack and undermine +the nondelalloc fallback logic in ext4_nonda_switch(). Warn if this +occurs and set i_allocated_meta_blocks to avoid this problem. + +This condition is reproduced by xfstests 270 against ext2 with +delalloc enabled: + +Mar 28 08:58:02 localhost kernel: [ 171.526344] EXT4-fs (loop1): delayed block allocation failed for inode 14 at logical offset 64486 with max blocks 64 with error -28 +Mar 28 08:58:02 localhost kernel: [ 171.526346] EXT4-fs (loop1): This should not happen!! Data will be lost + +270 ultimately fails with an inconsistent filesystem and requires an +fsck to repair. The cause of the error is an underflow in +ext4_da_update_reserve_space() due to an unreserved meta block +allocation. + +Signed-off-by: Brian Foster +Signed-off-by: "Theodore Ts'o" +Signed-off-by: Greg Kroah-Hartman + +--- + fs/ext4/inode.c | 9 +++++++++ + 1 file changed, 9 insertions(+) + +--- a/fs/ext4/inode.c ++++ b/fs/ext4/inode.c +@@ -346,6 +346,15 @@ void ext4_da_update_reserve_space(struct + used = ei->i_reserved_data_blocks; + } + ++ if (unlikely(ei->i_allocated_meta_blocks > ei->i_reserved_meta_blocks)) { ++ ext4_msg(inode->i_sb, KERN_NOTICE, "%s: ino %lu, allocated %d " ++ "with only %d reserved metadata blocks\n", __func__, ++ inode->i_ino, ei->i_allocated_meta_blocks, ++ ei->i_reserved_meta_blocks); ++ WARN_ON(1); ++ ei->i_allocated_meta_blocks = ei->i_reserved_meta_blocks; ++ } ++ + /* Update per-inode reservations */ + ei->i_reserved_data_blocks -= used; + ei->i_reserved_meta_blocks -= ei->i_allocated_meta_blocks; diff --git a/queue-3.5/ext4-fix-hole-punch-failure-when-depth-is-greater-than-0.patch b/queue-3.5/ext4-fix-hole-punch-failure-when-depth-is-greater-than-0.patch new file mode 100644 index 00000000000..a4a8ee833b9 --- /dev/null +++ b/queue-3.5/ext4-fix-hole-punch-failure-when-depth-is-greater-than-0.patch @@ -0,0 +1,124 @@ +From 968dee77220768a5f52cf8b21d0bdb73486febef Mon Sep 17 00:00:00 2001 +From: Ashish Sangwan +Date: Sun, 22 Jul 2012 22:49:08 -0400 +Subject: ext4: fix hole punch failure when depth is greater than 0 + +From: Ashish Sangwan + +commit 968dee77220768a5f52cf8b21d0bdb73486febef upstream. + +Whether to continue removing extents or not is decided by the return +value of function ext4_ext_more_to_rm() which checks 2 conditions: +a) if there are no more indexes to process. +b) if the number of entries are decreased in the header of "depth -1". + +In case of hole punch, if the last block to be removed is not part of +the last extent index than this index will not be deleted, hence the +number of valid entries in the extent header of "depth - 1" will +remain as it is and ext4_ext_more_to_rm will return 0 although the +required blocks are not yet removed. + +This patch fixes the above mentioned problem as instead of removing +the extents from the end of file, it starts removing the blocks from +the particular extent from which removing blocks is actually required +and continue backward until done. + +Signed-off-by: Ashish Sangwan +Signed-off-by: Namjae Jeon +Reviewed-by: Lukas Czerner +Signed-off-by: Greg Kroah-Hartman + +--- + fs/ext4/extents.c | 48 ++++++++++++++++++++++++++++++------------------ + 1 file changed, 30 insertions(+), 18 deletions(-) + +--- a/fs/ext4/extents.c ++++ b/fs/ext4/extents.c +@@ -2570,10 +2570,10 @@ static int ext4_ext_remove_space(struct + { + struct super_block *sb = inode->i_sb; + int depth = ext_depth(inode); +- struct ext4_ext_path *path; ++ struct ext4_ext_path *path = NULL; + ext4_fsblk_t partial_cluster = 0; + handle_t *handle; +- int i, err; ++ int i = 0, err; + + ext_debug("truncate since %u to %u\n", start, end); + +@@ -2606,8 +2606,12 @@ again: + } + depth = ext_depth(inode); + ex = path[depth].p_ext; +- if (!ex) ++ if (!ex) { ++ ext4_ext_drop_refs(path); ++ kfree(path); ++ path = NULL; + goto cont; ++ } + + ee_block = le32_to_cpu(ex->ee_block); + +@@ -2637,8 +2641,6 @@ again: + if (err < 0) + goto out; + } +- ext4_ext_drop_refs(path); +- kfree(path); + } + cont: + +@@ -2647,19 +2649,27 @@ cont: + * after i_size and walking into the tree depth-wise. + */ + depth = ext_depth(inode); +- path = kzalloc(sizeof(struct ext4_ext_path) * (depth + 1), GFP_NOFS); +- if (path == NULL) { +- ext4_journal_stop(handle); +- return -ENOMEM; +- } +- path[0].p_depth = depth; +- path[0].p_hdr = ext_inode_hdr(inode); +- +- if (ext4_ext_check(inode, path[0].p_hdr, depth)) { +- err = -EIO; +- goto out; ++ if (path) { ++ int k = i = depth; ++ while (--k > 0) ++ path[k].p_block = ++ le16_to_cpu(path[k].p_hdr->eh_entries)+1; ++ } else { ++ path = kzalloc(sizeof(struct ext4_ext_path) * (depth + 1), ++ GFP_NOFS); ++ if (path == NULL) { ++ ext4_journal_stop(handle); ++ return -ENOMEM; ++ } ++ path[0].p_depth = depth; ++ path[0].p_hdr = ext_inode_hdr(inode); ++ ++ if (ext4_ext_check(inode, path[0].p_hdr, depth)) { ++ err = -EIO; ++ goto out; ++ } + } +- i = err = 0; ++ err = 0; + + while (i >= 0 && err == 0) { + if (i == depth) { +@@ -2773,8 +2783,10 @@ cont: + out: + ext4_ext_drop_refs(path); + kfree(path); +- if (err == -EAGAIN) ++ if (err == -EAGAIN) { ++ path = NULL; + goto again; ++ } + ext4_journal_stop(handle); + + return err; diff --git a/queue-3.5/ext4-fix-overhead-calculation-used-by-ext4_statfs.patch b/queue-3.5/ext4-fix-overhead-calculation-used-by-ext4_statfs.patch new file mode 100644 index 00000000000..f5f265e7628 --- /dev/null +++ b/queue-3.5/ext4-fix-overhead-calculation-used-by-ext4_statfs.patch @@ -0,0 +1,297 @@ +From 952fc18ef9ec707ebdc16c0786ec360295e5ff15 Mon Sep 17 00:00:00 2001 +From: Theodore Ts'o +Date: Mon, 9 Jul 2012 16:27:05 -0400 +Subject: ext4: fix overhead calculation used by ext4_statfs() + +From: Theodore Ts'o + +commit 952fc18ef9ec707ebdc16c0786ec360295e5ff15 upstream. + +Commit f975d6bcc7a introduced bug which caused ext4_statfs() to +miscalculate the number of file system overhead blocks. This causes +the f_blocks field in the statfs structure to be larger than it should +be. This would in turn cause the "df" output to show the number of +data blocks in the file system and the number of data blocks used to +be larger than they should be. + +Signed-off-by: "Theodore Ts'o" +Signed-off-by: Greg Kroah-Hartman + +--- + fs/ext4/bitmap.c | 4 - + fs/ext4/ext4.h | 4 - + fs/ext4/resize.c | 7 +- + fs/ext4/super.c | 174 +++++++++++++++++++++++++++++++++++++++---------------- + 4 files changed, 132 insertions(+), 57 deletions(-) + +--- a/fs/ext4/bitmap.c ++++ b/fs/ext4/bitmap.c +@@ -11,8 +11,6 @@ + #include + #include "ext4.h" + +-#ifdef EXT4FS_DEBUG +- + static const int nibblemap[] = {4, 3, 3, 2, 3, 2, 2, 1, 3, 2, 2, 1, 2, 1, 1, 0}; + + unsigned int ext4_count_free(char *bitmap, unsigned int numchars) +@@ -25,8 +23,6 @@ unsigned int ext4_count_free(char *bitma + return sum; + } + +-#endif /* EXT4FS_DEBUG */ +- + int ext4_inode_bitmap_csum_verify(struct super_block *sb, ext4_group_t group, + struct ext4_group_desc *gdp, + struct buffer_head *bh, int sz) +--- a/fs/ext4/ext4.h ++++ b/fs/ext4/ext4.h +@@ -1161,8 +1161,7 @@ struct ext4_sb_info { + unsigned long s_desc_per_block; /* Number of group descriptors per block */ + ext4_group_t s_groups_count; /* Number of groups in the fs */ + ext4_group_t s_blockfile_groups;/* Groups acceptable for non-extent files */ +- unsigned long s_overhead_last; /* Last calculated overhead */ +- unsigned long s_blocks_last; /* Last seen block count */ ++ unsigned long s_overhead; /* # of fs overhead clusters */ + unsigned int s_cluster_ratio; /* Number of blocks per cluster */ + unsigned int s_cluster_bits; /* log2 of s_cluster_ratio */ + loff_t s_bitmap_maxbytes; /* max bytes for bitmap files */ +@@ -2037,6 +2036,7 @@ extern int ext4_group_extend(struct supe + extern int ext4_resize_fs(struct super_block *sb, ext4_fsblk_t n_blocks_count); + + /* super.c */ ++extern int ext4_calculate_overhead(struct super_block *sb); + extern int ext4_superblock_csum_verify(struct super_block *sb, + struct ext4_super_block *es); + extern void ext4_superblock_csum_set(struct super_block *sb, +--- a/fs/ext4/resize.c ++++ b/fs/ext4/resize.c +@@ -1197,7 +1197,7 @@ static void ext4_update_super(struct sup + struct ext4_new_group_data *group_data = flex_gd->groups; + struct ext4_sb_info *sbi = EXT4_SB(sb); + struct ext4_super_block *es = sbi->s_es; +- int i; ++ int i, ret; + + BUG_ON(flex_gd->count == 0 || group_data == NULL); + /* +@@ -1272,6 +1272,11 @@ static void ext4_update_super(struct sup + &sbi->s_flex_groups[flex_group].free_inodes); + } + ++ /* ++ * Update the fs overhead information ++ */ ++ ext4_calculate_overhead(sb); ++ + if (test_opt(sb, DEBUG)) + printk(KERN_DEBUG "EXT4-fs: added group %u:" + "%llu blocks(%llu free %llu reserved)\n", flex_gd->count, +--- a/fs/ext4/super.c ++++ b/fs/ext4/super.c +@@ -3085,6 +3085,114 @@ static int set_journal_csum_feature_set( + return ret; + } + ++/* ++ * Note: calculating the overhead so we can be compatible with ++ * historical BSD practice is quite difficult in the face of ++ * clusters/bigalloc. This is because multiple metadata blocks from ++ * different block group can end up in the same allocation cluster. ++ * Calculating the exact overhead in the face of clustered allocation ++ * requires either O(all block bitmaps) in memory or O(number of block ++ * groups**2) in time. We will still calculate the superblock for ++ * older file systems --- and if we come across with a bigalloc file ++ * system with zero in s_overhead_clusters the estimate will be close to ++ * correct especially for very large cluster sizes --- but for newer ++ * file systems, it's better to calculate this figure once at mkfs ++ * time, and store it in the superblock. If the superblock value is ++ * present (even for non-bigalloc file systems), we will use it. ++ */ ++static int count_overhead(struct super_block *sb, ext4_group_t grp, ++ char *buf) ++{ ++ struct ext4_sb_info *sbi = EXT4_SB(sb); ++ struct ext4_group_desc *gdp; ++ ext4_fsblk_t first_block, last_block, b; ++ ext4_group_t i, ngroups = ext4_get_groups_count(sb); ++ int s, j, count = 0; ++ ++ first_block = le32_to_cpu(sbi->s_es->s_first_data_block) + ++ (grp * EXT4_BLOCKS_PER_GROUP(sb)); ++ last_block = first_block + EXT4_BLOCKS_PER_GROUP(sb) - 1; ++ for (i = 0; i < ngroups; i++) { ++ gdp = ext4_get_group_desc(sb, i, NULL); ++ b = ext4_block_bitmap(sb, gdp); ++ if (b >= first_block && b <= last_block) { ++ ext4_set_bit(EXT4_B2C(sbi, b - first_block), buf); ++ count++; ++ } ++ b = ext4_inode_bitmap(sb, gdp); ++ if (b >= first_block && b <= last_block) { ++ ext4_set_bit(EXT4_B2C(sbi, b - first_block), buf); ++ count++; ++ } ++ b = ext4_inode_table(sb, gdp); ++ if (b >= first_block && b + sbi->s_itb_per_group <= last_block) ++ for (j = 0; j < sbi->s_itb_per_group; j++, b++) { ++ int c = EXT4_B2C(sbi, b - first_block); ++ ext4_set_bit(c, buf); ++ count++; ++ } ++ if (i != grp) ++ continue; ++ s = 0; ++ if (ext4_bg_has_super(sb, grp)) { ++ ext4_set_bit(s++, buf); ++ count++; ++ } ++ for (j = ext4_bg_num_gdb(sb, grp); j > 0; j--) { ++ ext4_set_bit(EXT4_B2C(sbi, s++), buf); ++ count++; ++ } ++ } ++ if (!count) ++ return 0; ++ return EXT4_CLUSTERS_PER_GROUP(sb) - ++ ext4_count_free(buf, EXT4_CLUSTERS_PER_GROUP(sb) / 8); ++} ++ ++/* ++ * Compute the overhead and stash it in sbi->s_overhead ++ */ ++int ext4_calculate_overhead(struct super_block *sb) ++{ ++ struct ext4_sb_info *sbi = EXT4_SB(sb); ++ struct ext4_super_block *es = sbi->s_es; ++ ext4_group_t i, ngroups = ext4_get_groups_count(sb); ++ ext4_fsblk_t overhead = 0; ++ char *buf = (char *) get_zeroed_page(GFP_KERNEL); ++ ++ memset(buf, 0, PAGE_SIZE); ++ if (!buf) ++ return -ENOMEM; ++ ++ /* ++ * Compute the overhead (FS structures). This is constant ++ * for a given filesystem unless the number of block groups ++ * changes so we cache the previous value until it does. ++ */ ++ ++ /* ++ * All of the blocks before first_data_block are overhead ++ */ ++ overhead = EXT4_B2C(sbi, le32_to_cpu(es->s_first_data_block)); ++ ++ /* ++ * Add the overhead found in each block group ++ */ ++ for (i = 0; i < ngroups; i++) { ++ int blks; ++ ++ blks = count_overhead(sb, i, buf); ++ overhead += blks; ++ if (blks) ++ memset(buf, 0, PAGE_SIZE); ++ cond_resched(); ++ } ++ sbi->s_overhead = overhead; ++ smp_wmb(); ++ free_page((unsigned long) buf); ++ return 0; ++} ++ + static int ext4_fill_super(struct super_block *sb, void *data, int silent) + { + char *orig_data = kstrdup(data, GFP_KERNEL); +@@ -3735,6 +3843,18 @@ static int ext4_fill_super(struct super_ + + no_journal: + /* ++ * Get the # of file system overhead blocks from the ++ * superblock if present. ++ */ ++ if (es->s_overhead_clusters) ++ sbi->s_overhead = le32_to_cpu(es->s_overhead_clusters); ++ else { ++ ret = ext4_calculate_overhead(sb); ++ if (ret) ++ goto failed_mount_wq; ++ } ++ ++ /* + * The maximum number of concurrent works can be high and + * concurrency isn't really necessary. Limit it to 1. + */ +@@ -4600,67 +4720,21 @@ restore_opts: + return err; + } + +-/* +- * Note: calculating the overhead so we can be compatible with +- * historical BSD practice is quite difficult in the face of +- * clusters/bigalloc. This is because multiple metadata blocks from +- * different block group can end up in the same allocation cluster. +- * Calculating the exact overhead in the face of clustered allocation +- * requires either O(all block bitmaps) in memory or O(number of block +- * groups**2) in time. We will still calculate the superblock for +- * older file systems --- and if we come across with a bigalloc file +- * system with zero in s_overhead_clusters the estimate will be close to +- * correct especially for very large cluster sizes --- but for newer +- * file systems, it's better to calculate this figure once at mkfs +- * time, and store it in the superblock. If the superblock value is +- * present (even for non-bigalloc file systems), we will use it. +- */ + static int ext4_statfs(struct dentry *dentry, struct kstatfs *buf) + { + struct super_block *sb = dentry->d_sb; + struct ext4_sb_info *sbi = EXT4_SB(sb); + struct ext4_super_block *es = sbi->s_es; +- struct ext4_group_desc *gdp; ++ ext4_fsblk_t overhead = 0; + u64 fsid; + s64 bfree; + +- if (test_opt(sb, MINIX_DF)) { +- sbi->s_overhead_last = 0; +- } else if (es->s_overhead_clusters) { +- sbi->s_overhead_last = le32_to_cpu(es->s_overhead_clusters); +- } else if (sbi->s_blocks_last != ext4_blocks_count(es)) { +- ext4_group_t i, ngroups = ext4_get_groups_count(sb); +- ext4_fsblk_t overhead = 0; +- +- /* +- * Compute the overhead (FS structures). This is constant +- * for a given filesystem unless the number of block groups +- * changes so we cache the previous value until it does. +- */ +- +- /* +- * All of the blocks before first_data_block are +- * overhead +- */ +- overhead = EXT4_B2C(sbi, le32_to_cpu(es->s_first_data_block)); +- +- /* +- * Add the overhead found in each block group +- */ +- for (i = 0; i < ngroups; i++) { +- gdp = ext4_get_group_desc(sb, i, NULL); +- overhead += ext4_num_overhead_clusters(sb, i, gdp); +- cond_resched(); +- } +- sbi->s_overhead_last = overhead; +- smp_wmb(); +- sbi->s_blocks_last = ext4_blocks_count(es); +- } ++ if (!test_opt(sb, MINIX_DF)) ++ overhead = sbi->s_overhead; + + buf->f_type = EXT4_SUPER_MAGIC; + buf->f_bsize = sb->s_blocksize; +- buf->f_blocks = (ext4_blocks_count(es) - +- EXT4_C2B(sbi, sbi->s_overhead_last)); ++ buf->f_blocks = ext4_blocks_count(es) - EXT4_C2B(sbi, sbi->s_overhead); + bfree = percpu_counter_sum_positive(&sbi->s_freeclusters_counter) - + percpu_counter_sum_positive(&sbi->s_dirtyclusters_counter); + /* prevent underflow in case that few free space is available */ diff --git a/queue-3.5/ext4-pass-a-char-to-ext4_count_free-instead-of-a-buffer_head-ptr.patch b/queue-3.5/ext4-pass-a-char-to-ext4_count_free-instead-of-a-buffer_head-ptr.patch new file mode 100644 index 00000000000..bbae2d6163f --- /dev/null +++ b/queue-3.5/ext4-pass-a-char-to-ext4_count_free-instead-of-a-buffer_head-ptr.patch @@ -0,0 +1,78 @@ +From f6fb99cadcd44660c68e13f6eab28333653621e6 Mon Sep 17 00:00:00 2001 +From: Theodore Ts'o +Date: Sat, 30 Jun 2012 19:14:57 -0400 +Subject: ext4: pass a char * to ext4_count_free() instead of a buffer_head ptr + +From: Theodore Ts'o + +commit f6fb99cadcd44660c68e13f6eab28333653621e6 upstream. + +Make it possible for ext4_count_free to operate on buffers and not +just data in buffer_heads. + +Signed-off-by: "Theodore Ts'o" +Signed-off-by: Greg Kroah-Hartman + +--- + fs/ext4/balloc.c | 3 ++- + fs/ext4/bitmap.c | 8 +++----- + fs/ext4/ext4.h | 2 +- + fs/ext4/ialloc.c | 3 ++- + 4 files changed, 8 insertions(+), 8 deletions(-) + +--- a/fs/ext4/balloc.c ++++ b/fs/ext4/balloc.c +@@ -609,7 +609,8 @@ ext4_fsblk_t ext4_count_free_clusters(st + if (bitmap_bh == NULL) + continue; + +- x = ext4_count_free(bitmap_bh, sb->s_blocksize); ++ x = ext4_count_free(bitmap_bh->b_data, ++ EXT4_BLOCKS_PER_GROUP(sb) / 8); + printk(KERN_DEBUG "group %u: stored = %d, counted = %u\n", + i, ext4_free_group_clusters(sb, gdp), x); + bitmap_count += x; +--- a/fs/ext4/bitmap.c ++++ b/fs/ext4/bitmap.c +@@ -15,15 +15,13 @@ + + static const int nibblemap[] = {4, 3, 3, 2, 3, 2, 2, 1, 3, 2, 2, 1, 2, 1, 1, 0}; + +-unsigned int ext4_count_free(struct buffer_head *map, unsigned int numchars) ++unsigned int ext4_count_free(char *bitmap, unsigned int numchars) + { + unsigned int i, sum = 0; + +- if (!map) +- return 0; + for (i = 0; i < numchars; i++) +- sum += nibblemap[map->b_data[i] & 0xf] + +- nibblemap[(map->b_data[i] >> 4) & 0xf]; ++ sum += nibblemap[bitmap[i] & 0xf] + ++ nibblemap[(bitmap[i] >> 4) & 0xf]; + return sum; + } + +--- a/fs/ext4/ext4.h ++++ b/fs/ext4/ext4.h +@@ -1852,7 +1852,7 @@ struct mmpd_data { + # define NORET_AND noreturn, + + /* bitmap.c */ +-extern unsigned int ext4_count_free(struct buffer_head *, unsigned); ++extern unsigned int ext4_count_free(char *bitmap, unsigned numchars); + void ext4_inode_bitmap_csum_set(struct super_block *sb, ext4_group_t group, + struct ext4_group_desc *gdp, + struct buffer_head *bh, int sz); +--- a/fs/ext4/ialloc.c ++++ b/fs/ext4/ialloc.c +@@ -1054,7 +1054,8 @@ unsigned long ext4_count_free_inodes(str + if (!bitmap_bh) + continue; + +- x = ext4_count_free(bitmap_bh, EXT4_INODES_PER_GROUP(sb) / 8); ++ x = ext4_count_free(bitmap_bh->b_data, ++ EXT4_INODES_PER_GROUP(sb) / 8); + printk(KERN_DEBUG "group %lu: stored = %d, counted = %lu\n", + (unsigned long) i, ext4_free_inodes_count(sb, gdp), x); + bitmap_count += x; diff --git a/queue-3.5/ext4-undo-ext4_calc_metadata_amount-if-we-fail-to-claim-space.patch b/queue-3.5/ext4-undo-ext4_calc_metadata_amount-if-we-fail-to-claim-space.patch new file mode 100644 index 00000000000..ab89e00f816 --- /dev/null +++ b/queue-3.5/ext4-undo-ext4_calc_metadata_amount-if-we-fail-to-claim-space.patch @@ -0,0 +1,90 @@ +From 03179fe92318e7934c180d96f12eff2cb36ef7b6 Mon Sep 17 00:00:00 2001 +From: Theodore Ts'o +Date: Mon, 23 Jul 2012 00:00:20 -0400 +Subject: ext4: undo ext4_calc_metadata_amount if we fail to claim space + +From: Theodore Ts'o + +commit 03179fe92318e7934c180d96f12eff2cb36ef7b6 upstream. + +The function ext4_calc_metadata_amount() has side effects, although +it's not obvious from its function name. So if we fail to claim +space, regardless of whether we retry to claim the space again, or +return an error, we need to undo these side effects. + +Otherwise we can end up incorrectly calculating the number of metadata +blocks needed for the operation, which was responsible for an xfstests +failure for test #271 when using an ext2 file system with delalloc +enabled. + +Reported-by: Brian Foster +Signed-off-by: "Theodore Ts'o" +Signed-off-by: Greg Kroah-Hartman + +--- + fs/ext4/inode.c | 32 +++++++++++++++++++++----------- + 1 file changed, 21 insertions(+), 11 deletions(-) + +--- a/fs/ext4/inode.c ++++ b/fs/ext4/inode.c +@@ -1180,6 +1180,17 @@ static int ext4_da_reserve_space(struct + struct ext4_inode_info *ei = EXT4_I(inode); + unsigned int md_needed; + int ret; ++ ext4_lblk_t save_last_lblock; ++ int save_len; ++ ++ /* ++ * We will charge metadata quota at writeout time; this saves ++ * us from metadata over-estimation, though we may go over by ++ * a small amount in the end. Here we just reserve for data. ++ */ ++ ret = dquot_reserve_block(inode, EXT4_C2B(sbi, 1)); ++ if (ret) ++ return ret; + + /* + * recalculate the amount of metadata blocks to reserve +@@ -1188,32 +1199,31 @@ static int ext4_da_reserve_space(struct + */ + repeat: + spin_lock(&ei->i_block_reservation_lock); ++ /* ++ * ext4_calc_metadata_amount() has side effects, which we have ++ * to be prepared undo if we fail to claim space. ++ */ ++ save_len = ei->i_da_metadata_calc_len; ++ save_last_lblock = ei->i_da_metadata_calc_last_lblock; + md_needed = EXT4_NUM_B2C(sbi, + ext4_calc_metadata_amount(inode, lblock)); + trace_ext4_da_reserve_space(inode, md_needed); +- spin_unlock(&ei->i_block_reservation_lock); + + /* +- * We will charge metadata quota at writeout time; this saves +- * us from metadata over-estimation, though we may go over by +- * a small amount in the end. Here we just reserve for data. +- */ +- ret = dquot_reserve_block(inode, EXT4_C2B(sbi, 1)); +- if (ret) +- return ret; +- /* + * We do still charge estimated metadata to the sb though; + * we cannot afford to run out of free blocks. + */ + if (ext4_claim_free_clusters(sbi, md_needed + 1, 0)) { +- dquot_release_reservation_block(inode, EXT4_C2B(sbi, 1)); ++ ei->i_da_metadata_calc_len = save_len; ++ ei->i_da_metadata_calc_last_lblock = save_last_lblock; ++ spin_unlock(&ei->i_block_reservation_lock); + if (ext4_should_retry_alloc(inode->i_sb, &retries)) { + yield(); + goto repeat; + } ++ dquot_release_reservation_block(inode, EXT4_C2B(sbi, 1)); + return -ENOSPC; + } +- spin_lock(&ei->i_block_reservation_lock); + ei->i_reserved_data_blocks++; + ei->i_reserved_meta_blocks += md_needed; + spin_unlock(&ei->i_block_reservation_lock); diff --git a/queue-3.5/nfs-fix-a-number-of-bugs-in-the-idmapper.patch b/queue-3.5/nfs-fix-a-number-of-bugs-in-the-idmapper.patch new file mode 100644 index 00000000000..f95f8067781 --- /dev/null +++ b/queue-3.5/nfs-fix-a-number-of-bugs-in-the-idmapper.patch @@ -0,0 +1,182 @@ +From a427b9ec4eda8cd6e641ea24541d30b641fc3140 Mon Sep 17 00:00:00 2001 +From: David Howells +Date: Wed, 25 Jul 2012 16:53:36 +0100 +Subject: NFS: Fix a number of bugs in the idmapper + +From: David Howells + +commit a427b9ec4eda8cd6e641ea24541d30b641fc3140 upstream. + +Fix a number of bugs in the NFS idmapper code: + + (1) Only registered key types can be passed to the core keys code, so + register the legacy idmapper key type. + + This is a requirement because the unregister function cleans up keys + belonging to that key type so that there aren't dangling pointers to the + module left behind - including the key->type pointer. + + (2) Rename the legacy key type. You can't have two key types with the same + name, and (1) would otherwise require that. + + (3) complete_request_key() must be called in the error path of + nfs_idmap_legacy_upcall(). + + (4) There is one idmap struct for each nfs_client struct. This means that + idmap->idmap_key_cons is shared without the use of a lock. This is a + problem because key_instantiate_and_link() - as called indirectly by + idmap_pipe_downcall() - releases anyone waiting for the key to be + instantiated. + + What happens is that idmap_pipe_downcall() running in the rpc.idmapd + thread, releases the NFS filesystem in whatever thread that is running in + to continue. This may then make another idmapper call, overwriting + idmap_key_cons before idmap_pipe_downcall() gets the chance to call + complete_request_key(). + + I *think* that reading idmap_key_cons only once, before + key_instantiate_and_link() is called, and then caching the result in a + variable is sufficient. + +Bug (4) is the cause of: + +BUG: unable to handle kernel NULL pointer dereference at (null) +IP: [< (null)>] (null) +PGD 0 +Oops: 0010 [#1] SMP +CPU 1 +Modules linked in: ppdev parport_pc lp parport ip6table_filter ip6_tables ebtable_nat ebtables ipt_MASQUERADE iptable_nat nf_nat nf_conntrack_ipv4 nf_defrag_ipv4 xt_state nf_conntrack nfs fscache xt_CHECKSUM auth_rpcgss iptable_mangle nfs_acl bridge stp llc lockd be2iscsi iscsi_boot_sysfs bnx2i cnic uio cxgb4i cxgb4 cxgb3i libcxgbi cxgb3 mdio ib_iser rdma_cm ib_cm iw_cm ib_sa ib_mad ib_core ib_addr iscsi_tcp libiscsi_tcp libiscsi scsi_transport_iscsi snd_hda_codec_realtek snd_usb_audio snd_hda_intel snd_hda_codec snd_seq snd_pcm snd_hwdep snd_usbmidi_lib snd_rawmidi snd_timer uvcvideo videobuf2_core videodev media videobuf2_vmalloc snd_seq_device videobuf2_memops e1000e vhost_net iTCO_wdt joydev coretemp snd soundcore macvtap macvlan i2c_i801 snd_page_alloc tun iTCO_vendor_support microcode kvm_intel kvm sunrpc hid_logitech_dj usb_storage i915 drm_kms_helper drm i2c_algo_bit i2c_core video [last unloaded: scsi_wait_scan] +Pid: 1229, comm: rpc.idmapd Not tainted 3.4.2-1.fc16.x86_64 #1 Gateway DX4710-UB801A/G33M05G1 +RIP: 0010:[<0000000000000000>] [< (null)>] (null) +RSP: 0018:ffff8801a3645d40 EFLAGS: 00010246 +RAX: ffff880077707e30 RBX: ffff880077707f50 RCX: ffff8801a18ccd80 +RDX: 0000000000000006 RSI: ffff8801a3645e75 RDI: ffff880077707f50 +RBP: ffff8801a3645d88 R08: ffff8801a430f9c0 R09: ffff8801a3645db0 +R10: 000000000000000a R11: 0000000000000246 R12: ffff8801a18ccd80 +R13: ffff8801a3645e75 R14: ffff8801a430f9c0 R15: 0000000000000006 +FS: 00007fb6fb51a700(0000) GS:ffff8801afc80000(0000) knlGS:0000000000000000 +CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 +CR2: 0000000000000000 CR3: 00000001a49b0000 CR4: 00000000000027e0 +DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000 +DR3: 0000000000000000 DR6: 00000000ffff0ff0 DR7: 0000000000000400 +Process rpc.idmapd (pid: 1229, threadinfo ffff8801a3644000, task ffff8801a3bf9710) +Stack: + ffffffff81260878 ffff8801a3645db0 ffff8801a3645db0 ffff880077707a90 + ffff880077707f50 ffff8801a18ccd80 0000000000000006 ffff8801a3645e75 + ffff8801a430f9c0 ffff8801a3645dd8 ffffffff81260983 ffff8801a3645de8 +Call Trace: + [] ? __key_instantiate_and_link+0x58/0x100 + [] key_instantiate_and_link+0x63/0xa0 + [] idmap_pipe_downcall+0x1cb/0x1e0 [nfs] + [] rpc_pipe_write+0x67/0x90 [sunrpc] + [] vfs_write+0xb3/0x180 + [] sys_write+0x4a/0x90 + [] system_call_fastpath+0x16/0x1b +Code: Bad RIP value. +RIP [< (null)>] (null) + RSP +CR2: 0000000000000000 + +Signed-off-by: David Howells +Reviewed-by: Steve Dickson +Signed-off-by: Trond Myklebust +Signed-off-by: Greg Kroah-Hartman + +--- + fs/nfs/idmap.c | 26 ++++++++++++++++++++------ + 1 file changed, 20 insertions(+), 6 deletions(-) + +--- a/fs/nfs/idmap.c ++++ b/fs/nfs/idmap.c +@@ -205,12 +205,18 @@ static int nfs_idmap_init_keyring(void) + if (ret < 0) + goto failed_put_key; + ++ ret = register_key_type(&key_type_id_resolver_legacy); ++ if (ret < 0) ++ goto failed_reg_legacy; ++ + set_bit(KEY_FLAG_ROOT_CAN_CLEAR, &keyring->flags); + cred->thread_keyring = keyring; + cred->jit_keyring = KEY_REQKEY_DEFL_THREAD_KEYRING; + id_resolver_cache = cred; + return 0; + ++failed_reg_legacy: ++ unregister_key_type(&key_type_id_resolver); + failed_put_key: + key_put(keyring); + failed_put_cred: +@@ -222,6 +228,7 @@ static void nfs_idmap_quit_keyring(void) + { + key_revoke(id_resolver_cache->thread_keyring); + unregister_key_type(&key_type_id_resolver); ++ unregister_key_type(&key_type_id_resolver_legacy); + put_cred(id_resolver_cache); + } + +@@ -385,7 +392,7 @@ static const struct rpc_pipe_ops idmap_u + }; + + static struct key_type key_type_id_resolver_legacy = { +- .name = "id_resolver", ++ .name = "id_legacy", + .instantiate = user_instantiate, + .match = user_match, + .revoke = user_revoke, +@@ -674,6 +681,7 @@ static int nfs_idmap_legacy_upcall(struc + if (ret < 0) + goto out2; + ++ BUG_ON(idmap->idmap_key_cons != NULL); + idmap->idmap_key_cons = cons; + + ret = rpc_queue_upcall(idmap->idmap_pipe, msg); +@@ -687,8 +695,7 @@ out2: + out1: + kfree(msg); + out0: +- key_revoke(cons->key); +- key_revoke(cons->authkey); ++ complete_request_key(cons, ret); + return ret; + } + +@@ -722,11 +729,18 @@ idmap_pipe_downcall(struct file *filp, c + { + struct rpc_inode *rpci = RPC_I(filp->f_path.dentry->d_inode); + struct idmap *idmap = (struct idmap *)rpci->private; +- struct key_construction *cons = idmap->idmap_key_cons; ++ struct key_construction *cons; + struct idmap_msg im; + size_t namelen_in; + int ret; + ++ /* If instantiation is successful, anyone waiting for key construction ++ * will have been woken up and someone else may now have used ++ * idmap_key_cons - so after this point we may no longer touch it. ++ */ ++ cons = ACCESS_ONCE(idmap->idmap_key_cons); ++ idmap->idmap_key_cons = NULL; ++ + if (mlen != sizeof(im)) { + ret = -ENOSPC; + goto out; +@@ -739,7 +753,7 @@ idmap_pipe_downcall(struct file *filp, c + + if (!(im.im_status & IDMAP_STATUS_SUCCESS)) { + ret = mlen; +- complete_request_key(idmap->idmap_key_cons, -ENOKEY); ++ complete_request_key(cons, -ENOKEY); + goto out_incomplete; + } + +@@ -756,7 +770,7 @@ idmap_pipe_downcall(struct file *filp, c + } + + out: +- complete_request_key(idmap->idmap_key_cons, ret); ++ complete_request_key(cons, ret); + out_incomplete: + return ret; + } diff --git a/queue-3.5/nfs-skip-commit-in-releasepage-if-we-re-freeing-memory-for-fs-related-reasons.patch b/queue-3.5/nfs-skip-commit-in-releasepage-if-we-re-freeing-memory-for-fs-related-reasons.patch new file mode 100644 index 00000000000..8c4435b237b --- /dev/null +++ b/queue-3.5/nfs-skip-commit-in-releasepage-if-we-re-freeing-memory-for-fs-related-reasons.patch @@ -0,0 +1,173 @@ +From 5cf02d09b50b1ee1c2d536c9cf64af5a7d433f56 Mon Sep 17 00:00:00 2001 +From: Jeff Layton +Date: Mon, 23 Jul 2012 13:58:51 -0400 +Subject: nfs: skip commit in releasepage if we're freeing memory for fs-related reasons + +From: Jeff Layton + +commit 5cf02d09b50b1ee1c2d536c9cf64af5a7d433f56 upstream. + +We've had some reports of a deadlock where rpciod ends up with a stack +trace like this: + + PID: 2507 TASK: ffff88103691ab40 CPU: 14 COMMAND: "rpciod/14" + #0 [ffff8810343bf2f0] schedule at ffffffff814dabd9 + #1 [ffff8810343bf3b8] nfs_wait_bit_killable at ffffffffa038fc04 [nfs] + #2 [ffff8810343bf3c8] __wait_on_bit at ffffffff814dbc2f + #3 [ffff8810343bf418] out_of_line_wait_on_bit at ffffffff814dbcd8 + #4 [ffff8810343bf488] nfs_commit_inode at ffffffffa039e0c1 [nfs] + #5 [ffff8810343bf4f8] nfs_release_page at ffffffffa038bef6 [nfs] + #6 [ffff8810343bf528] try_to_release_page at ffffffff8110c670 + #7 [ffff8810343bf538] shrink_page_list.clone.0 at ffffffff81126271 + #8 [ffff8810343bf668] shrink_inactive_list at ffffffff81126638 + #9 [ffff8810343bf818] shrink_zone at ffffffff8112788f + #10 [ffff8810343bf8c8] do_try_to_free_pages at ffffffff81127b1e + #11 [ffff8810343bf958] try_to_free_pages at ffffffff8112812f + #12 [ffff8810343bfa08] __alloc_pages_nodemask at ffffffff8111fdad + #13 [ffff8810343bfb28] kmem_getpages at ffffffff81159942 + #14 [ffff8810343bfb58] fallback_alloc at ffffffff8115a55a + #15 [ffff8810343bfbd8] ____cache_alloc_node at ffffffff8115a2d9 + #16 [ffff8810343bfc38] kmem_cache_alloc at ffffffff8115b09b + #17 [ffff8810343bfc78] sk_prot_alloc at ffffffff81411808 + #18 [ffff8810343bfcb8] sk_alloc at ffffffff8141197c + #19 [ffff8810343bfce8] inet_create at ffffffff81483ba6 + #20 [ffff8810343bfd38] __sock_create at ffffffff8140b4a7 + #21 [ffff8810343bfd98] xs_create_sock at ffffffffa01f649b [sunrpc] + #22 [ffff8810343bfdd8] xs_tcp_setup_socket at ffffffffa01f6965 [sunrpc] + #23 [ffff8810343bfe38] worker_thread at ffffffff810887d0 + #24 [ffff8810343bfee8] kthread at ffffffff8108dd96 + #25 [ffff8810343bff48] kernel_thread at ffffffff8100c1ca + +rpciod is trying to allocate memory for a new socket to talk to the +server. The VM ends up calling ->releasepage to get more memory, and it +tries to do a blocking commit. That commit can't succeed however without +a connected socket, so we deadlock. + +Fix this by setting PF_FSTRANS on the workqueue task prior to doing the +socket allocation, and having nfs_release_page check for that flag when +deciding whether to do a commit call. Also, set PF_FSTRANS +unconditionally in rpc_async_schedule since that function can also do +allocations sometimes. + +Signed-off-by: Jeff Layton +Signed-off-by: Trond Myklebust +Signed-off-by: Greg Kroah-Hartman + +--- + fs/nfs/file.c | 7 +++++-- + net/sunrpc/sched.c | 2 ++ + net/sunrpc/xprtrdma/transport.c | 3 ++- + net/sunrpc/xprtsock.c | 10 ++++++++++ + 4 files changed, 19 insertions(+), 3 deletions(-) + +--- a/fs/nfs/file.c ++++ b/fs/nfs/file.c +@@ -459,8 +459,11 @@ static int nfs_release_page(struct page + + dfprintk(PAGECACHE, "NFS: release_page(%p)\n", page); + +- /* Only do I/O if gfp is a superset of GFP_KERNEL */ +- if (mapping && (gfp & GFP_KERNEL) == GFP_KERNEL) { ++ /* Only do I/O if gfp is a superset of GFP_KERNEL, and we're not ++ * doing this memory reclaim for a fs-related allocation. ++ */ ++ if (mapping && (gfp & GFP_KERNEL) == GFP_KERNEL && ++ !(current->flags & PF_FSTRANS)) { + int how = FLUSH_SYNC; + + /* Don't let kswapd deadlock waiting for OOM RPC calls */ +--- a/net/sunrpc/sched.c ++++ b/net/sunrpc/sched.c +@@ -790,7 +790,9 @@ void rpc_execute(struct rpc_task *task) + + static void rpc_async_schedule(struct work_struct *work) + { ++ current->flags |= PF_FSTRANS; + __rpc_execute(container_of(work, struct rpc_task, u.tk_work)); ++ current->flags &= ~PF_FSTRANS; + } + + /** +--- a/net/sunrpc/xprtrdma/transport.c ++++ b/net/sunrpc/xprtrdma/transport.c +@@ -200,6 +200,7 @@ xprt_rdma_connect_worker(struct work_str + int rc = 0; + + if (!xprt->shutdown) { ++ current->flags |= PF_FSTRANS; + xprt_clear_connected(xprt); + + dprintk("RPC: %s: %sconnect\n", __func__, +@@ -212,10 +213,10 @@ xprt_rdma_connect_worker(struct work_str + + out: + xprt_wake_pending_tasks(xprt, rc); +- + out_clear: + dprintk("RPC: %s: exit\n", __func__); + xprt_clear_connecting(xprt); ++ current->flags &= ~PF_FSTRANS; + } + + /* +--- a/net/sunrpc/xprtsock.c ++++ b/net/sunrpc/xprtsock.c +@@ -1895,6 +1895,8 @@ static void xs_local_setup_socket(struct + if (xprt->shutdown) + goto out; + ++ current->flags |= PF_FSTRANS; ++ + clear_bit(XPRT_CONNECTION_ABORT, &xprt->state); + status = __sock_create(xprt->xprt_net, AF_LOCAL, + SOCK_STREAM, 0, &sock, 1); +@@ -1928,6 +1930,7 @@ static void xs_local_setup_socket(struct + out: + xprt_clear_connecting(xprt); + xprt_wake_pending_tasks(xprt, status); ++ current->flags &= ~PF_FSTRANS; + } + + static void xs_udp_finish_connecting(struct rpc_xprt *xprt, struct socket *sock) +@@ -1970,6 +1973,8 @@ static void xs_udp_setup_socket(struct w + if (xprt->shutdown) + goto out; + ++ current->flags |= PF_FSTRANS; ++ + /* Start by resetting any existing state */ + xs_reset_transport(transport); + sock = xs_create_sock(xprt, transport, +@@ -1988,6 +1993,7 @@ static void xs_udp_setup_socket(struct w + out: + xprt_clear_connecting(xprt); + xprt_wake_pending_tasks(xprt, status); ++ current->flags &= ~PF_FSTRANS; + } + + /* +@@ -2113,6 +2119,8 @@ static void xs_tcp_setup_socket(struct w + if (xprt->shutdown) + goto out; + ++ current->flags |= PF_FSTRANS; ++ + if (!sock) { + clear_bit(XPRT_CONNECTION_ABORT, &xprt->state); + sock = xs_create_sock(xprt, transport, +@@ -2162,6 +2170,7 @@ static void xs_tcp_setup_socket(struct w + case -EINPROGRESS: + case -EALREADY: + xprt_clear_connecting(xprt); ++ current->flags &= ~PF_FSTRANS; + return; + case -EINVAL: + /* Happens, for instance, if the user specified a link +@@ -2174,6 +2183,7 @@ out_eagain: + out: + xprt_clear_connecting(xprt); + xprt_wake_pending_tasks(xprt, status); ++ current->flags &= ~PF_FSTRANS; + } + + /** diff --git a/queue-3.5/nfsd4-fix-cr_principal-comparison-check-in-same_creds.patch b/queue-3.5/nfsd4-fix-cr_principal-comparison-check-in-same_creds.patch new file mode 100644 index 00000000000..b204ffd49b0 --- /dev/null +++ b/queue-3.5/nfsd4-fix-cr_principal-comparison-check-in-same_creds.patch @@ -0,0 +1,43 @@ +From 5559b50acdcdcad7e362882d3261bf934c9436f6 Mon Sep 17 00:00:00 2001 +From: Vivek Trivedi +Date: Tue, 24 Jul 2012 21:18:20 +0530 +Subject: nfsd4: fix cr_principal comparison check in same_creds + +From: Vivek Trivedi + +commit 5559b50acdcdcad7e362882d3261bf934c9436f6 upstream. + +This fixes a wrong check for same cr_principal in same_creds + +Introduced by 8fbba96e5b327665265ad02b7f331b68536828bf "nfsd4: stricter +cred comparison for setclientid/exchange_id". + +Signed-off-by: Vivek Trivedi +Signed-off-by: Namjae Jeon +Signed-off-by: J. Bruce Fields +Signed-off-by: Greg Kroah-Hartman + +--- + fs/nfsd/nfs4state.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +--- a/fs/nfsd/nfs4state.c ++++ b/fs/nfsd/nfs4state.c +@@ -1215,7 +1215,7 @@ static bool groups_equal(struct group_in + return true; + } + +-static int ++static bool + same_creds(struct svc_cred *cr1, struct svc_cred *cr2) + { + if ((cr1->cr_flavor != cr2->cr_flavor) +@@ -1227,7 +1227,7 @@ same_creds(struct svc_cred *cr1, struct + return true; + if (!cr1->cr_principal || !cr2->cr_principal) + return false; +- return 0 == strcmp(cr1->cr_principal, cr1->cr_principal); ++ return 0 == strcmp(cr1->cr_principal, cr2->cr_principal); + } + + static void gen_clid(struct nfs4_client *clp) diff --git a/queue-3.5/nfsd4-our-filesystems-are-normally-case-sensitive.patch b/queue-3.5/nfsd4-our-filesystems-are-normally-case-sensitive.patch new file mode 100644 index 00000000000..0364aa4b4e9 --- /dev/null +++ b/queue-3.5/nfsd4-our-filesystems-are-normally-case-sensitive.patch @@ -0,0 +1,30 @@ +From 2930d381d22b9c56f40dd4c63a8fa59719ca2c3c Mon Sep 17 00:00:00 2001 +From: "J. Bruce Fields" +Date: Tue, 5 Jun 2012 16:52:06 -0400 +Subject: nfsd4: our filesystems are normally case sensitive + +From: "J. Bruce Fields" + +commit 2930d381d22b9c56f40dd4c63a8fa59719ca2c3c upstream. + +Actually, xfs and jfs can optionally be case insensitive; we'll handle +that case in later patches. + +Signed-off-by: J. Bruce Fields +Signed-off-by: Greg Kroah-Hartman + +--- + fs/nfsd/nfs4xdr.c | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +--- a/fs/nfsd/nfs4xdr.c ++++ b/fs/nfsd/nfs4xdr.c +@@ -2259,7 +2259,7 @@ out_acl: + if (bmval0 & FATTR4_WORD0_CASE_INSENSITIVE) { + if ((buflen -= 4) < 0) + goto out_resource; +- WRITE32(1); ++ WRITE32(0); + } + if (bmval0 & FATTR4_WORD0_CASE_PRESERVING) { + if ((buflen -= 4) < 0) diff --git a/queue-3.5/nouveau-fix-alignment-requirements-on-src-and-dst-addresses.patch b/queue-3.5/nouveau-fix-alignment-requirements-on-src-and-dst-addresses.patch new file mode 100644 index 00000000000..f24eac0095d --- /dev/null +++ b/queue-3.5/nouveau-fix-alignment-requirements-on-src-and-dst-addresses.patch @@ -0,0 +1,740 @@ +From ce806a30470bcd846d148bf39d46de3ad7748228 Mon Sep 17 00:00:00 2001 +From: Maarten Lankhorst +Date: Mon, 4 Jun 2012 12:00:31 +0200 +Subject: nouveau: Fix alignment requirements on src and dst addresses + +From: Maarten Lankhorst + +commit ce806a30470bcd846d148bf39d46de3ad7748228 upstream. + +Linear copy works by adding the offset to the buffer address, +which may end up not being 16-byte aligned. + +Some tests I've written for prime_pcopy show that the engine +allows this correctly, so the restriction on lowest 4 bits of +address can be lifted safely. + +The comments added were by envyas, I think because I used +a newer version. + +Signed-off-by: Maarten Lankhorst +Signed-off-by: Greg Kroah-Hartman + +--- + drivers/gpu/drm/nouveau/nva3_copy.fuc | 4 - + drivers/gpu/drm/nouveau/nva3_copy.fuc.h | 94 ++++++++++++++++++++++++++++++-- + drivers/gpu/drm/nouveau/nvc0_copy.fuc.h | 87 ++++++++++++++++++++++++++++- + 3 files changed, 175 insertions(+), 10 deletions(-) + +--- a/drivers/gpu/drm/nouveau/nva3_copy.fuc ++++ b/drivers/gpu/drm/nouveau/nva3_copy.fuc +@@ -119,9 +119,9 @@ dispatch_dma: + // mthd 0x030c-0x0340, various stuff + .b16 0xc3 14 + .b32 #ctx_src_address_high ~0x000000ff +-.b32 #ctx_src_address_low ~0xfffffff0 ++.b32 #ctx_src_address_low ~0xffffffff + .b32 #ctx_dst_address_high ~0x000000ff +-.b32 #ctx_dst_address_low ~0xfffffff0 ++.b32 #ctx_dst_address_low ~0xffffffff + .b32 #ctx_src_pitch ~0x0007ffff + .b32 #ctx_dst_pitch ~0x0007ffff + .b32 #ctx_xcnt ~0x0000ffff +--- a/drivers/gpu/drm/nouveau/nva3_copy.fuc.h ++++ b/drivers/gpu/drm/nouveau/nva3_copy.fuc.h +@@ -1,37 +1,72 @@ +-uint32_t nva3_pcopy_data[] = { ++u32 nva3_pcopy_data[] = { ++/* 0x0000: ctx_object */ + 0x00000000, ++/* 0x0004: ctx_dma */ ++/* 0x0004: ctx_dma_query */ + 0x00000000, ++/* 0x0008: ctx_dma_src */ + 0x00000000, ++/* 0x000c: ctx_dma_dst */ + 0x00000000, ++/* 0x0010: ctx_query_address_high */ + 0x00000000, ++/* 0x0014: ctx_query_address_low */ + 0x00000000, ++/* 0x0018: ctx_query_counter */ + 0x00000000, ++/* 0x001c: ctx_src_address_high */ + 0x00000000, ++/* 0x0020: ctx_src_address_low */ + 0x00000000, ++/* 0x0024: ctx_src_pitch */ + 0x00000000, ++/* 0x0028: ctx_src_tile_mode */ + 0x00000000, ++/* 0x002c: ctx_src_xsize */ + 0x00000000, ++/* 0x0030: ctx_src_ysize */ + 0x00000000, ++/* 0x0034: ctx_src_zsize */ + 0x00000000, ++/* 0x0038: ctx_src_zoff */ + 0x00000000, ++/* 0x003c: ctx_src_xoff */ + 0x00000000, ++/* 0x0040: ctx_src_yoff */ + 0x00000000, ++/* 0x0044: ctx_src_cpp */ + 0x00000000, ++/* 0x0048: ctx_dst_address_high */ + 0x00000000, ++/* 0x004c: ctx_dst_address_low */ + 0x00000000, ++/* 0x0050: ctx_dst_pitch */ + 0x00000000, ++/* 0x0054: ctx_dst_tile_mode */ + 0x00000000, ++/* 0x0058: ctx_dst_xsize */ + 0x00000000, ++/* 0x005c: ctx_dst_ysize */ + 0x00000000, ++/* 0x0060: ctx_dst_zsize */ + 0x00000000, ++/* 0x0064: ctx_dst_zoff */ + 0x00000000, ++/* 0x0068: ctx_dst_xoff */ + 0x00000000, ++/* 0x006c: ctx_dst_yoff */ + 0x00000000, ++/* 0x0070: ctx_dst_cpp */ + 0x00000000, ++/* 0x0074: ctx_format */ + 0x00000000, ++/* 0x0078: ctx_swz_const0 */ + 0x00000000, ++/* 0x007c: ctx_swz_const1 */ + 0x00000000, ++/* 0x0080: ctx_xcnt */ + 0x00000000, ++/* 0x0084: ctx_ycnt */ + 0x00000000, + 0x00000000, + 0x00000000, +@@ -63,6 +98,7 @@ uint32_t nva3_pcopy_data[] = { + 0x00000000, + 0x00000000, + 0x00000000, ++/* 0x0100: dispatch_table */ + 0x00010000, + 0x00000000, + 0x00000000, +@@ -73,6 +109,7 @@ uint32_t nva3_pcopy_data[] = { + 0x00010162, + 0x00000000, + 0x00030060, ++/* 0x0128: dispatch_dma */ + 0x00010170, + 0x00000000, + 0x00010170, +@@ -118,11 +155,11 @@ uint32_t nva3_pcopy_data[] = { + 0x0000001c, + 0xffffff00, + 0x00000020, +- 0x0000000f, ++ 0x00000000, + 0x00000048, + 0xffffff00, + 0x0000004c, +- 0x0000000f, ++ 0x00000000, + 0x00000024, + 0xfff80000, + 0x00000050, +@@ -146,7 +183,8 @@ uint32_t nva3_pcopy_data[] = { + 0x00000800, + }; + +-uint32_t nva3_pcopy_code[] = { ++u32 nva3_pcopy_code[] = { ++/* 0x0000: main */ + 0x04fe04bd, + 0x3517f000, + 0xf10010fe, +@@ -158,23 +196,31 @@ uint32_t nva3_pcopy_code[] = { + 0x17f11031, + 0x27f01200, + 0x0012d003, ++/* 0x002f: spin */ + 0xf40031f4, + 0x0ef40028, ++/* 0x0035: ih */ + 0x8001cffd, + 0xf40812c4, + 0x21f4060b, ++/* 0x0041: ih_no_chsw */ + 0x0412c472, + 0xf4060bf4, ++/* 0x004a: ih_no_cmd */ + 0x11c4c321, + 0x4001d00c, ++/* 0x0052: swctx */ + 0x47f101f8, + 0x4bfe7700, + 0x0007fe00, + 0xf00204b9, + 0x01f40643, + 0x0604fa09, ++/* 0x006b: swctx_load */ + 0xfa060ef4, ++/* 0x006e: swctx_done */ + 0x03f80504, ++/* 0x0072: chsw */ + 0x27f100f8, + 0x23cf1400, + 0x1e3fc800, +@@ -183,18 +229,22 @@ uint32_t nva3_pcopy_code[] = { + 0x1e3af052, + 0xf00023d0, + 0x24d00147, ++/* 0x0093: chsw_no_unload */ + 0xcf00f880, + 0x3dc84023, + 0x220bf41e, + 0xf40131f4, + 0x57f05221, + 0x0367f004, ++/* 0x00a8: chsw_load_ctx_dma */ + 0xa07856bc, + 0xb6018068, + 0x87d00884, + 0x0162b600, ++/* 0x00bb: chsw_finish_load */ + 0xf0f018f4, + 0x23d00237, ++/* 0x00c3: dispatch */ + 0xf100f880, + 0xcf190037, + 0x33cf4032, +@@ -202,6 +252,7 @@ uint32_t nva3_pcopy_code[] = { + 0x1024b607, + 0x010057f1, + 0x74bd64bd, ++/* 0x00dc: dispatch_loop */ + 0x58005658, + 0x50b60157, + 0x0446b804, +@@ -211,6 +262,7 @@ uint32_t nva3_pcopy_code[] = { + 0xb60276bb, + 0x57bb0374, + 0xdf0ef400, ++/* 0x0100: dispatch_valid_mthd */ + 0xb60246bb, + 0x45bb0344, + 0x01459800, +@@ -220,31 +272,41 @@ uint32_t nva3_pcopy_code[] = { + 0xb0014658, + 0x1bf40064, + 0x00538009, ++/* 0x0127: dispatch_cmd */ + 0xf4300ef4, + 0x55f90132, + 0xf40c01f4, ++/* 0x0132: dispatch_invalid_bitfield */ + 0x25f0250e, ++/* 0x0135: dispatch_illegal_mthd */ + 0x0125f002, ++/* 0x0138: dispatch_error */ + 0x100047f1, + 0xd00042d0, + 0x27f04043, + 0x0002d040, ++/* 0x0148: hostirq_wait */ + 0xf08002cf, + 0x24b04024, + 0xf71bf400, ++/* 0x0154: dispatch_done */ + 0x1d0027f1, + 0xd00137f0, + 0x00f80023, ++/* 0x0160: cmd_nop */ ++/* 0x0162: cmd_pm_trigger */ + 0x27f100f8, + 0x34bd2200, + 0xd00233f0, + 0x00f80023, ++/* 0x0170: cmd_dma */ + 0x012842b7, + 0xf00145b6, + 0x43801e39, + 0x0040b701, + 0x0644b606, + 0xf80043d0, ++/* 0x0189: cmd_exec_set_format */ + 0xf030f400, + 0xb00001b0, + 0x01b00101, +@@ -256,20 +318,26 @@ uint32_t nva3_pcopy_code[] = { + 0x70b63847, + 0x0232f401, + 0x94bd84bd, ++/* 0x01b4: ncomp_loop */ + 0xb60f4ac4, + 0xb4bd0445, ++/* 0x01bc: bpc_loop */ + 0xf404a430, + 0xa5ff0f18, + 0x00cbbbc0, + 0xf40231f4, ++/* 0x01ce: cmp_c0 */ + 0x1bf4220e, + 0x10c7f00c, + 0xf400cbbb, ++/* 0x01da: cmp_c1 */ + 0xa430160e, + 0x0c18f406, + 0xbb14c7f0, + 0x0ef400cb, ++/* 0x01e9: cmp_zero */ + 0x80c7f107, ++/* 0x01ed: bpc_next */ + 0x01c83800, + 0xb60180b6, + 0xb5b801b0, +@@ -280,6 +348,7 @@ uint32_t nva3_pcopy_code[] = { + 0x98110680, + 0x68fd2008, + 0x0502f400, ++/* 0x0216: dst_xcnt */ + 0x75fd64bd, + 0x1c078000, + 0xf10078fd, +@@ -304,6 +373,7 @@ uint32_t nva3_pcopy_code[] = { + 0x980056d0, + 0x56d01f06, + 0x1030f440, ++/* 0x0276: cmd_exec_set_surface_tiled */ + 0x579800f8, + 0x6879c70a, + 0xb66478c7, +@@ -311,9 +381,11 @@ uint32_t nva3_pcopy_code[] = { + 0x0e76b060, + 0xf0091bf4, + 0x0ef40477, ++/* 0x0291: xtile64 */ + 0x027cf00f, + 0xfd1170b6, + 0x77f00947, ++/* 0x029d: xtileok */ + 0x0f5a9806, + 0xfd115b98, + 0xb7f000ab, +@@ -371,6 +443,7 @@ uint32_t nva3_pcopy_code[] = { + 0x67d00600, + 0x0060b700, + 0x0068d004, ++/* 0x0382: cmd_exec_set_surface_linear */ + 0x6cf000f8, + 0x0260b702, + 0x0864b602, +@@ -381,13 +454,16 @@ uint32_t nva3_pcopy_code[] = { + 0xb70067d0, + 0x98040060, + 0x67d00957, ++/* 0x03ab: cmd_exec_wait */ + 0xf900f800, + 0xf110f900, + 0xb6080007, ++/* 0x03b6: loop */ + 0x01cf0604, + 0x0114f000, + 0xfcfa1bf4, + 0xf800fc10, ++/* 0x03c5: cmd_exec_query */ + 0x0d34c800, + 0xf5701bf4, + 0xf103ab21, +@@ -417,6 +493,7 @@ uint32_t nva3_pcopy_code[] = { + 0x47f10153, + 0x44b60800, + 0x0045d006, ++/* 0x0438: query_counter */ + 0x03ab21f5, + 0x080c47f1, + 0x980644b6, +@@ -439,11 +516,13 @@ uint32_t nva3_pcopy_code[] = { + 0x47f10153, + 0x44b60800, + 0x0045d006, ++/* 0x0492: cmd_exec */ + 0x21f500f8, + 0x3fc803ab, + 0x0e0bf400, + 0x018921f5, + 0x020047f1, ++/* 0x04a7: cmd_exec_no_format */ + 0xf11e0ef4, + 0xb6081067, + 0x77f00664, +@@ -451,19 +530,24 @@ uint32_t nva3_pcopy_code[] = { + 0x981c0780, + 0x67d02007, + 0x4067d000, ++/* 0x04c2: cmd_exec_init_src_surface */ + 0x32f444bd, + 0xc854bd02, + 0x0bf4043f, + 0x8221f50a, + 0x0a0ef403, ++/* 0x04d4: src_tiled */ + 0x027621f5, ++/* 0x04db: cmd_exec_init_dst_surface */ + 0xf40749f0, + 0x57f00231, + 0x083fc82c, + 0xf50a0bf4, + 0xf4038221, ++/* 0x04ee: dst_tiled */ + 0x21f50a0e, + 0x49f00276, ++/* 0x04f5: cmd_exec_kick */ + 0x0057f108, + 0x0654b608, + 0xd0210698, +@@ -473,6 +557,8 @@ uint32_t nva3_pcopy_code[] = { + 0xc80054d0, + 0x0bf40c3f, + 0xc521f507, ++/* 0x0519: cmd_exec_done */ ++/* 0x051b: cmd_wrcache_flush */ + 0xf100f803, + 0xbd220027, + 0x0133f034, +--- a/drivers/gpu/drm/nouveau/nvc0_copy.fuc.h ++++ b/drivers/gpu/drm/nouveau/nvc0_copy.fuc.h +@@ -1,34 +1,65 @@ +-uint32_t nvc0_pcopy_data[] = { ++u32 nvc0_pcopy_data[] = { ++/* 0x0000: ctx_object */ + 0x00000000, ++/* 0x0004: ctx_query_address_high */ + 0x00000000, ++/* 0x0008: ctx_query_address_low */ + 0x00000000, ++/* 0x000c: ctx_query_counter */ + 0x00000000, ++/* 0x0010: ctx_src_address_high */ + 0x00000000, ++/* 0x0014: ctx_src_address_low */ + 0x00000000, ++/* 0x0018: ctx_src_pitch */ + 0x00000000, ++/* 0x001c: ctx_src_tile_mode */ + 0x00000000, ++/* 0x0020: ctx_src_xsize */ + 0x00000000, ++/* 0x0024: ctx_src_ysize */ + 0x00000000, ++/* 0x0028: ctx_src_zsize */ + 0x00000000, ++/* 0x002c: ctx_src_zoff */ + 0x00000000, ++/* 0x0030: ctx_src_xoff */ + 0x00000000, ++/* 0x0034: ctx_src_yoff */ + 0x00000000, ++/* 0x0038: ctx_src_cpp */ + 0x00000000, ++/* 0x003c: ctx_dst_address_high */ + 0x00000000, ++/* 0x0040: ctx_dst_address_low */ + 0x00000000, ++/* 0x0044: ctx_dst_pitch */ + 0x00000000, ++/* 0x0048: ctx_dst_tile_mode */ + 0x00000000, ++/* 0x004c: ctx_dst_xsize */ + 0x00000000, ++/* 0x0050: ctx_dst_ysize */ + 0x00000000, ++/* 0x0054: ctx_dst_zsize */ + 0x00000000, ++/* 0x0058: ctx_dst_zoff */ + 0x00000000, ++/* 0x005c: ctx_dst_xoff */ + 0x00000000, ++/* 0x0060: ctx_dst_yoff */ + 0x00000000, ++/* 0x0064: ctx_dst_cpp */ + 0x00000000, ++/* 0x0068: ctx_format */ + 0x00000000, ++/* 0x006c: ctx_swz_const0 */ + 0x00000000, ++/* 0x0070: ctx_swz_const1 */ + 0x00000000, ++/* 0x0074: ctx_xcnt */ + 0x00000000, ++/* 0x0078: ctx_ycnt */ + 0x00000000, + 0x00000000, + 0x00000000, +@@ -63,6 +94,7 @@ uint32_t nvc0_pcopy_data[] = { + 0x00000000, + 0x00000000, + 0x00000000, ++/* 0x0100: dispatch_table */ + 0x00010000, + 0x00000000, + 0x00000000, +@@ -111,11 +143,11 @@ uint32_t nvc0_pcopy_data[] = { + 0x00000010, + 0xffffff00, + 0x00000014, +- 0x0000000f, ++ 0x00000000, + 0x0000003c, + 0xffffff00, + 0x00000040, +- 0x0000000f, ++ 0x00000000, + 0x00000018, + 0xfff80000, + 0x00000044, +@@ -139,7 +171,8 @@ uint32_t nvc0_pcopy_data[] = { + 0x00000800, + }; + +-uint32_t nvc0_pcopy_code[] = { ++u32 nvc0_pcopy_code[] = { ++/* 0x0000: main */ + 0x04fe04bd, + 0x3517f000, + 0xf10010fe, +@@ -151,15 +184,20 @@ uint32_t nvc0_pcopy_code[] = { + 0x17f11031, + 0x27f01200, + 0x0012d003, ++/* 0x002f: spin */ + 0xf40031f4, + 0x0ef40028, ++/* 0x0035: ih */ + 0x8001cffd, + 0xf40812c4, + 0x21f4060b, ++/* 0x0041: ih_no_chsw */ + 0x0412c4ca, + 0xf5070bf4, ++/* 0x004b: ih_no_cmd */ + 0xc4010221, + 0x01d00c11, ++/* 0x0053: swctx */ + 0xf101f840, + 0xfe770047, + 0x47f1004b, +@@ -188,8 +226,11 @@ uint32_t nvc0_pcopy_code[] = { + 0xf00204b9, + 0x01f40643, + 0x0604fa09, ++/* 0x00c3: swctx_load */ + 0xfa060ef4, ++/* 0x00c6: swctx_done */ + 0x03f80504, ++/* 0x00ca: chsw */ + 0x27f100f8, + 0x23cf1400, + 0x1e3fc800, +@@ -198,18 +239,22 @@ uint32_t nvc0_pcopy_code[] = { + 0x1e3af053, + 0xf00023d0, + 0x24d00147, ++/* 0x00eb: chsw_no_unload */ + 0xcf00f880, + 0x3dc84023, + 0x090bf41e, + 0xf40131f4, ++/* 0x00fa: chsw_finish_load */ + 0x37f05321, + 0x8023d002, ++/* 0x0102: dispatch */ + 0x37f100f8, + 0x32cf1900, + 0x0033cf40, + 0x07ff24e4, + 0xf11024b6, + 0xbd010057, ++/* 0x011b: dispatch_loop */ + 0x5874bd64, + 0x57580056, + 0x0450b601, +@@ -219,6 +264,7 @@ uint32_t nvc0_pcopy_code[] = { + 0xbb0f08f4, + 0x74b60276, + 0x0057bb03, ++/* 0x013f: dispatch_valid_mthd */ + 0xbbdf0ef4, + 0x44b60246, + 0x0045bb03, +@@ -229,24 +275,33 @@ uint32_t nvc0_pcopy_code[] = { + 0x64b00146, + 0x091bf400, + 0xf4005380, ++/* 0x0166: dispatch_cmd */ + 0x32f4300e, + 0xf455f901, + 0x0ef40c01, ++/* 0x0171: dispatch_invalid_bitfield */ + 0x0225f025, ++/* 0x0174: dispatch_illegal_mthd */ ++/* 0x0177: dispatch_error */ + 0xf10125f0, + 0xd0100047, + 0x43d00042, + 0x4027f040, ++/* 0x0187: hostirq_wait */ + 0xcf0002d0, + 0x24f08002, + 0x0024b040, ++/* 0x0193: dispatch_done */ + 0xf1f71bf4, + 0xf01d0027, + 0x23d00137, ++/* 0x019f: cmd_nop */ + 0xf800f800, ++/* 0x01a1: cmd_pm_trigger */ + 0x0027f100, + 0xf034bd22, + 0x23d00233, ++/* 0x01af: cmd_exec_set_format */ + 0xf400f800, + 0x01b0f030, + 0x0101b000, +@@ -258,20 +313,26 @@ uint32_t nvc0_pcopy_code[] = { + 0x3847c701, + 0xf40170b6, + 0x84bd0232, ++/* 0x01da: ncomp_loop */ + 0x4ac494bd, + 0x0445b60f, ++/* 0x01e2: bpc_loop */ + 0xa430b4bd, + 0x0f18f404, + 0xbbc0a5ff, + 0x31f400cb, + 0x220ef402, ++/* 0x01f4: cmp_c0 */ + 0xf00c1bf4, + 0xcbbb10c7, + 0x160ef400, ++/* 0x0200: cmp_c1 */ + 0xf406a430, + 0xc7f00c18, + 0x00cbbb14, ++/* 0x020f: cmp_zero */ + 0xf1070ef4, ++/* 0x0213: bpc_next */ + 0x380080c7, + 0x80b601c8, + 0x01b0b601, +@@ -283,6 +344,7 @@ uint32_t nvc0_pcopy_code[] = { + 0x1d08980e, + 0xf40068fd, + 0x64bd0502, ++/* 0x023c: dst_xcnt */ + 0x800075fd, + 0x78fd1907, + 0x1057f100, +@@ -307,15 +369,18 @@ uint32_t nvc0_pcopy_code[] = { + 0x1c069800, + 0xf44056d0, + 0x00f81030, ++/* 0x029c: cmd_exec_set_surface_tiled */ + 0xc7075798, + 0x78c76879, + 0x0380b664, + 0xb06077c7, + 0x1bf40e76, + 0x0477f009, ++/* 0x02b7: xtile64 */ + 0xf00f0ef4, + 0x70b6027c, + 0x0947fd11, ++/* 0x02c3: xtileok */ + 0x980677f0, + 0x5b980c5a, + 0x00abfd0e, +@@ -374,6 +439,7 @@ uint32_t nvc0_pcopy_code[] = { + 0xb70067d0, + 0xd0040060, + 0x00f80068, ++/* 0x03a8: cmd_exec_set_surface_linear */ + 0xb7026cf0, + 0xb6020260, + 0x57980864, +@@ -384,12 +450,15 @@ uint32_t nvc0_pcopy_code[] = { + 0x0060b700, + 0x06579804, + 0xf80067d0, ++/* 0x03d1: cmd_exec_wait */ + 0xf900f900, + 0x0007f110, + 0x0604b608, ++/* 0x03dc: loop */ + 0xf00001cf, + 0x1bf40114, + 0xfc10fcfa, ++/* 0x03eb: cmd_exec_query */ + 0xc800f800, + 0x1bf40d34, + 0xd121f570, +@@ -419,6 +488,7 @@ uint32_t nvc0_pcopy_code[] = { + 0x0153f026, + 0x080047f1, + 0xd00644b6, ++/* 0x045e: query_counter */ + 0x21f50045, + 0x47f103d1, + 0x44b6080c, +@@ -442,11 +512,13 @@ uint32_t nvc0_pcopy_code[] = { + 0x080047f1, + 0xd00644b6, + 0x00f80045, ++/* 0x04b8: cmd_exec */ + 0x03d121f5, + 0xf4003fc8, + 0x21f50e0b, + 0x47f101af, + 0x0ef40200, ++/* 0x04cd: cmd_exec_no_format */ + 0x1067f11e, + 0x0664b608, + 0x800177f0, +@@ -454,18 +526,23 @@ uint32_t nvc0_pcopy_code[] = { + 0x1d079819, + 0xd00067d0, + 0x44bd4067, ++/* 0x04e8: cmd_exec_init_src_surface */ + 0xbd0232f4, + 0x043fc854, + 0xf50a0bf4, + 0xf403a821, ++/* 0x04fa: src_tiled */ + 0x21f50a0e, + 0x49f0029c, ++/* 0x0501: cmd_exec_init_dst_surface */ + 0x0231f407, + 0xc82c57f0, + 0x0bf4083f, + 0xa821f50a, + 0x0a0ef403, ++/* 0x0514: dst_tiled */ + 0x029c21f5, ++/* 0x051b: cmd_exec_kick */ + 0xf10849f0, + 0xb6080057, + 0x06980654, +@@ -475,7 +552,9 @@ uint32_t nvc0_pcopy_code[] = { + 0x54d00546, + 0x0c3fc800, + 0xf5070bf4, ++/* 0x053f: cmd_exec_done */ + 0xf803eb21, ++/* 0x0541: cmd_wrcache_flush */ + 0x0027f100, + 0xf034bd22, + 0x23d00133, diff --git a/queue-3.5/series b/queue-3.5/series index 31b9a4e9f82..8a09c3c359b 100644 --- a/queue-3.5/series +++ b/queue-3.5/series @@ -83,3 +83,15 @@ drm-radeon-on-hotplug-force-link-training-to-happen-v2.patch drm-radeon-fix-dpms-on-off-on-trinity-aruba-v2.patch drm-nouveau-init-vblank-requests-list.patch posix_types.h-cleanup-stale-__nfdbits-and-related.patch +dm-thin-reduce-endio_hook-pool-size.patch +dm-thin-fix-memory-leak-in-process_prepared_mapping-error-paths.patch +nfsd4-our-filesystems-are-normally-case-sensitive.patch +nfsd4-fix-cr_principal-comparison-check-in-same_creds.patch +nfs-skip-commit-in-releasepage-if-we-re-freeing-memory-for-fs-related-reasons.patch +nfs-fix-a-number-of-bugs-in-the-idmapper.patch +nouveau-fix-alignment-requirements-on-src-and-dst-addresses.patch +ext4-pass-a-char-to-ext4_count_free-instead-of-a-buffer_head-ptr.patch +ext4-fix-overhead-calculation-used-by-ext4_statfs.patch +ext4-fix-hole-punch-failure-when-depth-is-greater-than-0.patch +ext4-don-t-let-i_reserved_meta_blocks-go-negative.patch +ext4-undo-ext4_calc_metadata_amount-if-we-fail-to-claim-space.patch