tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge branch 'for-linus' of git://github.com/chrismason/linux

* 'for-linus' of git://github.com/chrismason/linux:
Btrfs: add dummy extent if dst offset excceeds file end in
Btrfs: calc file extent num_bytes correctly in file clone
btrfs: xattr: fix attribute removal
Btrfs: fix wrong nbytes information of the inode
Btrfs: fix the file extent gap when doing direct IO
Btrfs: fix unclosed transaction handle in btrfs_cont_expand
Btrfs: fix misuse of trans block rsv
Btrfs: reset to appropriate block rsv after orphan operations
Btrfs: skip locking if searching the commit root in csum lookup
btrfs: fix warning in iput for bad-inode
Btrfs: fix an oops when deleting snapshots

Linus Torvalds 0b001b2e 5dfcc87f

+62 -22
+5 -1
fs/btrfs/btrfs_inode.h
··· 176 176 { 177 177 u64 ino = BTRFS_I(inode)->location.objectid; 178 178 179 - if (ino <= BTRFS_FIRST_FREE_OBJECTID) 179 + /* 180 + * !ino: btree_inode 181 + * type == BTRFS_ROOT_ITEM_KEY: subvol dir 182 + */ 183 + if (!ino || BTRFS_I(inode)->location.type == BTRFS_ROOT_ITEM_KEY) 180 184 ino = inode->i_ino; 181 185 return ino; 182 186 }
+3 -1
fs/btrfs/file-item.c
··· 183 183 * read from the commit root and sidestep a nasty deadlock 184 184 * between reading the free space cache and updating the csum tree. 185 185 */ 186 - if (btrfs_is_free_space_inode(root, inode)) 186 + if (btrfs_is_free_space_inode(root, inode)) { 187 187 path->search_commit_root = 1; 188 + path->skip_locking = 1; 189 + } 188 190 189 191 disk_bytenr = (u64)bio->bi_sector << 9; 190 192 if (dio)
+10 -6
fs/btrfs/file.c
··· 1075 1075 start_pos = pos & ~((u64)root->sectorsize - 1); 1076 1076 last_pos = ((u64)index + num_pages) << PAGE_CACHE_SHIFT; 1077 1077 1078 - if (start_pos > inode->i_size) { 1079 - err = btrfs_cont_expand(inode, i_size_read(inode), start_pos); 1080 - if (err) 1081 - return err; 1082 - } 1083 - 1084 1078 again: 1085 1079 for (i = 0; i < num_pages; i++) { 1086 1080 pages[i] = find_or_create_page(inode->i_mapping, index + i, ··· 1332 1338 struct inode *inode = fdentry(file)->d_inode; 1333 1339 struct btrfs_root *root = BTRFS_I(inode)->root; 1334 1340 loff_t *ppos = &iocb->ki_pos; 1341 + u64 start_pos; 1335 1342 ssize_t num_written = 0; 1336 1343 ssize_t err = 0; 1337 1344 size_t count, ocount; ··· 1380 1385 1381 1386 file_update_time(file); 1382 1387 BTRFS_I(inode)->sequence++; 1388 + 1389 + start_pos = round_down(pos, root->sectorsize); 1390 + if (start_pos > i_size_read(inode)) { 1391 + err = btrfs_cont_expand(inode, i_size_read(inode), start_pos); 1392 + if (err) { 1393 + mutex_unlock(&inode->i_mutex); 1394 + goto out; 1395 + } 1396 + } 1383 1397 1384 1398 if (unlikely(file->f_flags & O_DIRECT)) { 1385 1399 num_written = __btrfs_direct_write(iocb, iov, nr_segs,
+4
fs/btrfs/free-space-cache.c
··· 190 190 struct btrfs_path *path, 191 191 struct inode *inode) 192 192 { 193 + struct btrfs_block_rsv *rsv; 193 194 loff_t oldsize; 194 195 int ret = 0; 195 196 197 + rsv = trans->block_rsv; 196 198 trans->block_rsv = root->orphan_block_rsv; 197 199 ret = btrfs_block_rsv_check(trans, root, 198 200 root->orphan_block_rsv, ··· 212 210 */ 213 211 ret = btrfs_truncate_inode_items(trans, root, inode, 214 212 0, BTRFS_EXTENT_DATA_KEY); 213 + 214 + trans->block_rsv = rsv; 215 215 if (ret) { 216 216 WARN_ON(1); 217 217 return ret;
+11 -11
fs/btrfs/inode.c
··· 1786 1786 &ordered_extent->list); 1787 1787 1788 1788 ret = btrfs_ordered_update_i_size(inode, 0, ordered_extent); 1789 - if (!ret) { 1789 + if (!ret || !test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) { 1790 1790 ret = btrfs_update_inode(trans, root, inode); 1791 1791 BUG_ON(ret); 1792 1792 } ··· 3510 3510 err = btrfs_drop_extents(trans, inode, cur_offset, 3511 3511 cur_offset + hole_size, 3512 3512 &hint_byte, 1); 3513 - if (err) 3513 + if (err) { 3514 + btrfs_end_transaction(trans, root); 3514 3515 break; 3516 + } 3515 3517 3516 3518 err = btrfs_insert_file_extent(trans, root, 3517 3519 btrfs_ino(inode), cur_offset, 0, 3518 3520 0, hole_size, 0, hole_size, 3519 3521 0, 0, 0); 3520 - if (err) 3522 + if (err) { 3523 + btrfs_end_transaction(trans, root); 3521 3524 break; 3525 + } 3522 3526 3523 3527 btrfs_drop_extent_cache(inode, hole_start, 3524 3528 last_byte - 1, 0); ··· 3956 3952 struct btrfs_root *root, int *new) 3957 3953 { 3958 3954 struct inode *inode; 3959 - int bad_inode = 0; 3960 3955 3961 3956 inode = btrfs_iget_locked(s, location->objectid, root); 3962 3957 if (!inode) ··· 3971 3968 if (new) 3972 3969 *new = 1; 3973 3970 } else { 3974 - bad_inode = 1; 3971 + unlock_new_inode(inode); 3972 + iput(inode); 3973 + inode = ERR_PTR(-ESTALE); 3975 3974 } 3976 - } 3977 - 3978 - if (bad_inode) { 3979 - iput(inode); 3980 - inode = ERR_PTR(-ESTALE); 3981 3975 } 3982 3976 3983 3977 return inode; ··· 5823 5823 5824 5824 add_pending_csums(trans, inode, ordered->file_offset, &ordered->list); 5825 5825 ret = btrfs_ordered_update_i_size(inode, 0, ordered); 5826 - if (!ret) 5826 + if (!ret || !test_bit(BTRFS_ORDERED_PREALLOC, &ordered->flags)) 5827 5827 btrfs_update_inode(trans, root, inode); 5828 5828 ret = 0; 5829 5829 out_unlock:
+16 -3
fs/btrfs/ioctl.c
··· 2220 2220 !IS_ALIGNED(destoff, bs)) 2221 2221 goto out_unlock; 2222 2222 2223 + if (destoff > inode->i_size) { 2224 + ret = btrfs_cont_expand(inode, inode->i_size, destoff); 2225 + if (ret) 2226 + goto out_unlock; 2227 + } 2228 + 2223 2229 /* do any pending delalloc/csum calc on src, one way or 2224 2230 another, and lock file content */ 2225 2231 while (1) { ··· 2331 2325 2332 2326 if (type == BTRFS_FILE_EXTENT_REG || 2333 2327 type == BTRFS_FILE_EXTENT_PREALLOC) { 2328 + /* 2329 + * a | --- range to clone ---| b 2330 + * | ------------- extent ------------- | 2331 + */ 2332 + 2333 + /* substract range b */ 2334 + if (key.offset + datal > off + len) 2335 + datal = off + len - key.offset; 2336 + 2337 + /* substract range a */ 2334 2338 if (off > key.offset) { 2335 2339 datao += off - key.offset; 2336 2340 datal -= off - key.offset; 2337 2341 } 2338 - 2339 - if (key.offset + datal > off + len) 2340 - datal = off + len - key.offset; 2341 2342 2342 2343 ret = btrfs_drop_extents(trans, inode, 2343 2344 new_key.offset,
+4
fs/btrfs/transaction.c
··· 884 884 struct btrfs_root *tree_root = fs_info->tree_root; 885 885 struct btrfs_root *root = pending->root; 886 886 struct btrfs_root *parent_root; 887 + struct btrfs_block_rsv *rsv; 887 888 struct inode *parent_inode; 888 889 struct dentry *parent; 889 890 struct dentry *dentry; ··· 895 894 u64 index = 0; 896 895 u64 objectid; 897 896 u64 root_flags; 897 + 898 + rsv = trans->block_rsv; 898 899 899 900 new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS); 900 901 if (!new_root_item) { ··· 1005 1002 btrfs_orphan_post_snapshot(trans, pending); 1006 1003 fail: 1007 1004 kfree(new_root_item); 1005 + trans->block_rsv = rsv; 1008 1006 btrfs_block_rsv_release(root, &pending->block_rsv, (u64)-1); 1009 1007 return 0; 1010 1008 }
+9
fs/btrfs/xattr.c
··· 116 116 if (ret) 117 117 goto out; 118 118 btrfs_release_path(path); 119 + 120 + /* 121 + * remove the attribute 122 + */ 123 + if (!value) 124 + goto out; 119 125 } 120 126 121 127 again: ··· 164 158 return ret; 165 159 } 166 160 161 + /* 162 + * @value: "" makes the attribute to empty, NULL removes it 163 + */ 167 164 int __btrfs_setxattr(struct btrfs_trans_handle *trans, 168 165 struct inode *inode, const char *name, 169 166 const void *value, size_t size, int flags)