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

don't put symlink bodies in pagecache into highmem

kmap() in page_follow_link_light() needed to go - allowing to hold
an arbitrary number of kmaps for long is a great way to deadlocking
the system.

new helper (inode_nohighmem(inode)) needs to be used for pagecache
symlinks inodes; done for all in-tree cases. page_follow_link_light()
instrumented to yell about anything missed.

Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

Al Viro 21fc61c7 aa80deab

+81 -46
+5
Documentation/filesystems/porting
··· 504 504 [mandatory] 505 505 __fd_install() & fd_install() can now sleep. Callers should not 506 506 hold a spinlock or other resources that do not allow a schedule. 507 + -- 508 + [mandatory] 509 + any symlink that might use page_follow_link_light/page_put_link() must 510 + have inode_nohighmem(inode) called before anything might start playing with 511 + its pagecache.
+1
fs/affs/inode.c
··· 140 140 break; 141 141 case ST_SOFTLINK: 142 142 inode->i_mode |= S_IFLNK; 143 + inode_nohighmem(inode); 143 144 inode->i_op = &affs_symlink_inode_operations; 144 145 inode->i_data.a_ops = &affs_symlink_aops; 145 146 break;
+1
fs/affs/namei.c
··· 344 344 return -ENOSPC; 345 345 346 346 inode->i_op = &affs_symlink_inode_operations; 347 + inode_nohighmem(inode); 347 348 inode->i_data.a_ops = &affs_symlink_aops; 348 349 inode->i_mode = S_IFLNK | 0777; 349 350 mode_to_prot(inode);
+1 -3
fs/affs/symlink.c
··· 14 14 { 15 15 struct buffer_head *bh; 16 16 struct inode *inode = page->mapping->host; 17 - char *link = kmap(page); 17 + char *link = page_address(page); 18 18 struct slink_front *lf; 19 19 int i, j; 20 20 char c; ··· 57 57 link[i] = '\0'; 58 58 affs_brelse(bh); 59 59 SetPageUptodate(page); 60 - kunmap(page); 61 60 unlock_page(page); 62 61 return 0; 63 62 fail: 64 63 SetPageError(page); 65 - kunmap(page); 66 64 unlock_page(page); 67 65 return -EIO; 68 66 }
+1
fs/afs/inode.c
··· 56 56 case AFS_FTYPE_SYMLINK: 57 57 inode->i_mode = S_IFLNK | vnode->status.mode; 58 58 inode->i_op = &page_symlink_inode_operations; 59 + inode_nohighmem(inode); 59 60 break; 60 61 default: 61 62 printk("kAFS: AFS vnode with undefined type\n");
+2 -3
fs/befs/linuxvfs.c
··· 397 397 } else if (S_ISLNK(inode->i_mode)) { 398 398 if (befs_ino->i_flags & BEFS_LONG_SYMLINK) { 399 399 inode->i_op = &page_symlink_inode_operations; 400 + inode_nohighmem(inode); 400 401 inode->i_mapping->a_ops = &befs_symlink_aops; 401 402 } else { 402 403 inode->i_link = befs_ino->i_data.symlink; ··· 470 469 struct befs_inode_info *befs_ino = BEFS_I(inode); 471 470 befs_data_stream *data = &befs_ino->i_data.ds; 472 471 befs_off_t len = data->size; 473 - char *link = kmap(page); 472 + char *link = page_address(page); 474 473 475 474 if (len == 0 || len > PAGE_SIZE) { 476 475 befs_error(sb, "Long symlink with illegal length"); ··· 484 483 } 485 484 link[len - 1] = '\0'; 486 485 SetPageUptodate(page); 487 - kunmap(page); 488 486 unlock_page(page); 489 487 return 0; 490 488 fail: 491 489 SetPageError(page); 492 - kunmap(page); 493 490 unlock_page(page); 494 491 return -EIO; 495 492 }
+2
fs/btrfs/inode.c
··· 3774 3774 break; 3775 3775 case S_IFLNK: 3776 3776 inode->i_op = &btrfs_symlink_inode_operations; 3777 + inode_nohighmem(inode); 3777 3778 inode->i_mapping->a_ops = &btrfs_symlink_aops; 3778 3779 break; 3779 3780 default: ··· 9706 9705 btrfs_free_path(path); 9707 9706 9708 9707 inode->i_op = &btrfs_symlink_inode_operations; 9708 + inode_nohighmem(inode); 9709 9709 inode->i_mapping->a_ops = &btrfs_symlink_aops; 9710 9710 inode_set_bytes(inode, name_len); 9711 9711 btrfs_i_size_write(inode, name_len);
+2
fs/coda/cnode.c
··· 8 8 9 9 #include <linux/coda.h> 10 10 #include <linux/coda_psdev.h> 11 + #include <linux/pagemap.h> 11 12 #include "coda_linux.h" 12 13 13 14 static inline int coda_fideq(struct CodaFid *fid1, struct CodaFid *fid2) ··· 36 35 inode->i_fop = &coda_dir_operations; 37 36 } else if (S_ISLNK(inode->i_mode)) { 38 37 inode->i_op = &coda_symlink_inode_operations; 38 + inode_nohighmem(inode); 39 39 inode->i_data.a_ops = &coda_symlink_aops; 40 40 inode->i_mapping = &inode->i_data; 41 41 } else
+1 -3
fs/coda/symlink.c
··· 26 26 int error; 27 27 struct coda_inode_info *cii; 28 28 unsigned int len = PAGE_SIZE; 29 - char *p = kmap(page); 29 + char *p = page_address(page); 30 30 31 31 cii = ITOC(inode); 32 32 ··· 34 34 if (error) 35 35 goto fail; 36 36 SetPageUptodate(page); 37 - kunmap(page); 38 37 unlock_page(page); 39 38 return 0; 40 39 41 40 fail: 42 41 SetPageError(page); 43 - kunmap(page); 44 42 unlock_page(page); 45 43 return error; 46 44 }
+1
fs/cramfs/inode.c
··· 100 100 break; 101 101 case S_IFLNK: 102 102 inode->i_op = &page_symlink_inode_operations; 103 + inode_nohighmem(inode); 103 104 inode->i_data.a_ops = &cramfs_aops; 104 105 break; 105 106 default:
+1
fs/efs/inode.c
··· 151 151 break; 152 152 case S_IFLNK: 153 153 inode->i_op = &page_symlink_inode_operations; 154 + inode_nohighmem(inode); 154 155 inode->i_data.a_ops = &efs_symlink_aops; 155 156 break; 156 157 case S_IFCHR:
+1 -3
fs/efs/symlink.c
··· 13 13 14 14 static int efs_symlink_readpage(struct file *file, struct page *page) 15 15 { 16 - char *link = kmap(page); 16 + char *link = page_address(page); 17 17 struct buffer_head * bh; 18 18 struct inode * inode = page->mapping->host; 19 19 efs_block_t size = inode->i_size; ··· 39 39 } 40 40 link[size] = '\0'; 41 41 SetPageUptodate(page); 42 - kunmap(page); 43 42 unlock_page(page); 44 43 return 0; 45 44 fail: 46 45 SetPageError(page); 47 - kunmap(page); 48 46 unlock_page(page); 49 47 return err; 50 48 }
+1
fs/exofs/inode.c
··· 1227 1227 inode->i_link = (char *)oi->i_data; 1228 1228 } else { 1229 1229 inode->i_op = &page_symlink_inode_operations; 1230 + inode_nohighmem(inode); 1230 1231 inode->i_mapping->a_ops = &exofs_aops; 1231 1232 } 1232 1233 } else {
+1
fs/exofs/namei.c
··· 111 111 if (l > sizeof(oi->i_data)) { 112 112 /* slow symlink */ 113 113 inode->i_op = &page_symlink_inode_operations; 114 + inode_nohighmem(inode); 114 115 inode->i_mapping->a_ops = &exofs_aops; 115 116 memset(oi->i_data, 0, sizeof(oi->i_data)); 116 117
+1
fs/ext2/inode.c
··· 1420 1420 sizeof(ei->i_data) - 1); 1421 1421 } else { 1422 1422 inode->i_op = &ext2_symlink_inode_operations; 1423 + inode_nohighmem(inode); 1423 1424 if (test_opt(inode->i_sb, NOBH)) 1424 1425 inode->i_mapping->a_ops = &ext2_nobh_aops; 1425 1426 else
+1
fs/ext2/namei.c
··· 183 183 if (l > sizeof (EXT2_I(inode)->i_data)) { 184 184 /* slow symlink */ 185 185 inode->i_op = &ext2_symlink_inode_operations; 186 + inode_nohighmem(inode); 186 187 if (test_opt(inode->i_sb, NOBH)) 187 188 inode->i_mapping->a_ops = &ext2_nobh_aops; 188 189 else
+1
fs/ext4/inode.c
··· 4283 4283 inode->i_op = &ext4_symlink_inode_operations; 4284 4284 ext4_set_aops(inode); 4285 4285 } 4286 + inode_nohighmem(inode); 4286 4287 } else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) || 4287 4288 S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) { 4288 4289 inode->i_op = &ext4_special_inode_operations;
+1
fs/ext4/namei.c
··· 3132 3132 if ((disk_link.len > EXT4_N_BLOCKS * 4)) { 3133 3133 if (!encryption_required) 3134 3134 inode->i_op = &ext4_symlink_inode_operations; 3135 + inode_nohighmem(inode); 3135 3136 ext4_set_aops(inode); 3136 3137 /* 3137 3138 * We cannot call page_symlink() with transaction started
+3 -7
fs/ext4/symlink.c
··· 45 45 cpage = read_mapping_page(inode->i_mapping, 0, NULL); 46 46 if (IS_ERR(cpage)) 47 47 return ERR_CAST(cpage); 48 - caddr = kmap(cpage); 48 + caddr = page_address(cpage); 49 49 caddr[size] = 0; 50 50 } 51 51 ··· 75 75 /* Null-terminate the name */ 76 76 if (res <= plen) 77 77 paddr[res] = '\0'; 78 - if (cpage) { 79 - kunmap(cpage); 78 + if (cpage) 80 79 page_cache_release(cpage); 81 - } 82 80 return *cookie = paddr; 83 81 errout: 84 - if (cpage) { 85 - kunmap(cpage); 82 + if (cpage) 86 83 page_cache_release(cpage); 87 - } 88 84 kfree(paddr); 89 85 return ERR_PTR(res); 90 86 }
+1
fs/f2fs/inode.c
··· 202 202 inode->i_op = &f2fs_encrypted_symlink_inode_operations; 203 203 else 204 204 inode->i_op = &f2fs_symlink_inode_operations; 205 + inode_nohighmem(inode); 205 206 inode->i_mapping->a_ops = &f2fs_dblock_aops; 206 207 } else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) || 207 208 S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
+2 -3
fs/f2fs/namei.c
··· 351 351 inode->i_op = &f2fs_encrypted_symlink_inode_operations; 352 352 else 353 353 inode->i_op = &f2fs_symlink_inode_operations; 354 + inode_nohighmem(inode); 354 355 inode->i_mapping->a_ops = &f2fs_dblock_aops; 355 356 356 357 f2fs_lock_op(sbi); ··· 943 942 cpage = read_mapping_page(inode->i_mapping, 0, NULL); 944 943 if (IS_ERR(cpage)) 945 944 return ERR_CAST(cpage); 946 - caddr = kmap(cpage); 945 + caddr = page_address(cpage); 947 946 caddr[size] = 0; 948 947 949 948 /* Symlink is encrypted */ ··· 983 982 /* Null-terminate the name */ 984 983 paddr[res] = '\0'; 985 984 986 - kunmap(cpage); 987 985 page_cache_release(cpage); 988 986 return *cookie = paddr; 989 987 errout: 990 988 kfree(cstr.name); 991 989 f2fs_fname_crypto_free_buffer(&pstr); 992 - kunmap(cpage); 993 990 page_cache_release(cpage); 994 991 return ERR_PTR(res); 995 992 }
+1
fs/freevxfs/vxfs_inode.c
··· 326 326 } else if (S_ISLNK(ip->i_mode)) { 327 327 if (!VXFS_ISIMMED(vip)) { 328 328 ip->i_op = &page_symlink_inode_operations; 329 + inode_nohighmem(ip); 329 330 ip->i_mapping->a_ops = &vxfs_aops; 330 331 } else { 331 332 ip->i_op = &simple_symlink_inode_operations;
+2
fs/hfsplus/inode.c
··· 403 403 } else if (S_ISLNK(inode->i_mode)) { 404 404 sbi->file_count++; 405 405 inode->i_op = &page_symlink_inode_operations; 406 + inode_nohighmem(inode); 406 407 inode->i_mapping->a_ops = &hfsplus_aops; 407 408 hip->clump_blocks = 1; 408 409 } else ··· 527 526 inode->i_mapping->a_ops = &hfsplus_aops; 528 527 } else if (S_ISLNK(inode->i_mode)) { 529 528 inode->i_op = &page_symlink_inode_operations; 529 + inode_nohighmem(inode); 530 530 inode->i_mapping->a_ops = &hfsplus_aops; 531 531 } else { 532 532 init_special_inode(inode, inode->i_mode,
+1
fs/hpfs/inode.c
··· 77 77 kfree(ea); 78 78 i->i_mode = S_IFLNK | 0777; 79 79 i->i_op = &page_symlink_inode_operations; 80 + inode_nohighmem(i); 80 81 i->i_data.a_ops = &hpfs_symlink_aops; 81 82 set_nlink(i, 1); 82 83 i->i_size = ea_size;
+2 -3
fs/hpfs/namei.c
··· 332 332 result->i_blocks = 1; 333 333 set_nlink(result, 1); 334 334 result->i_size = strlen(symlink); 335 + inode_nohighmem(result); 335 336 result->i_op = &page_symlink_inode_operations; 336 337 result->i_data.a_ops = &hpfs_symlink_aops; 337 338 ··· 501 500 502 501 static int hpfs_symlink_readpage(struct file *file, struct page *page) 503 502 { 504 - char *link = kmap(page); 503 + char *link = page_address(page); 505 504 struct inode *i = page->mapping->host; 506 505 struct fnode *fnode; 507 506 struct buffer_head *bh; ··· 517 516 goto fail; 518 517 hpfs_unlock(i->i_sb); 519 518 SetPageUptodate(page); 520 - kunmap(page); 521 519 unlock_page(page); 522 520 return 0; 523 521 524 522 fail: 525 523 hpfs_unlock(i->i_sb); 526 524 SetPageError(page); 527 - kunmap(page); 528 525 unlock_page(page); 529 526 return err; 530 527 }
+1
fs/hugetlbfs/inode.c
··· 760 760 break; 761 761 case S_IFLNK: 762 762 inode->i_op = &page_symlink_inode_operations; 763 + inode_nohighmem(inode); 763 764 break; 764 765 } 765 766 lockdep_annotate_inode_mutex_key(inode);
+6
fs/inode.c
··· 2028 2028 new_flags) != old_flags)); 2029 2029 } 2030 2030 EXPORT_SYMBOL(inode_set_flags); 2031 + 2032 + void inode_nohighmem(struct inode *inode) 2033 + { 2034 + mapping_set_gfp_mask(inode->i_mapping, GFP_USER); 2035 + } 2036 + EXPORT_SYMBOL(inode_nohighmem);
+1
fs/isofs/inode.c
··· 1417 1417 inode->i_fop = &isofs_dir_operations; 1418 1418 } else if (S_ISLNK(inode->i_mode)) { 1419 1419 inode->i_op = &page_symlink_inode_operations; 1420 + inode_nohighmem(inode); 1420 1421 inode->i_data.a_ops = &isofs_symlink_aops; 1421 1422 } else 1422 1423 /* XXX - parse_rock_ridge_inode() had already set i_rdev. */
+1 -3
fs/isofs/rock.c
··· 687 687 struct inode *inode = page->mapping->host; 688 688 struct iso_inode_info *ei = ISOFS_I(inode); 689 689 struct isofs_sb_info *sbi = ISOFS_SB(inode->i_sb); 690 - char *link = kmap(page); 690 + char *link = page_address(page); 691 691 unsigned long bufsize = ISOFS_BUFFER_SIZE(inode); 692 692 struct buffer_head *bh; 693 693 char *rpnt = link; ··· 774 774 brelse(bh); 775 775 *rpnt = '\0'; 776 776 SetPageUptodate(page); 777 - kunmap(page); 778 777 unlock_page(page); 779 778 return 0; 780 779 ··· 790 791 brelse(bh); 791 792 error: 792 793 SetPageError(page); 793 - kunmap(page); 794 794 unlock_page(page); 795 795 return -EIO; 796 796 }
+1
fs/jfs/inode.c
··· 60 60 } else if (S_ISLNK(inode->i_mode)) { 61 61 if (inode->i_size >= IDATASIZE) { 62 62 inode->i_op = &page_symlink_inode_operations; 63 + inode_nohighmem(inode); 63 64 inode->i_mapping->a_ops = &jfs_aops; 64 65 } else { 65 66 inode->i_op = &jfs_fast_symlink_inode_operations;
+1
fs/jfs/namei.c
··· 983 983 jfs_info("jfs_symlink: allocate extent ip:0x%p", ip); 984 984 985 985 ip->i_op = &jfs_symlink_inode_operations; 986 + inode_nohighmem(ip); 986 987 ip->i_mapping->a_ops = &jfs_aops; 987 988 988 989 /*
+1
fs/logfs/dir.c
··· 529 529 return PTR_ERR(inode); 530 530 531 531 inode->i_op = &page_symlink_inode_operations; 532 + inode_nohighmem(inode); 532 533 inode->i_mapping->a_ops = &logfs_reg_aops; 533 534 534 535 return __logfs_create(dir, dentry, inode, target, destlen);
+1
fs/logfs/inode.c
··· 65 65 break; 66 66 case S_IFLNK: 67 67 inode->i_op = &page_symlink_inode_operations; 68 + inode_nohighmem(inode); 68 69 inode->i_mapping->a_ops = &logfs_reg_aops; 69 70 break; 70 71 case S_IFSOCK: /* fall through */
+1
fs/minix/inode.c
··· 452 452 inode->i_mapping->a_ops = &minix_aops; 453 453 } else if (S_ISLNK(inode->i_mode)) { 454 454 inode->i_op = &minix_symlink_inode_operations; 455 + inode_nohighmem(inode); 455 456 inode->i_mapping->a_ops = &minix_aops; 456 457 } else 457 458 init_special_inode(inode, inode->i_mode, rdev);
+3 -6
fs/namei.c
··· 4527 4527 if (IS_ERR(page)) 4528 4528 return (char*)page; 4529 4529 *cookie = page; 4530 - kaddr = kmap(page); 4530 + BUG_ON(mapping_gfp_mask(mapping) & __GFP_HIGHMEM); 4531 + kaddr = page_address(page); 4531 4532 nd_terminate_link(kaddr, dentry->d_inode->i_size, PAGE_SIZE - 1); 4532 4533 return kaddr; 4533 4534 } ··· 4542 4541 void page_put_link(struct inode *unused, void *cookie) 4543 4542 { 4544 4543 struct page *page = cookie; 4545 - kunmap(page); 4546 4544 page_cache_release(page); 4547 4545 } 4548 4546 EXPORT_SYMBOL(page_put_link); ··· 4565 4565 struct page *page; 4566 4566 void *fsdata; 4567 4567 int err; 4568 - char *kaddr; 4569 4568 unsigned int flags = AOP_FLAG_UNINTERRUPTIBLE; 4570 4569 if (nofs) 4571 4570 flags |= AOP_FLAG_NOFS; ··· 4575 4576 if (err) 4576 4577 goto fail; 4577 4578 4578 - kaddr = kmap_atomic(page); 4579 - memcpy(kaddr, symname, len-1); 4580 - kunmap_atomic(kaddr); 4579 + memcpy(page_address(page), symname, len-1); 4581 4580 4582 4581 err = pagecache_write_end(NULL, mapping, 0, len-1, len-1, 4583 4582 page, fsdata);
+1
fs/ncpfs/inode.c
··· 283 283 #if defined(CONFIG_NCPFS_EXTRAS) || defined(CONFIG_NCPFS_NFS_NS) 284 284 } else if (S_ISLNK(inode->i_mode)) { 285 285 inode->i_op = &ncp_symlink_inode_operations; 286 + inode_nohighmem(inode); 286 287 inode->i_data.a_ops = &ncp_symlink_aops; 287 288 #endif 288 289 } else {
+3 -2
fs/nfs/inode.c
··· 408 408 inode->i_fop = NULL; 409 409 inode->i_flags |= S_AUTOMOUNT; 410 410 } 411 - } else if (S_ISLNK(inode->i_mode)) 411 + } else if (S_ISLNK(inode->i_mode)) { 412 412 inode->i_op = &nfs_symlink_inode_operations; 413 - else 413 + inode_nohighmem(inode); 414 + } else 414 415 init_special_inode(inode, inode->i_mode, fattr->rdev); 415 416 416 417 memset(&inode->i_atime, 0, sizeof(inode->i_atime));
+1 -1
fs/nfs/symlink.c
··· 56 56 if (IS_ERR(page)) 57 57 return ERR_CAST(page); 58 58 *cookie = page; 59 - return kmap(page); 59 + return page_address(page); 60 60 } 61 61 62 62 /*
+1
fs/nilfs2/inode.c
··· 510 510 inode->i_mapping->a_ops = &nilfs_aops; 511 511 } else if (S_ISLNK(inode->i_mode)) { 512 512 inode->i_op = &nilfs_symlink_inode_operations; 513 + inode_nohighmem(inode); 513 514 inode->i_mapping->a_ops = &nilfs_aops; 514 515 } else { 515 516 inode->i_op = &nilfs_special_inode_operations;
+1
fs/nilfs2/namei.c
··· 161 161 162 162 /* slow symlink */ 163 163 inode->i_op = &nilfs_symlink_inode_operations; 164 + inode_nohighmem(inode); 164 165 inode->i_mapping->a_ops = &nilfs_aops; 165 166 err = page_symlink(inode, symname, l); 166 167 if (err)
+1
fs/ocfs2/inode.c
··· 361 361 break; 362 362 case S_IFLNK: 363 363 inode->i_op = &ocfs2_symlink_inode_operations; 364 + inode_nohighmem(inode); 364 365 i_size_write(inode, le64_to_cpu(fe->i_size)); 365 366 break; 366 367 default:
+1
fs/ocfs2/namei.c
··· 1960 1960 inode->i_rdev = 0; 1961 1961 newsize = l - 1; 1962 1962 inode->i_op = &ocfs2_symlink_inode_operations; 1963 + inode_nohighmem(inode); 1963 1964 if (l > ocfs2_fast_symlink_chars(sb)) { 1964 1965 u32 offset = 0; 1965 1966
+1
fs/qnx4/inode.c
··· 316 316 inode->i_fop = &qnx4_dir_operations; 317 317 } else if (S_ISLNK(inode->i_mode)) { 318 318 inode->i_op = &page_symlink_inode_operations; 319 + inode_nohighmem(inode); 319 320 inode->i_mapping->a_ops = &qnx4_aops; 320 321 qnx4_i(inode)->mmu_private = inode->i_size; 321 322 } else {
+1
fs/qnx6/inode.c
··· 582 582 inode->i_mapping->a_ops = &qnx6_aops; 583 583 } else if (S_ISLNK(inode->i_mode)) { 584 584 inode->i_op = &page_symlink_inode_operations; 585 + inode_nohighmem(inode); 585 586 inode->i_mapping->a_ops = &qnx6_aops; 586 587 } else 587 588 init_special_inode(inode, inode->i_mode, 0);
+1
fs/ramfs/inode.c
··· 79 79 break; 80 80 case S_IFLNK: 81 81 inode->i_op = &page_symlink_inode_operations; 82 + inode_nohighmem(inode); 82 83 break; 83 84 } 84 85 }
+1
fs/reiserfs/inode.c
··· 1361 1361 inode->i_fop = &reiserfs_dir_operations; 1362 1362 } else if (S_ISLNK(inode->i_mode)) { 1363 1363 inode->i_op = &reiserfs_symlink_inode_operations; 1364 + inode_nohighmem(inode); 1364 1365 inode->i_mapping->a_ops = &reiserfs_address_space_operations; 1365 1366 } else { 1366 1367 inode->i_blocks = 0;
+1
fs/reiserfs/namei.c
··· 1170 1170 reiserfs_update_inode_transaction(parent_dir); 1171 1171 1172 1172 inode->i_op = &reiserfs_symlink_inode_operations; 1173 + inode_nohighmem(inode); 1173 1174 inode->i_mapping->a_ops = &reiserfs_address_space_operations; 1174 1175 1175 1176 retval = reiserfs_add_entry(&th, parent_dir, dentry->d_name.name,
+1
fs/romfs/super.c
··· 360 360 break; 361 361 case ROMFH_SYM: 362 362 i->i_op = &page_symlink_inode_operations; 363 + inode_nohighmem(i); 363 364 i->i_data.a_ops = &romfs_aops; 364 365 mode |= S_IRWXUGO; 365 366 break;
+2
fs/squashfs/inode.c
··· 41 41 #include <linux/fs.h> 42 42 #include <linux/vfs.h> 43 43 #include <linux/xattr.h> 44 + #include <linux/pagemap.h> 44 45 45 46 #include "squashfs_fs.h" 46 47 #include "squashfs_fs_sb.h" ··· 292 291 set_nlink(inode, le32_to_cpu(sqsh_ino->nlink)); 293 292 inode->i_size = le32_to_cpu(sqsh_ino->symlink_size); 294 293 inode->i_op = &squashfs_symlink_inode_ops; 294 + inode_nohighmem(inode); 295 295 inode->i_data.a_ops = &squashfs_symlink_aops; 296 296 inode->i_mode |= S_IFLNK; 297 297 squashfs_i(inode)->start = block;
+1
fs/sysv/inode.c
··· 163 163 inode->i_mapping->a_ops = &sysv_aops; 164 164 } else if (S_ISLNK(inode->i_mode)) { 165 165 inode->i_op = &sysv_symlink_inode_operations; 166 + inode_nohighmem(inode); 166 167 inode->i_mapping->a_ops = &sysv_aops; 167 168 } else 168 169 init_special_inode(inode, inode->i_mode, rdev);
+1
fs/udf/inode.c
··· 1541 1541 case ICBTAG_FILE_TYPE_SYMLINK: 1542 1542 inode->i_data.a_ops = &udf_symlink_aops; 1543 1543 inode->i_op = &page_symlink_inode_operations; 1544 + inode_nohighmem(inode); 1544 1545 inode->i_mode = S_IFLNK | S_IRWXUGO; 1545 1546 break; 1546 1547 case ICBTAG_FILE_TYPE_MAIN:
+1
fs/udf/namei.c
··· 922 922 923 923 inode->i_data.a_ops = &udf_symlink_aops; 924 924 inode->i_op = &page_symlink_inode_operations; 925 + inode_nohighmem(inode); 925 926 926 927 if (iinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) { 927 928 struct kernel_lb_addr eloc;
+1 -3
fs/udf/symlink.c
··· 107 107 struct buffer_head *bh = NULL; 108 108 unsigned char *symlink; 109 109 int err; 110 - unsigned char *p = kmap(page); 110 + unsigned char *p = page_address(page); 111 111 struct udf_inode_info *iinfo; 112 112 uint32_t pos; 113 113 ··· 141 141 142 142 up_read(&iinfo->i_data_sem); 143 143 SetPageUptodate(page); 144 - kunmap(page); 145 144 unlock_page(page); 146 145 return 0; 147 146 ··· 148 149 up_read(&iinfo->i_data_sem); 149 150 SetPageError(page); 150 151 out_unmap: 151 - kunmap(page); 152 152 unlock_page(page); 153 153 return err; 154 154 }
+1
fs/ufs/inode.c
··· 533 533 } else { 534 534 inode->i_mapping->a_ops = &ufs_aops; 535 535 inode->i_op = &page_symlink_inode_operations; 536 + inode_nohighmem(inode); 536 537 } 537 538 } else 538 539 init_special_inode(inode, inode->i_mode,
+1
fs/ufs/namei.c
··· 124 124 if (l > UFS_SB(sb)->s_uspi->s_maxsymlinklen) { 125 125 /* slow symlink */ 126 126 inode->i_op = &page_symlink_inode_operations; 127 + inode_nohighmem(inode); 127 128 inode->i_mapping->a_ops = &ufs_aops; 128 129 err = page_symlink(inode, symname, l); 129 130 if (err)
+1
include/linux/fs.h
··· 3025 3025 } 3026 3026 3027 3027 extern bool path_noexec(const struct path *path); 3028 + extern void inode_nohighmem(struct inode *inode); 3028 3029 3029 3030 #endif /* _LINUX_FS_H */
+3 -6
mm/shmem.c
··· 2444 2444 int len; 2445 2445 struct inode *inode; 2446 2446 struct page *page; 2447 - char *kaddr; 2448 2447 struct shmem_inode_info *info; 2449 2448 2450 2449 len = strlen(symname) + 1; ··· 2482 2483 } 2483 2484 inode->i_mapping->a_ops = &shmem_aops; 2484 2485 inode->i_op = &shmem_symlink_inode_operations; 2485 - kaddr = kmap_atomic(page); 2486 - memcpy(kaddr, symname, len); 2487 - kunmap_atomic(kaddr); 2486 + inode_nohighmem(inode); 2487 + memcpy(page_address(page), symname, len); 2488 2488 SetPageUptodate(page); 2489 2489 set_page_dirty(page); 2490 2490 unlock_page(page); ··· 2504 2506 return ERR_PTR(error); 2505 2507 unlock_page(page); 2506 2508 *cookie = page; 2507 - return kmap(page); 2509 + return page_address(page); 2508 2510 } 2509 2511 2510 2512 static void shmem_put_link(struct inode *unused, void *cookie) 2511 2513 { 2512 2514 struct page *page = cookie; 2513 - kunmap(page); 2514 2515 mark_page_accessed(page); 2515 2516 page_cache_release(page); 2516 2517 }