Searched refs:i_sb (Results 1 - 200 of 479) sorted by relevance

123

/linux-4.1.27/fs/hpfs/
H A Dinode.c15 struct super_block *sb = i->i_sb; hpfs_init_inode()
47 struct super_block *sb = i->i_sb; hpfs_read_inode()
61 if (hpfs_sb(i->i_sb)->sb_eas) { hpfs_read_inode()
62 if ((ea = hpfs_get_ea(i->i_sb, fnode, "UID", &ea_size))) { hpfs_read_inode()
69 if ((ea = hpfs_get_ea(i->i_sb, fnode, "GID", &ea_size))) { hpfs_read_inode()
76 if ((ea = hpfs_get_ea(i->i_sb, fnode, "SYMLINK", &ea_size))) { hpfs_read_inode()
87 if ((ea = hpfs_get_ea(i->i_sb, fnode, "MODE", &ea_size))) { hpfs_read_inode()
97 if ((ea = hpfs_get_ea(i->i_sb, fnode, "DEV", &ea_size))) { hpfs_read_inode()
126 hpfs_count_dnodes(i->i_sb, hpfs_inode->i_dno, &n_dnodes, &n_subdirs, NULL); hpfs_read_inode()
150 hpfs_error(i->i_sb, "fnode %08x has some unknown HPFS386 structures", i->i_ino); hpfs_write_inode_ea()
151 } else*/ if (hpfs_sb(i->i_sb)->sb_eas >= 2) { hpfs_write_inode_ea()
153 if (!uid_eq(i->i_uid, hpfs_sb(i->i_sb)->sb_uid) || hpfs_inode->i_ea_uid) { hpfs_write_inode_ea()
158 if (!gid_eq(i->i_gid, hpfs_sb(i->i_sb)->sb_gid) || hpfs_inode->i_ea_gid) { hpfs_write_inode_ea()
164 if ((i->i_mode != ((hpfs_sb(i->i_sb)->sb_mode & ~(S_ISDIR(i->i_mode) ? 0 : 0111)) hpfs_write_inode_ea()
166 && i->i_mode != ((hpfs_sb(i->i_sb)->sb_mode & ~(S_ISDIR(i->i_mode) ? 0222 : 0333)) hpfs_write_inode_ea()
184 if (i->i_ino == hpfs_sb(i->i_sb)->sb_root) return; hpfs_write_inode()
194 parent = iget_locked(i->i_sb, hpfs_inode->i_parent_dir); hpfs_write_inode()
214 if (i->i_ino == hpfs_sb(i->i_sb)->sb_root) return; hpfs_write_inode_nolock()
215 if (!(fnode = hpfs_map_fnode(i->i_sb, i->i_ino, &bh))) return; hpfs_write_inode_nolock()
216 if (i->i_ino != hpfs_sb(i->i_sb)->sb_root && i->i_nlink) { hpfs_write_inode_nolock()
217 if (!(de = map_fnode_dirent(i->i_sb, i->i_ino, fnode, &qbh))) { hpfs_write_inode_nolock()
231 de->write_date = cpu_to_le32(gmt_to_local(i->i_sb, i->i_mtime.tv_sec)); hpfs_write_inode_nolock()
232 de->read_date = cpu_to_le32(gmt_to_local(i->i_sb, i->i_atime.tv_sec)); hpfs_write_inode_nolock()
233 de->creation_date = cpu_to_le32(gmt_to_local(i->i_sb, i->i_ctime.tv_sec)); hpfs_write_inode_nolock()
241 de->write_date = cpu_to_le32(gmt_to_local(i->i_sb, i->i_mtime.tv_sec)); hpfs_write_inode_nolock()
242 de->read_date = cpu_to_le32(gmt_to_local(i->i_sb, i->i_atime.tv_sec)); hpfs_write_inode_nolock()
243 de->creation_date = cpu_to_le32(gmt_to_local(i->i_sb, i->i_ctime.tv_sec)); hpfs_write_inode_nolock()
250 hpfs_error(i->i_sb, hpfs_write_inode_nolock()
263 hpfs_lock(inode->i_sb); hpfs_setattr()
264 if (inode->i_ino == hpfs_sb(inode->i_sb)->sb_root) hpfs_setattr()
294 hpfs_unlock(inode->i_sb); hpfs_setattr()
311 hpfs_lock(inode->i_sb); hpfs_evict_inode()
312 hpfs_remove_fnode(inode->i_sb, inode->i_ino); hpfs_evict_inode()
313 hpfs_unlock(inode->i_sb); hpfs_evict_inode()
H A Dnamei.c38 hpfs_lock(dir->i_sb); hpfs_mkdir()
40 fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh); hpfs_mkdir()
43 dnode = hpfs_alloc_dnode(dir->i_sb, fno, &dno, &qbh0); hpfs_mkdir()
52 dee.creation_date = dee.write_date = dee.read_date = cpu_to_le32(gmt_to_local(dir->i_sb, get_seconds())); hpfs_mkdir()
53 result = new_inode(dir->i_sb); hpfs_mkdir()
60 result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, le32_to_cpu(dee.creation_date)); hpfs_mkdir()
92 de = hpfs_add_de(dir->i_sb, dnode, "\001\001", 2, 0); hpfs_mkdir()
93 de->creation_date = de->write_date = de->read_date = cpu_to_le32(gmt_to_local(dir->i_sb, get_seconds())); hpfs_mkdir()
115 hpfs_unlock(dir->i_sb); hpfs_mkdir()
121 hpfs_free_dnode(dir->i_sb, dno); hpfs_mkdir()
124 hpfs_free_sectors(dir->i_sb, fno, 1); hpfs_mkdir()
126 hpfs_unlock(dir->i_sb); hpfs_mkdir()
143 hpfs_lock(dir->i_sb); hpfs_create()
145 fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh); hpfs_create()
153 dee.creation_date = dee.write_date = dee.read_date = cpu_to_le32(gmt_to_local(dir->i_sb, get_seconds())); hpfs_create()
155 result = new_inode(dir->i_sb); hpfs_create()
167 result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, le32_to_cpu(dee.creation_date)); hpfs_create()
204 hpfs_unlock(dir->i_sb); hpfs_create()
211 hpfs_free_sectors(dir->i_sb, fno, 1); hpfs_create()
213 hpfs_unlock(dir->i_sb); hpfs_create()
229 if (hpfs_sb(dir->i_sb)->sb_eas < 2) return -EPERM; hpfs_mknod()
232 hpfs_lock(dir->i_sb); hpfs_mknod()
234 fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh); hpfs_mknod()
242 dee.creation_date = dee.write_date = dee.read_date = cpu_to_le32(gmt_to_local(dir->i_sb, get_seconds())); hpfs_mknod()
244 result = new_inode(dir->i_sb); hpfs_mknod()
251 result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, le32_to_cpu(dee.creation_date)); hpfs_mknod()
281 hpfs_unlock(dir->i_sb); hpfs_mknod()
287 hpfs_free_sectors(dir->i_sb, fno, 1); hpfs_mknod()
289 hpfs_unlock(dir->i_sb); hpfs_mknod()
305 hpfs_lock(dir->i_sb); hpfs_symlink()
306 if (hpfs_sb(dir->i_sb)->sb_eas < 2) { hpfs_symlink()
307 hpfs_unlock(dir->i_sb); hpfs_symlink()
311 fnode = hpfs_alloc_fnode(dir->i_sb, hpfs_i(dir)->i_dno, &fno, &bh); hpfs_symlink()
318 dee.creation_date = dee.write_date = dee.read_date = cpu_to_le32(gmt_to_local(dir->i_sb, get_seconds())); hpfs_symlink()
320 result = new_inode(dir->i_sb); hpfs_symlink()
326 result->i_ctime.tv_sec = result->i_mtime.tv_sec = result->i_atime.tv_sec = local_to_gmt(dir->i_sb, le32_to_cpu(dee.creation_date)); hpfs_symlink()
359 hpfs_unlock(dir->i_sb); hpfs_symlink()
365 hpfs_free_sectors(dir->i_sb, fno, 1); hpfs_symlink()
367 hpfs_unlock(dir->i_sb); hpfs_symlink()
382 hpfs_lock(dir->i_sb); hpfs_unlink()
401 hpfs_error(dir->i_sb, "there was error when removing dirent"); hpfs_unlink()
418 hpfs_unlock(dir->i_sb); hpfs_unlink()
435 hpfs_lock(dir->i_sb); hpfs_rmdir()
449 hpfs_count_dnodes(dir->i_sb, hpfs_i(inode)->i_dno, NULL, NULL, &n_items); hpfs_rmdir()
457 hpfs_error(dir->i_sb, "there was error when removing dirent"); hpfs_rmdir()
474 hpfs_unlock(dir->i_sb); hpfs_rmdir()
487 hpfs_lock(i->i_sb); hpfs_symlink_readpage()
488 if (!(fnode = hpfs_map_fnode(i->i_sb, i->i_ino, &bh))) hpfs_symlink_readpage()
490 err = hpfs_read_ea(i->i_sb, fnode, "SYMLINK", link, PAGE_SIZE); hpfs_symlink_readpage()
494 hpfs_unlock(i->i_sb); hpfs_symlink_readpage()
501 hpfs_unlock(i->i_sb); hpfs_symlink_readpage()
534 hpfs_lock(i->i_sb); hpfs_rename()
544 hpfs_error(i->i_sb, "lookup succeeded but map dirent failed"); hpfs_rename()
562 hpfs_error(new_dir->i_sb, "hpfs_rename: could not find dirent"); hpfs_rename()
573 if (r == -1) hpfs_error(new_dir->i_sb, "hpfs_rename: dirent already exists!"); hpfs_rename()
581 hpfs_error(i->i_sb, "lookup succeeded but map dirent failed at #2"); hpfs_rename()
587 hpfs_error(i->i_sb, "hpfs_rename: could not remove dirent"); hpfs_rename()
598 if ((fnode = hpfs_map_fnode(i->i_sb, i->i_ino, &bh))) { hpfs_rename()
611 hpfs_unlock(i->i_sb); hpfs_rename()
H A Ddir.c14 hpfs_lock(inode->i_sb); hpfs_dir_release()
17 hpfs_unlock(inode->i_sb); hpfs_dir_release()
30 struct super_block *s = i->i_sb; hpfs_dir_lseek()
72 hpfs_lock(inode->i_sb); hpfs_readdir()
74 if (hpfs_sb(inode->i_sb)->sb_chk) { hpfs_readdir()
75 if (hpfs_chk_sectors(inode->i_sb, inode->i_ino, 1, "dir_fnode")) { hpfs_readdir()
79 if (hpfs_chk_sectors(inode->i_sb, hpfs_inode->i_dno, 4, "dir_dnode")) { hpfs_readdir()
84 if (hpfs_sb(inode->i_sb)->sb_chk >= 2) { hpfs_readdir()
88 if (!(fno = hpfs_map_fnode(inode->i_sb, inode->i_ino, &bh))) { hpfs_readdir()
94 hpfs_error(inode->i_sb, "not a directory, fnode %08lx", hpfs_readdir()
99 hpfs_error(inode->i_sb, "corrupted inode: i_dno == %08x, fnode -> dnode == %08x", hpfs_inode->i_dno, le32_to_cpu(fno->u.external[0].disk_secno)); hpfs_readdir()
107 lc = hpfs_sb(inode->i_sb)->sb_lowercase; hpfs_readdir()
122 if (hpfs_sb(inode->i_sb)->sb_chk) hpfs_readdir()
123 if (hpfs_stop_cycles(inode->i_sb, ctx->pos, &c1, &c2, "hpfs_readdir")) { hpfs_readdir()
144 ctx->pos = ((loff_t) hpfs_de_as_down_as_possible(inode->i_sb, hpfs_inode->i_dno) << 4) + 1; hpfs_readdir()
155 if (hpfs_sb(inode->i_sb)->sb_chk) { hpfs_readdir()
158 hpfs_error(inode->i_sb, "hpfs_readdir: bad ^A^A entry; pos = %08lx", (unsigned long)ctx->pos); hpfs_readdir()
160 hpfs_error(inode->i_sb, "hpfs_readdir: bad \\377 entry; pos = %08lx", (unsigned long)ctx->pos); hpfs_readdir()
166 tempname = hpfs_translate_name(inode->i_sb, de->name, de->namelen, lc, de->not_8x3); hpfs_readdir()
177 hpfs_unlock(inode->i_sb); hpfs_readdir()
207 hpfs_lock(dir->i_sb); hpfs_lookup()
210 hpfs_unlock(dir->i_sb); hpfs_lookup()
238 result = iget_locked(dir->i_sb, ino); hpfs_lookup()
240 hpfs_error(dir->i_sb, "hpfs_lookup: can't get inode"); hpfs_lookup()
247 else if (le32_to_cpu(de->ea_size) && hpfs_sb(dir->i_sb)->sb_eas) hpfs_lookup()
261 if (de->has_acl || de->has_xtd_perm) if (!(dir->i_sb->s_flags & MS_RDONLY)) { hpfs_lookup()
262 hpfs_error(result->i_sb, "ACLs or XPERM found. This is probably HPFS386. This driver doesn't support it now. Send me some info on these structures"); hpfs_lookup()
272 if (!(result->i_ctime.tv_sec = local_to_gmt(dir->i_sb, le32_to_cpu(de->creation_date)))) hpfs_lookup()
275 result->i_mtime.tv_sec = local_to_gmt(dir->i_sb, le32_to_cpu(de->write_date)); hpfs_lookup()
277 result->i_atime.tv_sec = local_to_gmt(dir->i_sb, le32_to_cpu(de->read_date)); hpfs_lookup()
306 hpfs_unlock(dir->i_sb); hpfs_lookup()
319 hpfs_unlock(dir->i_sb); hpfs_lookup()
H A Dfile.c16 hpfs_lock(inode->i_sb); hpfs_file_release()
18 hpfs_unlock(inode->i_sb); hpfs_file_release()
30 return sync_blockdev(inode->i_sb->s_bdev); hpfs_file_fsync()
50 if (!(fnode = hpfs_map_fnode(inode->i_sb, inode->i_ino, &bh))) return 0; hpfs_bmap()
51 disk_secno = hpfs_bplus_lookup(inode->i_sb, inode, &fnode->btree, file_secno, bh); hpfs_bmap()
53 if (hpfs_chk_sectors(inode->i_sb, disk_secno, 1, "bmap")) return 0; hpfs_bmap()
66 hpfs_lock_assert(i->i_sb); hpfs_truncate()
71 hpfs_truncate_btree(i->i_sb, i->i_ino, 1, ((i->i_size + 511) >> 9)); hpfs_truncate()
81 hpfs_lock(inode->i_sb); hpfs_get_block()
86 map_bh(bh_result, inode->i_sb, s); hpfs_get_block()
96 if ((s = hpfs_add_sector_to_btree(inode->i_sb, inode->i_ino, 1, inode->i_blocks - 1)) == -1) { hpfs_get_block()
97 hpfs_truncate_btree(inode->i_sb, inode->i_ino, 1, inode->i_blocks - 1); hpfs_get_block()
104 map_bh(bh_result, inode->i_sb, s); hpfs_get_block()
108 hpfs_unlock(inode->i_sb); hpfs_get_block()
138 hpfs_lock(inode->i_sb); hpfs_write_failed()
145 hpfs_unlock(inode->i_sb); hpfs_write_failed()
175 hpfs_lock(inode->i_sb); hpfs_write_end()
177 hpfs_unlock(inode->i_sb); hpfs_write_end()
H A Ddnode.c254 hpfs_error(i->i_sb, "%s(): namelen == %d", __func__, namelen); hpfs_add_to_dnode()
259 if (!(d = hpfs_map_dnode(i->i_sb, dno, &qbh))) { hpfs_add_to_dnode()
265 if (hpfs_sb(i->i_sb)->sb_chk) hpfs_add_to_dnode()
266 if (hpfs_stop_cycles(i->i_sb, dno, &c1, &c2, "hpfs_add_to_dnode")) { hpfs_add_to_dnode()
274 copy_de(de=hpfs_add_de(i->i_sb, d, name, namelen, down_ptr), new_de); hpfs_add_to_dnode()
297 copy_de(de = hpfs_add_de(i->i_sb, nd, name, namelen, down_ptr), new_de); hpfs_add_to_dnode()
300 if (!(ad = hpfs_alloc_dnode(i->i_sb, le32_to_cpu(d->up), &adno, &qbh1))) { hpfs_add_to_dnode()
301 hpfs_error(i->i_sb, "unable to alloc dnode - dnode tree will be corrupted"); hpfs_add_to_dnode()
311 copy_de(hpfs_add_de(i->i_sb, ad, de->name, de->namelen, de->down ? de_down_pointer(de) : 0), de); hpfs_add_to_dnode()
321 set_last_pointer(i->i_sb, ad, de->down ? de_down_pointer(de) : 0); hpfs_add_to_dnode()
327 fix_up_ptrs(i->i_sb, ad); hpfs_add_to_dnode()
337 if (!(rd = hpfs_alloc_dnode(i->i_sb, le32_to_cpu(d->up), &rdno, &qbh2))) { hpfs_add_to_dnode()
338 hpfs_error(i->i_sb, "unable to alloc dnode - dnode tree will be corrupted"); hpfs_add_to_dnode()
349 if (!(fnode = hpfs_map_fnode(i->i_sb, le32_to_cpu(d->up), &bh))) { hpfs_add_to_dnode()
350 hpfs_free_dnode(i->i_sb, rdno); hpfs_add_to_dnode()
369 set_last_pointer(i->i_sb, rd, dno); hpfs_add_to_dnode()
396 if (hpfs_sb(i->i_sb)->sb_chk) hpfs_add_dirent()
397 if (hpfs_stop_cycles(i->i_sb, dno, &c1, &c2, "hpfs_add_dirent")) return 1; hpfs_add_dirent()
398 if (!(d = hpfs_map_dnode(i->i_sb, dno, &qbh))) return 1; hpfs_add_dirent()
401 if (!(c = hpfs_compare_names(i->i_sb, name, namelen, de->name, de->namelen, de->last))) { hpfs_add_dirent()
415 if (hpfs_check_free_dnodes(i->i_sb, FREE_DNODES_ADD)) { hpfs_add_dirent()
442 if (hpfs_sb(i->i_sb)->sb_chk) move_to_top()
443 if (hpfs_stop_cycles(i->i_sb, dno, &c1, &c2, "move_to_top")) move_to_top()
445 if (!(dnode = hpfs_map_dnode(i->i_sb, dno, &qbh))) return 0; move_to_top()
446 if (hpfs_sb(i->i_sb)->sb_chk) { move_to_top()
448 hpfs_error(i->i_sb, "move_to_top: up pointer from %08x should be %08x, is %08x", move_to_top()
456 hpfs_error(i->i_sb, "move_to_top: dnode %08x has no last de", dno); move_to_top()
467 hpfs_free_dnode(i->i_sb, dno); move_to_top()
472 if (!(dnode = hpfs_map_dnode(i->i_sb, up, &qbh))) return 0; move_to_top()
474 hpfs_error(i->i_sb, "move_to_top: got to root_dnode while moving from %08x to %08x", from, to); move_to_top()
480 hpfs_error(i->i_sb, "move_to_top: dnode %08x doesn't point down to %08x", up, dno); move_to_top()
494 hpfs_error(i->i_sb, "out of memory for dirent - directory will be corrupted"); move_to_top()
500 hpfs_delete_de(i->i_sb, dnode, de); move_to_top()
501 set_last_pointer(i->i_sb, dnode, ddno); move_to_top()
525 if (hpfs_stop_cycles(i->i_sb, dno, &c1, &c2, "delete_empty_dnode")) return; delete_empty_dnode()
526 if (!(dnode = hpfs_map_dnode(i->i_sb, dno, &qbh))) return; delete_empty_dnode()
534 if (hpfs_sb(i->i_sb)->sb_chk) if (root && !down) { delete_empty_dnode()
535 hpfs_error(i->i_sb, "delete_empty_dnode: root dnode %08x is empty", dno); delete_empty_dnode()
539 hpfs_free_dnode(i->i_sb, dno); delete_empty_dnode()
547 if (hpfs_sb(i->i_sb)->sb_chk) delete_empty_dnode()
549 hpfs_error(i->i_sb, delete_empty_dnode()
555 if ((d1 = hpfs_map_dnode(i->i_sb, down, &qbh1))) { delete_empty_dnode()
561 if ((fnode = hpfs_map_fnode(i->i_sb, up, &bh))) { delete_empty_dnode()
570 if (!(dnode = hpfs_map_dnode(i->i_sb, up, &qbh))) return; delete_empty_dnode()
575 hpfs_error(i->i_sb, "delete_empty_dnode: pointer to dnode %08x not found in dnode %08x", dno, up); delete_empty_dnode()
589 if ((d1 = hpfs_map_dnode(i->i_sb, down, &qbh1))) { delete_empty_dnode()
596 hpfs_error(i->i_sb, "delete_empty_dnode: dnode %08x, first_free == %03x", dno, le32_to_cpu(dnode->first_free)); delete_empty_dnode()
612 hpfs_delete_de(i->i_sb, dnode, de); delete_empty_dnode()
617 if (de_cp->down) if ((d1 = hpfs_map_dnode(i->i_sb, de_down_pointer(de_cp), &qbh1))) { delete_empty_dnode()
635 hpfs_error(i->i_sb, "delete_empty_dnode: empty dnode %08x", up); delete_empty_dnode()
643 if ((d1 = hpfs_map_dnode(i->i_sb, ndown, &qbh1))) { delete_empty_dnode()
648 if (hpfs_sb(i->i_sb)->sb_chk >= 2) { delete_empty_dnode()
655 if (hpfs_sb(i->i_sb)->sb_chk >= 2) { delete_empty_dnode()
678 hpfs_delete_de(i->i_sb, dnode, de_prev); delete_empty_dnode()
689 if (down) if ((d1 = hpfs_map_dnode(i->i_sb, de_down_pointer(de), &qbh1))) { delete_empty_dnode()
715 hpfs_error(i->i_sb, "hpfs_remove_dirent: attempt to delete first or last dirent in dnode %08x", dno); hpfs_remove_dirent()
721 if (hpfs_check_free_dnodes(i->i_sb, FREE_DNODES_DEL)) { hpfs_remove_dirent()
728 hpfs_delete_de(i->i_sb, dnode, de); hpfs_remove_dirent()
858 if (!(de = map_nth_dirent(inode->i_sb, dno, pos, qbh, &dnode))) map_pos_dirent()
864 hpfs_error(inode->i_sb, map_pos_dirent()
871 *posp = ((loff_t) hpfs_de_as_down_as_possible(inode->i_sb, de_down_pointer(d)) << 4) + 1; map_pos_dirent()
880 if (!(up_dnode = hpfs_map_dnode(inode->i_sb, le32_to_cpu(dnode->up), &qbh0))) map_pos_dirent()
887 if (!(++c & 077)) hpfs_error(inode->i_sb, map_pos_dirent()
896 hpfs_error(inode->i_sb, "map_pos_dirent: pointer to dnode %08x not found in parent dnode %08x", map_pos_dirent()
916 if (!S_ISDIR(inode->i_mode)) hpfs_error(inode->i_sb, "map_dirent: not a directory\n"); map_dirent()
918 if (hpfs_sb(inode->i_sb)->sb_chk) map_dirent()
919 if (hpfs_stop_cycles(inode->i_sb, dno, &c1, &c2, "map_dirent")) return NULL; map_dirent()
920 if (!(dnode = hpfs_map_dnode(inode->i_sb, dno, qbh))) return NULL; map_dirent()
924 int t = hpfs_compare_names(inode->i_sb, name, len, de->name, de->namelen, de->last); map_dirent()
/linux-4.1.27/fs/udf/
H A Ddirectory.c39 dir->i_sb->s_blocksize, udf_fileident_read()
52 if (fibh->eoffset == dir->i_sb->s_blocksize) { udf_fileident_read()
54 unsigned char blocksize_bits = dir->i_sb->s_blocksize_bits; udf_fileident_read()
60 block = udf_get_lb_pblock(dir->i_sb, eloc, *offset); udf_fileident_read()
70 fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block); udf_fileident_read()
80 block = udf_get_lb_pblock(dir->i_sb, eloc, udf_fileident_read()
82 tmp = udf_tgetblk(dir->i_sb, block); udf_fileident_read()
100 fi = udf_get_fileident(fibh->sbh->b_data, dir->i_sb->s_blocksize, udf_fileident_read()
108 if (fibh->eoffset <= dir->i_sb->s_blocksize) { udf_fileident_read()
111 } else if (fibh->eoffset > dir->i_sb->s_blocksize) { udf_fileident_read()
118 block = udf_get_lb_pblock(dir->i_sb, eloc, *offset); udf_fileident_read()
122 if ((*offset << dir->i_sb->s_blocksize_bits) >= *elen) udf_fileident_read()
127 fibh->soffset -= dir->i_sb->s_blocksize; udf_fileident_read()
128 fibh->eoffset -= dir->i_sb->s_blocksize; udf_fileident_read()
130 fibh->ebh = udf_tread(dir->i_sb, block); udf_fileident_read()
H A Dialloc.c31 struct super_block *sb = inode->i_sb; udf_free_inode()
50 struct super_block *sb = dir->i_sb; udf_new_inode()
66 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_EXTENDED_FE)) { udf_new_inode()
70 iinfo->i_ext.i_data = kzalloc(inode->i_sb->s_blocksize - udf_new_inode()
75 iinfo->i_ext.i_data = kzalloc(inode->i_sb->s_blocksize - udf_new_inode()
85 block = udf_new_block(dir->i_sb, NULL, udf_new_inode()
117 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_AD_IN_ICB)) udf_new_inode()
119 else if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD)) udf_new_inode()
124 iinfo->i_crtime = current_fs_time(inode->i_sb); udf_new_inode()
H A Dinode.c153 udf_warn(inode->i_sb, "Inode %lu (mode %o) has inode size %llu different from extent length %llu. Filesystem need not be standards compliant.\n", udf_evict_inode()
267 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD)) udf_expand_file_adinicb()
301 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD)) udf_expand_file_adinicb()
343 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD)) udf_expand_dir_adinicb()
355 *block = udf_new_block(inode->i_sb, inode, udf_expand_dir_adinicb()
360 newblock = udf_get_pblock(inode->i_sb, *block, udf_expand_dir_adinicb()
365 dbh = udf_tgetblk(inode->i_sb, newblock); udf_expand_dir_adinicb()
369 memset(dbh->b_data, 0x00, inode->i_sb->s_blocksize); udf_expand_dir_adinicb()
375 f_pos & (inode->i_sb->s_blocksize - 1); udf_expand_dir_adinicb()
430 map_bh(bh_result, inode->i_sb, phys); udf_get_block()
451 map_bh(bh_result, inode->i_sb, phys); udf_get_block()
468 bh = sb_getblk(inode->i_sb, dummy.b_blocknr); udf_getblk()
471 memset(bh->b_data, 0x00, inode->i_sb->s_blocksize); udf_getblk()
490 struct super_block *sb = inode->i_sb; udf_do_extend_file()
606 struct super_block *sb = inode->i_sb; udf_extend_file()
680 b_off = (loff_t)block << inode->i_sb->s_blocksize_bits; inode_getblk()
716 ((elen + inode->i_sb->s_blocksize - 1) >> inode_getblk()
717 inode->i_sb->s_blocksize_bits); inode_getblk()
723 offset = b_off >> inode->i_sb->s_blocksize_bits; inode_getblk()
735 if (elen & (inode->i_sb->s_blocksize - 1)) { inode_getblk()
737 ((elen + inode->i_sb->s_blocksize - 1) & inode_getblk()
738 ~(inode->i_sb->s_blocksize - 1)); inode_getblk()
744 newblock = udf_get_lb_pblock(inode->i_sb, &eloc, offset); inode_getblk()
785 inode->i_sb->s_blocksize; inode_getblk()
831 newblocknum = udf_new_block(inode->i_sb, inode, inode_getblk()
842 iinfo->i_lenExtents += inode->i_sb->s_blocksize; inode_getblk()
872 newblock = udf_get_pblock(inode->i_sb, newblocknum, inode_getblk()
881 inode->i_ctime = current_fs_time(inode->i_sb); inode_getblk()
896 unsigned long blocksize = inode->i_sb->s_blocksize; udf_split_extents()
897 unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits; udf_split_extents()
919 udf_free_blocks(inode->i_sb, inode, udf_split_extents()
974 inode->i_sb->s_blocksize - 1) >> udf_prealloc_extents()
975 inode->i_sb->s_blocksize_bits); udf_prealloc_extents()
988 inode->i_sb->s_blocksize - 1) >> udf_prealloc_extents()
989 inode->i_sb->s_blocksize_bits); udf_prealloc_extents()
997 inode->i_sb->s_blocksize - 1) >> udf_prealloc_extents()
998 inode->i_sb->s_blocksize_bits); udf_prealloc_extents()
999 int numalloc = udf_prealloc_blocks(inode->i_sb, inode, udf_prealloc_extents()
1008 inode->i_sb->s_blocksize_bits); udf_prealloc_extents()
1020 inode->i_sb->s_blocksize_bits); udf_prealloc_extents()
1027 inode->i_sb->s_blocksize - 1) >> udf_prealloc_extents()
1028 inode->i_sb->s_blocksize_bits; udf_prealloc_extents()
1033 inode->i_sb->s_blocksize_bits); udf_prealloc_extents()
1047 numalloc << inode->i_sb->s_blocksize_bits; udf_prealloc_extents()
1057 unsigned long blocksize = inode->i_sb->s_blocksize; udf_merge_extents()
1058 unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits; udf_merge_extents()
1105 udf_free_blocks(inode->i_sb, inode, &li->extLocation, 0, udf_merge_extents()
1138 udf_free_blocks(inode->i_sb, inode, udf_merge_extents()
1263 inode->i_mtime = inode->i_ctime = current_fs_time(inode->i_sb); udf_setsize()
1285 struct udf_sb_info *sbi = UDF_SB(inode->i_sb); udf_read_inode()
1289 int bs = inode->i_sb->s_blocksize; udf_read_inode()
1303 * i_sb = sb udf_read_inode()
1312 bh = udf_read_ptagged(inode->i_sb, iloc, 0, &ident); udf_read_inode()
1314 udf_err(inode->i_sb, "(ino %ld) failed !bh\n", inode->i_ino); udf_read_inode()
1320 udf_err(inode->i_sb, "(ino %ld) failed ident=%d\n", udf_read_inode()
1331 ibh = udf_read_ptagged(inode->i_sb, iloc, 1, &ident); udf_read_inode()
1344 udf_err(inode->i_sb, udf_read_inode()
1356 udf_err(inode->i_sb, "unsupported strategy type: %d\n", udf_read_inode()
1412 UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_UID_IGNORE) || udf_read_inode()
1413 UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_UID_SET)) udf_read_inode()
1414 inode->i_uid = UDF_SB(inode->i_sb)->s_uid; udf_read_inode()
1418 UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_GID_IGNORE) || udf_read_inode()
1419 UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_GID_SET)) udf_read_inode()
1420 inode->i_gid = UDF_SB(inode->i_sb)->s_gid; udf_read_inode()
1448 (inode->i_sb->s_blocksize_bits - 9); udf_read_inode()
1466 (inode->i_sb->s_blocksize_bits - 9); udf_read_inode()
1556 udf_err(inode->i_sb, "(ino %ld) failed unknown file type=%d\n", udf_read_inode()
1583 udf_err(inode->i_sb, "(ino %ld) no free memory\n", udf_alloc_i_data()
1630 struct udf_sb_info *sbi = UDF_SB(inode->i_sb); udf_update_inode()
1631 unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits; udf_update_inode()
1634 bh = udf_tgetblk(inode->i_sb, udf_update_inode()
1635 udf_get_lb_pblock(inode->i_sb, &iinfo->i_location, 0)); udf_update_inode()
1642 memset(bh->b_data, 0, inode->i_sb->s_blocksize); udf_update_inode()
1652 iinfo->i_ext.i_data, inode->i_sb->s_blocksize - udf_update_inode()
1668 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_UID_FORGET)) udf_update_inode()
1673 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_GID_FORGET)) udf_update_inode()
1730 inode->i_sb->s_blocksize - sizeof(struct fileEntry)); udf_update_inode()
1749 inode->i_sb->s_blocksize - udf_update_inode()
1840 udf_warn(inode->i_sb, "IO error syncing udf inode [%08lx]\n", udf_update_inode()
1898 if (epos->offset + (2 * adsize) > inode->i_sb->s_blocksize) { udf_add_aext()
1904 epos->block.logicalBlockNum = udf_new_block(inode->i_sb, NULL, udf_add_aext()
1909 nbh = udf_tgetblk(inode->i_sb, udf_get_lb_pblock(inode->i_sb, udf_add_aext()
1915 memset(nbh->b_data, 0x00, inode->i_sb->s_blocksize); udf_add_aext()
1921 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT)) udf_add_aext()
1924 if (epos->offset + adsize > inode->i_sb->s_blocksize) { udf_add_aext()
1945 if (UDF_SB(inode->i_sb)->s_udfrev >= 0x0200) udf_add_aext()
1955 inode->i_sb->s_blocksize); udf_add_aext()
1962 inode->i_sb->s_blocksize); udf_add_aext()
1968 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || udf_add_aext()
1969 UDF_SB(inode->i_sb)->s_udfrev >= 0x0201) udf_add_aext()
1990 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || udf_add_aext()
1991 UDF_SB(inode->i_sb)->s_udfrev >= 0x0201) udf_add_aext()
2038 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || udf_write_aext()
2039 UDF_SB(inode->i_sb)->s_udfrev >= 0x0201) { udf_write_aext()
2072 udf_err(inode->i_sb, udf_next_aext()
2081 block = udf_get_lb_pblock(inode->i_sb, &epos->block, 0); udf_next_aext()
2082 epos->bh = udf_tread(inode->i_sb, block); udf_next_aext()
2207 udf_free_blocks(inode->i_sb, inode, &epos.block, 0, 1); udf_delete_aext()
2216 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || udf_delete_aext()
2217 UDF_SB(inode->i_sb)->s_udfrev >= 0x0201) udf_delete_aext()
2233 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || udf_delete_aext()
2234 UDF_SB(inode->i_sb)->s_udfrev >= 0x0201) udf_delete_aext()
2254 unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits; inode_bmap()
2295 ret = udf_get_lb_pblock(inode->i_sb, &eloc, offset); udf_block_map()
2302 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_VARCONV)) udf_block_map()
H A Dtruncate.c34 int last_block = (elen + inode->i_sb->s_blocksize - 1) >> extent_trunc()
35 inode->i_sb->s_blocksize_bits; extent_trunc()
36 int first_block = (nelen + inode->i_sb->s_blocksize - 1) >> extent_trunc()
37 inode->i_sb->s_blocksize_bits; extent_trunc()
41 udf_free_blocks(inode->i_sb, inode, eloc, 0, extent_trunc()
56 udf_free_blocks(inode->i_sb, inode, eloc, extent_trunc()
96 if (lbcount - inode->i_size >= inode->i_sb->s_blocksize) udf_truncate_tail_extent()
97 udf_warn(inode->i_sb, udf_truncate_tail_extent()
109 udf_err(inode->i_sb, udf_truncate_tail_extent()
164 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || udf_discard_prealloc()
165 UDF_SB(inode->i_sb)->s_udfrev >= 0x0201) udf_discard_prealloc()
183 struct super_block *sb = inode->i_sb; udf_update_alloc_ext_desc()
208 struct super_block *sb = inode->i_sb; udf_truncate_extents()
H A Dnamei.c161 struct super_block *sb = dir->i_sb; udf_find_entry()
272 inode = udf_iget(dir->i_sb, lb); udf_lookup()
286 inode = udf_iget(dir->i_sb, &loc); udf_lookup()
299 struct super_block *sb = dir->i_sb; udf_add_entry()
341 fibh->soffset = fibh->eoffset = f_pos & (dir->i_sb->s_blocksize - 1); udf_add_entry()
344 if (inode_bmap(dir, f_pos >> dir->i_sb->s_blocksize_bits, &epos, udf_add_entry()
346 block = udf_get_lb_pblock(dir->i_sb, udf_add_entry()
351 block = udf_get_lb_pblock(dir->i_sb, &eloc, offset); udf_add_entry()
352 if ((++offset << dir->i_sb->s_blocksize_bits) < elen) { udf_add_entry()
360 fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block); udf_add_entry()
442 dir->i_sb->s_blocksize_bits); udf_add_entry()
465 dir->i_sb->s_blocksize_bits); udf_add_entry()
467 f_pos >> dir->i_sb->s_blocksize_bits, 1, err); udf_add_entry()
482 dir->i_sb->s_blocksize_bits); udf_add_entry()
545 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT)) udf_delete_entry()
566 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); udf_add_nondir()
571 dir->i_ctime = dir->i_mtime = current_fs_time(dir->i_sb); udf_add_nondir()
660 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); udf_mkdir()
678 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); udf_mkdir()
685 dir->i_ctime = dir->i_mtime = current_fs_time(dir->i_sb); udf_mkdir()
712 fibh.soffset = fibh.eoffset = f_pos & (dir->i_sb->s_blocksize - 1); empty_dir()
716 else if (inode_bmap(dir, f_pos >> dir->i_sb->s_blocksize_bits, empty_dir()
719 block = udf_get_lb_pblock(dir->i_sb, &eloc, offset); empty_dir()
720 if ((++offset << dir->i_sb->s_blocksize_bits) < elen) { empty_dir()
728 fibh.sbh = fibh.ebh = udf_tread(dir->i_sb, block); empty_dir()
782 if (udf_get_lb_pblock(dir->i_sb, &tloc, 0) != inode->i_ino) udf_rmdir()
791 udf_warn(inode->i_sb, "empty directory has nlink != 2 (%d)\n", udf_rmdir()
797 current_fs_time(dir->i_sb); udf_rmdir()
825 if (udf_get_lb_pblock(dir->i_sb, &tloc, 0) != inode->i_ino) udf_unlink()
836 dir->i_ctime = dir->i_mtime = current_fs_time(dir->i_sb); udf_unlink()
865 struct super_block *sb = dir->i_sb; udf_symlink()
1011 cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize); udf_link()
1013 if (UDF_SB(inode->i_sb)->s_lvid_bh) { udf_link()
1015 cpu_to_le32(lvid_get_unique_id(inode->i_sb)); udf_link()
1025 inode->i_ctime = current_fs_time(inode->i_sb); udf_link()
1027 dir->i_ctime = dir->i_mtime = current_fs_time(dir->i_sb); udf_link()
1058 if (!ofi || udf_get_lb_pblock(old_dir->i_sb, &tloc, 0) udf_rename()
1086 old_inode->i_sb->s_blocksize, &offset); udf_rename()
1092 old_inode->i_sb->s_blocksize, &offset); udf_rename()
1097 if (udf_get_lb_pblock(old_inode->i_sb, &tloc, 0) != udf_rename()
1112 old_inode->i_ctime = current_fs_time(old_inode->i_sb); udf_rename()
1128 new_inode->i_ctime = current_fs_time(new_inode->i_sb); udf_rename()
1131 old_dir->i_ctime = old_dir->i_mtime = current_fs_time(old_dir->i_sb); udf_rename()
1132 new_dir->i_ctime = new_dir->i_mtime = current_fs_time(new_dir->i_sb); udf_rename()
1190 inode = udf_iget(d_inode(child)->i_sb, &tloc); udf_get_parent()
H A Dsymlink.c112 if (inode->i_size > inode->i_sb->s_blocksize) { udf_symlink_filler()
124 bh = sb_bread(inode->i_sb, pos); udf_symlink_filler()
134 err = udf_pc_to_char(inode->i_sb, symlink, inode->i_size, p, PAGE_SIZE); udf_symlink_filler()
H A Dfile.c135 if (inode->i_sb->s_blocksize < udf_file_write_iter()
187 UDF_SB(inode->i_sb)->s_volume_ident, 32)) udf_ioctl()
201 result = udf_relocate_blocks(inode->i_sb, udf_ioctl()
/linux-4.1.27/fs/minix/
H A Ditree_v1.c31 block, bdevname(inode->i_sb->s_bdev, b)); block_to_path()
32 } else if (block >= (minix_sb(inode->i_sb)->s_max_size/BLOCK_SIZE)) { block_to_path()
36 block, bdevname(inode->i_sb->s_bdev, b)); block_to_path()
H A Dbitmap.c43 struct super_block *sb = inode->i_sb; minix_free_block()
72 struct minix_sb_info *sbi = minix_sb(inode->i_sb); minix_new_block()
73 int bits_per_zone = 8 * inode->i_sb->s_blocksize; minix_new_block()
163 raw_inode = minix_V1_raw_inode(inode->i_sb, inode->i_ino, &bh); minix_clear_inode()
170 raw_inode = minix_V2_raw_inode(inode->i_sb, inode->i_ino, &bh); minix_clear_inode()
184 struct super_block *sb = inode->i_sb; minix_free_inode()
185 struct minix_sb_info *sbi = minix_sb(inode->i_sb); minix_free_inode()
214 struct super_block *sb = dir->i_sb; minix_new_inode()
H A Ddir.c88 struct super_block *sb = inode->i_sb; minix_readdir()
160 struct super_block * sb = dir->i_sb; minix_find_entry()
209 struct super_block * sb = dir->i_sb; minix_add_link()
298 struct minix_sb_info *sbi = minix_sb(inode->i_sb); minix_delete_entry()
322 struct minix_sb_info *sbi = minix_sb(inode->i_sb); minix_make_empty()
369 struct minix_sb_info *sbi = minix_sb(inode->i_sb); minix_empty_dir()
420 struct minix_sb_info *sbi = minix_sb(dir->i_sb); minix_set_link()
445 struct minix_sb_info *sbi = minix_sb(dir->i_sb); minix_dotdot()
464 struct minix_sb_info *sbi = minix_sb(inode->i_sb); minix_inode_by_name()
H A Ditree_common.c35 struct super_block *sb = inode->i_sb; get_branch()
86 bh = sb_getblk(inode->i_sb, parent); alloc_branch()
164 map_bh(bh, inode->i_sb, block_to_cpu(chain[depth-1].key)); get_block()
280 bh = sb_bread(inode->i_sb, nr); free_branches()
295 struct super_block *sb = inode->i_sb; truncate()
H A Dnamei.c26 if (dentry->d_name.len > minix_sb(dir->i_sb)->s_namelen) minix_lookup()
31 inode = minix_iget(dir->i_sb, ino); minix_lookup()
82 if (i > dir->i_sb->s_blocksize) minix_symlink()
H A Ditree_v2.c30 struct super_block *sb = inode->i_sb; block_to_path()
/linux-4.1.27/fs/ufs/
H A Dnamei.c59 lock_ufs(dir->i_sb); ufs_lookup()
62 inode = ufs_iget(dir->i_sb, ino); ufs_lookup()
63 unlock_ufs(dir->i_sb); ufs_lookup()
91 lock_ufs(dir->i_sb); ufs_create()
93 unlock_ufs(dir->i_sb); ufs_create()
111 ufs_set_inode_dev(inode->i_sb, UFS_I(inode), rdev); ufs_mknod()
113 lock_ufs(dir->i_sb); ufs_mknod()
115 unlock_ufs(dir->i_sb); ufs_mknod()
123 struct super_block * sb = dir->i_sb; ufs_symlink()
131 lock_ufs(dir->i_sb); ufs_symlink()
154 unlock_ufs(dir->i_sb); ufs_symlink()
171 lock_ufs(dir->i_sb); ufs_link()
183 unlock_ufs(dir->i_sb); ufs_link()
192 lock_ufs(dir->i_sb); ufs_mkdir()
213 unlock_ufs(dir->i_sb); ufs_mkdir()
227 unlock_ufs(dir->i_sb); ufs_mkdir()
258 lock_ufs(dir->i_sb); ufs_rmdir()
267 unlock_ufs(dir->i_sb); ufs_rmdir()
H A Ddir.c81 res = fs32_to_cpu(dir->i_sb, de->d_ino); ufs_inode_by_name()
94 unsigned len = fs16_to_cpu(dir->i_sb, de->d_reclen); ufs_set_link()
101 de->d_ino = cpu_to_fs32(dir->i_sb, inode->i_ino); ufs_set_link()
102 ufs_set_de_type(dir->i_sb, de, inode->i_mode); ufs_set_link()
114 struct super_block *sb = dir->i_sb; ufs_check_page()
236 de = ufs_next_entry(dir->i_sb, ufs_dotdot()
254 struct super_block *sb = dir->i_sb; ufs_find_entry()
286 ufs_error(dir->i_sb, __func__, ufs_find_entry()
317 struct super_block *sb = dir->i_sb; ufs_add_link()
358 ufs_error(dir->i_sb, __func__, ufs_add_link()
437 struct super_block *sb = inode->i_sb; ufs_readdir()
514 struct super_block *sb = inode->i_sb; ufs_delete_entry()
532 ufs_error(inode->i_sb, __func__, ufs_delete_entry()
561 struct super_block * sb = dir->i_sb; ufs_make_empty()
609 struct super_block *sb = inode->i_sb; ufs_empty_dir()
627 ufs_error(inode->i_sb, __func__, ufs_empty_dir()
H A Dtruncate.c79 sb = inode->i_sb; ufs_trunc_direct()
186 sb = inode->i_sb; ufs_trunc_indirect()
265 sb = inode->i_sb; ufs_trunc_dindirect()
318 struct super_block *sb = inode->i_sb; ufs_trunc_tindirect()
376 struct super_block *sb = inode->i_sb; ufs_alloc_lastblock()
446 struct super_block *sb = inode->i_sb; ufs_truncate()
509 lock_ufs(inode->i_sb); ufs_setattr()
511 unlock_ufs(inode->i_sb); ufs_setattr()
H A Dinode.c48 struct ufs_sb_private_info *uspi = UFS_SB(inode->i_sb)->s_uspi; ufs_block_to_path()
73 ufs_warning(inode->i_sb, "ufs_block_to_path", "block > big"); ufs_block_to_path()
86 struct super_block *sb = inode->i_sb; ufs_frag_map()
178 struct super_block *sb = inode->i_sb; ufs_inode_getfrag()
334 struct super_block *sb = inode->i_sb; ufs_inode_getblock()
417 struct super_block * sb = inode->i_sb; ufs_getfrag_block()
583 ufs_get_inode_dev(inode->i_sb, UFS_I(inode))); ufs_set_inode_ops()
589 struct super_block *sb = inode->i_sb; ufs1_read_inode()
636 struct super_block *sb = inode->i_sb; ufs2_read_inode()
747 struct super_block *sb = inode->i_sb; ufs1_update_inode()
790 struct super_block *sb = inode->i_sb; ufs2_update_inode()
830 struct super_block *sb = inode->i_sb; ufs_update_inode()
870 lock_ufs(inode->i_sb); ufs_write_inode()
872 unlock_ufs(inode->i_sb); ufs_write_inode()
892 lock_ufs(inode->i_sb); ufs_evict_inode()
898 ufs_warning(inode->i_sb, __func__, "ufs_truncate failed\n"); ufs_evict_inode()
899 unlock_ufs(inode->i_sb); ufs_evict_inode()
906 lock_ufs(inode->i_sb); ufs_evict_inode()
908 unlock_ufs(inode->i_sb); ufs_evict_inode()
H A Dballoc.c46 sb = inode->i_sb; ufs_free_fragments()
141 sb = inode->i_sb; ufs_free_blocks()
267 ufs_error(inode->i_sb, __func__, ufs_change_blocknr()
293 map_bh(bh, inode->i_sb, oldb + pos); ufs_change_blocknr()
298 ufs_error(inode->i_sb, __func__, ufs_change_blocknr()
329 bh = sb_getblk(inode->i_sb, beg); ufs_clear_frags()
331 memset(bh->b_data, 0, inode->i_sb->s_blocksize); ufs_clear_frags()
355 sb = inode->i_sb; ufs_new_fragments()
505 sb = inode->i_sb; ufs_add_fragments()
582 sb = inode->i_sb; ufs_alloc_fragments()
690 sb = inode->i_sb; ufs_alloccg_block()
/linux-4.1.27/fs/reiserfs/
H A Dnamei.c311 if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize)) reiserfs_find_entry()
316 get_third_component(dir->i_sb, name, namelen), reiserfs_find_entry()
321 search_by_entry_key(dir->i_sb, &key_to_search, reiserfs_find_entry()
324 reiserfs_error(dir->i_sb, "zam-7001", "io error"); reiserfs_find_entry()
360 if (REISERFS_MAX_NAME(dir->i_sb->s_blocksize) < dentry->d_name.len) reiserfs_lookup()
363 reiserfs_write_lock(dir->i_sb); reiserfs_lookup()
371 inode = reiserfs_iget(dir->i_sb, reiserfs_lookup()
374 reiserfs_write_unlock(dir->i_sb); reiserfs_lookup()
385 reiserfs_write_unlock(dir->i_sb); reiserfs_lookup()
410 reiserfs_write_lock(dir->i_sb); reiserfs_get_parent()
414 reiserfs_write_unlock(dir->i_sb); reiserfs_get_parent()
417 inode = reiserfs_iget(dir->i_sb, (struct cpu_key *)&de.de_dir_id); reiserfs_get_parent()
418 reiserfs_write_unlock(dir->i_sb); reiserfs_get_parent()
456 if (namelen > REISERFS_MAX_NAME(dir->i_sb->s_blocksize)) reiserfs_add_entry()
461 get_third_component(dir->i_sb, name, namelen), reiserfs_add_entry()
518 reiserfs_error(dir->i_sb, "zam-7002", reiserfs_add_entry()
531 reiserfs_warning(dir->i_sb, "reiserfs-7010", reiserfs_add_entry()
548 if (search_by_entry_key(dir->i_sb, &entry_key, &path, &de) != reiserfs_add_entry()
550 reiserfs_warning(dir->i_sb, "vs-7032", reiserfs_add_entry()
631 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) + reiserfs_create()
632 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb)); reiserfs_create()
638 if (!(inode = new_inode(dir->i_sb))) { reiserfs_create()
650 reiserfs_write_lock(dir->i_sb); reiserfs_create()
652 retval = journal_begin(&th, dir->i_sb, jbegin_count); reiserfs_create()
690 reiserfs_write_unlock(dir->i_sb); reiserfs_create()
707 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) + reiserfs_mknod()
708 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb)); reiserfs_mknod()
715 if (!(inode = new_inode(dir->i_sb))) { reiserfs_mknod()
727 reiserfs_write_lock(dir->i_sb); reiserfs_mknod()
729 retval = journal_begin(&th, dir->i_sb, jbegin_count); reiserfs_mknod()
771 reiserfs_write_unlock(dir->i_sb); reiserfs_mknod()
787 2 * (REISERFS_QUOTA_INIT_BLOCKS(dir->i_sb) + reiserfs_mkdir()
788 REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb)); reiserfs_mkdir()
800 if (!(inode = new_inode(dir->i_sb))) { reiserfs_mkdir()
812 reiserfs_write_lock(dir->i_sb); reiserfs_mkdir()
814 retval = journal_begin(&th, dir->i_sb, jbegin_count); reiserfs_mkdir()
827 old_format_only(dir->i_sb) ? reiserfs_mkdir()
864 reiserfs_write_unlock(dir->i_sb); reiserfs_mkdir()
900 4 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb); reiserfs_rmdir()
904 reiserfs_write_lock(dir->i_sb); reiserfs_rmdir()
905 retval = journal_begin(&th, dir->i_sb, jbegin_count); reiserfs_rmdir()
945 reiserfs_error(inode->i_sb, "reiserfs-7040", reiserfs_rmdir()
963 reiserfs_write_unlock(dir->i_sb); reiserfs_rmdir()
974 reiserfs_write_unlock(dir->i_sb); reiserfs_rmdir()
1001 4 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb); reiserfs_unlink()
1003 reiserfs_write_lock(dir->i_sb); reiserfs_unlink()
1004 retval = journal_begin(&th, dir->i_sb, jbegin_count); reiserfs_unlink()
1031 reiserfs_warning(inode->i_sb, "reiserfs-7042", reiserfs_unlink()
1065 reiserfs_write_unlock(dir->i_sb); reiserfs_unlink()
1075 reiserfs_write_unlock(dir->i_sb); reiserfs_unlink()
1095 2 * (REISERFS_QUOTA_INIT_BLOCKS(parent_dir->i_sb) + reiserfs_symlink()
1096 REISERFS_QUOTA_TRANS_BLOCKS(parent_dir->i_sb)); reiserfs_symlink()
1100 if (!(inode = new_inode(parent_dir->i_sb))) { reiserfs_symlink()
1113 reiserfs_write_lock(parent_dir->i_sb); reiserfs_symlink()
1115 if (item_len > MAX_DIRECT_ITEM_LEN(parent_dir->i_sb->s_blocksize)) { reiserfs_symlink()
1130 retval = journal_begin(&th, parent_dir->i_sb, jbegin_count); reiserfs_symlink()
1169 reiserfs_write_unlock(parent_dir->i_sb); reiserfs_symlink()
1185 2 * REISERFS_QUOTA_TRANS_BLOCKS(dir->i_sb); reiserfs_link()
1189 reiserfs_write_lock(dir->i_sb); reiserfs_link()
1192 reiserfs_write_unlock(dir->i_sb); reiserfs_link()
1199 retval = journal_begin(&th, dir->i_sb, jbegin_count); reiserfs_link()
1202 reiserfs_write_unlock(dir->i_sb); reiserfs_link()
1218 reiserfs_write_unlock(dir->i_sb); reiserfs_link()
1228 reiserfs_write_unlock(dir->i_sb); reiserfs_link()
1255 reiserfs_panic(inode->i_sb, "vs-7042", entry_points_to_object()
1309 4 * REISERFS_QUOTA_TRANS_BLOCKS(old_dir->i_sb); reiserfs_rename()
1322 reiserfs_write_lock(old_dir->i_sb); reiserfs_rename()
1329 reiserfs_write_unlock(old_dir->i_sb); reiserfs_rename()
1334 reiserfs_write_unlock(old_dir->i_sb); reiserfs_rename()
1347 reiserfs_write_unlock(old_dir->i_sb); reiserfs_rename()
1362 reiserfs_write_unlock(old_dir->i_sb); reiserfs_rename()
1368 reiserfs_write_unlock(old_dir->i_sb); reiserfs_rename()
1373 retval = journal_begin(&th, old_dir->i_sb, jbegin_count); reiserfs_rename()
1375 reiserfs_write_unlock(old_dir->i_sb); reiserfs_rename()
1385 reiserfs_panic(old_dir->i_sb, "vs-7050", reiserfs_rename()
1390 reiserfs_write_unlock(old_dir->i_sb); reiserfs_rename()
1412 search_by_entry_key(new_dir->i_sb, &old_de.de_entry_key, reiserfs_rename()
1417 reiserfs_write_unlock(old_dir->i_sb); reiserfs_rename()
1423 reiserfs_prepare_for_journal(old_inode->i_sb, old_de.de_bh, 1); reiserfs_rename()
1441 reiserfs_write_unlock(old_dir->i_sb); reiserfs_rename()
1447 reiserfs_prepare_for_journal(old_inode->i_sb, new_de.de_bh, 1); reiserfs_rename()
1451 search_by_entry_key(new_dir->i_sb, reiserfs_rename()
1459 reiserfs_write_unlock(old_dir->i_sb); reiserfs_rename()
1465 reiserfs_prepare_for_journal(old_inode->i_sb, reiserfs_rename()
1493 reiserfs_restore_prepared_buffer(old_inode->i_sb, reiserfs_rename()
1495 reiserfs_restore_prepared_buffer(old_inode->i_sb, reiserfs_rename()
1499 i_sb, reiserfs_rename()
1509 i_sb, reiserfs_rename()
1512 i_sb, reiserfs_rename()
1515 i_sb, reiserfs_rename()
1589 reiserfs_error(old_dir->i_sb, "vs-7060", reiserfs_rename()
1606 reiserfs_write_unlock(old_dir->i_sb); reiserfs_rename()
H A Dxattr.h57 ret = _ROUND_UP(xattr_size(size), inode->i_sb->s_blocksize); reiserfs_xattr_nblocks()
58 ret >>= inode->i_sb->s_blocksize_bits; reiserfs_xattr_nblocks()
77 size_t nblocks = JOURNAL_BLOCKS_PER_OBJECT(inode->i_sb); reiserfs_xattr_jcreate_nblocks()
80 nblocks += JOURNAL_BLOCKS_PER_OBJECT(inode->i_sb); reiserfs_xattr_jcreate_nblocks()
81 if (d_really_is_negative(REISERFS_SB(inode->i_sb)->xattr_root)) reiserfs_xattr_jcreate_nblocks()
82 nblocks += JOURNAL_BLOCKS_PER_OBJECT(inode->i_sb); reiserfs_xattr_jcreate_nblocks()
H A Dioctl.c29 reiserfs_write_lock(inode->i_sb); reiserfs_ioctl()
44 if (!reiserfs_attrs(inode->i_sb)) { reiserfs_ioctl()
54 if (!reiserfs_attrs(inode->i_sb)) { reiserfs_ioctl()
127 reiserfs_write_unlock(inode->i_sb); reiserfs_ioctl()
178 unsigned long blocksize = inode->i_sb->s_blocksize; reiserfs_unpack()
190 reiserfs_mutex_lock_safe(&inode->i_mutex, inode->i_sb); reiserfs_unpack()
192 reiserfs_write_lock(inode->i_sb); reiserfs_unpack()
228 reiserfs_write_unlock(inode->i_sb); reiserfs_unpack()
H A Ddir.c42 reiserfs_write_lock(inode->i_sb); reiserfs_dir_fsync()
44 reiserfs_write_unlock(inode->i_sb); reiserfs_dir_fsync()
55 struct dentry *privroot = REISERFS_SB(dir->i_sb)->priv_root; is_privroot_deh()
79 reiserfs_write_lock(inode->i_sb); reiserfs_readdir_inode()
81 reiserfs_check_lock_depth(inode->i_sb, "readdir"); reiserfs_readdir_inode()
98 search_by_entry_key(inode->i_sb, &pos_key, &path_to_entry, reiserfs_readdir_inode()
168 REISERFS_MAX_NAME(inode->i_sb-> reiserfs_readdir_inode()
208 depth = reiserfs_write_unlock_nested(inode->i_sb); reiserfs_readdir_inode()
212 reiserfs_write_lock_nested(inode->i_sb, depth); reiserfs_readdir_inode()
218 reiserfs_write_lock_nested(inode->i_sb, depth); reiserfs_readdir_inode()
242 rkey = get_rkey(&path_to_entry, inode->i_sb); reiserfs_readdir_inode()
268 reiserfs_write_unlock(inode->i_sb); reiserfs_readdir_inode()
H A Dfile.c59 reiserfs_write_lock(inode->i_sb); reiserfs_file_release()
66 err = journal_begin(&th, inode->i_sb, 1); reiserfs_file_release()
74 err = journal_join_abort(&th, inode->i_sb); reiserfs_file_release()
87 reiserfs_warning(inode->i_sb, "clm-9001", reiserfs_file_release()
118 reiserfs_write_unlock(inode->i_sb); reiserfs_file_release()
164 reiserfs_write_lock(inode->i_sb); reiserfs_sync_file()
166 reiserfs_write_unlock(inode->i_sb); reiserfs_sync_file()
167 if (barrier_done != 1 && reiserfs_barrier_flush(inode->i_sb)) reiserfs_sync_file()
168 blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, NULL); reiserfs_sync_file()
186 struct super_block *s = inode->i_sb; reiserfs_commit_page()
222 if (reiserfs_data_ordered(inode->i_sb) && reiserfs_commit_page()
H A Dinode.c34 2 * REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb); reiserfs_evict_inode()
54 reiserfs_write_lock(inode->i_sb); reiserfs_evict_inode()
56 if (journal_begin(&th, inode->i_sb, jbegin_count)) reiserfs_evict_inode()
70 int depth = reiserfs_write_unlock_nested(inode->i_sb); reiserfs_evict_inode()
72 reiserfs_write_lock_nested(inode->i_sb, depth); reiserfs_evict_inode()
92 reiserfs_write_unlock(inode->i_sb); reiserfs_evict_inode()
233 map_bh(bh, inode->i_sb, block); set_block_dev_mapped()
245 block < (1 << (31 - inode->i_sb->s_blocksize_bits))) file_capable()
301 (loff_t) block * inode->i_sb->s_blocksize + 1, TYPE_ANY, _get_block_create_0()
304 result = search_for_position_by_key(inode->i_sb, &key, &path); _get_block_create_0()
336 map_bh(bh_result, inode->i_sb, blocknr); _get_block_create_0()
402 memset(p, 0, inode->i_sb->s_blocksize); _get_block_create_0()
441 result = search_for_position_by_key(inode->i_sb, &key, &path); _get_block_create_0()
462 map_bh(bh_result, inode->i_sb, 0); _get_block_create_0()
477 reiserfs_write_lock(inode->i_sb); reiserfs_bmap()
480 reiserfs_write_unlock(inode->i_sb); reiserfs_bmap()
551 reiserfs_write_lock(inode->i_sb); reiserfs_get_blocks_direct_io()
556 reiserfs_write_unlock(inode->i_sb); reiserfs_get_blocks_direct_io()
681 2 * REISERFS_QUOTA_TRANS_BLOCKS(inode->i_sb); reiserfs_get_block()
685 (((loff_t) block) << inode->i_sb->s_blocksize_bits) + 1; reiserfs_get_block()
687 reiserfs_write_lock(inode->i_sb); reiserfs_get_block()
691 reiserfs_write_unlock(inode->i_sb); reiserfs_get_block()
704 reiserfs_write_unlock(inode->i_sb); reiserfs_get_block()
713 reiserfs_transaction_running(inode->i_sb)) reiserfs_get_block()
721 if ((have_large_tails(inode->i_sb) reiserfs_get_block()
723 || (have_small_tails(inode->i_sb) reiserfs_get_block()
729 if ((new_offset + inode->i_sb->s_blocksize - 1) > inode->i_size) { reiserfs_get_block()
731 th = reiserfs_persistent_transaction(inode->i_sb, jbegin_count); reiserfs_get_block()
740 retval = search_for_position_by_key(inode->i_sb, &key, &path); reiserfs_get_block()
751 fs_gen = get_generation(inode->i_sb); reiserfs_get_block()
772 SB_JOURNAL(inode->i_sb)->j_next_async_flush = 1; reiserfs_get_block()
790 if (fs_changed(fs_gen, inode->i_sb) reiserfs_get_block()
806 reiserfs_prepare_for_journal(inode->i_sb, bh, 1); reiserfs_get_block()
807 if (fs_changed(fs_gen, inode->i_sb) reiserfs_get_block()
809 reiserfs_restore_prepared_buffer(inode->i_sb, reiserfs_get_block()
815 && reiserfs_data_ordered(inode->i_sb)) reiserfs_get_block()
828 reiserfs_write_unlock(inode->i_sb); reiserfs_get_block()
892 1) & ~(inode->i_sb->s_blocksize - 1)) + 1; reiserfs_get_block()
932 reiserfs_error(inode->i_sb, reiserfs_get_block()
944 th = reiserfs_persistent_transaction(inode->i_sb, 3); reiserfs_get_block()
1017 MAX_ITEM_LEN(inode->i_sb->s_blocksize) / reiserfs_get_block()
1032 inode->i_sb->s_blocksize), reiserfs_get_block()
1040 cpu_key_k_offset(&tmp_key)) >> inode->i_sb-> reiserfs_get_block()
1096 inode->i_sb->s_blocksize * blocks_needed; reiserfs_get_block()
1121 reiserfs_cond_resched(inode->i_sb); reiserfs_get_block()
1123 retval = search_for_position_by_key(inode->i_sb, &key, &path); reiserfs_get_block()
1129 reiserfs_warning(inode->i_sb, "vs-825", reiserfs_get_block()
1156 reiserfs_write_unlock(inode->i_sb); reiserfs_get_block()
1176 loff_t blocksize = inode->i_sb->s_blocksize; real_space_diff()
1192 (blocksize - 1)) >> inode->i_sb->s_blocksize_bits) * UNFM_P_SIZE + real_space_diff()
1278 blocks = _ROUND_UP(blocks, inode->i_sb->s_blocksize >> 9); init_inode()
1434 reiserfs_panic(inode->i_sb, "vs-13065", "key %k, found item %h", update_stat_data()
1465 retval = search_item(inode->i_sb, &key, &path); reiserfs_update_sd_size()
1467 reiserfs_error(inode->i_sb, "vs-13050", reiserfs_update_sd_size()
1476 /*reiserfs_warning (inode->i_sb, "vs-13050: reiserfs_update_sd: i_nlink == 0, stat data not found"); */ reiserfs_update_sd_size()
1479 reiserfs_warning(inode->i_sb, "vs-13060", reiserfs_update_sd_size()
1496 fs_gen = get_generation(inode->i_sb); reiserfs_update_sd_size()
1497 reiserfs_prepare_for_journal(inode->i_sb, bh, 1); reiserfs_update_sd_size()
1500 if (fs_changed(fs_gen, inode->i_sb) reiserfs_update_sd_size()
1502 reiserfs_restore_prepared_buffer(inode->i_sb, bh); reiserfs_update_sd_size()
1563 retval = search_item(inode->i_sb, &key, &path_to_sd); reiserfs_read_locked_inode()
1565 reiserfs_error(inode->i_sb, "vs-13070", reiserfs_read_locked_inode()
1602 !REISERFS_SB(inode->i_sb)->s_is_unlinked_ok) { reiserfs_read_locked_inode()
1603 reiserfs_warning(inode->i_sb, "vs-13075", reiserfs_read_locked_inode()
1780 if (inode->i_sb->s_flags & MS_RDONLY) reiserfs_write_inode()
1790 reiserfs_write_lock(inode->i_sb); reiserfs_write_inode()
1791 if (!journal_begin(&th, inode->i_sb, jbegin_count)) { reiserfs_write_inode()
1795 reiserfs_write_unlock(inode->i_sb); reiserfs_write_inode()
1934 struct super_block *sb = dir->i_sb; reiserfs_new_inode()
1973 depth = reiserfs_write_unlock_nested(inode->i_sb); reiserfs_new_inode()
1976 reiserfs_write_lock_nested(inode->i_sb, depth); reiserfs_new_inode()
2104 if (reiserfs_posixacl(inode->i_sb)) { reiserfs_new_inode()
2105 reiserfs_write_unlock(inode->i_sb); reiserfs_new_inode()
2107 reiserfs_write_lock(inode->i_sb); reiserfs_new_inode()
2114 } else if (inode->i_sb->s_flags & MS_POSIXACL) { reiserfs_new_inode()
2115 reiserfs_warning(inode->i_sb, "jdm-13090", reiserfs_new_inode()
2122 reiserfs_write_unlock(inode->i_sb); reiserfs_new_inode()
2124 reiserfs_write_lock(inode->i_sb); reiserfs_new_inode()
2145 depth = reiserfs_write_unlock_nested(inode->i_sb); reiserfs_new_inode()
2147 reiserfs_write_lock_nested(inode->i_sb, depth); reiserfs_new_inode()
2155 depth = reiserfs_write_unlock_nested(inode->i_sb); reiserfs_new_inode()
2157 reiserfs_write_lock_nested(inode->i_sb, depth); reiserfs_new_inode()
2194 unsigned long blocksize = inode->i_sb->s_blocksize; grab_tail_page()
2240 reiserfs_error(inode->i_sb, "clm-6000", grab_tail_page()
2268 unsigned blocksize = inode->i_sb->s_blocksize; reiserfs_truncate_file()
2275 reiserfs_write_lock(inode->i_sb); reiserfs_truncate_file()
2286 reiserfs_error(inode->i_sb, "clm-6001", reiserfs_truncate_file()
2306 error = journal_begin(&th, inode->i_sb, reiserfs_truncate_file()
2350 reiserfs_write_unlock(inode->i_sb); reiserfs_truncate_file()
2359 reiserfs_write_unlock(inode->i_sb); reiserfs_truncate_file()
2378 loff_t byte_offset = ((loff_t)block << inode->i_sb->s_blocksize_bits)+1; map_block_for_writepage()
2397 reiserfs_write_lock(inode->i_sb); map_block_for_writepage()
2401 retval = search_for_position_by_key(inode->i_sb, &key, &path); map_block_for_writepage()
2415 reiserfs_warning(inode->i_sb, "clm-6002", map_block_for_writepage()
2431 fs_gen = get_generation(inode->i_sb); map_block_for_writepage()
2436 retval = journal_begin(&th, inode->i_sb, jbegin_count); map_block_for_writepage()
2441 if (fs_changed(fs_gen, inode->i_sb) map_block_for_writepage()
2443 reiserfs_restore_prepared_buffer(inode->i_sb, map_block_for_writepage()
2449 reiserfs_prepare_for_journal(inode->i_sb, bh, 1); map_block_for_writepage()
2451 if (fs_changed(fs_gen, inode->i_sb) map_block_for_writepage()
2453 reiserfs_restore_prepared_buffer(inode->i_sb, bh); map_block_for_writepage()
2473 reiserfs_warning(inode->i_sb, "clm-6003", map_block_for_writepage()
2488 reiserfs_write_unlock(inode->i_sb); map_block_for_writepage()
2536 struct super_block *s = inode->i_sb; reiserfs_write_full_page()
2747 reiserfs_wait_on_write_block(inode->i_sb); reiserfs_writepage()
2771 (pos & (inode->i_sb->s_blocksize - 1)) == 0) { reiserfs_write_begin()
2782 reiserfs_wait_on_write_block(inode->i_sb); reiserfs_write_begin()
2784 if (reiserfs_transaction_running(inode->i_sb)) { reiserfs_write_begin()
2794 if (ret && reiserfs_transaction_running(inode->i_sb)) { reiserfs_write_begin()
2814 reiserfs_write_lock(inode->i_sb); reiserfs_write_begin()
2816 reiserfs_write_unlock(inode->i_sb); reiserfs_write_begin()
2838 depth = reiserfs_write_unlock_nested(inode->i_sb); __reiserfs_write_begin()
2839 reiserfs_wait_on_write_block(inode->i_sb); __reiserfs_write_begin()
2840 reiserfs_write_lock_nested(inode->i_sb, depth); __reiserfs_write_begin()
2843 if (reiserfs_transaction_running(inode->i_sb)) { __reiserfs_write_begin()
2854 if (ret && reiserfs_transaction_running(inode->i_sb)) { __reiserfs_write_begin()
2874 reiserfs_write_lock(inode->i_sb); __reiserfs_write_begin()
2876 reiserfs_write_unlock(inode->i_sb); __reiserfs_write_begin()
2905 reiserfs_wait_on_write_block(inode->i_sb); reiserfs_write_end()
2906 if (reiserfs_transaction_running(inode->i_sb)) reiserfs_write_end()
2929 reiserfs_write_lock(inode->i_sb); reiserfs_write_end()
2936 if ((have_large_tails(inode->i_sb) reiserfs_write_end()
2938 || (have_small_tails(inode->i_sb) reiserfs_write_end()
2942 ret = journal_begin(&myth, inode->i_sb, 1); reiserfs_write_end()
2962 reiserfs_write_lock(inode->i_sb); reiserfs_write_end()
2974 reiserfs_write_unlock(inode->i_sb); reiserfs_write_end()
2984 reiserfs_write_unlock(inode->i_sb); reiserfs_write_end()
3004 depth = reiserfs_write_unlock_nested(inode->i_sb); reiserfs_commit_write()
3005 reiserfs_wait_on_write_block(inode->i_sb); reiserfs_commit_write()
3006 reiserfs_write_lock_nested(inode->i_sb, depth); reiserfs_commit_write()
3008 if (reiserfs_transaction_running(inode->i_sb)) { reiserfs_commit_write()
3025 if ((have_large_tails(inode->i_sb) reiserfs_commit_write()
3027 || (have_small_tails(inode->i_sb) reiserfs_commit_write()
3031 ret = journal_begin(&myth, inode->i_sb, 1); reiserfs_commit_write()
3072 if (reiserfs_attrs(inode->i_sb)) { sd_attrs_to_i_attrs()
3098 if (reiserfs_attrs(inode->i_sb)) { i_attrs_to_sd_attrs()
3125 struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb); invalidatepage_can_drop()
3163 && jl != SB_JOURNAL(inode->i_sb)->j_current_jl) invalidatepage_can_drop()
3251 struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb); reiserfs_releasepage()
3324 reiserfs_write_lock(inode->i_sb); reiserfs_setattr()
3332 reiserfs_write_unlock(inode->i_sb); reiserfs_setattr()
3346 err = journal_begin(&th, inode->i_sb, 4); reiserfs_setattr()
3355 reiserfs_write_unlock(inode->i_sb); reiserfs_setattr()
3365 reiserfs_write_unlock(inode->i_sb); reiserfs_setattr()
3380 (REISERFS_QUOTA_INIT_BLOCKS(inode->i_sb) + reiserfs_setattr()
3381 REISERFS_QUOTA_DEL_BLOCKS(inode->i_sb)) + reiserfs_setattr()
3393 reiserfs_write_lock(inode->i_sb); reiserfs_setattr()
3394 error = journal_begin(&th, inode->i_sb, jbegin_count); reiserfs_setattr()
3395 reiserfs_write_unlock(inode->i_sb); reiserfs_setattr()
3399 reiserfs_write_lock(inode->i_sb); reiserfs_setattr()
3402 reiserfs_write_unlock(inode->i_sb); reiserfs_setattr()
3416 reiserfs_write_unlock(inode->i_sb); reiserfs_setattr()
3441 if (!error && reiserfs_posixacl(inode->i_sb)) { reiserfs_setattr()
H A Dxattr_acl.c36 reiserfs_write_lock(inode->i_sb); reiserfs_set_acl()
37 error = journal_begin(&th, inode->i_sb, jcreate_blocks); reiserfs_set_acl()
38 reiserfs_write_unlock(inode->i_sb); reiserfs_set_acl()
41 reiserfs_write_lock(inode->i_sb); reiserfs_set_acl()
43 reiserfs_write_unlock(inode->i_sb); reiserfs_set_acl()
383 nblocks += JOURNAL_BLOCKS_PER_OBJECT(inode->i_sb); reiserfs_cache_default_acl()
403 !reiserfs_posixacl(inode->i_sb)) reiserfs_acl_chmod()
H A Dxattr.c151 xaroot = open_xa_root(inode->i_sb, flags); open_xa_dir()
292 4 * REISERFS_QUOTA_TRANS_BLOCKS(inode->i_sb); reiserfs_for_each_xattr()
295 reiserfs_write_lock(inode->i_sb); reiserfs_for_each_xattr()
296 err = journal_begin(&th, inode->i_sb, blocks); reiserfs_for_each_xattr()
297 reiserfs_write_unlock(inode->i_sb); reiserfs_for_each_xattr()
304 reiserfs_write_lock(inode->i_sb); reiserfs_for_each_xattr()
306 reiserfs_write_unlock(inode->i_sb); reiserfs_for_each_xattr()
355 reiserfs_warning(inode->i_sb, "jdm-20004", reiserfs_delete_xattrs()
366 reiserfs_warning(inode->i_sb, "jdm-20007", reiserfs_chown_xattrs()
453 struct timespec now = current_fs_time(inode->i_sb); update_ctime()
556 reiserfs_write_lock(inode->i_sb); reiserfs_xattr_set_handle()
565 reiserfs_write_unlock(inode->i_sb); reiserfs_xattr_set_handle()
578 .ia_ctime = current_fs_time(inode->i_sb), reiserfs_xattr_set_handle()
608 reiserfs_write_lock(inode->i_sb); reiserfs_xattr_set()
609 error = journal_begin(&th, inode->i_sb, jbegin_count); reiserfs_xattr_set()
610 reiserfs_write_unlock(inode->i_sb); reiserfs_xattr_set()
618 reiserfs_write_lock(inode->i_sb); reiserfs_xattr_set()
620 reiserfs_write_unlock(inode->i_sb); reiserfs_xattr_set()
700 reiserfs_warning(inode->i_sb, "jdm-20001", reiserfs_xattr_get()
720 reiserfs_warning(inode->i_sb, "jdm-20002", reiserfs_xattr_get()
H A Dstree.c1031 struct super_block *sb = inode->i_sb; prepare_for_delete_or_cut()
1237 struct super_block *sb = inode->i_sb; reiserfs_delete_item()
1360 depth = reiserfs_write_unlock_nested(inode->i_sb); reiserfs_delete_item()
1362 reiserfs_write_lock_nested(inode->i_sb, depth); reiserfs_delete_item()
1546 struct super_block *sb = inode->i_sb; maybe_indirect_to_direct()
1591 (cpu_key_k_offset(&tail_key) & (inode->i_sb->s_blocksize - 1)) - 1; indirect_to_direct_roll_back()
1594 if (search_for_position_by_key(inode->i_sb, &tail_key, path) == indirect_to_direct_roll_back()
1596 reiserfs_panic(inode->i_sb, "vs-5615", indirect_to_direct_roll_back()
1614 reiserfs_warning(inode->i_sb, "reiserfs-5091", "indirect_to_direct " indirect_to_direct_roll_back()
1627 struct super_block *sb = inode->i_sb; reiserfs_cut_from_item()
1648 init_tb_struct(th, &s_cut_balance, inode->i_sb, path, reiserfs_cut_from_item()
1832 reiserfs_debug(inode->i_sb, REISERFS_DEBUG_CODE, reiserfs_cut_from_item()
1847 reiserfs_error(inode->i_sb, "vs-5655", "link count != 0"); truncate_directory()
1902 search_for_position_by_key(inode->i_sb, &s_item_key, reiserfs_do_truncate()
1905 reiserfs_error(inode->i_sb, "vs-5657", reiserfs_do_truncate()
1912 reiserfs_error(inode->i_sb, "PAP-5660", reiserfs_do_truncate()
1929 op_bytes_number(p_le_ih, inode->i_sb->s_blocksize); reiserfs_do_truncate()
1958 reiserfs_warning(inode->i_sb, "vs-5665", reiserfs_do_truncate()
1998 err = journal_begin(th, inode->i_sb, reiserfs_do_truncate()
2005 search_for_position_by_key(inode->i_sb, &s_item_key, reiserfs_do_truncate()
2076 struct super_block *sb = inode->i_sb; reiserfs_paste_into_item()
2084 fs_gen = get_generation(inode->i_sb); reiserfs_paste_into_item()
2087 reiserfs_debug(inode->i_sb, REISERFS_DEBUG_CODE, reiserfs_paste_into_item()
2107 if (fs_changed(fs_gen, inode->i_sb)) { reiserfs_paste_into_item()
2125 reiserfs_warning(inode->i_sb, "PAP-5710", reiserfs_paste_into_item()
2149 reiserfs_debug(inode->i_sb, REISERFS_DEBUG_CODE, reiserfs_paste_into_item()
2181 fs_gen = get_generation(inode->i_sb); reiserfs_insert_item()
2190 quota_bytes = inode->i_sb->s_blocksize + UNFM_P_SIZE; reiserfs_insert_item()
2192 reiserfs_debug(inode->i_sb, REISERFS_DEBUG_CODE, reiserfs_insert_item()
2200 depth = reiserfs_write_unlock_nested(inode->i_sb); reiserfs_insert_item()
2202 reiserfs_write_lock_nested(inode->i_sb, depth); reiserfs_insert_item()
2217 if (inode && fs_changed(fs_gen, inode->i_sb)) { reiserfs_insert_item()
2257 int depth = reiserfs_write_unlock_nested(inode->i_sb); reiserfs_insert_item()
2259 reiserfs_write_lock_nested(inode->i_sb, depth); reiserfs_insert_item()
H A Dxattr_security.c81 if (sec->length && reiserfs_xattrs_initialized(inode->i_sb)) { reiserfs_security_init()
H A Dtail_conversion.c28 struct super_block *sb = inode->i_sb; direct2indirect()
180 struct reiserfs_journal *j = SB_JOURNAL(inode->i_sb); reiserfs_unmap_buffer()
210 struct super_block *sb = inode->i_sb; indirect2direct()
/linux-4.1.27/fs/nilfs2/
H A Dnamei.c77 inode = ino ? nilfs_iget(dir->i_sb, NILFS_I(dir)->i_root, ino) : NULL; nilfs_lookup()
96 err = nilfs_transaction_begin(dir->i_sb, &ti, 1); nilfs_create()
109 err = nilfs_transaction_commit(dir->i_sb); nilfs_create()
111 nilfs_transaction_abort(dir->i_sb); nilfs_create()
126 err = nilfs_transaction_begin(dir->i_sb, &ti, 1); nilfs_mknod()
137 err = nilfs_transaction_commit(dir->i_sb); nilfs_mknod()
139 nilfs_transaction_abort(dir->i_sb); nilfs_mknod()
148 struct super_block *sb = dir->i_sb; nilfs_symlink()
156 err = nilfs_transaction_begin(dir->i_sb, &ti, 1); nilfs_symlink()
178 err = nilfs_transaction_commit(dir->i_sb); nilfs_symlink()
180 nilfs_transaction_abort(dir->i_sb); nilfs_symlink()
199 err = nilfs_transaction_begin(dir->i_sb, &ti, 1); nilfs_link()
210 err = nilfs_transaction_commit(dir->i_sb); nilfs_link()
214 nilfs_transaction_abort(dir->i_sb); nilfs_link()
226 err = nilfs_transaction_begin(dir->i_sb, &ti, 1); nilfs_mkdir()
256 err = nilfs_transaction_commit(dir->i_sb); nilfs_mkdir()
258 nilfs_transaction_abort(dir->i_sb); nilfs_mkdir()
292 nilfs_warning(inode->i_sb, __func__, nilfs_do_unlink()
313 err = nilfs_transaction_begin(dir->i_sb, &ti, 0); nilfs_unlink()
322 err = nilfs_transaction_commit(dir->i_sb); nilfs_unlink()
324 nilfs_transaction_abort(dir->i_sb); nilfs_unlink()
335 err = nilfs_transaction_begin(dir->i_sb, &ti, 0); nilfs_rmdir()
351 err = nilfs_transaction_commit(dir->i_sb); nilfs_rmdir()
353 nilfs_transaction_abort(dir->i_sb); nilfs_rmdir()
370 err = nilfs_transaction_begin(old_dir->i_sb, &ti, 1); nilfs_rename()
430 err = nilfs_transaction_commit(old_dir->i_sb); nilfs_rename()
442 nilfs_transaction_abort(old_dir->i_sb); nilfs_rename()
462 inode = nilfs_iget(d_inode(child)->i_sb, root, ino); nilfs_get_parent()
H A Dfile.c46 err = nilfs_construct_dsync_segment(inode->i_sb, inode, nilfs_sync_file()
49 err = nilfs_construct_segment(inode->i_sb); nilfs_sync_file()
52 nilfs = inode->i_sb->s_fs_info; nilfs_sync_file()
66 if (unlikely(nilfs_near_disk_full(inode->i_sb->s_fs_info))) nilfs_page_mkwrite()
69 sb_start_pagefault(inode->i_sb); nilfs_page_mkwrite()
106 ret = nilfs_transaction_begin(inode->i_sb, &ti, 1); nilfs_page_mkwrite()
114 nilfs_transaction_abort(inode->i_sb); nilfs_page_mkwrite()
118 nilfs_transaction_commit(inode->i_sb); nilfs_page_mkwrite()
123 sb_end_pagefault(inode->i_sb); nilfs_page_mkwrite()
H A Dinode.c87 struct the_nilfs *nilfs = inode->i_sb->s_fs_info; nilfs_get_block()
96 map_bh(bh_result, inode->i_sb, blknum); nilfs_get_block()
106 err = nilfs_transaction_begin(inode->i_sb, &ti, 1); nilfs_get_block()
128 nilfs_transaction_abort(inode->i_sb); nilfs_get_block()
132 nilfs_transaction_commit(inode->i_sb); /* never fails */ nilfs_get_block()
136 map_bh(bh_result, inode->i_sb, 0); /* dbn must be changed nilfs_get_block()
181 if (inode->i_sb->s_flags & MS_RDONLY) { nilfs_writepages()
187 err = nilfs_construct_dsync_segment(inode->i_sb, inode, nilfs_writepages()
198 if (inode->i_sb->s_flags & MS_RDONLY) { nilfs_writepage()
214 err = nilfs_construct_segment(inode->i_sb); nilfs_writepage()
218 nilfs_flush_segment(inode->i_sb, inode->i_ino); nilfs_writepage()
275 int err = nilfs_transaction_begin(inode->i_sb, NULL, 1); nilfs_write_begin()
284 nilfs_transaction_abort(inode->i_sb); nilfs_write_begin()
303 err = nilfs_transaction_commit(inode->i_sb); nilfs_write_end()
364 struct super_block *sb = dir->i_sb; nilfs_new_inode()
672 struct the_nilfs *nilfs = inode->i_sb->s_fs_info; nilfs_write_inode_common()
733 nilfs_relax_pressure_in_lock(ii->vfs_inode.i_sb); nilfs_truncate_bmap()
739 nilfs_warning(ii->vfs_inode.i_sb, __func__, nilfs_truncate_bmap()
749 struct super_block *sb = inode->i_sb; nilfs_truncate()
803 struct super_block *sb = inode->i_sb; nilfs_evict_inode()
839 struct super_block *sb = inode->i_sb; nilfs_setattr()
885 struct the_nilfs *nilfs = inode->i_sb->s_fs_info; nilfs_load_inode_block()
914 struct the_nilfs *nilfs = inode->i_sb->s_fs_info; nilfs_inode_dirty()
929 struct the_nilfs *nilfs = inode->i_sb->s_fs_info; nilfs_set_file_dirty()
944 nilfs_warning(inode->i_sb, __func__, nilfs_set_file_dirty()
965 nilfs_warning(inode->i_sb, __func__, __nilfs_mark_inode_dirty()
992 nilfs_warning(inode->i_sb, __func__, nilfs_dirty_inode()
1001 nilfs_transaction_begin(inode->i_sb, &ti, 0); nilfs_dirty_inode()
1003 nilfs_transaction_commit(inode->i_sb); /* never fails */ nilfs_dirty_inode()
1009 struct the_nilfs *nilfs = inode->i_sb->s_fs_info; nilfs_fiemap()
H A Dioctl.c174 ret = nilfs_transaction_begin(inode->i_sb, &ti, 0); nilfs_ioctl_setflags()
187 ret = nilfs_transaction_commit(inode->i_sb); nilfs_ioctl_setflags()
224 struct the_nilfs *nilfs = inode->i_sb->s_fs_info; nilfs_ioctl_change_cpmode()
242 nilfs_transaction_begin(inode->i_sb, &ti, 0); nilfs_ioctl_change_cpmode()
246 nilfs_transaction_abort(inode->i_sb); nilfs_ioctl_change_cpmode()
248 nilfs_transaction_commit(inode->i_sb); /* never fails */ nilfs_ioctl_change_cpmode()
279 struct the_nilfs *nilfs = inode->i_sb->s_fs_info; nilfs_ioctl_delete_checkpoint()
295 nilfs_transaction_begin(inode->i_sb, &ti, 0); nilfs_ioctl_delete_checkpoint()
298 nilfs_transaction_abort(inode->i_sb); nilfs_ioctl_delete_checkpoint()
300 nilfs_transaction_commit(inode->i_sb); /* never fails */ nilfs_ioctl_delete_checkpoint()
358 struct the_nilfs *nilfs = inode->i_sb->s_fs_info; nilfs_ioctl_get_cpstat()
425 struct the_nilfs *nilfs = inode->i_sb->s_fs_info; nilfs_ioctl_get_sustat()
534 struct the_nilfs *nilfs = inode->i_sb->s_fs_info; nilfs_ioctl_get_bdescs()
921 nilfs = inode->i_sb->s_fs_info; nilfs_ioctl_clean_segments()
964 ret = nilfs_ioctl_move_blocks(inode->i_sb, &argv[0], kbufs[0]); nilfs_ioctl_clean_segments()
971 ret = nilfs_clean_segments(inode->i_sb, argv, kbufs); nilfs_ioctl_clean_segments()
1020 ret = nilfs_construct_segment(inode->i_sb); nilfs_ioctl_sync()
1024 nilfs = inode->i_sb->s_fs_info; nilfs_ioctl_sync()
1064 ret = nilfs_resize_fs(inode->i_sb, newsize); nilfs_ioctl_resize()
1085 struct the_nilfs *nilfs = inode->i_sb->s_fs_info; nilfs_ioctl_trim_fs()
1127 struct the_nilfs *nilfs = inode->i_sb->s_fs_info; nilfs_ioctl_set_alloc_range()
1141 if (range[1] > i_size_read(inode->i_sb->s_bdev->bd_inode)) nilfs_ioctl_set_alloc_range()
1187 struct the_nilfs *nilfs = inode->i_sb->s_fs_info; nilfs_ioctl_get_info()
1233 struct the_nilfs *nilfs = inode->i_sb->s_fs_info; nilfs_ioctl_set_suinfo()
1280 nilfs_transaction_begin(inode->i_sb, &ti, 0); nilfs_ioctl_set_suinfo()
1284 nilfs_transaction_abort(inode->i_sb); nilfs_ioctl_set_suinfo()
1286 nilfs_transaction_commit(inode->i_sb); /* never fails */ nilfs_ioctl_set_suinfo()
H A Ddir.c55 return inode->i_sb->s_blocksize; nilfs_chunk_size()
113 struct super_block *sb = dir->i_sb; nilfs_check_page()
263 struct super_block *sb = inode->i_sb; nilfs_readdir()
355 nilfs_error(dir->i_sb, __func__, nilfs_find_entry()
370 nilfs_error(dir->i_sb, __func__, nilfs_find_entry()
479 nilfs_error(dir->i_sb, __func__, nilfs_add_link()
550 nilfs_error(inode->i_sb, __func__, nilfs_delete_entry()
637 nilfs_error(inode->i_sb, __func__, nilfs_empty_dir()
H A Dbtnode.c59 bh->b_bdev = inode->i_sb->s_bdev; nilfs_btnode_create_block()
91 struct the_nilfs *nilfs = inode->i_sb->s_fs_info; nilfs_btnode_submit_block()
118 bh->b_bdev = inode->i_sb->s_bdev; nilfs_btnode_submit_block()
/linux-4.1.27/fs/omfs/
H A Dfile.c33 struct omfs_sb_info *sbi = OMFS_SB(inode->i_sb); omfs_shrink_inode()
52 bh = omfs_bread(inode->i_sb, next); omfs_shrink_inode()
79 omfs_clear_range(inode->i_sb, start, (int) count); omfs_shrink_inode()
87 omfs_clear_range(inode->i_sb, last, sbi->s_mirrors); omfs_shrink_inode()
92 bh = omfs_bread(inode->i_sb, next); omfs_shrink_inode()
121 struct omfs_sb_info *sbi = OMFS_SB(inode->i_sb); omfs_grow_extent()
148 if (omfs_allocate_block(inode->i_sb, new_block)) { omfs_grow_extent()
162 ret = omfs_allocate_range(inode->i_sb, 1, sbi->s_clustersize, omfs_grow_extent()
197 int numblocks = clus_to_blk(OMFS_SB(inode->i_sb), find_block()
207 return clus_to_blk(OMFS_SB(inode->i_sb), find_block()
228 struct omfs_sb_info *sbi = OMFS_SB(inode->i_sb); omfs_get_block()
233 bh = omfs_bread(inode->i_sb, inode->i_ino); omfs_get_block()
256 map_bh(bh_result, inode->i_sb, offset); omfs_get_block()
266 bh = omfs_bread(inode->i_sb, next); omfs_get_block()
277 map_bh(bh_result, inode->i_sb, omfs_get_block()
H A Ddir.c31 return omfs_bread(dir->i_sb, dir->i_ino); omfs_get_bucket()
44 bh = omfs_bread(dir->i_sb, block); omfs_scan_list()
51 if (omfs_is_bad(OMFS_SB(dir->i_sb), &oi->i_head, block)) { omfs_scan_list()
134 bh = omfs_bread(dir->i_sb, inode->i_ino); omfs_add_link()
190 bh = omfs_bread(dir->i_sb, prev); omfs_delete_entry()
202 dirty = omfs_iget(dir->i_sb, prev); omfs_delete_entry()
223 bh = omfs_bread(inode->i_sb, inode->i_ino); omfs_dir_is_empty()
266 err = omfs_make_empty(inode, dir->i_sb); omfs_add_node()
307 inode = omfs_iget(dir->i_sb, ino); omfs_lookup()
335 struct buffer_head *bh = omfs_bread(dir->i_sb, fsblock); omfs_fill_chain()
344 if (omfs_is_bad(OMFS_SB(dir->i_sb), &oi->i_head, fsblock)) { omfs_fill_chain()
427 bh = omfs_bread(dir->i_sb, dir->i_ino); omfs_readdir()
H A Dinode.c37 struct omfs_sb_info *sbi = OMFS_SB(dir->i_sb); omfs_new_inode()
39 inode = new_inode(dir->i_sb); omfs_new_inode()
43 err = omfs_allocate_range(dir->i_sb, sbi->s_mirrors, sbi->s_mirrors, omfs_new_inode()
103 struct omfs_sb_info *sbi = OMFS_SB(inode->i_sb); __omfs_write_inode()
111 bh = omfs_bread(inode->i_sb, inode->i_ino); __omfs_write_inode()
150 bh2 = omfs_bread(inode->i_sb, inode->i_ino + i); __omfs_write_inode()
197 omfs_clear_range(inode->i_sb, inode->i_ino, 2); omfs_evict_inode()
215 bh = omfs_bread(inode->i_sb, ino); omfs_iget()
/linux-4.1.27/fs/jfs/
H A Djfs_discard.c47 struct super_block *sb = ip->i_sb; jfs_issue_discard()
82 struct inode *ipbmap = JFS_SBI(ip->i_sb)->ipbmap; jfs_ioc_trim()
83 struct bmap *bmp = JFS_SBI(ip->i_sb)->bmap; jfs_ioc_trim()
84 struct super_block *sb = ipbmap->i_sb; jfs_ioc_trim()
112 agno = BLKTOAG(start, JFS_SBI(ip->i_sb)); jfs_ioc_trim()
113 agno_end = BLKTOAG(end, JFS_SBI(ip->i_sb)); jfs_ioc_trim()
H A Dinode.c111 tid = txBegin(inode->i_sb, COMMIT_INODE); jfs_commit_inode()
138 jfs_flush_journal(JFS_SBI(inode->i_sb)->log, wait); jfs_write_inode()
214 if (((lblock64 << ip->i_sb->s_blocksize_bits) < ip->i_size) && jfs_get_block()
242 map_bh(bh_result, ip->i_sb, xaddr); jfs_get_block()
253 if ((rc = extHint(ip, lblock64 << ip->i_sb->s_blocksize_bits, &xad))) jfs_get_block()
260 map_bh(bh_result, ip->i_sb, addressXAD(&xad)); jfs_get_block()
387 tid = txBegin(ip->i_sb, 0); jfs_truncate_nolock()
H A Dfile.c45 jfs_flush_journal(JFS_SBI(inode->i_sb)->log, 1); jfs_fsync()
77 struct jfs_sb_info *jfs_sb = JFS_SBI(inode->i_sb); jfs_open()
92 struct bmap *bmap = JFS_SBI(inode->i_sb)->bmap; jfs_release()
H A Djfs_extent.c88 struct jfs_sb_info *sbi = JFS_SBI(ip->i_sb); extAlloc()
94 txBeginAnon(ip->i_sb); extAlloc()
217 struct super_block *sb = ip->i_sb; extRealloc()
224 txBeginAnon(ip->i_sb); extRealloc()
366 struct super_block *sb = ip->i_sb; extHint()
391 jfs_error(ip->i_sb, "corrupt xtree\n"); extHint()
428 txBeginAnon(ip->i_sb); extRecord()
458 int rc, nbperpage = JFS_SBI(ip->i_sb)->nbperpage; extFill()
512 struct jfs_sb_info *sbi = JFS_SBI(ip->i_sb); extBalloc()
H A Djfs_metapage.c253 sector_t file_blocks = (inode->i_size + inode->i_sb->s_blocksize - 1) >> metapage_get_blocks()
353 int blocks_per_mp = JFS_SBI(inode->i_sb)->nbperpage; metapage_writepage()
430 len = min(xlen, (int)JFS_SBI(inode->i_sb)->nbperpage); metapage_writepage()
433 bio->bi_bdev = inode->i_sb->s_bdev; metapage_writepage()
512 bio->bi_bdev = inode->i_sb->s_bdev; metapage_readpage()
612 mapping = JFS_SBI(inode->i_sb)->direct_inode->i_mapping; __get_metapage()
643 jfs_error(inode->i_sb, __get_metapage()
654 jfs_error(inode->i_sb, __get_metapage()
777 JFS_SBI(ip->i_sb)->direct_inode->i_mapping; __invalidate_metapages()
H A Djfs_dmap.c182 BMAPBLKNO << JFS_SBI(ipbmap->i_sb)->l2nbperpage, dbMount()
213 JFS_SBI(ipbmap->i_sb)->bmap = bmp; dbMount()
244 struct bmap *bmp = JFS_SBI(ipbmap->i_sb)->bmap; dbUnmount()
266 struct bmap *bmp = JFS_SBI(ipbmap->i_sb)->bmap; dbSync()
275 BMAPBLKNO << JFS_SBI(ipbmap->i_sb)->l2nbperpage, dbSync()
337 struct inode *ipbmap = JFS_SBI(ip->i_sb)->ipbmap; dbFree()
338 struct bmap *bmp = JFS_SBI(ip->i_sb)->bmap; dbFree()
339 struct super_block *sb = ipbmap->i_sb; dbFree()
349 jfs_error(ip->i_sb, "block to be freed is outside the map\n"); dbFree()
386 jfs_error(ip->i_sb, "error in block map\n"); dbFree()
429 struct bmap *bmp = JFS_SBI(ipbmap->i_sb)->bmap; dbUpdatePMap()
443 jfs_error(ipbmap->i_sb, "blocks are outside the map\n"); dbUpdatePMap()
610 struct bmap *bmp = JFS_SBI(ipbmap->i_sb)->bmap; dbNextAG()
703 struct inode *ipbmap = JFS_SBI(ip->i_sb)->ipbmap; dbAlloc()
721 bmp = JFS_SBI(ip->i_sb)->bmap; dbAlloc()
727 jfs_error(ip->i_sb, "the hint is outside the map\n"); dbAlloc()
896 struct inode *ipbmap = JFS_SBI(ip->i_sb)->ipbmap; dbAllocExact()
897 struct bmap *bmp = JFS_SBI(ip->i_sb)->bmap; dbAllocExact()
1028 struct jfs_sb_info *sbi = JFS_SBI(ip->i_sb); dbExtend()
1058 jfs_error(ip->i_sb, "the block is outside the filesystem\n"); dbExtend()
1134 jfs_error(bmp->db_ipbmap->i_sb, "Corrupt dmap page\n"); dbAllocNext()
1264 jfs_error(bmp->db_ipbmap->i_sb, "Corrupt dmap page\n"); dbAllocNear()
1378 jfs_error(bmp->db_ipbmap->i_sb, dbAllocAG()
1413 jfs_error(bmp->db_ipbmap->i_sb, dbAllocAG()
1430 jfs_error(bmp->db_ipbmap->i_sb, "Corrupt dmapctl page\n"); dbAllocAG()
1470 jfs_error(bmp->db_ipbmap->i_sb, dbAllocAG()
1510 jfs_error(bmp->db_ipbmap->i_sb, dbAllocAG()
1522 jfs_error(bmp->db_ipbmap->i_sb, dbAllocAG()
1582 jfs_error(bmp->db_ipbmap->i_sb, "unable to allocate blocks\n"); dbAllocAny()
1621 struct inode *ipbmap = JFS_SBI(ip->i_sb)->ipbmap; dbDiscardAG()
1622 struct bmap *bmp = JFS_SBI(ip->i_sb)->bmap; dbDiscardAG()
1626 struct super_block *sb = ipbmap->i_sb; dbDiscardAG()
1646 jfs_error(bmp->db_ipbmap->i_sb, "no memory for trim array\n"); dbDiscardAG()
1675 jfs_error(bmp->db_ipbmap->i_sb, "-EIO\n"); dbDiscardAG()
1752 jfs_error(bmp->db_ipbmap->i_sb, dbFindCtl()
1773 jfs_error(bmp->db_ipbmap->i_sb, dbFindCtl()
1897 jfs_error(bmp->db_ipbmap->i_sb, dbAllocCtl()
1944 jfs_error(bmp->db_ipbmap->i_sb, dbAllocCtl()
1957 jfs_error(bmp->db_ipbmap->i_sb, "Block Leakage\n"); dbAllocCtl()
2253 jfs_error(bmp->db_ipbmap->i_sb, dbAllocBits()
2527 jfs_error(bmp->db_ipbmap->i_sb, "Corrupt dmapctl page\n"); dbAdjCtl()
2627 jfs_error(bmp->db_ipbmap->i_sb, dbAdjCtl()
3214 struct inode *ipbmap = JFS_SBI(ip->i_sb)->ipbmap; dbAllocBottomUp()
3215 struct bmap *bmp = JFS_SBI(ip->i_sb)->bmap; dbAllocBottomUp()
3386 struct jfs_sb_info *sbi = JFS_SBI(ipbmap->i_sb); dbExtendFS()
3470 jfs_error(ipbmap->i_sb, "L2 page could not be read\n"); dbExtendFS()
3635 jfs_error(ipbmap->i_sb, "function has not returned as expected\n"); dbExtendFS()
3658 struct bmap *bmp = JFS_SBI(ipbmap->i_sb)->bmap; dbFinalizeBmap()
3704 jfs_error(ipbmap->i_sb, dbFinalizeBmap()
4054 struct super_block *sb = ipbmap->i_sb; dbMapFileSizeToMapSize()
H A Djfs_imap.c127 IMAPBLKNO << JFS_SBI(ipimap->i_sb)->l2nbperpage, diMount()
231 IMAPBLKNO << JFS_SBI(ipimap->i_sb)->l2nbperpage, diSync()
306 struct jfs_sb_info *sbi = JFS_SBI(ip->i_sb); diRead()
389 jfs_error(ip->i_sb, "i_ino != di_number\n"); diRead()
519 struct jfs_sb_info *sbi = JFS_SBI(ip->i_sb); diWriteSpecial()
601 struct jfs_sb_info *sbi = JFS_SBI(ip->i_sb); diWrite()
628 jfs_error(ip->i_sb, "ixpxd invalid\n"); diWrite()
872 struct inode *ipimap = JFS_SBI(ip->i_sb)->ipimap; diFree()
896 jfs_error(ip->i_sb, "inum = %d, iagno = %d, nextiag = %d\n", diFree()
903 agno = BLKTOAG(JFS_IP(ip)->agstart, JFS_SBI(ip->i_sb)); diFree()
932 jfs_error(ip->i_sb, "wmap shows inode already free\n"); diFree()
939 jfs_error(ip->i_sb, "invalid inoext\n"); diFree()
951 jfs_error(ip->i_sb, "numfree > numinos\n"); diFree()
1200 jfs_error(ip->i_sb, "the pmap does not show inode free\n"); diFree()
1249 tid = txBegin(ipimap->i_sb, COMMIT_FORCE); diFree()
1355 ipimap = JFS_SBI(pip->i_sb)->ipimap; diAlloc()
1364 agno = dbNextAG(JFS_SBI(pip->i_sb)->ipbmap); diAlloc()
1379 agno = BLKTOAG(JFS_IP(pip)->agstart, JFS_SBI(pip->i_sb)); diAlloc()
1381 if (atomic_read(&JFS_SBI(pip->i_sb)->bmap->db_active[agno])) { diAlloc()
1387 agno = dbNextAG(JFS_SBI(pip->i_sb)->ipbmap); diAlloc()
1518 jfs_error(ip->i_sb, diAlloc()
1660 jfs_error(ip->i_sb, "numfree > numinos\n"); diAllocAG()
1722 int maxag = JFS_SBI(imap->im_ipimap->i_sb)->bmap->db_maxag; diAllocAny()
1811 jfs_error(ip->i_sb, "nfreeinos = 0, but iag on freelist\n"); diAllocIno()
1822 jfs_error(ip->i_sb, diAllocIno()
1838 jfs_error(ip->i_sb, "no free extent found\n"); diAllocIno()
1849 jfs_error(ip->i_sb, "free inode not found\n"); diAllocIno()
1935 jfs_error(ip->i_sb, "error reading iag\n"); diAllocExt()
1947 jfs_error(ip->i_sb, "free ext summary map not found\n"); diAllocExt()
1960 jfs_error(ip->i_sb, "free extent not found\n"); diAllocExt()
2061 agno = BLKTOAG(le64_to_cpu(iagp->agstart), JFS_SBI(imap->im_ipimap->i_sb)); diAllocBit()
2079 jfs_error(imap->im_ipimap->i_sb, "iag inconsistent\n"); diAllocBit()
2186 jfs_error(imap->im_ipimap->i_sb, "no free extents\n"); diNewExt()
2193 sbi = JFS_SBI(ipimap->i_sb); diNewExt()
2257 jfs_error(imap->im_ipimap->i_sb, diNewExt()
2468 sb = ipimap->i_sb; diNewIAG()
2494 jfs_error(imap->im_ipimap->i_sb, diNewIAG()
2681 blkno = IAGTOLBLK(iagno, JFS_SBI(ipimap->i_sb)->l2nbperpage); diIAGRead()
2755 jfs_error(ipimap->i_sb, "the iag is outside the map\n"); diUpdatePMap()
2783 jfs_error(ipimap->i_sb, diUpdatePMap()
2788 jfs_error(ipimap->i_sb, diUpdatePMap()
2804 jfs_error(ipimap->i_sb, diUpdatePMap()
2810 jfs_error(ipimap->i_sb, diUpdatePMap()
2864 struct bmap *mp = JFS_SBI(ipbmap->i_sb)->bmap; diExtendFS()
2903 jfs_error(ipimap->i_sb, "unexpected value of iagnum\n"); diExtendFS()
2979 jfs_error(ipimap->i_sb, "numinos or numfree incorrect\n"); diExtendFS()
3049 struct jfs_sb_info *sbi = JFS_SBI(ip->i_sb); copy_from_dinode()
3091 ip->i_blocks = LBLK2PBLK(ip->i_sb, le64_to_cpu(dip->di_nblocks)); copy_from_dinode()
3133 struct jfs_sb_info *sbi = JFS_SBI(ip->i_sb); copy_to_dinode()
3140 dip->di_nblocks = cpu_to_le64(PBLK2LBLK(ip->i_sb, ip->i_blocks)); copy_to_dinode()
H A Dnamei.c109 tid = txBegin(dip->i_sb, 0); jfs_create()
241 tid = txBegin(dip->i_sb, 0); jfs_mkdir()
371 tid = txBegin(dip->i_sb, 0); jfs_rmdir()
494 tid = txBegin(dip->i_sb, 0); jfs_unlink()
567 tid = txBegin(dip->i_sb, 0); jfs_unlink()
804 tid = txBegin(ip->i_sb, 0); jfs_link()
917 tid = txBegin(dip->i_sb, 0); jfs_symlink()
977 sb = ip->i_sb; jfs_symlink()
1140 tid = txBegin(new_dir->i_sb, 0); jfs_rename()
1176 jfs_error(new_ip->i_sb, jfs_rename()
1261 new_dir->i_ctime = new_dir->i_mtime = current_fs_time(new_dir->i_sb); jfs_rename()
1299 tid = txBegin(new_ip->i_sb, 0); jfs_rename()
1370 tid = txBegin(dir->i_sb, 0); jfs_mknod()
1457 ip = jfs_iget(dip->i_sb, inum); jfs_lookup()
1505 return d_obtain_alias(jfs_iget(d_inode(dentry)->i_sb, parent_ino)); jfs_get_parent()
/linux-4.1.27/fs/ext3/
H A Dfsync.c45 journal_t *journal = EXT3_SB(inode->i_sb)->s_journal; ext3_sync_file()
51 if (inode->i_sb->s_flags & MS_RDONLY) { ext3_sync_file()
54 if (EXT3_SB(inode->i_sb)->s_mount_state & EXT3_ERROR_FS) ext3_sync_file()
79 ret = ext3_force_commit(inode->i_sb); ext3_sync_file()
88 if (test_opt(inode->i_sb, BARRIER) && ext3_sync_file()
102 err = blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, NULL); ext3_sync_file()
H A Dnamei.h21 ext3_error(inode->i_sb, __func__, ext3_dir_bread()
H A Dnamei.c46 *block = inode->i_size >> inode->i_sb->s_blocksize_bits; ext3_append()
49 inode->i_size += inode->i_sb->s_blocksize; ext3_append()
225 unsigned entry_space = dir->i_sb->s_blocksize - EXT3_DIR_REC_LEN(1) - dx_root_limit()
232 unsigned entry_space = dir->i_sb->s_blocksize - EXT3_DIR_REC_LEN(0); dx_node_limit()
291 unsigned blocksize = dir->i_sb->s_blocksize; dx_show_entries()
348 ext3_warning(dir->i_sb, __func__, dx_probe()
357 hinfo->hash_version += EXT3_SB(dir->i_sb)->s_hash_unsigned; dx_probe()
358 hinfo->seed = EXT3_SB(dir->i_sb)->s_hash_seed; dx_probe()
364 ext3_warning(dir->i_sb, __func__, dx_probe()
373 ext3_warning(dir->i_sb, __func__, dx_probe()
386 ext3_warning(dir->i_sb, __func__, dx_probe()
398 ext3_warning(dir->i_sb, __func__, dx_probe()
445 ext3_warning(dir->i_sb, __func__, dx_probe()
461 ext3_warning(dir->i_sb, __func__, dx_probe()
573 dir->i_sb->s_blocksize - htree_dirblock_to_tree()
577 (block<<EXT3_BLOCK_SIZE_BITS(dir->i_sb)) htree_dirblock_to_tree()
625 hinfo.hash_version = EXT3_SB(dir->i_sb)->s_def_hash_version; ext3_htree_fill_tree()
628 EXT3_SB(dir->i_sb)->s_hash_unsigned; ext3_htree_fill_tree()
629 hinfo.seed = EXT3_SB(dir->i_sb)->s_hash_seed; ext3_htree_fill_tree()
769 if (!EXT3_HAS_COMPAT_FEATURE(inode->i_sb, ext3_update_dx_flag()
806 dlimit = bh->b_data + dir->i_sb->s_blocksize; search_dirblock()
860 sb = dir->i_sb; ext3_find_entry()
968 struct super_block *sb = dir->i_sb; ext3_dx_find_entry()
1028 if (!ext3_valid_inum(dir->i_sb, ino)) { ext3_lookup()
1029 ext3_error(dir->i_sb, "ext3_lookup", ext3_lookup()
1033 inode = ext3_iget(dir->i_sb, ino); ext3_lookup()
1035 ext3_error(dir->i_sb, __func__, ext3_lookup()
1058 if (!ext3_valid_inum(d_inode(child)->i_sb, ino)) { ext3_get_parent()
1059 ext3_error(d_inode(child)->i_sb, "ext3_get_parent", ext3_get_parent()
1064 return d_obtain_alias(ext3_iget(d_inode(child)->i_sb, ino)); ext3_get_parent()
1142 unsigned blocksize = dir->i_sb->s_blocksize; do_split()
1224 ext3_std_error(dir->i_sb, err); do_split()
1257 top = bh->b_data + dir->i_sb->s_blocksize - reclen; add_dirent_to_buf()
1281 ext3_std_error(dir->i_sb, err); add_dirent_to_buf()
1298 ext3_set_de_type(dir->i_sb, de, inode->i_mode); add_dirent_to_buf()
1321 ext3_std_error(dir->i_sb, err); add_dirent_to_buf()
1349 blocksize = dir->i_sb->s_blocksize; make_indexed_dir()
1353 ext3_std_error(dir->i_sb, retval); make_indexed_dir()
1364 ext3_error(dir->i_sb, __func__, make_indexed_dir()
1391 root->info.hash_version = EXT3_SB(dir->i_sb)->s_def_hash_version; make_indexed_dir()
1400 hinfo.hash_version += EXT3_SB(dir->i_sb)->s_hash_unsigned; make_indexed_dir()
1401 hinfo.seed = EXT3_SB(dir->i_sb)->s_hash_seed; make_indexed_dir()
1447 sb = dir->i_sb; ext3_add_entry()
1493 struct super_block * sb = dir->i_sb; ext3_dx_add_entry()
1611 ext3_std_error(dir->i_sb, err); ext3_dx_add_entry()
1656 ext3_std_error(dir->i_sb, err); ext3_delete_entry()
1702 handle = ext3_journal_start(dir, EXT3_DATA_TRANS_BLOCKS(dir->i_sb) + ext3_create()
1704 EXT3_MAXQUOTAS_INIT_BLOCKS(dir->i_sb)); ext3_create()
1720 if (err == -ENOSPC && ext3_should_retry_alloc(dir->i_sb, &retries)) ext3_create()
1738 handle = ext3_journal_start(dir, EXT3_DATA_TRANS_BLOCKS(dir->i_sb) + ext3_mknod()
1740 EXT3_MAXQUOTAS_INIT_BLOCKS(dir->i_sb)); ext3_mknod()
1757 if (err == -ENOSPC && ext3_should_retry_alloc(dir->i_sb, &retries)) ext3_mknod()
1771 handle = ext3_journal_start(dir, EXT3_MAXQUOTAS_INIT_BLOCKS(dir->i_sb) + ext3_tmpfile()
1791 if (err == -ENOSPC && ext3_should_retry_alloc(dir->i_sb, &retries)) ext3_tmpfile()
1814 handle = ext3_journal_start(dir, EXT3_DATA_TRANS_BLOCKS(dir->i_sb) + ext3_mkdir()
1816 EXT3_MAXQUOTAS_INIT_BLOCKS(dir->i_sb)); ext3_mkdir()
1830 inode->i_size = EXT3_I(inode)->i_disksize = inode->i_sb->s_blocksize; ext3_mkdir()
1844 ext3_set_de_type(dir->i_sb, de, S_IFDIR); ext3_mkdir()
1847 de->rec_len = ext3_rec_len_to_disk(inode->i_sb->s_blocksize - ext3_mkdir()
1851 ext3_set_de_type(dir->i_sb, de, S_IFDIR); ext3_mkdir()
1881 if (err == -ENOSPC && ext3_should_retry_alloc(dir->i_sb, &retries)) ext3_mkdir()
1897 sb = inode->i_sb; empty_dir()
1901 ext3_error(inode->i_sb, __func__, empty_dir()
1905 ext3_warning(inode->i_sb, __func__, empty_dir()
1916 ext3_warning (inode->i_sb, "empty_dir", empty_dir()
1969 struct super_block *sb = inode->i_sb; ext3_orphan_add()
2026 ext3_std_error(inode->i_sb, err); ext3_orphan_add()
2043 mutex_lock(&EXT3_SB(inode->i_sb)->s_orphan_lock); ext3_orphan_del()
2049 sbi = EXT3_SB(inode->i_sb); ext3_orphan_del()
2093 ext3_std_error(inode->i_sb, err); ext3_orphan_del()
2095 mutex_unlock(&EXT3_SB(inode->i_sb)->s_orphan_lock); ext3_orphan_del()
2116 handle = ext3_journal_start(dir, EXT3_DELETE_TRANS_BLOCKS(dir->i_sb)); ext3_rmdir()
2142 ext3_warning (inode->i_sb, "ext3_rmdir", ext3_rmdir()
2178 handle = ext3_journal_start(dir, EXT3_DELETE_TRANS_BLOCKS(dir->i_sb)); ext3_unlink()
2197 ext3_warning (inode->i_sb, "ext3_unlink", ext3_unlink()
2231 if (l > dir->i_sb->s_blocksize) ext3_symlink()
2243 credits = 4 + EXT3_MAXQUOTAS_INIT_BLOCKS(dir->i_sb) + ext3_symlink()
2252 credits = EXT3_DATA_TRANS_BLOCKS(dir->i_sb) + ext3_symlink()
2254 EXT3_MAXQUOTAS_INIT_BLOCKS(dir->i_sb); ext3_symlink()
2296 EXT3_DATA_TRANS_BLOCKS(dir->i_sb) + ext3_symlink()
2318 if (err == -ENOSPC && ext3_should_retry_alloc(dir->i_sb, &retries)) ext3_symlink()
2340 handle = ext3_journal_start(dir, EXT3_DATA_TRANS_BLOCKS(dir->i_sb) + ext3_link()
2366 if (err == -ENOSPC && ext3_should_retry_alloc(dir->i_sb, &retries)) ext3_link()
2397 EXT3_DATA_TRANS_BLOCKS(old_dir->i_sb) + ext3_rename()
2452 if (EXT3_HAS_INCOMPAT_FEATURE(new_dir->i_sb, ext3_rename()
2497 ext3_warning(old_dir->i_sb, "ext3_rename", ext3_rename()
2518 ext3_std_error(new_dir->i_sb, retval); ext3_rename()
H A Dxattr.c74 inode->i_sb->s_id, inode->i_ino); \
226 bh = sb_bread(inode->i_sb, EXT3_I(inode)->i_file_acl); ext3_xattr_block_get()
232 bad_block: ext3_error(inode->i_sb, __func__, ext3_xattr_block_get()
280 end = (void *)raw_inode + EXT3_SB(inode->i_sb)->s_inode_size; ext3_xattr_ibody_get()
369 bh = sb_bread(inode->i_sb, EXT3_I(inode)->i_file_acl); ext3_xattr_block_list()
376 ext3_error(inode->i_sb, __func__, ext3_xattr_block_list()
408 end = (void *)raw_inode + EXT3_SB(inode->i_sb)->s_inode_size; ext3_xattr_ibody_list()
506 ext3_std_error(inode->i_sb, error); ext3_xattr_release_block()
634 struct super_block *sb = inode->i_sb; ext3_xattr_block_find()
678 struct super_block *sb = inode->i_sb; ext3_xattr_block_set()
859 ext3_error(inode->i_sb, __func__, ext3_xattr_block_set()
886 is->s.end = (void *)raw_inode + EXT3_SB(inode->i_sb)->s_inode_size; ext3_xattr_ibody_find()
974 memset(raw_inode, 0, EXT3_SB(inode->i_sb)->s_inode_size); ext3_xattr_set_handle()
1024 ext3_xattr_update_super_block(handle, inode->i_sb); ext3_xattr_set_handle()
1059 handle = ext3_journal_start(inode, EXT3_DATA_TRANS_BLOCKS(inode->i_sb)); ext3_xattr_set()
1069 ext3_should_retry_alloc(inode->i_sb, &retries)) ext3_xattr_set()
1092 bh = sb_bread(inode->i_sb, EXT3_I(inode)->i_file_acl); ext3_xattr_delete_inode()
1094 ext3_error(inode->i_sb, __func__, ext3_xattr_delete_inode()
1101 ext3_error(inode->i_sb, __func__, ext3_xattr_delete_inode()
1216 ce = mb_cache_entry_find_first(ext3_xattr_cache, inode->i_sb->s_bdev, ext3_xattr_cache_find()
1226 bh = sb_bread(inode->i_sb, ce->e_block); ext3_xattr_cache_find()
1228 ext3_error(inode->i_sb, __func__, ext3_xattr_cache_find()
1242 ce = mb_cache_entry_find_next(ce, inode->i_sb->s_bdev, hash); ext3_xattr_cache_find()
H A Dioctl.c153 if (test_opt(inode->i_sb, RESERVATION) ext3_ioctl()
163 if (!test_opt(inode->i_sb, RESERVATION) ||!S_ISREG(inode->i_mode)) ext3_ioctl()
202 struct super_block *sb = inode->i_sb; ext3_ioctl()
228 struct super_block *sb = inode->i_sb; ext3_ioctl()
256 struct super_block *sb = inode->i_sb; ext3_ioctl()
H A Dinode.c44 (inode->i_sb->s_blocksize >> 9) : 0; ext3_inode_is_fast_symlink()
71 test_opt(inode->i_sb, DATA_FLAGS)); ext3_forget()
78 if (test_opt(inode->i_sb, DATA_FLAGS) == EXT3_MOUNT_JOURNAL_DATA || ext3_forget()
93 ext3_abort(inode->i_sb, __func__, ext3_forget()
107 needed = inode->i_blocks >> (inode->i_sb->s_blocksize_bits - 9); blocks_for_truncate()
123 return EXT3_DATA_TRANS_BLOCKS(inode->i_sb) + needed; blocks_for_truncate()
144 ext3_std_error(inode->i_sb, PTR_ERR(result)); start_transaction()
221 EXT3_SB(inode->i_sb)->s_journal && ext3_evict_inode()
225 journal_t *journal = EXT3_SB(inode->i_sb)->s_journal; ext3_evict_inode()
329 * inode->i_sb).
345 int ptrs = EXT3_ADDR_PER_BLOCK(inode->i_sb); ext3_block_to_path()
346 int ptrs_bits = EXT3_ADDR_PER_BLOCK_BITS(inode->i_sb); ext3_block_to_path()
354 ext3_warning (inode->i_sb, "ext3_block_to_path", "block < 0"); ext3_block_to_path()
374 ext3_warning(inode->i_sb, "ext3_block_to_path", "block > big"); ext3_block_to_path()
413 struct super_block *sb = inode->i_sb; ext3_get_branch()
488 bg_start = ext3_group_first_block_no(inode->i_sb, ei->i_block_group); ext3_find_near()
490 (EXT3_BLOCKS_PER_GROUP(inode->i_sb) / 16); ext3_find_near()
657 int blocksize = inode->i_sb->s_blocksize; ext3_alloc_branch()
680 bh = sb_getblk(inode->i_sb, new_blocks[n-1]); ext3_alloc_branch()
990 map_bh(bh_result, inode->i_sb, le32_to_cpu(chain[depth-1].key)); ext3_get_blocks_handle()
1032 EXT3_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb)); ext3_get_block()
1086 bh = sb_getblk(inode->i_sb, dummy.b_blocknr); ext3_getblk()
1106 memset(bh->b_data,0,inode->i_sb->s_blocksize); ext3_getblk()
1311 if (ret == -ENOSPC && ext3_should_retry_alloc(inode->i_sb, &retries)) ext3_write_begin()
1586 * ordered to avoid dereferencing inode->i_sb in non-error case to ext3_ordered_writepage()
1590 !(EXT3_SB(inode->i_sb)->s_mount_state & EXT3_ERROR_FS)); ext3_ordered_writepage()
1601 create_empty_buffers(page, inode->i_sb->s_blocksize, ext3_ordered_writepage()
1664 * ordered to avoid dereferencing inode->i_sb in non-error case to ext3_writeback_writepage()
1668 !(EXT3_SB(inode->i_sb)->s_mount_state & EXT3_ERROR_FS)); ext3_writeback_writepage()
1713 * ordered to avoid dereferencing inode->i_sb in non-error case to ext3_journalled_writepage()
1717 !(EXT3_SB(inode->i_sb)->s_mount_state & EXT3_ERROR_FS)); ext3_journalled_writepage()
1871 if (ret == -ENOSPC && ext3_should_retry_alloc(inode->i_sb, &retries)) ext3_direct_IO()
2006 blocksize = inode->i_sb->s_blocksize; ext3_block_truncate_page()
2014 iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits); ext3_block_truncate_page()
2233 bh = sb_find_get_block(inode->i_sb, nr); ext3_clear_blocks()
2320 ext3_error(inode->i_sb, "ext3_free_data", ext3_free_data()
2353 int addr_per_block = EXT3_ADDR_PER_BLOCK(inode->i_sb); ext3_free_branches()
2361 bh = sb_bread(inode->i_sb, nr); ext3_free_branches()
2368 ext3_error(inode->i_sb, "ext3_free_branches", ext3_free_branches()
2498 int addr_per_block = EXT3_ADDR_PER_BLOCK(inode->i_sb); ext3_truncate()
2505 unsigned blocksize = inode->i_sb->s_blocksize; ext3_truncate()
2520 >> EXT3_BLOCK_SIZE_BITS(inode->i_sb); ext3_truncate()
2693 block = ext3_get_inode_block(inode->i_sb, inode->i_ino, iloc); __ext3_get_inode_loc()
2697 bh = sb_getblk(inode->i_sb, block); __ext3_get_inode_loc()
2699 ext3_error (inode->i_sb, "ext3_get_inode_loc", __ext3_get_inode_loc()
2737 EXT3_INODES_PER_GROUP(inode->i_sb); __ext3_get_inode_loc()
2739 EXT3_INODE_SIZE(inode->i_sb); __ext3_get_inode_loc()
2741 EXT3_INODES_PER_GROUP(inode->i_sb)); __ext3_get_inode_loc()
2745 desc = ext3_get_group_desc(inode->i_sb, __ext3_get_inode_loc()
2750 bitmap_bh = sb_getblk(inode->i_sb, __ext3_get_inode_loc()
2792 ext3_error(inode->i_sb, "ext3_get_inode_loc", __ext3_get_inode_loc()
2879 if(!(test_opt (inode->i_sb, NO_UID32))) { ext3_iget()
2902 !(EXT3_SB(inode->i_sb)->s_mount_state & EXT3_ORPHAN_FS)) { ext3_iget()
2962 if (inode->i_ino >= EXT3_FIRST_INO(inode->i_sb) + 1 && ext3_iget()
2963 EXT3_INODE_SIZE(inode->i_sb) > EXT3_GOOD_OLD_INODE_SIZE) { ext3_iget()
2971 EXT3_INODE_SIZE(inode->i_sb)) { ext3_iget()
3052 memset(raw_inode, 0, EXT3_SB(inode->i_sb)->s_inode_size); ext3_do_update_inode()
3058 if(!(test_opt(inode->i_sb, NO_UID32))) { ext3_do_update_inode()
3109 struct super_block *sb = inode->i_sb; ext3_do_update_inode()
3164 ext3_std_error(inode->i_sb, err); ext3_do_update_inode()
3221 return ext3_force_commit(inode->i_sb); ext3_write_inode()
3259 handle = ext3_journal_start(inode, EXT3_MAXQUOTAS_INIT_BLOCKS(inode->i_sb)+ ext3_setattr()
3260 EXT3_MAXQUOTAS_DEL_BLOCKS(inode->i_sb)+3); ext3_setattr()
3333 ext3_std_error(inode->i_sb, error); ext3_setattr()
3381 ret += EXT3_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb); ext3_writepage_trans_blocks()
3426 ext3_std_error(inode->i_sb, err); ext3_reserve_inode_write()
3517 ext3_std_error(inode->i_sb, err);
3570 ext3_std_error(inode->i_sb, err); ext3_change_inode_journal_flag()
H A Ddir.c51 struct super_block *sb = inode->i_sb; is_dx_dir()
53 if (EXT3_HAS_COMPAT_FEATURE(inode->i_sb, is_dx_dir()
76 else if (unlikely((((char *) de - bh->b_data) + rlen > dir->i_sb->s_blocksize))) ext3_check_dir_entry()
79 le32_to_cpu(EXT3_SB(dir->i_sb)->s_es->s_inodes_count))) ext3_check_dir_entry()
83 ext3_error (dir->i_sb, function, ext3_check_dir_entry()
100 struct super_block *sb = inode->i_sb; ext3_readdir()
413 struct super_block *sb = inode->i_sb; call_filldir()
H A Dacl.c243 handle = ext3_journal_start(inode, EXT3_DATA_TRANS_BLOCKS(inode->i_sb)); ext3_set_acl()
248 if (error == -ENOSPC && ext3_should_retry_alloc(inode->i_sb, &retries)) ext3_set_acl()
/linux-4.1.27/fs/isofs/
H A Djoliet.c47 utf8 = ISOFS_SB(inode->i_sb)->s_utf8; get_joliet_filename()
48 nls = ISOFS_SB(inode->i_sb)->s_nls_iocharset; get_joliet_filename()
H A Drock.c48 ISOFS_SB(inode->i_sb)->s_rock_offset = rr->u.SP.skip; check_sp()
63 if (ISOFS_SB(inode->i_sb)->s_rock_offset != -1) { setup_rock_ridge()
64 rs->len -= ISOFS_SB(inode->i_sb)->s_rock_offset; setup_rock_ridge()
65 rs->chr += ISOFS_SB(inode->i_sb)->s_rock_offset; setup_rock_ridge()
114 bh = sb_bread(rs->inode->i_sb, rs->cont_extent); rock_continue()
209 if (!ISOFS_SB(inode->i_sb)->s_rock) get_rock_ridge_filename()
320 if (!ISOFS_SB(inode->i_sb)->s_rock) parse_rock_ridge_inode_internal()
375 ISOFS_SB(inode->i_sb)->s_rock = 1; parse_rock_ridge_inode_internal()
523 reloc = isofs_iget_reloc(inode->i_sb, reloc_block, 0); parse_rock_ridge_inode_internal()
544 if (ISOFS_SB(inode->i_sb)->s_nocompress) parse_rock_ridge_inode_internal()
680 if ((ISOFS_SB(inode->i_sb)->s_rock_offset == -1) parse_rock_ridge_inode()
681 && (ISOFS_SB(inode->i_sb)->s_rock == 2)) { parse_rock_ridge_inode()
696 struct isofs_sb_info *sbi = ISOFS_SB(inode->i_sb); rock_ridge_symlink_readpage()
714 bh = sb_bread(inode->i_sb, block); rock_ridge_symlink_readpage()
H A Dexport.c77 bh = sb_bread(child_inode->i_sb, parent_block); isofs_export_get_parent()
101 rv = d_obtain_alias(isofs_iget(child_inode->i_sb, parent_block, isofs_export_get_parent()
H A Dnamei.c43 struct isofs_sb_info *sbi = ISOFS_SB(dir->i_sb); isofs_find_entry()
169 inode = found ? isofs_iget(dir->i_sb, block, offset) : NULL; isofs_lookup()
/linux-4.1.27/include/trace/events/
H A Dfilemap.h31 if (page->mapping->host->i_sb)
32 __entry->s_dev = page->mapping->host->i_sb->s_dev;
H A Dext3.h24 __entry->dev = inode->i_sb->s_dev;
51 __entry->dev = dir->i_sb->s_dev;
74 __entry->dev = inode->i_sb->s_dev;
98 __entry->dev = inode->i_sb->s_dev;
120 __entry->dev = inode->i_sb->s_dev;
142 __entry->dev = inode->i_sb->s_dev;
167 __entry->dev = inode->i_sb->s_dev;
196 __entry->dev = inode->i_sb->s_dev;
249 __entry->dev = page->mapping->host->i_sb->s_dev;
311 __entry->dev = page->mapping->host->i_sb->s_dev;
358 __entry->dev = inode->i_sb->s_dev;
385 __entry->dev = inode->i_sb->s_dev;
414 __entry->dev = inode->i_sb->s_dev;
442 __entry->dev = d_inode(dentry)->i_sb->s_dev;
468 __entry->dev = inode->i_sb->s_dev;
538 __entry->dev = inode->i_sb->s_dev;
606 __entry->dev = inode->i_sb->s_dev;
655 __entry->dev = inode->i_sb->s_dev;
685 __entry->dev = inode->i_sb->s_dev;
715 __entry->dev = d_inode(dentry)->i_sb->s_dev;
738 __entry->dev = d_inode(dentry)->i_sb->s_dev;
761 __entry->dev = inode->i_sb->s_dev;
800 __entry->dev = inode->i_sb->s_dev;
829 __entry->dev = inode->i_sb->s_dev;
855 __entry->dev = inode->i_sb->s_dev;
H A Dext4.h92 __entry->dev = inode->i_sb->s_dev;
121 __entry->dev = inode->i_sb->s_dev;
147 __entry->dev = dir->i_sb->s_dev;
170 __entry->dev = inode->i_sb->s_dev;
194 __entry->dev = inode->i_sb->s_dev;
216 __entry->dev = inode->i_sb->s_dev;
238 __entry->dev = inode->i_sb->s_dev;
260 __entry->dev = inode->i_sb->s_dev;
287 __entry->dev = inode->i_sb->s_dev;
331 __entry->dev = inode->i_sb->s_dev;
387 __entry->dev = inode->i_sb->s_dev;
425 __entry->dev = inode->i_sb->s_dev;
453 __entry->dev = inode->i_sb->s_dev;
483 __entry->dev = inode->i_sb->s_dev;
514 __entry->dev = page->mapping->host->i_sb->s_dev;
560 __entry->dev = page->mapping->host->i_sb->s_dev;
670 __entry->dev = pa->pa_inode->i_sb->s_dev;
717 __entry->dev = inode->i_sb->s_dev;
766 __entry->dev = ar->inode->i_sb->s_dev;
807 __entry->dev = ar->inode->i_sb->s_dev;
845 __entry->dev = inode->i_sb->s_dev;
875 __entry->dev = d_inode(dentry)->i_sb->s_dev;
899 __entry->dev = inode->i_sb->s_dev;
944 __entry->dev = inode->i_sb->s_dev;
985 __entry->dev = ac->ac_inode->i_sb->s_dev;
1042 __entry->dev = ac->ac_inode->i_sb->s_dev;
1131 __entry->dev = inode->i_sb->s_dev;
1162 __entry->dev = inode->i_sb->s_dev;
1203 __entry->dev = inode->i_sb->s_dev;
1238 __entry->dev = inode->i_sb->s_dev;
1321 __entry->dev = inode->i_sb->s_dev;
1350 __entry->dev = inode->i_sb->s_dev;
1379 __entry->dev = inode->i_sb->s_dev;
1429 __entry->dev = inode->i_sb->s_dev;
1456 __entry->dev = d_inode(dentry)->i_sb->s_dev;
1480 __entry->dev = d_inode(dentry)->i_sb->s_dev;
1503 __entry->dev = inode->i_sb->s_dev;
1545 __entry->dev = inode->i_sb->s_dev;
1586 __entry->dev = inode->i_sb->s_dev;
1623 __entry->dev = inode->i_sb->s_dev;
1668 __entry->dev = inode->i_sb->s_dev;
1713 __entry->dev = inode->i_sb->s_dev;
1736 __entry->dev = inode->i_sb->s_dev;
1859 __entry->dev = inode->i_sb->s_dev;
1923 __entry->dev = inode->i_sb->s_dev;
1951 __entry->dev = inode->i_sb->s_dev;
1982 __entry->dev = inode->i_sb->s_dev;
2013 __entry->dev = inode->i_sb->s_dev;
2041 __entry->dev = inode->i_sb->s_dev;
2075 __entry->dev = inode->i_sb->s_dev;
2115 __entry->dev = inode->i_sb->s_dev;
2147 __entry->dev = inode->i_sb->s_dev;
2173 __entry->dev = inode->i_sb->s_dev;
2205 __entry->dev = inode->i_sb->s_dev;
2240 __entry->dev = inode->i_sb->s_dev;
2280 __entry->dev = inode->i_sb->s_dev;
2304 __entry->dev = inode->i_sb->s_dev;
2329 __entry->dev = inode->i_sb->s_dev;
2356 __entry->dev = inode->i_sb->s_dev;
2383 __entry->dev = inode->i_sb->s_dev;
2469 __entry->dev = inode->i_sb->s_dev;
H A Df2fs.h134 __entry->dev = inode->i_sb->s_dev;
168 __entry->dev = inode->i_sb->s_dev;
200 __entry->dev = inode->i_sb->s_dev;
282 __entry->dev = dir->i_sb->s_dev;
326 __entry->dev = inode->i_sb->s_dev;
355 __entry->dev = inode->i_sb->s_dev;
412 __entry->dev = inode->i_sb->s_dev;
460 __entry->dev = inode->i_sb->s_dev;
495 __entry->dev = inode->i_sb->s_dev;
579 __entry->dev = inode->i_sb->s_dev;
615 __entry->dev = inode->i_sb->s_dev;
646 __entry->dev = inode->i_sb->s_dev;
676 __entry->dev = inode->i_sb->s_dev;
703 __entry->dev = page->mapping->host->i_sb->s_dev;
805 __entry->dev = inode->i_sb->s_dev;
835 __entry->dev = inode->i_sb->s_dev;
866 __entry->dev = page->mapping->host->i_sb->s_dev;
960 __entry->dev = inode->i_sb->s_dev;
1084 __entry->dev = inode->i_sb->s_dev;
1113 __entry->dev = inode->i_sb->s_dev;
1144 __entry->dev = inode->i_sb->s_dev;
1194 __entry->dev = inode->i_sb->s_dev;
H A Dfilelock.h57 __entry->s_dev = inode->i_sb->s_dev;
/linux-4.1.27/fs/efs/
H A Dsymlink.c28 bh = sb_bread(inode->i_sb, efs_bmap(inode, 0)); efs_symlink_readpage()
34 bh = sb_bread(inode->i_sb, efs_bmap(inode, 1)); efs_symlink_readpage()
H A Dnamei.c32 bh = sb_bread(inode->i_sb, efs_bmap(inode, block)); efs_find_entry()
71 inode = efs_iget(dir->i_sb, inodenum); efs_lookup()
116 parent = d_obtain_alias(efs_iget(d_inode(child)->i_sb, ino)); efs_get_parent()
H A Dfile.c32 map_bh(bh_result, inode->i_sb, phys); efs_get_block()
H A Ddir.c44 bh = sb_bread(inode->i_sb, efs_bmap(inode, block)); efs_readdir()
H A Dinode.c90 bh = sb_bread(inode->i_sb, block); efs_iget()
198 struct efs_sb_info *sb = SUPER_INFO(inode->i_sb); efs_map_block()
277 bh = sb_bread(inode->i_sb, iblock); efs_map_block()
/linux-4.1.27/fs/affs/
H A Dsymlink.c27 bh = affs_bread(inode->i_sb, inode->i_ino); affs_symlink_readpage()
36 struct affs_sb_info *sbi = AFFS_SB(inode->i_sb); affs_symlink_readpage()
H A Dinode.c168 struct super_block *sb = inode->i_sb; affs_write_inode()
226 affs_test_opt(AFFS_SB(inode->i_sb)->s_flags, SF_SETUID)) || affs_notify_change()
228 affs_test_opt(AFFS_SB(inode->i_sb)->s_flags, SF_SETGID)) || affs_notify_change()
230 (AFFS_SB(inode->i_sb)->s_flags & affs_notify_change()
232 if (!affs_test_opt(AFFS_SB(inode->i_sb)->s_flags, SF_QUIET)) affs_notify_change()
284 affs_free_block(inode->i_sb, inode->i_ino); affs_evict_inode()
290 struct super_block *sb = dir->i_sb; affs_new_inode()
347 struct super_block *sb = dir->i_sb; affs_add_entry()
H A Dnamei.c190 struct super_block *sb = dir->i_sb; affs_find_entry()
219 struct super_block *sb = dir->i_sb; affs_lookup()
262 struct super_block *sb = dir->i_sb; affs_create()
331 struct super_block *sb = dir->i_sb; affs_symlink()
418 struct super_block *sb = old_dir->i_sb; affs_rename()
H A Dfile.c49 struct super_block *sb = inode->i_sb; affs_grow_extcache()
119 struct super_block *sb = inode->i_sb; affs_alloc_extblock()
171 struct super_block *sb = inode->i_sb; affs_get_extblock_slow()
296 struct super_block *sb = inode->i_sb; affs_get_block()
355 affs_error(inode->i_sb, "get_block", "strange block request %llu", affs_get_block()
452 bh = affs_bread(inode->i_sb, tmp_bh.b_blocknr); affs_bread_ino()
471 bh = affs_getzeroblk(inode->i_sb, tmp_bh.b_blocknr); affs_getzeroblk_ino()
490 bh = affs_getemptyblk(inode->i_sb, tmp_bh.b_blocknr); affs_getemptyblk_ino()
504 struct super_block *sb = inode->i_sb; affs_do_readpage_ofs()
541 struct super_block *sb = inode->i_sb; affs_extent_file_ofs()
673 struct super_block *sb = inode->i_sb; affs_write_end_ofs()
821 struct super_block *sb = inode->i_sb; affs_free_prealloc()
836 struct super_block *sb = inode->i_sb; affs_truncate()
963 err = sync_blockdev(inode->i_sb->s_bdev); affs_file_fsync()
H A Damigaffs.c25 struct super_block *sb = dir->i_sb; affs_insert_hash()
80 sb = dir->i_sb; affs_remove_hash()
142 struct super_block *sb = inode->i_sb; affs_remove_link()
233 struct super_block *sb = inode->i_sb; affs_empty_dir()
272 sb = dir->i_sb; affs_remove_header()
476 return affs_test_opt(AFFS_SB(inode->i_sb)->s_flags, SF_NO_TRUNCATE); affs_nofilenametruncate()
/linux-4.1.27/fs/bfs/
H A Ddir.c40 dir->i_sb->s_id, dir->i_ino); bfs_readdir()
47 bh = sb_bread(dir->i_sb, block); bfs_readdir()
83 struct super_block *s = dir->i_sb; bfs_create()
132 struct bfs_sb_info *info = BFS_SB(dir->i_sb); bfs_lookup()
142 inode = bfs_iget(dir->i_sb, ino); bfs_lookup()
157 struct bfs_sb_info *info = BFS_SB(inode->i_sb); bfs_link()
182 struct bfs_sb_info *info = BFS_SB(inode->i_sb); bfs_unlink()
191 inode->i_sb->s_id, inode->i_ino, bfs_unlink()
223 info = BFS_SB(old_inode->i_sb); bfs_rename()
294 bh = sb_bread(dir->i_sb, block); bfs_add_entry()
343 bh = sb_bread(dir->i_sb, BFS_I(dir)->i_sblock + block); bfs_find_entry()
H A Dinode.c47 if ((ino < BFS_ROOT_INO) || (ino > BFS_SB(inode->i_sb)->si_lasti)) { bfs_iget()
48 printf("Bad inode number %s:%08lx\n", inode->i_sb->s_id, ino); bfs_iget()
53 bh = sb_bread(inode->i_sb, block); bfs_iget()
55 printf("Unable to read inode %s:%08lx\n", inode->i_sb->s_id, bfs_iget()
119 struct bfs_sb_info *info = BFS_SB(inode->i_sb); bfs_write_inode()
128 di = find_inode(inode->i_sb, ino, &bh); bfs_write_inode()
168 struct super_block *s = inode->i_sb; bfs_evict_inode()
H A Dfile.c68 struct super_block *sb = inode->i_sb; bfs_get_block()
124 err = bfs_move_blocks(inode->i_sb, bi->i_sblock, bfs_get_block()
/linux-4.1.27/fs/sysv/
H A Ditree.c24 struct super_block *sb = inode->i_sb; block_to_path()
93 struct super_block *sb = inode->i_sb; get_branch()
129 int blocksize = inode->i_sb->s_blocksize; alloc_branch()
133 branch[0].key = sysv_new_block(inode->i_sb); alloc_branch()
138 branch[n].key = sysv_new_block(inode->i_sb); alloc_branch()
145 parent = block_to_cpu(SYSV_SB(inode->i_sb), branch[n-1].key); alloc_branch()
146 bh = sb_getblk(inode->i_sb, parent); alloc_branch()
163 sysv_free_block(inode->i_sb, branch[i].key); alloc_branch()
198 sysv_free_block(inode->i_sb, where[i].key); splice_branch()
207 struct super_block *sb = inode->i_sb; get_block()
331 sysv_free_block(inode->i_sb, nr); free_data()
340 struct super_block *sb = inode->i_sb; free_branches()
378 blocksize = inode->i_sb->s_blocksize; sysv_truncate()
380 >> inode->i_sb->s_blocksize_bits; sysv_truncate()
H A Dialloc.c102 struct super_block *sb = inode->i_sb; sysv_free_inode()
109 sb = inode->i_sb; sysv_free_inode()
118 "%s\n", inode->i_sb->s_id); sysv_free_inode()
137 struct super_block *sb = dir->i_sb; sysv_new_inode()
H A Ddir.c72 struct super_block *sb = inode->i_sb; sysv_readdir()
221 de->inode = cpu_to_fs16(SYSV_SB(inode->i_sb), inode->i_ino); sysv_add_link()
272 de->inode = cpu_to_fs16(SYSV_SB(inode->i_sb), inode->i_ino); sysv_make_empty()
275 de->inode = cpu_to_fs16(SYSV_SB(inode->i_sb), dir->i_ino); sysv_make_empty()
290 struct super_block *sb = inode->i_sb; sysv_empty_dir()
342 de->inode = cpu_to_fs16(SYSV_SB(inode->i_sb), inode->i_ino); sysv_set_link()
H A Dnamei.c55 inode = sysv_iget(dir->i_sb, ino); sysv_lookup()
94 if (l > dir->i_sb->s_blocksize) sysv_symlink()
H A Dinode.c201 inode->i_sb->s_id); sysv_iget()
239 struct super_block * sb = inode->i_sb; __sysv_write_inode()
250 inode->i_sb->s_id, ino); __sysv_write_inode()
/linux-4.1.27/fs/coda/
H A Dpioctl.c78 if (target_inode->i_sb != inode->i_sb) { coda_pioctl()
86 error = venus_pioctl(inode->i_sb, &(cnp->c_fid), cmd, &data); coda_pioctl()
H A Ddir.c42 struct super_block *sb = dir->i_sb; coda_lookup()
93 error = venus_access(inode->i_sb, coda_i2f(inode), mask); coda_permission()
146 error = venus_create(dir->i_sb, coda_i2f(dir), name, length, coda_create()
151 inode = coda_iget(dir->i_sb, &newfid, &attrs); coda_create()
179 error = venus_mkdir(dir->i_sb, coda_i2f(dir), coda_mkdir()
184 inode = coda_iget(dir->i_sb, &newfid, &attrs); coda_mkdir()
212 error = venus_link(dir_inode->i_sb, coda_i2f(inode), coda_link()
247 error = venus_symlink(dir_inode->i_sb, coda_i2f(dir_inode), name, len, coda_symlink()
264 error = venus_remove(dir->i_sb, coda_i2f(dir), name, len); coda_unlink()
279 error = venus_rmdir(dir->i_sb, coda_i2f(dir), name, len); coda_rmdir()
302 error = venus_rename(old_dir->i_sb, coda_i2f(old_dir), coda_rename()
520 error = venus_getattr(inode->i_sb, &(cii->c_fid), &attr); coda_revalidate_inode()
H A Dsymlink.c33 error = venus_readlink(inode->i_sb, &cii->c_fid, p, &len); coda_symlink_filler()
H A Dfile.c135 error = venus_open(coda_inode->i_sb, coda_i2f(coda_inode), coda_flags, coda_open()
168 err = venus_close(coda_inode->i_sb, coda_i2f(coda_inode), coda_release()
214 err = venus_fsync(coda_inode->i_sb, coda_i2f(coda_inode)); coda_fsync()
/linux-4.1.27/fs/fat/
H A Dfile.c32 struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb); fat_ioctl_set_attributes()
61 ia.ia_ctime = current_fs_time(inode->i_sb); fat_ioctl_set_attributes()
115 struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb); fat_ioctl_get_volume_id()
148 MSDOS_SB(inode->i_sb)->options.flush) { fat_file_release()
149 fat_flush_inodes(inode->i_sb, inode, NULL); fat_file_release()
161 err = sync_mapping_buffers(MSDOS_SB(inode->i_sb)->fat_inode->i_mapping); fat_file_fsync()
220 struct super_block *sb = inode->i_sb; fat_free()
289 struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb); fat_truncate_blocks()
303 fat_flush_inodes(inode->i_sb, inode, NULL); fat_truncate_blocks()
310 stat->blksize = MSDOS_SB(inode->i_sb)->cluster_size; fat_getattr()
312 if (MSDOS_SB(inode->i_sb)->options.nfs == FAT_NFS_NOSTALE_RO) { fat_getattr()
314 stat->ino = fat_i_pos_read(MSDOS_SB(inode->i_sb), inode); fat_getattr()
H A Dnamei_msdos.c120 struct msdos_sb_info *sbi = MSDOS_SB(dir->i_sb); msdos_find()
202 struct super_block *sb = dir->i_sb; msdos_lookup()
229 struct msdos_sb_info *sbi = MSDOS_SB(dir->i_sb); msdos_add_entry()
265 struct super_block *sb = dir->i_sb; msdos_create()
310 struct super_block *sb = dir->i_sb; msdos_rmdir()
346 struct super_block *sb = dir->i_sb; msdos_mkdir()
406 struct super_block *sb = inode->i_sb; msdos_unlink()
590 fat_fs_error(new_dir->i_sb, do_msdos_rename()
601 struct super_block *sb = old_dir->i_sb; msdos_rename()
609 &MSDOS_SB(old_dir->i_sb)->options); msdos_rename()
614 &MSDOS_SB(new_dir->i_sb)->options); msdos_rename()
H A Ddir.c50 struct super_block *sb = dir->i_sb; fat_dir_readahead()
83 struct super_block *sb = dir->i_sb; fat__get_entry()
123 MSDOS_SB(dir->i_sb)->dir_per_block - 1) { fat_get_entry()
465 struct super_block *sb = inode->i_sb; fat_search_long()
556 struct super_block *sb = inode->i_sb; __fat_readdir()
951 struct super_block *sb = dir->i_sb; fat_scan()
975 struct super_block *sb = dir->i_sb; fat_scan_logstart()
993 struct super_block *sb = dir->i_sb; __fat_remove_entries()
1028 struct super_block *sb = dir->i_sb; fat_remove_entries()
1081 struct super_block *sb = dir->i_sb; fat_zeroed_cluster()
1129 struct super_block *sb = dir->i_sb; fat_alloc_new_dir()
1193 struct super_block *sb = dir->i_sb; fat_add_new_entries()
1272 struct super_block *sb = dir->i_sb; fat_add_entries()
H A Dcache.c226 struct super_block *sb = inode->i_sb; fat_get_cluster()
287 struct super_block *sb = inode->i_sb; fat_bmap_cluster()
307 struct super_block *sb = inode->i_sb; fat_bmap()
H A Dfatent.c350 struct super_block *sb = inode->i_sb; fat_ent_read()
351 struct msdos_sb_info *sbi = MSDOS_SB(inode->i_sb); fat_ent_read()
409 struct super_block *sb = inode->i_sb; fat_ent_write()
464 struct super_block *sb = inode->i_sb; fat_alloc_clusters()
552 struct super_block *sb = inode->i_sb; fat_free_clusters()
/linux-4.1.27/fs/qnx6/
H A Dnamei.c29 foundinode = qnx6_iget(dir->i_sb, ino); qnx6_lookup()
H A Ddir.c72 struct super_block *s = inode->i_sb; qnx6_dir_longfilename()
119 struct super_block *s = inode->i_sb; qnx6_readdir()
182 struct super_block *s = dir->i_sb; qnx6_long_match()
220 struct super_block *s = dir->i_sb; qnx6_find_entry()
/linux-4.1.27/fs/squashfs/
H A Dfile_cache.c26 struct squashfs_cache_entry *buffer = squashfs_get_datablock(i->i_sb, squashfs_readpage_block()
H A Dfile.c64 struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info; locate_meta_index()
102 struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info; empty_meta_index()
162 struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info; release_meta_index()
239 struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info; fill_meta_index()
285 long long res = read_indexes(inode->i_sb, blocks, fill_meta_index()
357 blks = read_indexes(inode->i_sb, index - res, &start, &offset); read_blocklist()
366 res = squashfs_read_metadata(inode->i_sb, &size, &start, &offset, read_blocklist()
378 struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info; squashfs_copy_cache()
422 struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info; squashfs_readpage_fragment()
423 struct squashfs_cache_entry *buffer = squashfs_get_fragment(inode->i_sb, squashfs_readpage_fragment()
444 struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info; squashfs_readpage_sparse()
456 struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info; squashfs_readpage()
H A Dnamei.c145 struct squashfs_sb_info *msblk = dir->i_sb->s_fs_info; squashfs_lookup()
166 length = get_dir_index_using_name(dir->i_sb, &block, &offset, squashfs_lookup()
175 err = squashfs_read_metadata(dir->i_sb, &dirh, &block, squashfs_lookup()
191 err = squashfs_read_metadata(dir->i_sb, dire, &block, squashfs_lookup()
202 err = squashfs_read_metadata(dir->i_sb, dire->name, squashfs_lookup()
225 inode = squashfs_iget(dir->i_sb, ino, ino_num); squashfs_lookup()
H A Ddir.c113 struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info; squashfs_readdir()
157 length = get_dir_index_using_offset(inode->i_sb, &block, &offset, squashfs_readdir()
167 err = squashfs_read_metadata(inode->i_sb, &dirh, &block, squashfs_readdir()
183 err = squashfs_read_metadata(inode->i_sb, dire, &block, squashfs_readdir()
194 err = squashfs_read_metadata(inode->i_sb, dire->name, squashfs_readdir()
H A Dfile_direct.c31 struct squashfs_sb_info *msblk = inode->i_sb->s_fs_info; squashfs_readpage_block()
94 res = squashfs_read_data(inode->i_sb, block, bsize, NULL, actor); squashfs_readpage_block()
144 struct squashfs_cache_entry *buffer = squashfs_get_datablock(i->i_sb, squashfs_read_cache()
H A Dsymlink.c49 struct super_block *sb = inode->i_sb; squashfs_symlink_readpage()
/linux-4.1.27/fs/f2fs/
H A Dtrace.c76 MAJOR(inode->i_sb->s_dev), MINOR(inode->i_sb->s_dev), f2fs_trace_pid()
97 major = MAJOR(inode->i_sb->s_dev); f2fs_trace_ios()
98 minor = MINOR(inode->i_sb->s_dev); f2fs_trace_ios()
H A Dfile.c43 sb_start_pagefault(inode->i_sb); f2fs_vm_page_mkwrite()
88 sb_end_pagefault(inode->i_sb); f2fs_vm_page_mkwrite()
186 if (unlikely(f2fs_readonly(inode->i_sb))) f2fs_sync_file()
237 ret = f2fs_sync_fs(inode->i_sb, 1); f2fs_sync_file()
316 loff_t maxbytes = inode->i_sb->s_maxbytes; f2fs_seek_block()
388 loff_t maxbytes = inode->i_sb->s_maxbytes; f2fs_llseek()
493 unsigned int blocksize = inode->i_sb->s_blocksize; truncate_blocks()
595 inode->i_sb->s_time_gran); __setattr_copy()
598 inode->i_sb->s_time_gran); __setattr_copy()
601 inode->i_sb->s_time_gran); __setattr_copy()
1085 struct super_block *sb = inode->i_sb; f2fs_ioc_fitrim()
H A Dinode.c107 f2fs_msg(inode->i_sb, KERN_ERR, "bad inode number: %lu", do_read_inode()
333 sb_start_intwrite(inode->i_sb); f2fs_evict_inode()
344 sb_end_intwrite(inode->i_sb); f2fs_evict_inode()
/linux-4.1.27/fs/ocfs2/
H A Dmove_extents.c65 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); __ocfs2_move_extent()
70 u64 old_blkno = ocfs2_clusters_to_blocks(inode->i_sb, p_cpos); __ocfs2_move_extent()
82 replace_rec.e_blkno = cpu_to_le64(ocfs2_clusters_to_blocks(inode->i_sb, __ocfs2_move_extent()
102 ocfs2_error(inode->i_sb, __ocfs2_move_extent()
178 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_lock_allocators_move_extents()
233 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_defrag_extent()
237 u64 phys_blkno = ocfs2_clusters_to_blocks(inode->i_sb, phys_cpos); ocfs2_defrag_extent()
335 ret = ocfs2_cow_sync_writeback(inode->i_sb, context->inode, cpos, *len); ocfs2_defrag_extent()
375 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_find_victim_alloc_group()
402 inode->i_sb->s_blocksize_bits; ocfs2_find_victim_alloc_group()
476 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_validate_and_adjust_move_goal()
478 inode->i_sb->s_blocksize_bits); ocfs2_validate_and_adjust_move_goal()
483 range->me_goal = ocfs2_block_to_cluster_start(inode->i_sb, ocfs2_validate_and_adjust_move_goal()
532 u32 base_cpos = ocfs2_blocks_to_clusters(inode->i_sb, ocfs2_probe_alloc_group()
572 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_move_extent()
579 u32 move_max_hop = ocfs2_blocks_to_clusters(inode->i_sb, ocfs2_move_extent()
583 phys_blkno = ocfs2_clusters_to_blocks(inode->i_sb, phys_cpos); ocfs2_move_extent()
654 new_phys_blkno = ocfs2_clusters_to_blocks(inode->i_sb, *new_phys_cpos); ocfs2_move_extent()
704 ret = ocfs2_cow_sync_writeback(inode->i_sb, context->inode, cpos, len); ocfs2_move_extent()
773 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); __ocfs2_move_extents_range()
812 new_phys_cpos = ocfs2_blocks_to_clusters(inode->i_sb, __ocfs2_move_extents_range()
905 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_move_extents()
H A Dextent_map.c236 ins.ei_phys = ocfs2_blocks_to_clusters(inode->i_sb, ocfs2_extent_map_insert_rec()
307 ocfs2_error(inode->i_sb, ocfs2_last_eb_is_empty()
443 ocfs2_error(inode->i_sb, ocfs2_get_clusters_nocache()
478 ocfs2_error(inode->i_sb, "Inode %lu has bad extent " ocfs2_get_clusters_nocache()
566 ocfs2_error(inode->i_sb, ocfs2_xattr_get_clusters()
585 ocfs2_error(inode->i_sb, "Inode %lu has bad extent " ocfs2_xattr_get_clusters()
593 *p_cluster = ocfs2_blocks_to_clusters(inode->i_sb, ocfs2_xattr_get_clusters()
652 ocfs2_relative_extent_offsets(inode->i_sb, v_cluster, &rec, ocfs2_get_clusters()
675 int bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1); ocfs2_extent_map_get_blocks()
679 cpos = ocfs2_blocks_to_clusters(inode->i_sb, v_blkno); ocfs2_extent_map_get_blocks()
692 boff = ocfs2_clusters_to_blocks(inode->i_sb, p_cluster); ocfs2_extent_map_get_blocks()
699 *ret_count = ocfs2_clusters_to_blocks(inode->i_sb, num_clusters); ocfs2_extent_map_get_blocks()
726 id_count = ocfs2_fast_symlink_chars(inode->i_sb); ocfs2_fiemap_inline()
731 phys = oi->ip_blkno << inode->i_sb->s_blocksize_bits; ocfs2_fiemap_inline()
755 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_fiemap()
782 mapping_end = ocfs2_clusters_for_bytes(inode->i_sb, ocfs2_fiemap()
838 u16 cs_bits = OCFS2_SB(inode->i_sb)->s_clustersize_bits; ocfs2_seek_data_hole_offset()
867 cend = ocfs2_clusters_for_bytes(inode->i_sb, i_size_read(inode)); ocfs2_seek_data_hole_offset()
940 if (((v_block + nr - 1) << inode->i_sb->s_blocksize_bits) >= ocfs2_read_virt_blocks()
962 inode->i_sb->s_blocksize_bits); ocfs2_read_virt_blocks()
H A Dxattr.c91 #define OCFS2_XATTR_FREE_IN_BLOCK(ptr) ((ptr)->i_sb->s_blocksize \
333 int blks = ocfs2_blocks_per_xattr_bucket(inode->i_sb); ocfs2_xattr_bucket_new()
377 bucket->bu_bhs[i] = sb_getblk(bucket->bu_inode->i_sb, ocfs2_init_xattr_bucket()
413 spin_lock(&OCFS2_SB(bucket->bu_inode->i_sb)->osb_xattr_lock); ocfs2_read_xattr_bucket()
414 rc = ocfs2_validate_meta_ecc_bhs(bucket->bu_inode->i_sb, ocfs2_read_xattr_bucket()
418 spin_unlock(&OCFS2_SB(bucket->bu_inode->i_sb)->osb_xattr_lock); ocfs2_read_xattr_bucket()
452 spin_lock(&OCFS2_SB(bucket->bu_inode->i_sb)->osb_xattr_lock); ocfs2_xattr_bucket_journal_dirty()
453 ocfs2_compute_meta_ecc_bhs(bucket->bu_inode->i_sb, ocfs2_xattr_bucket_journal_dirty()
456 spin_unlock(&OCFS2_SB(bucket->bu_inode->i_sb)->osb_xattr_lock); ocfs2_xattr_bucket_journal_dirty()
466 int blocksize = src->bu_inode->i_sb->s_blocksize; ocfs2_xattr_bucket_copy_data()
562 u32 hash = OCFS2_SB(inode->i_sb)->uuid_hash; ocfs2_xattr_name_hash()
600 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb); ocfs2_calc_security_init()
609 if (dir->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE || ocfs2_calc_security_init()
621 int new_clusters = ocfs2_clusters_for_bytes(dir->i_sb, ocfs2_calc_security_init()
624 *xattr_credits += ocfs2_clusters_to_blocks(dir->i_sb, ocfs2_calc_security_init()
640 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb); ocfs2_calc_xattr_init()
676 if (dir->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE || ocfs2_calc_xattr_init()
683 if (dir->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE && ocfs2_calc_xattr_init()
686 *xattr_credits += ocfs2_blocks_per_xattr_bucket(dir->i_sb); ocfs2_calc_xattr_init()
694 new_clusters = ocfs2_clusters_for_bytes(dir->i_sb, ocfs2_calc_xattr_init()
696 *xattr_credits += ocfs2_clusters_to_blocks(dir->i_sb, ocfs2_calc_xattr_init()
704 ocfs2_clusters_for_bytes(dir->i_sb, acl_len); ocfs2_calc_xattr_init()
705 *xattr_credits += ocfs2_clusters_to_blocks(dir->i_sb, ocfs2_calc_xattr_init()
763 credits = ocfs2_calc_extend_credits(inode->i_sb, ocfs2_xattr_extend_allocation()
784 u64 phys_blkno = ocfs2_clusters_to_blocks(inode->i_sb, phys_cpos); __ocfs2_remove_xattr_range()
809 ocfs2_blocks_to_clusters(inode->i_sb, __ocfs2_remove_xattr_range()
858 block = ocfs2_clusters_to_blocks(inode->i_sb, phys_cpos); ocfs2_xattr_shrink_size()
875 u32 new_clusters = ocfs2_clusters_for_bytes(inode->i_sb, len); ocfs2_xattr_value_truncate()
952 ((void *)di + inode->i_sb->s_blocksize - ocfs2_has_inline_xattr_value_outside()
975 ((void *)di + inode->i_sb->s_blocksize - ocfs2_xattr_ibody_list()
1105 bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1); ocfs2_xattr_get_value_outside()
1106 blocksize = inode->i_sb->s_blocksize; ocfs2_xattr_get_value_outside()
1117 blkno = ocfs2_clusters_to_blocks(inode->i_sb, p_cluster); ocfs2_xattr_get_value_outside()
1159 xs->end = (void *)di + inode->i_sb->s_blocksize; ocfs2_xattr_ibody_get()
1236 ret = ocfs2_xattr_bucket_get_name_value(inode->i_sb, ocfs2_xattr_block_get()
1287 if (!ocfs2_supports_xattr(OCFS2_SB(inode->i_sb))) ocfs2_xattr_get_nolock()
1343 u16 blocksize = inode->i_sb->s_blocksize; __ocfs2_xattr_set_value_outside()
1345 u32 cpos = 0, bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1); __ocfs2_xattr_set_value_outside()
1346 u32 clusters = ocfs2_clusters_for_bytes(inode->i_sb, value_len); __ocfs2_xattr_set_value_outside()
1365 blkno = ocfs2_clusters_to_blocks(inode->i_sb, p_cluster); __ocfs2_xattr_set_value_outside()
1716 block = offset >> loc->xl_inode->i_sb->s_blocksize_bits; ocfs2_xa_bucket_offset_pointer()
1717 block_offset = offset % loc->xl_inode->i_sb->s_blocksize; ocfs2_xa_bucket_offset_pointer()
1757 struct super_block *sb = loc->xl_inode->i_sb; ocfs2_xa_bucket_check_space()
1839 struct super_block *sb = loc->xl_inode->i_sb; ocfs2_xa_bucket_add_namevalue()
1854 struct super_block *sb = loc->xl_inode->i_sb; ocfs2_xa_bucket_fill_value_buf()
2342 ret = ocfs2_reserve_new_metadata_blocks(OCFS2_SB(inode->i_sb), ocfs2_lock_xattr_remove_allocators()
2358 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_remove_value_outside()
2425 ((void *)di + inode->i_sb->s_blocksize - ocfs2_xattr_ibody_remove()
2478 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_xattr_free_block()
2559 if (!ocfs2_supports_xattr(OCFS2_SB(inode->i_sb))) ocfs2_xattr_remove()
2566 ret = ocfs2_lock_refcount_tree(OCFS2_SB(inode->i_sb), ocfs2_xattr_remove()
2596 handle = ocfs2_start_trans((OCFS2_SB(inode->i_sb)), ocfs2_xattr_remove()
2620 ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle); ocfs2_xattr_remove()
2623 ocfs2_unlock_refcount_tree(OCFS2_SB(inode->i_sb), ref_tree, 1); ocfs2_xattr_remove()
2632 unsigned int xattrsize = OCFS2_SB(inode->i_sb)->s_xattr_inline_size; ocfs2_xattr_has_space_inline()
2642 free = ocfs2_fast_symlink_chars(inode->i_sb) - ocfs2_xattr_has_space_inline()
2672 if (inode->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE) ocfs2_xattr_ibody_find()
2684 xs->end = (void *)di + inode->i_sb->s_blocksize; ocfs2_xattr_ibody_find()
2690 (xs->end - OCFS2_SB(inode->i_sb)->s_xattr_inline_size); ocfs2_xattr_ibody_find()
2712 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_xattr_ibody_init()
2767 if (inode->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE) ocfs2_xattr_ibody_set()
2878 new_bh = sb_getblk(inode->i_sb, first_blkno); ocfs2_create_xattr_block()
2897 memset(xblk, 0, inode->i_sb->s_blocksize); ocfs2_create_xattr_block()
2903 cpu_to_le32(OCFS2_SB(inode->i_sb)->fs_generation); ocfs2_create_xattr_block()
2911 ocfs2_xattr_recs_per_xb(inode->i_sb)); ocfs2_create_xattr_block()
2963 xs->end = (void *)xblk + inode->i_sb->s_blocksize; ocfs2_xattr_block_set()
3041 u32 new_clusters = ocfs2_clusters_for_bytes(inode->i_sb, ocfs2_calc_xattr_set_need()
3052 ocfs2_clusters_to_blocks(inode->i_sb, 1); ocfs2_calc_xattr_set_need()
3055 credits += ocfs2_blocks_per_xattr_bucket(inode->i_sb); ocfs2_calc_xattr_set_need()
3059 credits += ocfs2_calc_extend_credits(inode->i_sb, ocfs2_calc_xattr_set_need()
3082 ret = ocfs2_xattr_bucket_get_name_value(inode->i_sb, ocfs2_calc_xattr_set_need()
3087 credits += ocfs2_blocks_per_xattr_bucket(inode->i_sb); ocfs2_calc_xattr_set_need()
3103 credits += ocfs2_remove_extent_credits(inode->i_sb); ocfs2_calc_xattr_set_need()
3120 credits += ocfs2_remove_extent_credits(inode->i_sb) + ocfs2_calc_xattr_set_need()
3124 inode->i_sb, ocfs2_calc_xattr_set_need()
3135 old_clusters = ocfs2_clusters_for_bytes(inode->i_sb, ocfs2_calc_xattr_set_need()
3144 credits += ocfs2_remove_extent_credits(inode->i_sb); ocfs2_calc_xattr_set_need()
3149 credits += ocfs2_calc_extend_credits(inode->i_sb, ocfs2_calc_xattr_set_need()
3195 credits += ocfs2_calc_extend_credits(inode->i_sb, ocfs2_calc_xattr_set_need()
3208 credits += ocfs2_blocks_per_xattr_bucket(inode->i_sb); ocfs2_calc_xattr_set_need()
3210 OCFS2_SB(inode->i_sb)->s_clustersize) { ocfs2_calc_xattr_set_need()
3211 credits += ocfs2_blocks_per_xattr_bucket(inode->i_sb); ocfs2_calc_xattr_set_need()
3219 credits += ocfs2_calc_extend_credits(inode->i_sb, ocfs2_calc_xattr_set_need()
3246 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_init_xattr_set_ctxt()
3469 if (!ocfs2_supports_xattr(OCFS2_SB(inode->i_sb))) ocfs2_xattr_set_handle()
3477 if (inode->i_sb->s_blocksize == OCFS2_MIN_BLOCKSIZE) { ocfs2_xattr_set_handle()
3526 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_xattr_set()
3547 if (!ocfs2_supports_xattr(OCFS2_SB(inode->i_sb))) ocfs2_xattr_set()
3697 ocfs2_error(inode->i_sb, ocfs2_xattr_get_rec()
3716 ocfs2_error(inode->i_sb, "Inode %lu has bad extent " ocfs2_xattr_get_rec()
3769 ret = ocfs2_xattr_bucket_get_name_value(inode->i_sb, ocfs2_find_xe_in_bucket()
3814 u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb); ocfs2_xattr_bucket_find()
3899 xs->end = xs->base + inode->i_sb->s_blocksize; ocfs2_xattr_bucket_find()
3966 u32 bpc = ocfs2_xattr_buckets_per_cluster(OCFS2_SB(inode->i_sb)); ocfs2_iterate_xattr_buckets()
4052 ret = ocfs2_xattr_bucket_get_name_value(inode->i_sb, ocfs2_list_xattr_bucket()
4182 int i, blocksize = inode->i_sb->s_blocksize; ocfs2_cp_xattr_block_to_bucket()
4183 int blks = ocfs2_blocks_per_xattr_bucket(inode->i_sb); ocfs2_cp_xattr_block_to_bucket()
4257 xs->end = xs->base + inode->i_sb->s_blocksize; ocfs2_xattr_update_xattr_search()
4313 blkno = ocfs2_clusters_to_blocks(inode->i_sb, bit_off); ocfs2_xattr_create_index_block()
4336 memset(&xb->xb_attrs, 0, inode->i_sb->s_blocksize - ocfs2_xattr_create_index_block()
4343 xr->xt_list.l_count = cpu_to_le16(ocfs2_xattr_recs_per_xb(inode->i_sb)); ocfs2_xattr_create_index_block()
4389 size_t blocksize = inode->i_sb->s_blocksize; ocfs2_defrag_xattr_bucket()
4510 struct super_block *sb = inode->i_sb; ocfs2_mv_xattr_bucket_cross_cluster()
4631 int blocksize = inode->i_sb->s_blocksize; ocfs2_divide_xattr_bucket()
4876 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_mv_xattr_buckets()
4877 int blks_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb); ocfs2_mv_xattr_buckets()
4979 u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb); ocfs2_divide_xattr_cluster()
4982 BUG_ON(OCFS2_XATTR_BUCKET_SIZE < OCFS2_SB(inode->i_sb)->s_clustersize); ocfs2_divide_xattr_cluster()
5036 if (ocfs2_xattr_buckets_per_cluster(OCFS2_SB(inode->i_sb)) > 1) { ocfs2_adjust_xattr_cross_cluster()
5049 ocfs2_clusters_to_blocks(inode->i_sb, 1)); ocfs2_adjust_xattr_cross_cluster()
5099 u16 bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1); ocfs2_add_new_xattr_cluster()
5104 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_add_new_xattr_cluster()
5194 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_extend_xattr_bucket()
5195 u16 blk_per_bucket = ocfs2_blocks_per_xattr_bucket(inode->i_sb); ocfs2_extend_xattr_bucket()
5274 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_add_new_xattr_bucket()
5358 size_t blocksize = inode->i_sb->s_blocksize; ocfs2_xattr_bucket_value_truncate()
5419 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_rm_xattr_cluster()
5655 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_delete_xattr_in_bucket()
5658 ocfs2_blocks_per_xattr_bucket(inode->i_sb); ocfs2_delete_xattr_in_bucket()
5670 ret = ocfs2_get_xattr_tree_value_root(inode->i_sb, bucket, ocfs2_delete_xattr_in_bucket()
5771 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_prepare_refcount_xattr()
5792 ret = ocfs2_xattr_bucket_get_name_value(inode->i_sb, ocfs2_prepare_refcount_xattr()
5977 (fe_bh->b_data + inode->i_sb->s_blocksize - ocfs2_xattr_inline_attach_refcount()
6052 if (ocfs2_meta_ecc(OCFS2_SB(inode->i_sb))) ocfs2_xattr_bucket_value_refcount()
6064 ret = ocfs2_get_xattr_tree_value_root(inode->i_sb, bucket, i, ocfs2_xattr_bucket_value_refcount()
6344 struct super_block *sb = args->old_inode->i_sb; ocfs2_reflink_xattr_header()
6431 args->old_inode->i_sb, ocfs2_reflink_xattr_header()
6462 struct ocfs2_super *osb = OCFS2_SB(args->old_inode->i_sb); ocfs2_reflink_xattr_inline()
6546 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_create_empty_xattr_block()
6584 struct ocfs2_super *osb = OCFS2_SB(args->new_inode->i_sb); ocfs2_reflink_xattr_block()
6729 return ocfs2_value_metas_in_xattr_header(inode->i_sb, bucket->bu_bhs[0], ocfs2_calc_value_tree_metas()
6750 struct ocfs2_super *osb = OCFS2_SB(args->reflink->old_inode->i_sb); ocfs2_lock_reflink_xattr_rec_allocators()
6835 struct super_block *sb = args->reflink->old_inode->i_sb; ocfs2_reflink_xattr_bucket()
6931 ocfs2_xattr_buckets_per_cluster(OCFS2_SB(inode->i_sb)); ocfs2_reflink_xattr_buckets()
6949 new_blkno = ocfs2_clusters_to_blocks(inode->i_sb, p_cluster); ocfs2_reflink_xattr_buckets()
6979 blkno += ocfs2_clusters_to_blocks(inode->i_sb, num_clusters); ocfs2_reflink_xattr_buckets()
7000 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_reflink_xattr_rec()
7139 ret = ocfs2_lock_refcount_tree(OCFS2_SB(old_inode->i_sb), ocfs2_reflink_xattrs()
7186 ocfs2_unlock_refcount_tree(OCFS2_SB(old_inode->i_sb), ocfs2_reflink_xattrs()
7191 ocfs2_schedule_truncate_log_flush(OCFS2_SB(old_inode->i_sb), 1); ocfs2_reflink_xattrs()
7192 ocfs2_run_deallocs(OCFS2_SB(old_inode->i_sb), &dealloc); ocfs2_reflink_xattrs()
7292 if (!ocfs2_supports_xattr(OCFS2_SB(dir->i_sb))) ocfs2_init_security_get()
H A Dresize.c65 blkno = ocfs2_backup_super_blkno(inode->i_sb, i); ocfs2_calc_new_backup_super()
66 cluster = ocfs2_blocks_to_clusters(inode->i_sb, blkno); ocfs2_calc_new_backup_super()
94 struct ocfs2_super *osb = OCFS2_SB(bm_inode->i_sb); ocfs2_update_last_group_and_inode()
184 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); update_backups()
188 blkno = ocfs2_backup_super_blkno(inode->i_sb, i); update_backups()
189 cluster = ocfs2_blocks_to_clusters(inode->i_sb, blkno); update_backups()
199 memcpy(backup->b_data, data, inode->i_sb->s_blocksize); update_backups()
223 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_update_super_and_backups()
273 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_group_extend()
386 ret = ocfs2_check_group_descriptor(inode->i_sb, di, group_bh); ocfs2_check_new_group()
422 u32 cluster = ocfs2_blocks_to_clusters(inode->i_sb, input->group); ocfs2_verify_group_and_input()
460 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_group_add()
H A Dfile.c86 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_free_file_private()
179 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_sync_file()
205 ret = blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, NULL); ocfs2_sync_file()
220 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_should_update_atime()
226 ((inode->i_sb->s_flags & MS_NODIRATIME) && S_ISDIR(inode->i_mode))) ocfs2_should_update_atime()
263 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_update_inode_atime()
293 ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle); ocfs2_update_inode_atime()
324 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_simple_size_update()
350 u32 phys, cpos = offset >> OCFS2_SB(inode->i_sb)->s_clustersize_bits; ocfs2_cow_file_pos()
359 if ((offset & (OCFS2_SB(inode->i_sb)->s_clustersize - 1)) == 0) ocfs2_cow_file_pos()
419 cluster_bytes = ocfs2_align_bytes_to_clusters(inode->i_sb, new_i_size); ocfs2_orphan_for_truncate()
450 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_truncate_file()
573 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); __ocfs2_extend_allocation()
726 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_zero_start_ordered_transaction()
853 ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle); ocfs2_write_zero_page()
878 zero_start >> OCFS2_SB(inode->i_sb)->s_clustersize_bits; ocfs2_zero_extend_get_range()
879 u32 last_cpos = ocfs2_clusters_for_bytes(inode->i_sb, zero_end); ocfs2_zero_extend_get_range()
932 *range_start = ocfs2_clusters_to_bytes(inode->i_sb, zero_cpos); ocfs2_zero_extend_get_range()
933 *range_end = ocfs2_clusters_to_bytes(inode->i_sb, ocfs2_zero_extend_get_range()
983 struct super_block *sb = inode->i_sb; ocfs2_zero_extend()
1032 clusters_to_add = ocfs2_clusters_for_bytes(inode->i_sb, new_i_size); ocfs2_extend_no_holes()
1104 if (ocfs2_sparse_alloc(OCFS2_SB(inode->i_sb))) ocfs2_extend_file()
1130 struct super_block *sb = inode->i_sb; ocfs2_setattr()
1279 struct super_block *sb = d_inode(dentry)->i_sb; ocfs2_getattr()
1325 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); __ocfs2_write_remove_suid()
1372 struct super_block *sb = inode->i_sb; ocfs2_check_range_for_holes()
1454 cpos = start >> OCFS2_SB(inode->i_sb)->s_clustersize_bits; ocfs2_allocate_unwritten_extents()
1455 clusters = ocfs2_clusters_for_bytes(inode->i_sb, start + len); ocfs2_allocate_unwritten_extents()
1507 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_truncate_cluster_pages()
1511 start = (loff_t)ocfs2_align_bytes_to_clusters(inode->i_sb, byte_start); ocfs2_truncate_cluster_pages()
1526 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_zero_partial_clusters()
1655 ocfs2_clusters_to_blocks(inode->i_sb, coff); ocfs2_calc_trunc_pos()
1679 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_remove_inode_range()
1775 ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb, ocfs2_remove_inode_range()
1809 phys_cpos = ocfs2_blocks_to_clusters(inode->i_sb, blkno); ocfs2_remove_inode_range()
1845 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); __ocfs2_change_file_space()
1848 unsigned long long max_off = inode->i_sb->s_maxbytes; __ocfs2_change_file_space()
1980 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_change_file_space()
2008 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_fallocate()
2038 struct super_block *sb = inode->i_sb; ocfs2_check_range_for_refcount()
2040 if (!ocfs2_refcount_tree(OCFS2_SB(inode->i_sb)) || ocfs2_check_range_for_refcount()
2073 int blockmask = inode->i_sb->s_blocksize - 1; ocfs2_is_io_unaligned()
2088 u32 cpos = pos >> OCFS2_SB(inode->i_sb)->s_clustersize_bits; ocfs2_prepare_inode_for_refcount()
2090 ocfs2_clusters_for_bytes(inode->i_sb, pos + count) - cpos; ocfs2_prepare_inode_for_refcount()
2119 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_prepare_inode_for_write()
2262 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_file_write_iter()
2592 offset = vfs_setpos(file, offset, inode->i_sb->s_maxbytes); ocfs2_file_llseek()
H A Daops.c64 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_symlink_get_block()
73 if ((iblock << inode->i_sb->s_blocksize_bits) > PATH_MAX + 1) { ocfs2_symlink_get_block()
86 if ((u64)iblock >= ocfs2_clusters_to_blocks(inode->i_sb, ocfs2_symlink_get_block()
126 map_bh(bh_result, inode->i_sb, ocfs2_symlink_get_block()
144 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_get_block()
190 map_bh(bh_result, inode->i_sb, p_blkno); ocfs2_get_block()
208 past_eof = ocfs2_blocks_for_bytes(inode->i_sb, i_size_read(inode)); ocfs2_get_block()
230 ocfs2_error(inode->i_sb, "Inode %llu lost inline data flag", ocfs2_read_inline_data()
238 size > ocfs2_max_inline_data_with_xattr(inode->i_sb, di)) { ocfs2_read_inline_data()
239 ocfs2_error(inode->i_sb, ocfs2_read_inline_data()
523 unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits; ocfs2_direct_IO_get_blocks()
528 cpos = ocfs2_blocks_to_clusters(inode->i_sb, iblock); ocfs2_direct_IO_get_blocks()
534 inode_blocks = ocfs2_blocks_for_bytes(inode->i_sb, i_size_read(inode)); ocfs2_direct_IO_get_blocks()
562 clusters_to_alloc = ocfs2_clusters_for_bytes(inode->i_sb, len); ocfs2_direct_IO_get_blocks()
591 map_bh(bh_result, inode->i_sb, p_blkno); ocfs2_direct_IO_get_blocks()
723 clusters_to_add = ocfs2_bytes_to_clusters(inode->i_sb, offset) - ocfs2_direct_IO_extend_no_holes()
724 ocfs2_bytes_to_clusters(inode->i_sb, i_size_read(inode)); ocfs2_direct_IO_extend_no_holes()
788 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_direct_IO_write()
836 if (ocfs2_sparse_alloc(OCFS2_SB(inode->i_sb))) ocfs2_direct_IO_write()
858 written = __blockdev_direct_IO(iocb, inode, inode->i_sb->s_bdev, iter, ocfs2_direct_IO_write()
953 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_direct_IO()
971 return __blockdev_direct_IO(iocb, inode, inode->i_sb->s_bdev, ocfs2_direct_IO()
1049 if (ocfs2_sparse_alloc(OCFS2_SB(inode->i_sb))) ocfs2_should_read_blk()
1102 map_bh(bh, inode->i_sb, *p_blkno); ocfs2_map_page_blocks()
1390 ocfs2_figure_cluster_boundaries(OCFS2_SB(inode->i_sb), cpos, ocfs2_prepare_page_for_write()
1451 ocfs2_clear_page_regions(page, OCFS2_SB(inode->i_sb), ocfs2_prepare_page_for_write()
1484 wc->w_num_pages = ocfs2_pages_per_cluster(inode->i_sb); ocfs2_grab_pages_for_write()
1485 start = ocfs2_align_clusters_to_page_index(inode->i_sb, cpos); ocfs2_grab_pages_for_write()
1568 ret = ocfs2_add_inode_data(OCFS2_SB(inode->i_sb), inode, ocfs2_write_cluster()
1601 v_blkno = ocfs2_clusters_to_blocks(inode->i_sb, cpos); ocfs2_write_cluster()
1603 v_blkno = user_pos >> inode->i_sb->s_blocksize_bits; ocfs2_write_cluster()
1656 struct ocfs2_super *osb = OCFS2_SB(mapping->host->i_sb); ocfs2_write_cluster_by_desc()
1837 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_write_begin_inline()
1941 end > ocfs2_max_inline_data_with_xattr(inode->i_sb, di)) ocfs2_try_to_write_inline_data()
1977 BUG_ON(ocfs2_sparse_alloc(OCFS2_SB(inode->i_sb))); ocfs2_expand_nonsparse_inode()
1987 ocfs2_clusters_for_bytes(inode->i_sb, i_size_read(inode)); ocfs2_expand_nonsparse_inode()
1997 BUG_ON(!ocfs2_sparse_alloc(OCFS2_SB(inode->i_sb))); ocfs2_zero_tail()
2051 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_write_begin_nolock()
2145 credits = ocfs2_calc_extend_credits(inode->i_sb, ocfs2_write_begin_nolock()
2342 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_write_end_nolock()
H A Dacl.c184 handle = ocfs2_start_trans(OCFS2_SB(inode->i_sb), ocfs2_acl_set_mode()
214 ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle); ocfs2_acl_set_mode()
297 osb = OCFS2_SB(inode->i_sb); ocfs2_iop_get_acl()
314 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_acl_chmod()
348 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_init_acl()
H A Dlocks.c113 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_flock()
133 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_lock()
H A Dioctl.c83 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_set_inode_attr()
153 oib.ib_blocksize = inode->i_sb->s_blocksize; ocfs2_info_handle_blocksize()
167 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_info_handle_clustersize()
186 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_info_handle_maxslots()
205 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_info_handle_label()
224 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_info_handle_uuid()
243 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_info_handle_fs_features()
264 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_info_handle_journal_size()
335 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_info_handle_freeinode()
625 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_info_handle_freefrag()
928 struct super_block *sb = inode->i_sb; ocfs2_ioctl()
H A Ddir.c90 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb); ocfs2_supports_dir_trailer()
108 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb); ocfs2_new_dir_wants_trailer()
157 trailer = ocfs2_trailer_from_bh(bh, inode->i_sb); ocfs2_init_dir_trailer()
184 trailer = ocfs2_trailer_from_bh(dirdata_bh, dir->i_sb); ocfs2_dx_dir_link_trailer()
273 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb); ocfs2_dx_dir_name_hash()
331 ((char *) de - bh->b_data) + rlen > dir->i_sb->s_blocksize)) ocfs2_check_dir_entry()
481 trailer = ocfs2_trailer_from_bh(bh, dir->i_sb); ocfs2_check_dir_trailer()
484 ocfs2_error(dir->i_sb, ocfs2_check_dir_trailer()
493 ocfs2_error(dir->i_sb, ocfs2_check_dir_trailer()
503 ocfs2_error(dir->i_sb, ocfs2_check_dir_trailer()
707 sb = dir->i_sb; ocfs2_find_entry_el()
815 ocfs2_error(inode->i_sb, ocfs2_dx_dir_lookup_rec()
835 ocfs2_error(inode->i_sb, "Inode %lu has bad extent " ocfs2_dx_dir_lookup_rec()
893 blkno += ocfs2_clusters_to_blocks(inode->i_sb, clen - 1); ocfs2_dx_dir_lookup()
896 blkno += ocfs2_clusters_to_blocks(inode->i_sb, ocfs2_dx_dir_lookup()
906 blkno += ocfs2_dx_dir_hash_idx(OCFS2_SB(inode->i_sb), hinfo); ocfs2_dx_dir_lookup()
998 dir->i_sb->s_blocksize, &dir_ent); ocfs2_dx_dir_search()
1309 trailer = ocfs2_trailer_from_bh(leaf_bh, dir->i_sb); ocfs2_delete_entry_dx()
1351 max_rec_len = ocfs2_find_max_rec_len(dir->i_sb, leaf_bh); ocfs2_delete_entry_dx()
1557 trailer = ocfs2_trailer_from_bh(lookup->dl_leaf_bh, dir->i_sb); ocfs2_remove_block_from_free_list()
1565 prev = ocfs2_trailer_from_bh(bh, dir->i_sb); ocfs2_remove_block_from_free_list()
1587 max_rec_len = ocfs2_find_max_rec_len(dir->i_sb, lookup->dl_leaf_bh); ocfs2_recalc_free_list()
1594 trailer = ocfs2_trailer_from_bh(lookup->dl_leaf_bh, dir->i_sb); ocfs2_recalc_free_list()
1619 struct super_block *sb = dir->i_sb; __ocfs2_add_entry()
1687 offset, ocfs2_dir_trailer_blk_off(dir->i_sb)); __ocfs2_add_entry()
1844 struct super_block * sb = inode->i_sb; ocfs2_dir_foreach_blk_el()
2264 size = ocfs2_dir_trailer_blk_off(parent->i_sb); ocfs2_fill_new_dir_el()
2300 i_size_write(inode, inode->i_sb->s_blocksize); ocfs2_fill_new_dir_el()
2336 ocfs2_trailer_from_bh(dirdata_bh, dir->i_sb); ocfs2_dx_dir_attach_index()
2474 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb); __ocfs2_dx_dir_new_cluster()
2637 limit = de_buf + dir->i_sb->s_blocksize; ocfs2_dx_dir_index_block()
2648 i = ocfs2_dx_dir_hash_idx(OCFS2_SB(dir->i_sb), &hinfo); ocfs2_dx_dir_index_block()
2684 limit = de_buf + dir->i_sb->s_blocksize; ocfs2_dx_dir_index_root_block()
2735 return dirent_count < ocfs2_dx_entries_per_root(dir->i_sb); ocfs2_new_dx_should_be_inline()
2755 struct super_block *sb = dir->i_sb; ocfs2_expand_last_dirent()
2808 struct super_block *sb = dir->i_sb; ocfs2_expand_inline_dir()
2813 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb); ocfs2_expand_inline_dir()
2906 bytes_allocated += ocfs2_clusters_to_bytes(dir->i_sb, 1); ocfs2_expand_inline_dir()
2921 bytes_allocated += ocfs2_clusters_to_bytes(dir->i_sb, 1); ocfs2_expand_inline_dir()
2928 blkno = ocfs2_clusters_to_blocks(dir->i_sb, bit_off); ocfs2_expand_inline_dir()
3063 blkno = ocfs2_clusters_to_blocks(dir->i_sb, bit_off); ocfs2_expand_inline_dir()
3071 bytes_allocated += ocfs2_clusters_to_bytes(dir->i_sb, 1); ocfs2_expand_inline_dir()
3084 off = ocfs2_dx_dir_hash_idx(OCFS2_SB(dir->i_sb), ocfs2_expand_inline_dir()
3345 dir_i_size += dir->i_sb->s_blocksize; ocfs2_extend_dir()
3379 struct super_block *sb = dir->i_sb; ocfs2_find_dir_space_id()
3384 unsigned int rec_len, new_rec_len, free_space = dir->i_sb->s_blocksize; ocfs2_find_dir_space_id()
3393 free_space = dir->i_sb->s_blocksize - i_size_read(dir); ocfs2_find_dir_space_id()
3451 struct super_block *sb = dir->i_sb; ocfs2_find_dir_space_el()
3453 int blocksize = dir->i_sb->s_blocksize; ocfs2_find_dir_space_el()
3691 memcpy(tmp_dx_leaf, orig_dx_leaf, dir->i_sb->s_blocksize); ocfs2_dx_dir_transfer_leaf()
3705 memcpy(orig_dx_leaf, tmp_dx_leaf, dir->i_sb->s_blocksize); ocfs2_dx_dir_transfer_leaf()
3799 ocfs2_clusters_to_bytes(dir->i_sb, 1)); ocfs2_dx_dir_rebalance()
3854 orig_leaves_start = ocfs2_block_to_cluster_start(dir->i_sb, leaf_blkno); ocfs2_dx_dir_rebalance()
3895 ocfs2_clusters_to_bytes(dir->i_sb, 1)); ocfs2_dx_dir_rebalance()
4020 db = ocfs2_trailer_from_bh(leaf_bh, dir->i_sb); ocfs2_search_dx_free_list()
4050 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb); ocfs2_expand_inline_dx_root()
4142 ocfs2_clusters_to_bytes(dir->i_sb, 1)); ocfs2_expand_inline_dx_root()
4180 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb); ocfs2_prepare_dx_dir_for_insert()
4357 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb); ocfs2_dx_dir_remove_index()
4439 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb); ocfs2_dx_dir_truncate()
4472 p_cpos = ocfs2_blocks_to_clusters(dir->i_sb, blkno); ocfs2_dx_dir_truncate()
H A Dmmap.c139 sb_start_pagefault(inode->i_sb); ocfs2_page_mkwrite()
169 sb_end_pagefault(inode->i_sb); ocfs2_page_mkwrite()
H A Dsuballoc.c337 rc = ocfs2_validate_gd_parent(inode->i_sb, di, tmp, 0); ocfs2_read_group_descriptor()
382 struct ocfs2_super *osb = OCFS2_SB(alloc_inode->i_sb); ocfs2_block_group_fill()
384 struct super_block * sb = alloc_inode->i_sb; ocfs2_block_group_fill()
387 ocfs2_error(alloc_inode->i_sb, "group block (%llu) != " ocfs2_block_group_fill()
523 struct ocfs2_super *osb = OCFS2_SB(alloc_inode->i_sb); ocfs2_block_group_grow_discontig()
619 struct ocfs2_super *osb = OCFS2_SB(alloc_inode->i_sb); ocfs2_block_group_alloc_discontig()
769 fe->i_size = cpu_to_le64(ocfs2_clusters_to_bytes(alloc_inode->i_sb, ocfs2_block_group_alloc()
837 ocfs2_error(alloc_inode->i_sb, "Invalid chain allocator %llu", ocfs2_reserve_suballoc_bits()
1373 ocfs2_error(alloc_inode->i_sb, "Group descriptor # %llu has bit" ocfs2_block_group_set_bits()
1491 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_cluster_group_search()
1505 gd_cluster_off = ocfs2_blocks_to_clusters(inode->i_sb, ocfs2_cluster_group_search()
1516 ret = ocfs2_block_group_find_clear_bits(OCFS2_SB(inode->i_sb), ocfs2_cluster_group_search()
1523 blkoff = ocfs2_clusters_to_blocks(inode->i_sb, ocfs2_cluster_group_search()
1566 ret = ocfs2_block_group_find_clear_bits(OCFS2_SB(inode->i_sb), ocfs2_block_group_search()
1662 if (!ocfs2_supports_discontig_bg(OCFS2_SB(ac->ac_inode->i_sb)) || ocfs2_bg_discontig_fix_result()
1908 ocfs2_error(ac->ac_inode->i_sb, ocfs2_claim_suballoc_bits()
2017 atomic_inc(&OCFS2_SB(ac->ac_inode->i_sb)->alloc_stats.bg_allocs); ocfs2_claim_metadata()
2093 handle = ocfs2_start_trans(OCFS2_SB(dir->i_sb), OCFS2_SUBALLOC_ALLOC); ocfs2_find_new_inode_loc()
2119 ocfs2_commit_trans(OCFS2_SB(dir->i_sb), handle); ocfs2_find_new_inode_loc()
2183 atomic_inc(&OCFS2_SB(ac->ac_inode->i_sb)->alloc_stats.bg_allocs); ocfs2_claim_new_inode_at_loc()
2225 atomic_inc(&OCFS2_SB(ac->ac_inode->i_sb)->alloc_stats.bg_allocs); ocfs2_claim_new_inode()
2247 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_desc_bitmap_to_cluster_off()
2253 cluster = ocfs2_blocks_to_clusters(inode->i_sb, bg_blkno); ocfs2_desc_bitmap_to_cluster_off()
2262 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_which_cluster_group()
2270 return ocfs2_clusters_to_blocks(inode->i_sb, ocfs2_which_cluster_group()
2281 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_block_to_cluster_group()
2312 struct ocfs2_super *osb = OCFS2_SB(ac->ac_inode->i_sb); __ocfs2_claim_clusters()
2432 ocfs2_error(alloc_inode->i_sb, "Group descriptor # %llu has bit" ocfs2_block_group_clear_bits()
2565 BUG_ON(start_blk != ocfs2_clusters_to_blocks(bitmap_inode->i_sb, ocfs2_blocks_to_clusters(bitmap_inode->i_sb, start_blk))); _ocfs2_free_clusters()
2584 ocfs2_local_alloc_seen_free_bits(OCFS2_SB(bitmap_inode->i_sb), _ocfs2_free_clusters()
2684 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_lock_allocators()
H A Dsymlink.c75 len = strnlen(link, ocfs2_fast_symlink_chars(inode->i_sb)); ocfs2_fast_symlink_readpage()
H A Drefcounttree.c567 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_create_refcount_tree()
615 new_bh = sb_getblk(inode->i_sb, first_blkno); ocfs2_create_refcount_tree()
632 memset(rb, 0, inode->i_sb->s_blocksize); ocfs2_create_refcount_tree()
708 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_set_refcount_tree()
770 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_remove_refcount_tree()
2320 ret = ocfs2_get_refcount_tree(OCFS2_SB(inode->i_sb), ref_blkno, &tree); ocfs2_decrease_refcount()
2363 if (!ocfs2_refcount_tree(OCFS2_SB(inode->i_sb))) { ocfs2_mark_extent_refcounted()
2364 ocfs2_error(inode->i_sb, "Inode %lu want to use refcount " ocfs2_mark_extent_refcounted()
2547 u64 start_cpos = ocfs2_blocks_to_clusters(inode->i_sb, phys_blkno); ocfs2_prepare_refcount_change_for_del()
2549 if (!ocfs2_refcount_tree(OCFS2_SB(inode->i_sb))) { ocfs2_prepare_refcount_change_for_del()
2550 ocfs2_error(inode->i_sb, "Inode %lu want to use refcount " ocfs2_prepare_refcount_change_for_del()
2559 ret = ocfs2_get_refcount_tree(OCFS2_SB(inode->i_sb), ocfs2_prepare_refcount_change_for_del()
2573 ret = ocfs2_calc_refcount_meta_credits(inode->i_sb, ocfs2_prepare_refcount_change_for_del()
2661 int contig_clusters = ocfs2_cow_contig_clusters(inode->i_sb); ocfs2_refcount_cal_cow_clusters()
2677 ocfs2_error(inode->i_sb, ocfs2_refcount_cal_cow_clusters()
2757 want_clusters = ocfs2_cow_align_length(inode->i_sb, ocfs2_refcount_cal_cow_clusters()
2790 *cow_start = ocfs2_cow_align_start(inode->i_sb, ocfs2_refcount_cal_cow_clusters()
2802 *cow_start = ocfs2_cow_align_start(inode->i_sb, ocfs2_refcount_cal_cow_clusters()
2806 want_clusters = ocfs2_cow_align_length(inode->i_sb, ocfs2_refcount_cal_cow_clusters()
2930 struct super_block *sb = inode->i_sb; ocfs2_duplicate_clusters_by_page()
3020 struct super_block *sb = inode->i_sb; ocfs2_duplicate_clusters_by_jbd()
3378 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_replace_cow()
3380 if (!ocfs2_refcount_tree(OCFS2_SB(inode->i_sb))) { ocfs2_replace_cow()
3381 ocfs2_error(inode->i_sb, "Inode %lu want to use refcount " ocfs2_replace_cow()
3402 ret = ocfs2_make_clusters_writable(inode->i_sb, context, ocfs2_replace_cow()
3434 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_refcount_cow_hunk()
3628 *credits += ocfs2_calc_extend_credits(inode->i_sb, ocfs2_refcounted_xattr_delete_need()
3683 ocfs2_clusters_to_blocks(inode->i_sb, 1) * cow_len; ocfs2_refcount_cow_xattr()
3714 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_add_refcount_flag()
3717 ret = ocfs2_calc_refcount_meta_credits(inode->i_sb, ocfs2_add_refcount_flag()
3729 ret = ocfs2_reserve_new_metadata_blocks(OCFS2_SB(inode->i_sb), ocfs2_add_refcount_flag()
3784 handle = ocfs2_start_trans(OCFS2_SB(inode->i_sb), ocfs2_change_ctime()
3806 ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle); ocfs2_change_ctime()
3818 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_attach_refcount_tree()
3851 clusters = ocfs2_clusters_for_bytes(inode->i_sb, size); ocfs2_attach_refcount_tree()
3924 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_add_refcounted_extent()
3927 ret = ocfs2_lock_refcount_allocators(inode->i_sb, ocfs2_add_refcounted_extent()
3945 ocfs2_clusters_to_blocks(inode->i_sb, p_cluster), ocfs2_add_refcounted_extent()
3973 struct ocfs2_super *osb = OCFS2_SB(s_inode->i_sb); ocfs2_duplicate_inline_data()
4025 clusters = ocfs2_clusters_for_bytes(s_inode->i_sb, size); ocfs2_duplicate_extent_list()
4073 handle = ocfs2_start_trans(OCFS2_SB(t_inode->i_sb), ocfs2_complete_reflink()
4128 ocfs2_commit_trans(OCFS2_SB(t_inode->i_sb), handle); ocfs2_complete_reflink()
4141 struct ocfs2_super *osb = OCFS2_SB(s_inode->i_sb); ocfs2_create_reflink_node()
4270 if (!ocfs2_refcount_tree(OCFS2_SB(inode->i_sb))) ocfs2_reflink()
4375 if (dir->i_sb != inode->i_sb) ocfs2_vfs_reflink()
4430 if (!ocfs2_refcount_tree(OCFS2_SB(inode->i_sb))) ocfs2_reflink_ioctl()
H A Dinode.c272 sb = inode->i_sb; ocfs2_populate_inode()
374 inode->i_ino = ino_from_blkno(inode->i_sb, ocfs2_populate_inode()
416 sb = inode->i_sb; ocfs2_read_locked_inode()
620 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_remove_inode()
642 ocfs2_quota_trans_credits(inode->i_sb)); ocfs2_remove_inode()
731 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_wipe_inode()
820 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_inode_is_valid_to_delete()
1006 status = ocfs2_nfs_sync_lock(OCFS2_SB(inode->i_sb), 0); ocfs2_delete_inode()
1070 ocfs2_nfs_sync_unlock(OCFS2_SB(inode->i_sb), 0); ocfs2_delete_inode()
1082 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); ocfs2_clear_inode()
1088 mlog_bug_on_msg(OCFS2_SB(inode->i_sb) == NULL, ocfs2_clear_inode()
1103 ocfs2_resv_discard(&OCFS2_SB(inode->i_sb)->osb_la_resmap, ocfs2_clear_inode()
1173 jbd2_journal_release_jbd_inode(OCFS2_SB(inode->i_sb)->journal->j_journal, ocfs2_clear_inode()
1421 return oi->vfs_inode.i_sb; ocfs2_inode_cache_get_super()
/linux-4.1.27/fs/ext4/
H A Dmigrate.c124 unsigned long max_entries = inode->i_sb->s_blocksize >> 2; update_ind_extent_range()
126 bh = sb_bread(inode->i_sb, pblock); update_ind_extent_range()
153 unsigned long max_entries = inode->i_sb->s_blocksize >> 2; update_dind_extent_range()
155 bh = sb_bread(inode->i_sb, pblock); update_dind_extent_range()
183 unsigned long max_entries = inode->i_sb->s_blocksize >> 2; update_tind_extent_range()
185 bh = sb_bread(inode->i_sb, pblock); update_tind_extent_range()
218 needed = 3 + EXT4_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb); extend_credit_for_blkdel()
232 unsigned long max_entries = inode->i_sb->s_blocksize >> 2; free_dind_blocks()
234 bh = sb_bread(inode->i_sb, le32_to_cpu(i_data)); free_dind_blocks()
262 unsigned long max_entries = inode->i_sb->s_blocksize >> 2; free_tind_blocks()
264 bh = sb_bread(inode->i_sb, le32_to_cpu(i_data)); free_tind_blocks()
392 bh = sb_bread(inode->i_sb, block); free_ext_idx()
451 if (!EXT4_HAS_INCOMPAT_FEATURE(inode->i_sb, ext4_ext_migrate()
468 4 + EXT4_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb)); ext4_ext_migrate()
474 goal = (((inode->i_ino - 1) / EXT4_INODES_PER_GROUP(inode->i_sb)) * ext4_ext_migrate()
475 EXT4_INODES_PER_GROUP(inode->i_sb)) + 1; ext4_ext_migrate()
478 tmp_inode = ext4_new_inode(handle, d_inode(inode->i_sb->s_root), ext4_ext_migrate()
533 max_entries = inode->i_sb->s_blocksize >> 2; ext4_ext_migrate()
619 struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es; ext4_ind_migrate()
628 if (!EXT4_HAS_INCOMPAT_FEATURE(inode->i_sb, ext4_ind_migrate()
633 if (EXT4_HAS_RO_COMPAT_FEATURE(inode->i_sb, ext4_ind_migrate()
642 if (test_opt(inode->i_sb, DELALLOC)) ext4_ind_migrate()
H A Dtruncate.h27 needed = inode->i_blocks >> (inode->i_sb->s_blocksize_bits - 9); ext4_blocks_for_truncate()
43 return EXT4_DATA_TRANS_BLOCKS(inode->i_sb) + needed; ext4_blocks_for_truncate()
H A Dfsync.c91 journal_t *journal = EXT4_SB(inode->i_sb)->s_journal; ext4_sync_file()
100 if (inode->i_sb->s_flags & MS_RDONLY) { ext4_sync_file()
103 if (EXT4_SB(inode->i_sb)->s_mount_flags & EXT4_MF_FS_ABORTED) ext4_sync_file()
133 ret = ext4_force_commit(inode->i_sb); ext4_sync_file()
143 err = blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, NULL); ext4_sync_file()
H A Dnamei.c57 if (unlikely(EXT4_SB(inode->i_sb)->s_max_dir_size_kb && ext4_append()
59 EXT4_SB(inode->i_sb)->s_max_dir_size_kb))) ext4_append()
62 *block = inode->i_size >> inode->i_sb->s_blocksize_bits; ext4_append()
67 inode->i_size += inode->i_sb->s_blocksize; ext4_append()
73 ext4_std_error(inode->i_sb, err); ext4_append()
100 __ext4_warning(inode->i_sb, __func__, line, __ext4_read_dirblock()
117 inode->i_sb->s_blocksize) == __ext4_read_dirblock()
118 inode->i_sb->s_blocksize) __ext4_read_dirblock()
126 if (!ext4_has_metadata_csum(inode->i_sb) || __ext4_read_dirblock()
296 (EXT4_BLOCK_SIZE(inode->i_sb) - get_dirent_tail()
307 t = EXT4_DIRENT_TAIL(de, EXT4_BLOCK_SIZE(inode->i_sb)); get_dirent_tail()
322 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); ext4_dirent_csum()
332 ext4_warning(inode->i_sb, "no space in directory inode %lu leaf for " warn_no_space_for_csum()
340 if (!ext4_has_metadata_csum(inode->i_sb)) ext4_dirent_csum_verify()
361 if (!ext4_has_metadata_csum(inode->i_sb)) ext4_dirent_csum_set()
390 if (le16_to_cpu(dirent->rec_len) == EXT4_BLOCK_SIZE(inode->i_sb)) get_dx_countlimit()
395 EXT4_BLOCK_SIZE(inode->i_sb) - 12) get_dx_countlimit()
413 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); ext4_dx_csum()
436 if (!ext4_has_metadata_csum(inode->i_sb)) ext4_dx_csum_verify()
447 EXT4_BLOCK_SIZE(inode->i_sb) - sizeof(struct dx_tail)) { ext4_dx_csum_verify()
465 if (!ext4_has_metadata_csum(inode->i_sb)) ext4_dx_csum_set()
476 EXT4_BLOCK_SIZE(inode->i_sb) - sizeof(struct dx_tail)) { ext4_dx_csum_set()
550 unsigned entry_space = dir->i_sb->s_blocksize - EXT4_DIR_REC_LEN(1) - dx_root_limit()
553 if (ext4_has_metadata_csum(dir->i_sb)) dx_root_limit()
560 unsigned entry_space = dir->i_sb->s_blocksize - EXT4_DIR_REC_LEN(0); dx_node_limit()
562 if (ext4_has_metadata_csum(dir->i_sb)) dx_node_limit()
685 unsigned blocksize = dir->i_sb->s_blocksize; dx_show_entries()
745 ext4_warning(dir->i_sb, "Unrecognised inode hash code %d", dx_probe()
751 hinfo->hash_version += EXT4_SB(dir->i_sb)->s_hash_unsigned; dx_probe()
752 hinfo->seed = EXT4_SB(dir->i_sb)->s_hash_seed; dx_probe()
778 ext4_warning(dir->i_sb, "Unimplemented inode hash flags: %#06x", dx_probe()
784 ext4_warning(dir->i_sb, "Unimplemented inode hash depth: %#06x", dx_probe()
794 ext4_warning(dir->i_sb, "dx entry: limit != root limit"); dx_probe()
802 ext4_warning(dir->i_sb, dx_probe()
849 ext4_warning(dir->i_sb, dx_probe()
861 ext4_warning(dir->i_sb, dx_probe()
976 dir->i_sb->s_blocksize - htree_dirblock_to_tree()
996 for (; de < top; de = ext4_next_entry(de, dir->i_sb->s_blocksize)) { htree_dirblock_to_tree()
999 (block<<EXT4_BLOCK_SIZE_BITS(dir->i_sb)) htree_dirblock_to_tree()
1071 hinfo.hash_version = EXT4_SB(dir->i_sb)->s_def_hash_version; ext4_htree_fill_tree()
1074 EXT4_SB(dir->i_sb)->s_hash_unsigned; ext4_htree_fill_tree()
1075 hinfo.seed = EXT4_SB(dir->i_sb)->s_hash_seed; ext4_htree_fill_tree()
1111 de = ext4_next_entry(de, dir->i_sb->s_blocksize); ext4_htree_fill_tree()
1162 return search_dir(bh, bh->b_data, dir->i_sb->s_blocksize, dir, search_dirblock()
1314 dir->i_sb->s_blocksize); search_dir()
1333 struct super_block *sb = dir->i_sb; is_dx_internal_node()
1376 sb = dir->i_sb; ext4_find_entry()
1509 struct super_block * sb = dir->i_sb; ext4_dx_find_entry()
1575 if (!ext4_valid_inum(dir->i_sb, ino)) { ext4_lookup()
1584 inode = ext4_iget_normal(dir->i_sb, ino); ext4_lookup()
1597 ext4_warning(inode->i_sb, ext4_lookup()
1623 if (!ext4_valid_inum(d_inode(child)->i_sb, ino)) { ext4_get_parent()
1629 return d_obtain_alias(ext4_iget_normal(d_inode(child)->i_sb, ino)); ext4_get_parent()
1690 unsigned blocksize = dir->i_sb->s_blocksize; do_split()
1703 if (ext4_has_metadata_csum(dir->i_sb)) do_split()
1792 ext4_std_error(dir->i_sb, err); do_split()
1910 ext4_set_de_type(inode->i_sb, de, inode->i_mode); ext4_insert_dentry()
1934 unsigned int blocksize = dir->i_sb->s_blocksize; add_dirent_to_buf()
1938 if (ext4_has_metadata_csum(inode->i_sb)) add_dirent_to_buf()
1951 ext4_std_error(dir->i_sb, err); add_dirent_to_buf()
1980 ext4_std_error(dir->i_sb, err); add_dirent_to_buf()
2020 if (ext4_has_metadata_csum(inode->i_sb)) make_indexed_dir()
2023 blocksize = dir->i_sb->s_blocksize; make_indexed_dir()
2028 ext4_std_error(dir->i_sb, retval); make_indexed_dir()
2074 root->info.hash_version = EXT4_SB(dir->i_sb)->s_def_hash_version; make_indexed_dir()
2083 hinfo.hash_version += EXT4_SB(dir->i_sb)->s_hash_unsigned; make_indexed_dir()
2084 hinfo.seed = EXT4_SB(dir->i_sb)->s_hash_seed; make_indexed_dir()
2156 if (ext4_has_metadata_csum(inode->i_sb)) ext4_add_entry()
2159 sb = dir->i_sb; ext4_add_entry()
2231 struct super_block *sb = dir->i_sb; ext4_dx_add_entry()
2344 ext4_std_error(inode->i_sb, err); ext4_dx_add_entry()
2357 ext4_std_error(dir->i_sb, err); ext4_dx_add_entry()
2377 unsigned int blocksize = dir->i_sb->s_blocksize; ext4_generic_delete_entry()
2422 if (ext4_has_metadata_csum(dir->i_sb)) ext4_delete_entry()
2432 dir->i_sb->s_blocksize, csum_size); ext4_delete_entry()
2444 ext4_std_error(dir->i_sb, err); ext4_delete_entry()
2459 EXT4_SET_RO_COMPAT_FEATURE(inode->i_sb, ext4_inc_count()
2509 credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) + ext4_create()
2523 DUMMY_ENCRYPTION_ENABLED(EXT4_SB(dir->i_sb)))) { ext4_create()
2539 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries)) ext4_create()
2556 credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) + ext4_mknod()
2572 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries)) ext4_mknod()
2589 EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb) + ext4_tmpfile()
2606 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries)) ext4_tmpfile()
2625 ext4_set_de_type(inode->i_sb, de, S_IFDIR); ext4_init_dot_dotdot()
2638 ext4_set_de_type(inode->i_sb, de, S_IFDIR); ext4_init_dot_dotdot()
2650 unsigned int blocksize = dir->i_sb->s_blocksize; ext4_init_new_dir()
2654 if (ext4_has_metadata_csum(dir->i_sb)) ext4_init_new_dir()
2698 credits = (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) + ext4_mkdir()
2716 DUMMY_ENCRYPTION_ENABLED(EXT4_SB(dir->i_sb))) { ext4_mkdir()
2746 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries)) ext4_mkdir()
2770 sb = inode->i_sb; ext4_empty_dir()
2785 ext4_warning(inode->i_sb, ext4_empty_dir()
2837 struct super_block *sb = inode->i_sb; ext4_orphan_add()
2920 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); ext4_orphan_del()
2965 err = ext4_handle_dirty_super(handle, inode->i_sb); ext4_orphan_del()
2987 ext4_std_error(inode->i_sb, err); ext4_orphan_del()
3026 EXT4_DATA_TRANS_BLOCKS(dir->i_sb)); ext4_rmdir()
3040 ext4_warning(inode->i_sb, ext4_rmdir()
3091 EXT4_DATA_TRANS_BLOCKS(dir->i_sb)); ext4_unlink()
3102 ext4_warning(inode->i_sb, ext4_unlink()
3142 DUMMY_ENCRYPTION_ENABLED(EXT4_SB(dir->i_sb))); ext4_symlink()
3145 if (disk_link.len > dir->i_sb->s_blocksize) ext4_symlink()
3157 credits = 4 + EXT4_MAXQUOTAS_INIT_BLOCKS(dir->i_sb) + ext4_symlink()
3166 credits = EXT4_DATA_TRANS_BLOCKS(dir->i_sb) + ext4_symlink()
3194 inode->i_sb->s_blocksize); ext4_symlink()
3238 EXT4_DATA_TRANS_BLOCKS(dir->i_sb) + ext4_symlink()
3294 (EXT4_DATA_TRANS_BLOCKS(dir->i_sb) + ext4_link()
3320 if (err == -ENOSPC && ext4_should_retry_alloc(dir->i_sb, &retries)) ext4_link()
3347 inode->i_sb->s_blocksize); ext4_get_first_dir_block()
3409 ext4_std_error(ent->dir->i_sb, retval); ext4_rename_dir_finish()
3425 if (EXT4_HAS_INCOMPAT_FEATURE(ent->dir->i_sb, ext4_setent()
3437 ext4_std_error(ent->dir->i_sb, retval); ext4_setent()
3490 ext4_warning(ent->dir->i_sb, ext4_rename_delete()
3518 credits += (EXT4_MAXQUOTAS_TRANS_BLOCKS(ent->dir->i_sb) + ext4_whiteout_for_rename()
3530 ext4_should_retry_alloc(ent->dir->i_sb, &retries)) ext4_whiteout_for_rename()
3611 if (new.inode && !test_opt(new.dir->i_sb, NO_AUTO_DA_ALLOC)) ext4_rename()
3614 credits = (2 * EXT4_DATA_TRANS_BLOCKS(old.dir->i_sb) + ext4_rename()
3792 (2 * EXT4_DATA_TRANS_BLOCKS(old.dir->i_sb) + ext4_cross_rename()
H A Dinode.c52 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); ext4_inode_csum()
59 if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE && ext4_inode_csum()
66 EXT4_INODE_SIZE(inode->i_sb)); ext4_inode_csum()
69 if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE && ext4_inode_csum()
81 if (EXT4_SB(inode->i_sb)->s_es->s_creator_os != ext4_inode_csum_verify()
83 !ext4_has_metadata_csum(inode->i_sb)) ext4_inode_csum_verify()
88 if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE && ext4_inode_csum_verify()
102 if (EXT4_SB(inode->i_sb)->s_es->s_creator_os != ext4_inode_csum_set()
104 !ext4_has_metadata_csum(inode->i_sb)) ext4_inode_csum_set()
109 if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE && ext4_inode_csum_set()
144 EXT4_CLUSTER_SIZE(inode->i_sb) >> 9 : 0; ext4_inode_is_fast_symlink()
210 journal_t *journal = EXT4_SB(inode->i_sb)->s_journal; ext4_evict_inode()
236 sb_start_intwrite(inode->i_sb); ext4_evict_inode()
240 ext4_std_error(inode->i_sb, PTR_ERR(handle)); ext4_evict_inode()
247 sb_end_intwrite(inode->i_sb); ext4_evict_inode()
256 ext4_warning(inode->i_sb, ext4_evict_inode()
274 ext4_warning(inode->i_sb, ext4_evict_inode()
279 sb_end_intwrite(inode->i_sb); ext4_evict_inode()
308 sb_end_intwrite(inode->i_sb); ext4_evict_inode()
328 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); ext4_da_update_reserve_space()
334 ext4_warning(inode->i_sb, "%s: ino %lu, used %d " ext4_da_update_reserve_space()
374 if (!ext4_data_block_valid(EXT4_SB(inode->i_sb), map->m_pblk, __check_block_validity()
524 ext4_warning(inode->i_sb, ext4_map_blocks()
620 ext4_warning(inode->i_sb, ext4_map_blocks()
722 map_bh(bh, inode->i_sb, map.m_pblk); _ext4_get_block()
736 bh->b_size = inode->i_sb->s_blocksize * map.m_len; _ext4_get_block()
773 bh = sb_getblk(inode->i_sb, map.m_pblk); ext4_getblk()
795 memset(bh->b_data, 0, inode->i_sb->s_blocksize); ext4_getblk()
922 unsigned blocksize = inode->i_sb->s_blocksize; ext4_block_write_begin()
1108 ext4_should_retry_alloc(inode->i_sb, &retries)) ext4_write_begin()
1289 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); ext4_da_reserve_space()
1329 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); ext4_da_release_space()
1345 ext4_warning(inode->i_sb, "ext4_da_release_space: " ext4_da_release_space()
1370 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); ext4_da_page_release_reservation()
1486 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); ext4_print_free_blocks()
1487 struct super_block *sb = inode->i_sb; ext4_print_free_blocks()
1491 EXT4_C2B(EXT4_SB(inode->i_sb), ext4_print_free_blocks()
1530 if (invalid_block < ext4_blocks_count(EXT4_SB(inode->i_sb)->s_es)) ext4_da_map_blocks()
1551 map_bh(bh, inode->i_sb, invalid_block); ext4_da_map_blocks()
1599 if (EXT4_SB(inode->i_sb)->s_cluster_ratio <= 1 || ext4_da_map_blocks()
1616 map_bh(bh, inode->i_sb, invalid_block); ext4_da_map_blocks()
1624 ext4_warning(inode->i_sb, ext4_da_map_blocks()
1664 BUG_ON(bh->b_size != inode->i_sb->s_blocksize); ext4_da_get_block_prep()
1678 map_bh(bh, inode->i_sb, map.m_pblk); ext4_da_get_block_prep()
2163 struct block_device *bdev = inode->i_sb->s_bdev; mpage_map_one_extent()
2207 struct super_block *sb = inode->i_sb; mpage_map_and_submit_extent()
2267 ext4_error(inode->i_sb, mpage_map_and_submit_extent()
2426 struct ext4_sb_info *sbi = EXT4_SB(mapping->host->i_sb); ext4_writepages()
2536 ext4_msg(inode->i_sb, KERN_CRIT, "%s: jbd2_start: " ext4_writepages()
2641 if (likely(EXT4_HAS_RO_COMPAT_FEATURE(inode->i_sb, ext4_da_write_credits()
2664 if (ext4_nonda_switch(inode->i_sb)) { ext4_da_write_begin()
2738 ext4_should_retry_alloc(inode->i_sb, &retries)) ext4_da_write_begin()
2918 test_opt(inode->i_sb, DELALLOC)) { ext4_bmap()
3191 inode->i_sb->s_bdev, iter, offset, ext4_ext_direct_IO()
3356 if (test_opt(inode->i_sb, DELALLOC)) ext4_set_aops()
3379 blocksize = inode->i_sb->s_blocksize; __ext4_block_zero_page_range()
3381 iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits); __ext4_block_zero_page_range()
3463 unsigned blocksize = inode->i_sb->s_blocksize; ext4_block_zero_page_range()
3492 blocksize = inode->i_sb->s_blocksize; ext4_block_truncate_page()
3501 struct super_block *sb = inode->i_sb; ext4_zero_partial_blocks()
3589 struct super_block *sb = inode->i_sb; ext4_punch_hole()
3724 if (ei->jinode || !EXT4_SB(inode->i_sb)->s_journal) ext4_inode_attach_jinode()
3793 if (inode->i_size == 0 && !test_opt(inode->i_sb, NO_AUTO_DA_ALLOC)) ext4_truncate()
3805 if (inode->i_size & (inode->i_sb->s_blocksize - 1)) { ext4_truncate()
3817 ext4_std_error(inode->i_sb, PTR_ERR(handle)); ext4_truncate()
3821 if (inode->i_size & (inode->i_sb->s_blocksize - 1)) ext4_truncate()
3879 struct super_block *sb = inode->i_sb; __ext4_get_inode_loc()
4033 if (test_opt(inode->i_sb, DAX)) ext4_set_inode_flags()
4069 struct super_block *sb = inode->i_sb; ext4_inode_blocks()
4126 if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) { ext4_iget()
4129 EXT4_INODE_SIZE(inode->i_sb)) { ext4_iget()
4132 EXT4_INODE_SIZE(inode->i_sb)); ext4_iget()
4141 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); ext4_iget()
4160 if (!(test_opt(inode->i_sb, NO_UID32))) { ext4_iget()
4179 !(EXT4_SB(inode->i_sb)->s_mount_state & EXT4_ORPHAN_FS)) && ext4_iget()
4239 if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) { ext4_iget()
4254 if (likely(!test_opt2(inode->i_sb, HURD_COMPAT))) { ext4_iget()
4256 if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) { ext4_iget()
4344 struct super_block *sb = inode->i_sb; ext4_inode_blocks_set()
4455 struct super_block *sb = inode->i_sb; ext4_do_update_inode()
4466 memset(raw_inode, 0, EXT4_SB(inode->i_sb)->s_inode_size); ext4_do_update_inode()
4472 if (!(test_opt(inode->i_sb, NO_UID32))) { ext4_do_update_inode()
4508 if (likely(!test_opt2(inode->i_sb, HURD_COMPAT))) ext4_do_update_inode()
4540 if (likely(!test_opt2(inode->i_sb, HURD_COMPAT))) { ext4_do_update_inode()
4552 if (inode->i_sb->s_flags & MS_LAZYTIME) ext4_do_update_inode()
4553 ext4_update_other_inodes_time(inode->i_sb, inode->i_ino, ext4_do_update_inode()
4575 ext4_std_error(inode->i_sb, err); ext4_do_update_inode()
4620 if (EXT4_SB(inode->i_sb)->s_journal) { ext4_write_inode()
4635 err = ext4_force_commit(inode->i_sb); ext4_write_inode()
4667 journal_t *journal = EXT4_SB(inode->i_sb)->s_journal; ext4_wait_for_tail_page_commit()
4744 (EXT4_MAXQUOTAS_INIT_BLOCKS(inode->i_sb) + ext4_setattr()
4745 EXT4_MAXQUOTAS_DEL_BLOCKS(inode->i_sb)) + 3); ext4_setattr()
4769 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); ext4_setattr()
4864 ext4_std_error(inode->i_sb, error); ext4_setattr()
4898 delalloc_blocks = EXT4_C2B(EXT4_SB(inode->i_sb), ext4_getattr()
4900 stat->blocks += delalloc_blocks << (inode->i_sb->s_blocksize_bits - 9); ext4_getattr()
4926 ext4_group_t groups, ngroups = ext4_get_groups_count(inode->i_sb); ext4_meta_trans_blocks()
4947 if (groups > EXT4_SB(inode->i_sb)->s_gdb_count) ext4_meta_trans_blocks()
4948 gdpblocks = EXT4_SB(inode->i_sb)->s_gdb_count; ext4_meta_trans_blocks()
4954 ret += EXT4_META_TRANS_BLOCKS(inode->i_sb); ext4_meta_trans_blocks()
5037 ext4_std_error(inode->i_sb, err); ext4_reserve_inode_write()
5090 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); ext4_mark_inode_dirty()
5108 EXT4_DATA_TRANS_BLOCKS(inode->i_sb))) == 0) { ext4_mark_inode_dirty()
5117 ext4_warning(inode->i_sb, ext4_mark_inode_dirty()
5192 ext4_std_error(inode->i_sb, err);
5224 if (val && test_opt(inode->i_sb, DELALLOC)) { ext4_change_inode_journal_flag()
5269 ext4_std_error(inode->i_sb, err); ext4_change_inode_journal_flag()
5292 sb_start_pagefault(inode->i_sb); ext4_page_mkwrite()
5297 if (test_opt(inode->i_sb, DELALLOC) && ext4_page_mkwrite()
5299 !ext4_nonda_switch(inode->i_sb)) { ext4_page_mkwrite()
5304 ext4_should_retry_alloc(inode->i_sb, &retries)); ext4_page_mkwrite()
5360 if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries)) ext4_page_mkwrite()
5366 sb_end_pagefault(inode->i_sb); ext4_page_mkwrite()
H A Dxattr.c66 inode->i_sb->s_id, inode->i_ino); \
118 inode->i_sb->s_fs_info)->s_mb_cache)
124 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); ext4_xattr_block_csum()
134 EXT4_BLOCK_SIZE(inode->i_sb)); ext4_xattr_block_csum()
144 if (ext4_has_metadata_csum(inode->i_sb) && ext4_xattr_block_csum_verify()
154 if (!ext4_has_metadata_csum(inode->i_sb)) ext4_xattr_block_csum_set()
291 bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl); ext4_xattr_block_get()
345 end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size; ext4_xattr_ibody_get()
439 bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl); ext4_xattr_block_list()
477 end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size; ext4_xattr_ibody_list()
589 dquot_free_block(inode, EXT4_C2B(EXT4_SB(inode->i_sb), 1)); ext4_xattr_release_block()
594 ext4_std_error(inode->i_sb, error); ext4_xattr_release_block()
736 struct super_block *sb = inode->i_sb; ext4_xattr_block_find()
779 struct super_block *sb = inode->i_sb; ext4_xattr_block_set()
992 is->s.end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size; ext4_xattr_ibody_find()
1118 memset(raw_inode, 0, EXT4_SB(inode->i_sb)->s_inode_size); ext4_xattr_set_handle()
1168 ext4_xattr_update_super_block(handle, inode->i_sb); ext4_xattr_set_handle()
1218 ext4_should_retry_alloc(inode->i_sb, &retries)) ext4_xattr_set()
1269 int s_min_extra_isize = le16_to_cpu(EXT4_SB(inode->i_sb)->s_es->s_min_extra_isize); ext4_expand_extra_isize_ea()
1287 end = (void *)raw_inode + EXT4_SB(inode->i_sb)->s_inode_size; ext4_expand_extra_isize_ea()
1299 inode->i_sb->s_blocksize); ext4_expand_extra_isize_ea()
1310 bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl); ext4_expand_extra_isize_ea()
1336 free = inode->i_sb->s_blocksize; ext4_expand_extra_isize_ea()
1436 inode->i_sb->s_blocksize); ext4_expand_extra_isize_ea()
1493 bh = sb_bread(inode->i_sb, EXT4_I(inode)->i_file_acl); ext4_xattr_delete_inode()
1616 ce = mb_cache_entry_find_first(ext4_mb_cache, inode->i_sb->s_bdev, ext4_xattr_cache_find()
1626 bh = sb_bread(inode->i_sb, ce->e_block); ext4_xattr_cache_find()
1641 ce = mb_cache_entry_find_next(ce, inode->i_sb->s_bdev, hash); ext4_xattr_cache_find()
H A Dinline.c43 min_offs = EXT4_SB(inode->i_sb)->s_inode_size - get_max_inline_xattr_value_size()
437 if (EXT4_HAS_INCOMPAT_FEATURE(inode->i_sb, ext4_destroy_inline_data_nolock()
472 ext4_warning(inode->i_sb, "inode %lu doesn't have inline data.", ext4_read_inline_page()
616 if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries)) ext4_convert_inline_data_to_extent()
733 ext4_std_error(inode->i_sb, ret); ext4_write_inline_data_end()
765 ext4_std_error(inode->i_sb, ret); ext4_journalled_write_inline_data()
891 ext4_should_retry_alloc(inode->i_sb, &retries)) ext4_da_write_inline_data_begin()
1131 inode->i_sb->s_blocksize, csum_size, ext4_finish_convert_inline_dir()
1138 if (ext4_has_metadata_csum(inode->i_sb)) ext4_finish_convert_inline_dir()
1141 inode->i_size = inode->i_sb->s_blocksize; ext4_finish_convert_inline_dir()
1142 i_size_write(inode, inode->i_sb->s_blocksize); ext4_finish_convert_inline_dir()
1143 EXT4_I(inode)->i_disksize = inode->i_sb->s_blocksize; ext4_finish_convert_inline_dir()
1146 inode->i_sb->s_blocksize - csum_size); ext4_finish_convert_inline_dir()
1150 inode->i_sb->s_blocksize); ext4_finish_convert_inline_dir()
1151 initialize_dirent_tail(t, inode->i_sb->s_blocksize); ext4_finish_convert_inline_dir()
1210 data_bh = sb_getblk(inode->i_sb, map.m_pblk); ext4_convert_inline_data_nolock()
1223 memset(data_bh->b_data, 0, inode->i_sb->s_blocksize); ext4_convert_inline_data_nolock()
1374 ext4_set_de_type(inode->i_sb, &fake, S_IFDIR); htree_inlinedir_to_tree()
1384 ext4_set_de_type(inode->i_sb, &fake, S_IFDIR); htree_inlinedir_to_tree()
1469 sb = inode->i_sb; ext4_read_inline_dir()
1713 ext4_std_error(dir->i_sb, err); ext4_delete_inline_entry()
1770 ext4_warning(dir->i_sb, empty_inline_dir()
1784 ext4_warning(dir->i_sb, empty_inline_dir()
1846 physical = (__u64)iloc.bh->b_blocknr << inode->i_sb->s_blocksize_bits; ext4_inline_data_fiemap()
H A Dext4_jbd2.h22 #define EXT4_JOURNAL(inode) (EXT4_SB((inode)->i_sb)->s_journal)
111 int credits = EXT4_DATA_TRANS_BLOCKS(inode->i_sb); ext4_jbd2_credits_xattr()
312 return __ext4_journal_start_sb(inode->i_sb, line, type, blocks, __ext4_journal_start()
400 test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA) ext4_inode_journal_mode()
403 !test_opt(inode->i_sb, DELALLOC)) ext4_inode_journal_mode()
405 if (test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_ORDERED_DATA) ext4_inode_journal_mode()
407 if (test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_WRITEBACK_DATA) ext4_inode_journal_mode()
439 if (!test_opt(inode->i_sb, DIOREAD_NOLOCK)) ext4_should_dioread_nolock()
H A Dsymlink.c36 u32 plen, max_size = inode->i_sb->s_blocksize; ext4_follow_link()
41 ctx = ext4_get_fname_crypto_ctx(inode, inode->i_sb->s_blocksize); ext4_follow_link()
H A Dext4_jbd2.c198 test_opt(inode->i_sb, DATA_FLAGS)); __ext4_forget()
211 if (test_opt(inode->i_sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA || __ext4_forget()
232 __ext4_abort(inode->i_sb, where, line, __ext4_forget()
299 es = EXT4_SB(inode->i_sb)->s_es; __ext4_handle_dirty_metadata()
H A Dindirect.c59 * inode->i_sb).
76 int ptrs = EXT4_ADDR_PER_BLOCK(inode->i_sb); ext4_block_to_path()
77 int ptrs_bits = EXT4_ADDR_PER_BLOCK_BITS(inode->i_sb); ext4_block_to_path()
103 ext4_warning(inode->i_sb, "block %lu > max in inode %lu", ext4_block_to_path()
146 struct super_block *sb = inode->i_sb; ext4_get_branch()
347 bh = branch[i].bh = sb_getblk(ar->inode->i_sb, new_blocks[i-1]); ext4_alloc_branch()
564 if (EXT4_HAS_RO_COMPAT_FEATURE(inode->i_sb, ext4_ind_map_blocks()
697 inode->i_sb->s_bdev, iter, ext4_ind_direct_IO()
718 if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries)) ext4_ind_direct_IO()
768 sector_t dind_mask = ~((sector_t)EXT4_ADDR_PER_BLOCK(inode->i_sb) - 1); ext4_ind_calc_metadata_amount()
784 return (blk_bits / EXT4_ADDR_PER_BLOCK_BITS(inode->i_sb)) + 1; ext4_ind_calc_metadata_amount()
795 * N/EXT4_ADDR_PER_BLOCK(inode->i_sb) + 1 indirect blocks, ext4_ind_trans_blocks()
798 return DIV_ROUND_UP(nrblocks, EXT4_ADDR_PER_BLOCK(inode->i_sb)) + 4; ext4_ind_trans_blocks()
947 if (!ext4_data_block_valid(EXT4_SB(inode->i_sb), block_to_free, ext4_clear_blocks()
983 ext4_std_error(inode->i_sb, err); ext4_clear_blocks()
1103 int addr_per_block = EXT4_ADDR_PER_BLOCK(inode->i_sb); ext4_free_branches()
1110 if (!ext4_data_block_valid(EXT4_SB(inode->i_sb), ext4_free_branches()
1120 bh = sb_bread(inode->i_sb, nr); ext4_free_branches()
1207 int addr_per_block = EXT4_ADDR_PER_BLOCK(inode->i_sb); ext4_ind_truncate()
1214 unsigned blocksize = inode->i_sb->s_blocksize; ext4_ind_truncate()
1217 >> EXT4_BLOCK_SIZE_BITS(inode->i_sb); ext4_ind_truncate()
1218 max_block = (EXT4_SB(inode->i_sb)->s_bitmap_maxbytes + blocksize-1) ext4_ind_truncate()
1219 >> EXT4_BLOCK_SIZE_BITS(inode->i_sb); ext4_ind_truncate()
1320 int addr_per_block = EXT4_ADDR_PER_BLOCK(inode->i_sb); ext4_ind_remove_space()
1327 unsigned blocksize = inode->i_sb->s_blocksize; ext4_ind_remove_space()
1329 max_block = (EXT4_SB(inode->i_sb)->s_bitmap_maxbytes + blocksize-1) ext4_ind_remove_space()
1330 >> EXT4_BLOCK_SIZE_BITS(inode->i_sb); ext4_ind_remove_space()
H A Dfile.c78 struct super_block *sb = inode->i_sb; ext4_unaligned_aio()
125 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); ext4_file_write_iter()
254 struct super_block *sb = inode->i_sb; ext4_file_open()
255 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); ext4_file_open()
341 blkbits = inode->i_sb->s_blocksize_bits; ext4_find_unwritten_pgoff()
477 blkbits = inode->i_sb->s_blocksize_bits; ext4_seek_data()
550 blkbits = inode->i_sb->s_blocksize_bits; ext4_seek_hole()
616 maxbytes = EXT4_SB(inode->i_sb)->s_bitmap_maxbytes; ext4_llseek()
618 maxbytes = inode->i_sb->s_maxbytes; ext4_llseek()
H A Dblock_validity.c225 struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es; ext4_check_blockref()
232 unlikely(!ext4_data_block_valid(EXT4_SB(inode->i_sb), ext4_check_blockref()
H A Dextents_status.c301 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); ext4_es_list_add()
317 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); ext4_es_list_del()
346 percpu_counter_inc(&EXT4_SB(inode->i_sb)-> ext4_es_alloc_extent()
351 percpu_counter_inc(&EXT4_SB(inode->i_sb)->s_es_stats.es_stats_all_cnt); ext4_es_alloc_extent()
359 percpu_counter_dec(&EXT4_SB(inode->i_sb)->s_es_stats.es_stats_all_cnt); ext4_es_free_extent()
366 percpu_counter_dec(&EXT4_SB(inode->i_sb)-> ext4_es_free_extent()
708 ext4_warning(inode->i_sb, "Inserting extent [%u/%u] as " ext4_es_insert_extent()
727 if (err == -ENOMEM && __es_shrink(EXT4_SB(inode->i_sb), ext4_es_insert_extent()
820 stats = &EXT4_SB(inode->i_sb)->s_es_stats; ext4_es_lookup_extent()
887 __es_shrink(EXT4_SB(inode->i_sb), __es_remove_extent()
1302 ext4_warning(inode->i_sb, "forced shrink of precached extents"); es_reclaim_extents()
H A Dextents.c63 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); ext4_extent_block_csum()
76 if (!ext4_has_metadata_csum(inode->i_sb)) ext4_extent_block_csum_verify()
90 if (!ext4_has_metadata_csum(inode->i_sb)) ext4_extent_block_csum_set()
242 size = (inode->i_sb->s_blocksize - sizeof(struct ext4_extent_header)) ext4_ext_space_block()
255 size = (inode->i_sb->s_blocksize - sizeof(struct ext4_extent_header)) ext4_ext_space_block_idx()
316 idxs = ((inode->i_sb->s_blocksize - sizeof(struct ext4_extent_header)) ext4_ext_calc_metadata_amount()
382 return ext4_data_block_valid(EXT4_SB(inode->i_sb), block, len); ext4_valid_extent()
390 return ext4_data_block_valid(EXT4_SB(inode->i_sb), block, 1); ext4_valid_extent_idx()
406 struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es; ext4_valid_extent_entries()
506 bh = sb_getblk_gfp(inode->i_sb, pblk, __GFP_MOVABLE | GFP_NOFS); __read_extent_tree_block()
1007 ext4_std_error(inode->i_sb, err); ext4_ext_insert_index()
1091 bh = sb_getblk_gfp(inode->i_sb, newblock, __GFP_MOVABLE | GFP_NOFS); ext4_ext_split()
1164 bh = sb_getblk(inode->i_sb, newblock); ext4_ext_split()
1269 struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es; ext4_ext_grow_indepth()
1285 bh = sb_getblk_gfp(inode->i_sb, newblock, __GFP_MOVABLE | GFP_NOFS); ext4_ext_grow_indepth()
2155 unsigned char blksize_bits = inode->i_sb->s_blocksize_bits; ext4_fill_fiemap_extents()
2429 ret = 2 + EXT4_META_TRANS_BLOCKS(inode->i_sb); ext4_ext_calc_credits_for_single_extent()
2479 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); ext4_remove_blocks()
2510 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); ext4_remove_blocks()
2595 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); ext4_ext_rm_leaf()
2683 credits = 7 + 2*(ex_ee_len/EXT4_BLOCKS_PER_GROUP(inode->i_sb)); ext4_ext_rm_leaf()
2688 credits += EXT4_MAXQUOTAS_TRANS_BLOCKS(inode->i_sb); ext4_ext_rm_leaf()
2800 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); ext4_ext_remove_space()
3128 ret = sb_issue_zeroout(inode->i_sb, ee_pblock, ee_len, GFP_NOFS); ext4_ext_zeroout()
3412 sbi = EXT4_SB(inode->i_sb); ext4_ext_convert_to_initialized()
3413 eof_block = (inode->i_size + inode->i_sb->s_blocksize - 1) >> ext4_ext_convert_to_initialized()
3414 inode->i_sb->s_blocksize_bits; ext4_ext_convert_to_initialized()
3558 (inode->i_sb->s_blocksize_bits - 10); ext4_ext_convert_to_initialized()
3672 eof_block = (inode->i_size + inode->i_sb->s_blocksize - 1) >> ext4_split_convert_extents()
3673 inode->i_sb->s_blocksize_bits; ext4_split_convert_extents()
3847 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); ext4_find_delalloc_cluster()
3894 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); get_reserved_cluster_alloc()
4107 unmap_underlying_metadata_blocks(inode->i_sb->s_bdev, ext4_ext_handle_unwritten_extents()
4275 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); ext4_ext_map_blocks()
4385 get_implied_cluster_alloc(inode->i_sb, map, ex, path)) { ext4_ext_map_blocks()
4406 get_implied_cluster_alloc(inode->i_sb, map, ex2, path)) { ext4_ext_map_blocks()
4625 struct super_block *sb = inode->i_sb; ext4_ext_truncate()
4650 ext4_std_error(inode->i_sb, err); ext4_ext_truncate()
4654 ext4_std_error(inode->i_sb, err); ext4_ext_truncate()
4723 ext4_should_retry_alloc(inode->i_sb, &retries)) { ext4_alloc_file_blocks()
4753 ret = ext4_force_commit(inode->i_sb); ext4_zero_range()
4855 ext4_std_error(inode->i_sb, ret); ext4_zero_range()
4976 if (file->f_flags & O_SYNC && EXT4_SB(inode->i_sb)->s_journal) { ext4_fallocate()
4977 ret = jbd2_complete_transaction(EXT4_SB(inode->i_sb)->s_journal, ext4_fallocate()
5043 ext4_warning(inode->i_sb, ext4_convert_unwritten_extents()
5114 int blockbits = inode->i_sb->s_blocksize_bits; ext4_xattr_fiemap()
5129 length = EXT4_SB(inode->i_sb)->s_inode_size - offset; ext4_xattr_fiemap()
5134 length = inode->i_sb->s_blocksize; ext4_xattr_fiemap()
5179 start_blk = start >> inode->i_sb->s_blocksize_bits; ext4_fiemap()
5180 last_blk = (start + len - 1) >> inode->i_sb->s_blocksize_bits; ext4_fiemap()
5396 struct super_block *sb = inode->i_sb; ext4_collapse_range()
5426 ret = ext4_force_commit(inode->i_sb); ext4_collapse_range()
H A Ddir.c41 struct super_block *sb = inode->i_sb; is_dx_dir()
43 if (EXT4_HAS_COMPAT_FEATURE(inode->i_sb, is_dx_dir()
69 dir->i_sb->s_blocksize); __ext4_check_dir_entry()
80 le32_to_cpu(EXT4_SB(dir->i_sb)->s_es->s_inodes_count))) __ext4_check_dir_entry()
110 struct super_block *sb = inode->i_sb; ext4_readdir()
492 struct super_block *sb = inode->i_sb; call_filldir()
/linux-4.1.27/fs/nfs/
H A Dnfstrace.h62 __entry->dev = inode->i_sb->s_dev;
100 __entry->dev = inode->i_sb->s_dev;
186 __entry->dev = dir->i_sb->s_dev;
230 __entry->dev = dir->i_sb->s_dev;
297 __entry->dev = dir->i_sb->s_dev;
336 __entry->dev = dir->i_sb->s_dev;
373 __entry->dev = dir->i_sb->s_dev;
409 __entry->dev = dir->i_sb->s_dev;
441 __entry->dev = dir->i_sb->s_dev;
479 __entry->dev = dir->i_sb->s_dev;
533 __entry->dev = inode->i_sb->s_dev;
568 __entry->dev = inode->i_sb->s_dev;
605 __entry->dev = old_dir->i_sb->s_dev;
653 __entry->dev = old_dir->i_sb->s_dev;
708 __entry->dev = dir->i_sb->s_dev;
H A Dnfs4trace.h476 __entry->dev = inode->i_sb->s_dev;
536 __entry->dev = inode->i_sb->s_dev;
587 __entry->dev = inode->i_sb->s_dev;
662 __entry->dev = inode->i_sb->s_dev;
707 __entry->dev = dir->i_sb->s_dev;
761 __entry->dev = olddir->i_sb->s_dev;
799 __entry->dev = inode->i_sb->s_dev;
952 __entry->dev = inode->i_sb->s_dev;
1003 __entry->dev = inode->i_sb->s_dev;
1055 __entry->dev = inode->i_sb->s_dev;
1114 __entry->dev = inode->i_sb->s_dev;
/linux-4.1.27/fs/hfsplus/
H A Dxattr.c283 err = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &cat_fd); __hfsplus_setxattr()
289 err = hfsplus_find_cat(inode->i_sb, inode->i_ino, &cat_fd); __hfsplus_setxattr()
336 if (!HFSPLUS_SB(inode->i_sb)->attr_tree) { __hfsplus_setxattr()
337 err = hfsplus_create_attributes_file(inode->i_sb); __hfsplus_setxattr()
462 res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &fd); hfsplus_getxattr_finder_info()
467 res = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd); hfsplus_getxattr_finder_info()
517 if (!HFSPLUS_SB(inode->i_sb)->attr_tree) __hfsplus_getxattr()
526 res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->attr_tree, &fd); __hfsplus_getxattr()
532 res = hfsplus_find_attr(inode->i_sb, inode->i_ino, name, &fd); __hfsplus_getxattr()
631 res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &fd); hfsplus_listxattr_finder_info()
637 res = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd); hfsplus_listxattr_finder_info()
706 else if (!HFSPLUS_SB(inode->i_sb)->attr_tree) hfsplus_listxattr()
709 err = hfs_find_init(HFSPLUS_SB(inode->i_sb)->attr_tree, &fd); hfsplus_listxattr()
722 err = hfsplus_find_attr(inode->i_sb, inode->i_ino, NULL, &fd); hfsplus_listxattr()
749 if (hfsplus_uni2asc(inode->i_sb, hfsplus_listxattr()
789 if (!HFSPLUS_SB(inode->i_sb)->attr_tree) hfsplus_removexattr()
795 err = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &cat_fd); hfsplus_removexattr()
801 err = hfsplus_find_cat(inode->i_sb, inode->i_ino, &cat_fd); hfsplus_removexattr()
H A Ddir.c41 sb = dir->i_sb; hfsplus_lookup()
118 inode = hfsplus_iget(dir->i_sb, cnid); hfsplus_lookup()
134 struct super_block *sb = inode->i_sb; hfsplus_readdir()
298 struct hfsplus_sb_info *sbi = HFSPLUS_SB(dst_dir->i_sb); hfsplus_link()
347 hfsplus_mark_mdb_dirty(dst_dir->i_sb); hfsplus_link()
355 struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb); hfsplus_unlink()
412 struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb); hfsplus_rmdir()
435 struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb); hfsplus_symlink()
440 inode = hfsplus_new_inode(dir->i_sb, S_IFLNK | S_IRWXUGO); hfsplus_symlink()
477 struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb); hfsplus_mknod()
482 inode = hfsplus_new_inode(dir->i_sb, mode); hfsplus_mknod()
H A Dattributes.c171 struct super_block *sb = inode->i_sb; hfsplus_attr_exists()
197 struct super_block *sb = inode->i_sb; hfsplus_create_attr()
300 struct super_block *sb = inode->i_sb; hfsplus_delete_attr()
346 if (!HFSPLUS_SB(dir->i_sb)->attr_tree) { hfsplus_delete_all_attrs()
351 err = hfs_find_init(HFSPLUS_SB(dir->i_sb)->attr_tree, &fd); hfsplus_delete_all_attrs()
356 err = hfsplus_find_attr(dir->i_sb, cnid, NULL, &fd); hfsplus_delete_all_attrs()
H A Dinode.c68 struct super_block *sb = inode->i_sb; hfsplus_releasepage()
184 struct hfsplus_sb_info *sbi = HFSPLUS_SB(inode->i_sb); hfsplus_get_perms()
227 struct super_block *sb = inode->i_sb; hfsplus_file_release()
283 struct hfsplus_sb_info *sbi = HFSPLUS_SB(inode->i_sb); hfsplus_file_fsync()
328 blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, NULL); hfsplus_file_fsync()
419 struct super_block *sb = inode->i_sb; hfsplus_delete_inode()
441 struct super_block *sb = inode->i_sb; hfsplus_inode_read_fork()
557 if (hfs_find_init(HFSPLUS_SB(main_inode->i_sb)->cat_tree, &fd)) hfsplus_cat_write_inode()
561 if (hfsplus_find_cat(main_inode->i_sb, main_inode->i_ino, &fd)) hfsplus_cat_write_inode()
H A Dcatalog.c107 struct hfsplus_sb_info *sbi = HFSPLUS_SB(inode->i_sb); hfsplus_cat_build_record()
224 struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb); hfsplus_subfolders_inc()
237 struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb); hfsplus_subfolders_dec()
255 struct super_block *sb = dir->i_sb; hfsplus_create_cat()
323 struct super_block *sb = dir->i_sb; hfsplus_delete_cat()
418 struct super_block *sb = src_dir->i_sb; hfsplus_rename_cat()
H A Dsuper.c27 struct hfsplus_vh *vhdr = HFSPLUS_SB(inode->i_sb)->s_vhdr; hfsplus_system_read_inode()
77 err = hfs_find_init(HFSPLUS_SB(inode->i_sb)->cat_tree, &fd); hfsplus_iget()
79 err = hfsplus_find_cat(inode->i_sb, inode->i_ino, &fd); hfsplus_iget()
99 struct hfsplus_sb_info *sbi = HFSPLUS_SB(inode->i_sb); hfsplus_system_write_inode()
129 hfsplus_mark_mdb_dirty(inode->i_sb); hfsplus_system_write_inode()
253 err = hfsplus_sync_fs(sbi->alloc_file->i_sb, 1); delayed_sync_fs()
H A Dextents.c131 res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->ext_tree, &fd); hfsplus_ext_write_extent_locked()
211 res = hfs_find_init(HFSPLUS_SB(inode->i_sb)->ext_tree, &fd); hfsplus_ext_read_extent()
223 struct super_block *sb = inode->i_sb; hfsplus_get_block()
430 struct super_block *sb = inode->i_sb; hfsplus_file_extend()
533 struct super_block *sb = inode->i_sb; hfsplus_file_truncate()
/linux-4.1.27/fs/hfs/
H A Dinode.c73 struct super_block *sb = inode->i_sb; hfs_releasepage()
183 struct super_block *sb = dir->i_sb; hfs_new_inode()
208 inode->i_mode &= ~HFS_SB(inode->i_sb)->s_dir_umask; hfs_new_inode()
220 inode->i_mode &= ~HFS_SB(inode->i_sb)->s_file_umask; hfs_new_inode()
239 struct super_block *sb = inode->i_sb; hfs_delete_inode()
266 struct super_block *sb = inode->i_sb; hfs_inode_read_fork()
314 struct hfs_sb_info *hsb = HFS_SB(inode->i_sb); hfs_read_inode()
412 HFS_SB(inode->i_sb)->alloc_blksz); hfs_inode_write_fork()
432 hfs_btree_write(HFS_SB(inode->i_sb)->ext_tree); hfs_write_inode()
435 hfs_btree_write(HFS_SB(inode->i_sb)->cat_tree); hfs_write_inode()
449 if (hfs_find_init(HFS_SB(main_inode->i_sb)->cat_tree, &fd)) hfs_write_inode()
518 inode = new_inode(dir->i_sb); hfs_file_lookup()
522 res = hfs_find_init(HFS_SB(dir->i_sb)->cat_tree, &fd); hfs_file_lookup()
568 //struct super_block *sb = inode->i_sb; hfs_file_release()
604 struct hfs_sb_info *hsb = HFS_SB(inode->i_sb); hfs_inode_setattr()
665 sb = inode->i_sb; hfs_file_fsync()
H A Dattr.c28 res = hfs_find_init(HFS_SB(inode->i_sb)->cat_tree, &fd); hfs_setxattr()
72 res = hfs_find_init(HFS_SB(inode->i_sb)->cat_tree, &fd); hfs_getxattr()
H A Ddir.c28 res = hfs_find_init(HFS_SB(dir->i_sb)->cat_tree, &fd); hfs_lookup()
31 hfs_cat_build_key(dir->i_sb, fd.search_key, dir->i_ino, &dentry->d_name); hfs_lookup()
42 inode = hfs_iget(dir->i_sb, &fd.search_key->cat, &rec); hfs_lookup()
57 struct super_block *sb = inode->i_sb; hfs_readdir()
298 hfs_cat_build_key(old_dir->i_sb, hfs_rename()
H A Dcatalog.c59 rec->file.UsrWds.fdType = HFS_SB(inode->i_sb)->s_type; hfs_cat_build_record()
60 rec->file.UsrWds.fdCreator = HFS_SB(inode->i_sb)->s_creator; hfs_cat_build_record()
95 sb = dir->i_sb; hfs_cat_create()
221 sb = dir->i_sb; hfs_cat_delete()
291 sb = src_dir->i_sb; hfs_cat_move()
H A Dextent.c137 res = hfs_find_init(HFS_SB(inode->i_sb)->ext_tree, &fd); hfs_ext_write_extent()
196 res = hfs_find_init(HFS_SB(inode->i_sb)->ext_tree, &fd); hfs_ext_read_extent()
339 sb = inode->i_sb; hfs_get_block()
387 struct super_block *sb = inode->i_sb; hfs_extend_file()
472 struct super_block *sb = inode->i_sb; hfs_file_truncate()
/linux-4.1.27/fs/romfs/
H A Dsuper.c124 ret = romfs_dev_read(inode->i_sb, pos, buf, fillsize); romfs_readpage()
159 maxoff = romfs_maxsize(i->i_sb); romfs_readdir()
164 ret = romfs_dev_read(i->i_sb, offset, &ri, ROMFH_SIZE); romfs_readdir()
180 ret = romfs_dev_read(i->i_sb, offset, &ri, ROMFH_SIZE); romfs_readdir()
184 j = romfs_dev_strnlen(i->i_sb, offset + ROMFH_SIZE, romfs_readdir()
189 ret = romfs_dev_read(i->i_sb, offset + ROMFH_SIZE, fsname, j); romfs_readdir()
221 ret = romfs_dev_read(dir->i_sb, offset, &ri, ROMFH_SIZE); romfs_lookup()
227 maxoff = romfs_maxsize(dir->i_sb); romfs_lookup()
237 ret = romfs_dev_read(dir->i_sb, offset, &ri, sizeof(ri)); romfs_lookup()
242 ret = romfs_dev_strcmp(dir->i_sb, offset + ROMFH_SIZE, name, romfs_lookup()
257 inode = romfs_iget(dir->i_sb, offset); romfs_lookup()
H A Dmmap-nommu.c29 struct mtd_info *mtd = inode->i_sb->s_mtd; romfs_get_unmapped_area()
75 struct mtd_info *mtd = file_inode(file)->i_sb->s_mtd; romfs_mmap_capabilities()
/linux-4.1.27/fs/ext2/
H A Dnamei.c68 inode = ext2_iget(dir->i_sb, ino); ext2_lookup()
70 ext2_error(dir->i_sb, __func__, ext2_lookup()
85 return d_obtain_alias(ext2_iget(d_inode(child)->i_sb, ino)); ext2_get_parent()
107 if (test_opt(inode->i_sb, NOBH)) { ext2_create()
125 if (test_opt(inode->i_sb, NOBH)) { ext2_tmpfile()
164 struct super_block * sb = dir->i_sb; ext2_symlink()
182 if (test_opt(inode->i_sb, NOBH)) ext2_symlink()
246 if (test_opt(inode->i_sb, NOBH)) ext2_mkdir()
H A Dinode.c47 (inode->i_sb->s_blocksize >> 9) : 0; ext2_inode_is_fast_symlink()
83 sb_start_intwrite(inode->i_sb); ext2_evict_inode()
106 sb_end_intwrite(inode->i_sb); ext2_evict_inode()
146 * inode->i_sb).
162 int ptrs = EXT2_ADDR_PER_BLOCK(inode->i_sb); ext2_block_to_path()
163 int ptrs_bits = EXT2_ADDR_PER_BLOCK_BITS(inode->i_sb); ext2_block_to_path()
171 ext2_msg(inode->i_sb, KERN_WARNING, ext2_block_to_path()
192 ext2_msg(inode->i_sb, KERN_WARNING, ext2_block_to_path()
236 struct super_block *sb = inode->i_sb; ext2_get_branch()
311 bg_start = ext2_group_first_block_no(inode->i_sb, ei->i_block_group); ext2_find_near()
313 (EXT2_BLOCKS_PER_GROUP(inode->i_sb) / 16); ext2_find_near()
476 int blocksize = inode->i_sb->s_blocksize; ext2_alloc_branch()
499 bh = sb_getblk(inode->i_sb, new_blocks[n-1]); ext2_alloc_branch()
751 map_bh(bh_result, inode->i_sb, le32_to_cpu(chain[depth-1].key)); ext2_get_blocks()
1058 int addr_per_block = EXT2_ADDR_PER_BLOCK(inode->i_sb); ext2_free_branches()
1064 bh = sb_bread(inode->i_sb, nr); ext2_free_branches()
1070 ext2_error(inode->i_sb, "ext2_free_branches", ext2_free_branches()
1091 int addr_per_block = EXT2_ADDR_PER_BLOCK(inode->i_sb); __ext2_truncate_blocks()
1099 blocksize = inode->i_sb->s_blocksize; __ext2_truncate_blocks()
1100 iblock = (offset + blocksize-1) >> EXT2_BLOCK_SIZE_BITS(inode->i_sb); __ext2_truncate_blocks()
1206 else if (test_opt(inode->i_sb, NOBH)) ext2_setsize()
1288 if (test_opt(inode->i_sb, DAX)) ext2_set_inode_flags()
1331 raw_inode = ext2_get_inode(inode->i_sb, ino, &bh); ext2_iget()
1340 if (!(test_opt (inode->i_sb, NO_UID32))) { ext2_iget()
1378 ei->i_block_group = (ino - 1) / EXT2_INODES_PER_GROUP(inode->i_sb); ext2_iget()
1390 if (test_opt(inode->i_sb, NOBH)) { ext2_iget()
1400 if (test_opt(inode->i_sb, NOBH)) ext2_iget()
1411 if (test_opt(inode->i_sb, NOBH)) ext2_iget()
1438 struct super_block *sb = inode->i_sb; __ext2_write_inode()
H A Dioctl.c116 if (test_opt(inode->i_sb, RESERVATION) ext2_ioctl()
125 if (!test_opt(inode->i_sb, RESERVATION) ||!S_ISREG(inode->i_mode)) ext2_ioctl()
H A Dxattr.c75 inode->i_sb->s_id, inode->i_ino); \
172 bh = sb_bread(inode->i_sb, EXT2_I(inode)->i_file_acl); ext2_xattr_get()
181 bad_block: ext2_error(inode->i_sb, "ext2_xattr_get", ext2_xattr_get()
210 if (size > inode->i_sb->s_blocksize || ext2_xattr_get()
211 le16_to_cpu(entry->e_value_offs) + size > inode->i_sb->s_blocksize) ext2_xattr_get()
261 bh = sb_bread(inode->i_sb, EXT2_I(inode)->i_file_acl); ext2_xattr_list()
270 bad_block: ext2_error(inode->i_sb, "ext2_xattr_list", ext2_xattr_list()
361 struct super_block *sb = inode->i_sb; ext2_xattr_set()
624 struct super_block *sb = inode->i_sb; ext2_xattr_set2()
763 bh = sb_bread(inode->i_sb, EXT2_I(inode)->i_file_acl); ext2_xattr_delete_inode()
765 ext2_error(inode->i_sb, "ext2_xattr_delete_inode", ext2_xattr_delete_inode()
773 ext2_error(inode->i_sb, "ext2_xattr_delete_inode", ext2_xattr_delete_inode()
910 ce = mb_cache_entry_find_first(ext2_xattr_cache, inode->i_sb->s_bdev, ext2_xattr_cache_find()
921 bh = sb_bread(inode->i_sb, ce->e_block); ext2_xattr_cache_find()
923 ext2_error(inode->i_sb, "ext2_xattr_cache_find", ext2_xattr_cache_find()
943 ce = mb_cache_entry_find_next(ce, inode->i_sb->s_bdev, hash); ext2_xattr_cache_find()
H A Ddir.c64 return inode->i_sb->s_blocksize; ext2_chunk_size()
121 struct super_block *sb = dir->i_sb; ext2_check_page()
283 if (EXT2_HAS_INCOMPAT_FEATURE(inode->i_sb, EXT2_FEATURE_INCOMPAT_FILETYPE)) ext2_set_de_type()
294 struct super_block *sb = inode->i_sb; ext2_readdir()
398 ext2_error(dir->i_sb, __func__, ext2_find_entry()
415 ext2_error(dir->i_sb, __func__, ext2_find_entry()
530 ext2_error(dir->i_sb, __func__, ext2_add_link()
600 ext2_error(inode->i_sb, __func__, ext2_delete_entry()
692 ext2_error(inode->i_sb, __func__, ext2_empty_dir()
H A Dialloc.c105 struct super_block * sb = inode->i_sb; ext2_free_inode()
179 block_group = (inode->i_ino - 1) / EXT2_INODES_PER_GROUP(inode->i_sb); ext2_preread_inode()
180 gdp = ext2_get_group_desc(inode->i_sb, block_group, NULL); ext2_preread_inode()
187 offset = ((inode->i_ino - 1) % EXT2_INODES_PER_GROUP(inode->i_sb)) * ext2_preread_inode()
188 EXT2_INODE_SIZE(inode->i_sb); ext2_preread_inode()
190 (offset >> EXT2_BLOCK_SIZE_BITS(inode->i_sb)); ext2_preread_inode()
191 sb_breadahead(inode->i_sb, block); ext2_preread_inode()
445 sb = dir->i_sb; ext2_new_inode()
H A Dfile.c77 struct super_block *sb = file->f_mapping->host->i_sb; ext2_fsync()
/linux-4.1.27/fs/ntfs/
H A Dinode.c242 vi = iget5_locked(base_vi->i_sb, na.mft_no, (test_t)ntfs_test_inode, ntfs_attr_iget()
297 vi = iget5_locked(base_vi->i_sb, na.mft_no, (test_t)ntfs_test_inode, ntfs_index_iget()
531 * called are i_sb, pointing to the mounted device's super block, and i_ino,
551 ntfs_volume *vol = NTFS_SB(vi->i_sb); ntfs_read_locked_inode()
594 ntfs_error(vi->i_sb, "Inode is not in use!"); ntfs_read_locked_inode()
598 ntfs_error(vi->i_sb, "Inode is an extent inode!"); ntfs_read_locked_inode()
657 ntfs_error(vi->i_sb, "$STANDARD_INFORMATION attribute " ntfs_read_locked_inode()
695 ntfs_error(vi->i_sb, "Failed to lookup attribute list " ntfs_read_locked_inode()
706 ntfs_error(vi->i_sb, "Attribute list attribute is " ntfs_read_locked_inode()
713 ntfs_error(vi->i_sb, "Non-resident attribute " ntfs_read_locked_inode()
718 ntfs_warning(vi->i_sb, "Resident attribute list " ntfs_read_locked_inode()
731 ntfs_error(vi->i_sb, "Not enough memory to allocate " ntfs_read_locked_inode()
739 ntfs_error(vi->i_sb, "Attribute list has non " ntfs_read_locked_inode()
752 ntfs_error(vi->i_sb, "Mapping pairs " ntfs_read_locked_inode()
761 ntfs_error(vi->i_sb, "Failed to load " ntfs_read_locked_inode()
770 ntfs_error(vi->i_sb, "Corrupt attribute list " ntfs_read_locked_inode()
801 ntfs_error(vi->i_sb, "$INDEX_ROOT attribute " ntfs_read_locked_inode()
830 ntfs_error(vi->i_sb, "Found encrypted and " ntfs_read_locked_inode()
842 ntfs_error(vi->i_sb, "$INDEX_ROOT attribute is " ntfs_read_locked_inode()
849 ntfs_error(vi->i_sb, "Directory index is corrupt."); ntfs_read_locked_inode()
853 ntfs_error(vi->i_sb, "Indexed attribute is not " ntfs_read_locked_inode()
858 ntfs_error(vi->i_sb, "Index collation rule is not " ntfs_read_locked_inode()
866 ntfs_error(vi->i_sb, "Index block size (%u) is not a " ntfs_read_locked_inode()
872 ntfs_error(vi->i_sb, "Index block size (%u) > " ntfs_read_locked_inode()
881 ntfs_error(vi->i_sb, "Index block size (%u) < " ntfs_read_locked_inode()
924 ntfs_error(vi->i_sb, "$INDEX_ALLOCATION " ntfs_read_locked_inode()
928 ntfs_error(vi->i_sb, "Failed to lookup " ntfs_read_locked_inode()
935 ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute " ntfs_read_locked_inode()
952 ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute " ntfs_read_locked_inode()
957 ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute " ntfs_read_locked_inode()
962 ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute " ntfs_read_locked_inode()
967 ntfs_error(vi->i_sb, "First extent of " ntfs_read_locked_inode()
988 ntfs_error(vi->i_sb, "Failed to get bitmap attribute."); ntfs_read_locked_inode()
995 ntfs_error(vi->i_sb, "$BITMAP attribute is compressed " ntfs_read_locked_inode()
1003 ntfs_error(vi->i_sb, "Index bitmap too small (0x%llx) " ntfs_read_locked_inode()
1030 ntfs_error(vi->i_sb, "Failed to lookup $DATA " ntfs_read_locked_inode()
1053 ntfs_error(vi->i_sb, "$DATA attribute is missing."); ntfs_read_locked_inode()
1062 ntfs_error(vi->i_sb, "Found " ntfs_read_locked_inode()
1073 ntfs_error(vi->i_sb, "Found unknown " ntfs_read_locked_inode()
1084 ntfs_error(vi->i_sb, "Found encrypted and " ntfs_read_locked_inode()
1095 ntfs_error(vi->i_sb, "Found " ntfs_read_locked_inode()
1130 ntfs_error(vi->i_sb, "First extent of $DATA " ntfs_read_locked_inode()
1148 ntfs_error(vi->i_sb, "Resident data attribute " ntfs_read_locked_inode()
1228 ntfs_volume *vol = NTFS_SB(vi->i_sb); ntfs_read_locked_attr_inode()
1276 ntfs_error(vi->i_sb, "Found compressed " ntfs_read_locked_attr_inode()
1285 ntfs_error(vi->i_sb, "Found compressed " ntfs_read_locked_attr_inode()
1294 ntfs_error(vi->i_sb, "Found unknown " ntfs_read_locked_attr_inode()
1304 ntfs_error(vi->i_sb, "Found mst protected attribute " ntfs_read_locked_attr_inode()
1317 ntfs_error(vi->i_sb, "Found encrypted and compressed " ntfs_read_locked_attr_inode()
1326 ntfs_error(vi->i_sb, "Found mst protected attribute " ntfs_read_locked_attr_inode()
1334 ntfs_error(vi->i_sb, "Found encrypted non-data " ntfs_read_locked_attr_inode()
1349 ntfs_error(vi->i_sb, "Found mst protected attribute " ntfs_read_locked_attr_inode()
1360 ntfs_error(vi->i_sb, "Resident attribute is corrupt " ntfs_read_locked_attr_inode()
1380 ntfs_error(vi->i_sb, "Found non-standard " ntfs_read_locked_attr_inode()
1408 ntfs_error(vi->i_sb, "First extent of attribute has " ntfs_read_locked_attr_inode()
1495 ntfs_volume *vol = NTFS_SB(vi->i_sb); ntfs_read_locked_index_inode()
1536 ntfs_error(vi->i_sb, "$INDEX_ROOT attribute is " ntfs_read_locked_index_inode()
1559 ntfs_error(vi->i_sb, "Found compressed/encrypted/sparse index " ntfs_read_locked_index_inode()
1566 ntfs_error(vi->i_sb, "$INDEX_ROOT attribute is corrupt."); ntfs_read_locked_index_inode()
1571 ntfs_error(vi->i_sb, "Index is corrupt."); ntfs_read_locked_index_inode()
1575 ntfs_error(vi->i_sb, "Index type is not 0 (type is 0x%x).", ntfs_read_locked_index_inode()
1584 ntfs_error(vi->i_sb, "Index block size (%u) is not a power of " ntfs_read_locked_index_inode()
1589 ntfs_error(vi->i_sb, "Index block size (%u) > PAGE_CACHE_SIZE " ntfs_read_locked_index_inode()
1596 ntfs_error(vi->i_sb, "Index block size (%u) < NTFS_BLOCK_SIZE " ntfs_read_locked_index_inode()
1629 ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute is " ntfs_read_locked_index_inode()
1633 ntfs_error(vi->i_sb, "Failed to lookup " ntfs_read_locked_index_inode()
1639 ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute is " ntfs_read_locked_index_inode()
1654 ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute is " ntfs_read_locked_index_inode()
1659 ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute is sparse."); ntfs_read_locked_index_inode()
1663 ntfs_error(vi->i_sb, "$INDEX_ALLOCATION attribute is " ntfs_read_locked_index_inode()
1668 ntfs_error(vi->i_sb, "First extent of $INDEX_ALLOCATION " ntfs_read_locked_index_inode()
1687 ntfs_error(vi->i_sb, "Failed to get bitmap attribute."); ntfs_read_locked_index_inode()
1694 ntfs_error(vi->i_sb, "$BITMAP attribute is compressed and/or " ntfs_read_locked_index_inode()
1701 ntfs_error(vi->i_sb, "Index bitmap too small (0x%llx) for " ntfs_read_locked_index_inode()
1731 ntfs_error(vi->i_sb, "Failed with error code %i while reading index " ntfs_read_locked_index_inode()
1779 struct super_block *sb = vi->i_sb; ntfs_read_inode_mount()
2273 ntfs_error(vi->i_sb, "Failed to commit dirty inode " ntfs_evict_big_inode()
2395 ntfs_error(vi->i_sb, "Failed to map mft record for inode 0x%lx " ntfs_truncate()
2403 ntfs_error(vi->i_sb, "Failed to allocate a search context for " ntfs_truncate()
2413 ntfs_error(vi->i_sb, "Open attribute is missing from " ntfs_truncate()
2418 ntfs_error(vi->i_sb, "Failed to lookup attribute in " ntfs_truncate()
2492 ntfs_warning(vi->i_sb, "Changes in inode size are not " ntfs_truncate()
2816 struct timespec now = current_fs_time(VFS_I(base_ni)->i_sb); ntfs_truncate()
2901 ntfs_warning(vi->i_sb, "Changes in user/group/mode are not " ntfs_setattr()
2914 ntfs_warning(vi->i_sb, "Changes in inode size " ntfs_setattr()
2936 vi->i_sb->s_time_gran); ntfs_setattr()
2939 vi->i_sb->s_time_gran); ntfs_setattr()
2942 vi->i_sb->s_time_gran); ntfs_setattr()
3100 ntfs_warning(vi->i_sb, "Not enough memory to write inode. " __ntfs_write_inode()
3105 ntfs_error(vi->i_sb, "Failed (error %i): Run chkdsk.", -err); __ntfs_write_inode()
H A Dlogfile.c70 ntfs_error(vi->i_sb, "$LogFile uses unsupported page size."); ntfs_check_restart_page_header()
78 ntfs_error(vi->i_sb, "Found restart area in incorrect " ntfs_check_restart_page_header()
85 ntfs_error(vi->i_sb, "$LogFile version %i.%i is not " ntfs_check_restart_page_header()
102 ntfs_error(vi->i_sb, "$LogFile restart page specifies " ntfs_check_restart_page_header()
111 ntfs_error(vi->i_sb, "$LogFile restart page specifies " ntfs_check_restart_page_header()
126 ntfs_error(vi->i_sb, "$LogFile restart page specifies " ntfs_check_restart_page_header()
135 ntfs_error(vi->i_sb, "$LogFile restart page is not modified " ntfs_check_restart_page_header()
174 ntfs_error(vi->i_sb, "$LogFile restart area specifies " ntfs_check_restart_area()
188 ntfs_error(vi->i_sb, "$LogFile restart area specifies " ntfs_check_restart_area()
203 ntfs_error(vi->i_sb, "$LogFile restart area is out of bounds " ntfs_check_restart_area()
220 ntfs_error(vi->i_sb, "$LogFile restart area specifies " ntfs_check_restart_area()
235 ntfs_error(vi->i_sb, "$LogFile restart area specifies " ntfs_check_restart_area()
242 ntfs_error(vi->i_sb, "$LogFile restart area specifies " ntfs_check_restart_area()
249 ntfs_error(vi->i_sb, "$LogFile restart area specifies " ntfs_check_restart_area()
318 ntfs_error(vi->i_sb, "$LogFile log client array is corrupt."); ntfs_check_log_client_array()
375 ntfs_error(vi->i_sb, "Failed to allocate memory for $LogFile " ntfs_check_and_load_restart_page()
402 ntfs_error(vi->i_sb, "Error mapping $LogFile " ntfs_check_and_load_restart_page()
432 ntfs_error(vi->i_sb, "Multi sector transfer error " ntfs_check_and_load_restart_page()
488 ntfs_volume *vol = NTFS_SB(log_vi->i_sb); ntfs_check_logfile()
681 ntfs_volume *vol = NTFS_SB(log_vi->i_sb); ntfs_is_logfile_clean()
H A Dbitmap.c78 ntfs_error(vi->i_sb, "Failed to map first page (error " __ntfs_bitmap_set_bits_in_run()
180 ntfs_error(vi->i_sb, "Failed to map subsequent page (error " __ntfs_bitmap_set_bits_in_run()
184 ntfs_error(vi->i_sb, "Failed to map subsequent page (error " __ntfs_bitmap_set_bits_in_run()
188 NVolSetErrors(NTFS_SB(vi->i_sb)); __ntfs_bitmap_set_bits_in_run()
/linux-4.1.27/fs/
H A Dinode.c30 * inode->i_sb->s_inode_lru, inode->i_lru
137 inode->i_sb = sb; inode_init_always()
207 if (inode->i_sb->s_op->destroy_inode) alloc_inode()
208 inode->i_sb->s_op->destroy_inode(inode); alloc_inode()
230 WARN_ON(atomic_long_read(&inode->i_sb->s_remove_count) == 0); __destroy_inode()
231 atomic_long_dec(&inode->i_sb->s_remove_count); __destroy_inode()
254 if (inode->i_sb->s_op->destroy_inode) destroy_inode()
255 inode->i_sb->s_op->destroy_inode(inode); destroy_inode()
276 atomic_long_inc(&inode->i_sb->s_remove_count); drop_nlink()
292 atomic_long_inc(&inode->i_sb->s_remove_count); clear_nlink()
312 atomic_long_dec(&inode->i_sb->s_remove_count); set_nlink()
331 atomic_long_dec(&inode->i_sb->s_remove_count); inc_nlink()
396 if (list_lru_add(&inode->i_sb->s_inode_lru, &inode->i_lru)) inode_lru_list_add()
409 !atomic_read(&inode->i_count) && inode->i_sb->s_flags & MS_ACTIVE) inode_add_lru()
417 if (list_lru_del(&inode->i_sb->s_inode_lru, &inode->i_lru)) inode_lru_list_del()
428 list_add(&inode->i_sb_list, &inode->i_sb->s_inodes); inode_sb_list_add()
462 struct hlist_head *b = inode_hashtable + hash(inode->i_sb, hashval); __insert_inode_hash()
523 const struct super_operations *op = inode->i_sb->s_op; evict()
767 if (inode->i_sb != sb) hlist_for_each_entry()
796 if (inode->i_sb != sb) hlist_for_each_entry()
900 struct file_system_type *type = inode->i_sb->s_type; lockdep_annotate_inode_mutex_key()
1126 if (inode->i_ino == ino && inode->i_sb == sb) { hlist_for_each_entry()
1308 if (inode->i_sb != sb) hlist_for_each_entry()
1325 struct super_block *sb = inode->i_sb; insert_inode_locked()
1335 if (old->i_sb != sb) hlist_for_each_entry()
1368 struct super_block *sb = inode->i_sb; insert_inode_locked4()
1376 if (old->i_sb != sb) hlist_for_each_entry()
1427 struct super_block *sb = inode->i_sb; iput_final()
1428 const struct super_operations *op = inode->i_sb->s_op; iput_final()
1558 if (!(inode->i_sb->s_flags & MS_LAZYTIME) || (flags & S_VERSION)) generic_update_time()
1597 if ((inode->i_sb->s_flags & MS_NODIRATIME) && S_ISDIR(inode->i_mode)) touch_atime()
1605 now = current_fs_time(inode->i_sb); touch_atime()
1613 if (!sb_start_write_trylock(inode->i_sb)) touch_atime()
1630 sb_end_write(inode->i_sb); touch_atime()
1727 now = current_fs_time(inode->i_sb); file_update_time()
1869 " inode %s:%lu\n", mode, inode->i_sb->s_id, init_special_inode()
H A Dattr.c107 if (offset > inode->i_sb->s_maxbytes) inode_newsize_ok()
152 inode->i_sb->s_time_gran); setattr_copy()
155 inode->i_sb->s_time_gran); setattr_copy()
158 inode->i_sb->s_time_gran); setattr_copy()
212 now = current_fs_time(inode->i_sb); notify_change()
H A Dfs-writeback.c88 sb = inode->i_sb; inode_to_bdi()
303 if (sb_is_blkdev_sb(inode->i_sb)) move_expired_inodes()
305 if (sb && sb != inode->i_sb) move_expired_inodes()
307 sb = inode->i_sb; move_expired_inodes()
318 sb = wb_inode(tmp.prev)->i_sb; move_expired_inodes()
321 if (inode->i_sb == sb) move_expired_inodes()
356 if (inode->i_sb->s_op->write_inode && !is_bad_inode(inode)) { write_inode()
358 ret = inode->i_sb->s_op->write_inode(inode, wbc); write_inode()
684 if (inode->i_sb != sb) { writeback_sb_inodes()
788 struct super_block *sb = inode->i_sb; __writeback_inodes_wb()
1204 if (inode->i_ino || strcmp(inode->i_sb->s_id, "bdev")) { block_dump___mark_inode_dirty()
1216 name, inode->i_sb->s_id); block_dump___mark_inode_dirty()
1251 struct super_block *sb = inode->i_sb; __mark_inode_dirty()
/linux-4.1.27/fs/freevxfs/
H A Dvxfs_bmap.c69 struct super_block *sb = ip->i_sb; vxfs_bmap_ext4()
134 for (i = 0; i < size * VXFS_TYPED_PER_BLOCK(ip->i_sb); i++) { vxfs_bmap_indir()
138 bp = sb_bread(ip->i_sb, vxfs_bmap_indir()
139 indir + (i / VXFS_TYPED_PER_BLOCK(ip->i_sb))); vxfs_bmap_indir()
144 (i % VXFS_TYPED_PER_BLOCK(ip->i_sb)); vxfs_bmap_indir()
H A Dvxfs_lookup.c74 u_long bsize = ip->i_sb->s_blocksize; dir_blocks()
117 u_long bsize = ip->i_sb->s_blocksize; vxfs_find_entry()
123 pblocks = VXFS_BLOCK_PER_PAGE(ip->i_sb); vxfs_find_entry()
216 ip = vxfs_iget(dip->i_sb, ino); vxfs_lookup()
241 struct super_block *sbp = ip->i_sb; vxfs_readdir()
H A Dvxfs_subr.c108 bp = sb_bread(ip->i_sb, pblock); vxfs_bread()
136 map_bh(bp, ip->i_sb, pblock); vxfs_getblk()
/linux-4.1.27/fs/logfs/
H A Dreadwrite.c189 struct super_block *sb = inode->i_sb; __logfs_set_blocks()
423 logfs_write_anchor(inode->i_sb); inode_write_block()
609 block = __alloc_block(inode->i_sb, LOGFS_INO_MASTER, inode->i_ino, 0); alloc_inode_block()
654 block = __alloc_block(inode->i_sb, inode->i_ino, bix, level); alloc_data_block()
946 struct super_block *sb = inode->i_sb; logfs_seek_data()
1084 struct logfs_super *super = logfs_super(inode->i_sb); logfs_reserve_bytes()
1103 struct logfs_super *super = logfs_super(inode->i_sb); get_page_reserve()
1110 logfs_get_wblocks(inode->i_sb, page, WF_LOCK); get_page_reserve()
1124 logfs_put_wblocks(inode->i_sb, page, WF_LOCK); get_page_reserve()
1136 struct logfs_super *super = logfs_super(inode->i_sb); logfs_handle_transaction()
1220 struct logfs_super *super = logfs_super(inode->i_sb); alloc_shadow()
1234 struct logfs_super *super = logfs_super(inode->i_sb); free_shadow()
1277 struct logfs_super *super = logfs_super(inode->i_sb); fill_shadow_tree()
1286 block->ops->free_block(inode->i_sb, block); fill_shadow_tree()
1336 logfs_set_alias(inode->i_sb, li->li_block, INODE_USED_OFS); set_iused()
1337 logfs_set_alias(inode->i_sb, li->li_block, INODE_SIZE_OFS); set_iused()
1393 logfs_set_alias(inode->i_sb, li->li_block, logfs_write_direct()
1461 logfs_set_alias(inode->i_sb, logfs_block(ipage), child_no); __logfs_write_rec()
1489 logfs_set_alias(inode->i_sb, li->li_block, logfs_write_rec()
1535 logfs_set_alias(inode->i_sb, li->li_block, INODE_HEIGHT_OFS); grow_inode()
1542 struct logfs_super *super = logfs_super(inode->i_sb); __logfs_write_buf()
1567 struct super_block *sb = inode->i_sb; logfs_write_buf()
1594 struct super_block *sb = inode->i_sb; logfs_delete()
1634 logfs_write_anchor(inode->i_sb); logfs_rewrite_block()
1647 loff_t pageofs = page->index << inode->i_sb->s_blocksize_bits; truncate_data_block()
1870 struct super_block *sb = inode->i_sb; logfs_truncate()
1953 struct super_block *sb = inode->i_sb; logfs_read_inode()
1981 struct inode *master_inode = logfs_super(inode->i_sb)->s_master_inode; inode_to_page()
2000 struct super_block *sb = inode->i_sb; do_write_inode()
2002 loff_t size = (inode->i_ino + 1) << inode->i_sb->s_blocksize_bits; do_write_inode()
2134 struct super_block *sb = inode->i_sb; __logfs_write_inode()
2145 struct super_block *sb = inode->i_sb; do_delete_inode()
2170 struct super_block *sb = inode->i_sb; logfs_evict_inode()
2194 block->ops->free_block(inode->i_sb, block); logfs_evict_inode()
2241 loff_t pos = bix << inode->i_sb->s_blocksize_bits; logfs_inode_write()
H A Ddir.c86 loff_t pos = bix << inode->i_sb->s_blocksize_bits; beyond_eof()
202 LOGFS_BUG_ON(ret, inode->i_sb); logfs_remove_inode()
215 struct logfs_super *super = logfs_super(dir->i_sb); logfs_unlink()
268 data = logfs_seek_data(dir, 0) << dir->i_sb->s_blocksize_bits; logfs_empty_dir()
354 inode = logfs_iget(dir->i_sb, ino); logfs_lookup()
363 index = (index + 1) << dir->i_sb->s_blocksize_bits; grow_dir()
410 struct logfs_super *super = logfs_super(dir->i_sb); __logfs_create()
524 if (destlen > dir->i_sb->s_blocksize) logfs_symlink()
588 struct logfs_super *super = logfs_super(old_dir->i_sb); logfs_rename_cross()
627 LOGFS_BUG_ON(err, old_dir->i_sb); logfs_rename_cross()
660 struct logfs_super *super = logfs_super(old_dir->i_sb); logfs_rename_target()
707 LOGFS_BUG_ON(err, old_dir->i_sb); logfs_rename_target()
H A Dfile.c48 BUG_ON(PAGE_CACHE_SIZE != inode->i_sb->s_blocksize); logfs_write_end()
168 struct super_block *sb = page->mapping->host->i_sb; logfs_invalidatepage()
225 struct super_block *sb = file->f_mapping->host->i_sb; logfs_fsync()
/linux-4.1.27/fs/nfsd/
H A Dblocklayout.c52 struct super_block *sb = inode->i_sb; nfsd4_block_proc_layoutget()
160 lcp->lc_mtime = current_fs_time(inode->i_sb); nfsd4_block_proc_layoutcommit()
169 error = inode->i_sb->s_export_op->commit_blocks(inode, iomaps, nfsd4_block_proc_layoutcommit()
/linux-4.1.27/fs/adfs/
H A Ddir.c23 struct super_block *sb = inode->i_sb; adfs_readdir()
131 struct super_block *sb = inode->i_sb; adfs_dir_lookup_byname()
274 inode = adfs_iget(dir->i_sb, &obj); adfs_lookup()
H A Dinode.c26 block = __adfs_block_map(inode->i_sb, inode->i_ino, block); adfs_get_block()
28 map_bh(bh, inode->i_sb, block); adfs_get_block()
302 struct super_block *sb = inode->i_sb; adfs_notify_change()
357 struct super_block *sb = inode->i_sb; adfs_write_inode()
/linux-4.1.27/fs/notify/
H A Dfdinfo.c86 inode_mark->wd, inode->i_ino, inode->i_sb->s_dev, inotify_fdinfo()
119 inode->i_ino, inode->i_sb->s_dev, fanotify_fdinfo()
/linux-4.1.27/fs/qnx4/
H A Dnamei.c69 bh = sb_bread(dir->i_sb, block); qnx4_find_entry()
115 foundinode = qnx4_iget(dir->i_sb, ino); qnx4_lookup()
H A Ddir.c33 bh = sb_bread(inode->i_sb, blknum); qnx4_readdir()
/linux-4.1.27/include/linux/
H A Dcleancache.h53 return page->mapping->host->i_sb->cleancache_poolid >= 0; cleancache_fs_enabled()
57 return mapping->host->i_sb->cleancache_poolid >= 0; cleancache_fs_enabled_mapping()
/linux-4.1.27/fs/jffs2/
H A Dfile.c35 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb); jffs2_fsync()
85 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb); jffs2_do_readpage_nolock()
153 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb); jffs2_write_begin()
246 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb); jffs2_write_end()
H A Ddir.c107 inode = jffs2_iget(dir_i->i_sb, ino); jffs2_lookup()
171 c = JFFS2_SB_INFO(dir_i->i_sb); jffs2_create()
225 struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb); jffs2_unlink()
244 struct jffs2_sb_info *c = JFFS2_SB_INFO(d_inode(old_dentry)->i_sb); jffs2_link()
301 c = JFFS2_SB_INFO(dir_i->i_sb); jffs2_symlink()
459 c = JFFS2_SB_INFO(dir_i->i_sb); jffs2_mkdir()
586 struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb); jffs2_rmdir()
630 c = JFFS2_SB_INFO(dir_i->i_sb); jffs2_mknod()
763 struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dir_i->i_sb); jffs2_rename()
/linux-4.1.27/security/integrity/
H A Dintegrity_audit.c60 audit_log_untrustedstring(ab, inode->i_sb->s_id); integrity_audit_msg()
/linux-4.1.27/mm/
H A Dcleancache.c150 struct super_block *sb = inode->i_sb; cleancache_get_key()
189 pool_id = page->mapping->host->i_sb->cleancache_poolid; __cleancache_get_page()
227 pool_id = page->mapping->host->i_sb->cleancache_poolid; __cleancache_put_page()
248 int pool_id = mapping->host->i_sb->cleancache_poolid; __cleancache_invalidate_page()
276 int pool_id = mapping->host->i_sb->cleancache_poolid; __cleancache_invalidate_inode()
/linux-4.1.27/fs/xfs/
H A Dxfs_trace.h59 __entry->dev = VFS_I(ctx->dp)->i_sb->s_dev;
183 __entry->dev = VFS_I(ctx->dp)->i_sb->s_dev;
231 __entry->dev = VFS_I(ip)->i_sb->s_dev;
275 __entry->dev = VFS_I(ip)->i_sb->s_dev;
552 __entry->dev = VFS_I(ip)->i_sb->s_dev;
584 __entry->dev = VFS_I(ip)->i_sb->s_dev;
611 __entry->dev = VFS_I(ip)->i_sb->s_dev;
641 __entry->dev = VFS_I(ip)->i_sb->s_dev;
703 __entry->dev = VFS_I(ip)->i_sb->s_dev;
729 __entry->dev = VFS_I(ip)->i_sb->s_dev;
761 __entry->dev = VFS_I(dp)->i_sb->s_dev;
797 __entry->dev = VFS_I(src_dp)->i_sb->s_dev;
1101 __entry->dev = VFS_I(ip)->i_sb->s_dev;
1146 __entry->dev = inode->i_sb->s_dev;
1192 __entry->dev = VFS_I(ip)->i_sb->s_dev;
1242 __entry->dev = VFS_I(ip)->i_sb->s_dev;
1278 __entry->dev = VFS_I(ip)->i_sb->s_dev;
1308 __entry->dev = VFS_I(ip)->i_sb->s_dev;
1336 __entry->dev = VFS_I(ip)->i_sb->s_dev;
1642 __entry->dev = VFS_I(args->dp)->i_sb->s_dev;
1706 __entry->dev = VFS_I(args->dp)->i_sb->s_dev;
1811 __entry->dev = VFS_I(args->dp)->i_sb->s_dev;
1844 __entry->dev = VFS_I(args->dp)->i_sb->s_dev;
1884 __entry->dev = VFS_I(ip)->i_sb->s_dev;
H A Dxfs_acl.c243 iattr.ia_ctime = current_fs_time(inode->i_sb); xfs_set_mode()
254 int len = XFS_ACL_MAX_SIZE(XFS_M(inode->i_sb)); xfs_acl_exists()
283 if (acl->a_count > XFS_ACL_MAX_ENTRIES(XFS_M(inode->i_sb))) xfs_set_acl()
/linux-4.1.27/fs/cifs/
H A Ddir.c201 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); cifs_do_create()
223 rc = cifs_posix_open(full_path, &newinode, inode->i_sb, mode, cifs_do_create()
377 rc = cifs_get_inode_info_unix(&newinode, full_path, inode->i_sb, cifs_do_create()
380 rc = cifs_get_inode_info(&newinode, full_path, buf, inode->i_sb, cifs_do_create()
467 tlink = cifs_sb_tlink(CIFS_SB(inode->i_sb)); cifs_atomic_open()
501 CIFS_SB(inode->i_sb)->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) { cifs_atomic_open()
502 if (CIFS_SB(inode->i_sb)->mnt_cifs_flags & CIFS_MOUNT_NO_BRL) cifs_atomic_open()
546 tlink = cifs_sb_tlink(CIFS_SB(inode->i_sb)); cifs_create()
591 cifs_sb = CIFS_SB(inode->i_sb); cifs_mknod()
628 inode->i_sb, xid); cifs_mknod()
726 cifs_sb = CIFS_SB(parent_dir_inode->i_sb); cifs_lookup()
757 parent_dir_inode->i_sb, xid); cifs_lookup()
760 parent_dir_inode->i_sb, xid, NULL); cifs_lookup()
H A Dinode.c39 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
157 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); cifs_fattr_to_inode()
338 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); cifs_get_file_info_unix()
347 cifs_create_dfs_fattr(&fattr, inode->i_sb); cifs_get_file_info_unix()
660 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); cifs_get_file_info()
676 cifs_create_dfs_fattr(&fattr, inode->i_sb); cifs_get_file_info()
1037 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); cifs_set_file_info()
1096 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); cifs_rename_pending_delete()
1236 struct super_block *sb = dir->i_sb; cifs_unlink()
1348 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb, cifs_mkdir_qinfo()
1351 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb, cifs_mkdir_qinfo()
1449 cifs_fill_uniqueid(inode->i_sb, &fattr); cifs_posix_mkdir()
1450 newinode = cifs_iget(inode->i_sb, &fattr); cifs_posix_mkdir()
1487 cifs_sb = CIFS_SB(inode->i_sb); cifs_mkdir()
1559 cifs_sb = CIFS_SB(inode->i_sb); cifs_rmdir()
1596 current_fs_time(inode->i_sb); cifs_rmdir()
1681 cifs_sb = CIFS_SB(source_dir->i_sb); cifs_rename2()
1769 target_dir->i_mtime = current_fs_time(source_dir->i_sb); cifs_rename2()
1784 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); cifs_inode_needs_reval()
2033 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); cifs_set_file_size()
2105 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); cifs_setattr_unix()
2244 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); cifs_setattr_nounix()
2402 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); cifs_setattr()
/linux-4.1.27/fs/ncpfs/
H A Dfile.c116 if (pos > inode->i_sb->s_maxbytes) ncp_file_read_iter()
118 iov_iter_truncate(to, inode->i_sb->s_maxbytes - pos); ncp_file_read_iter()
H A Dncp_fs.h48 #define NCP_SERVER(inode) NCP_SBP((inode)->i_sb) NCP_FINFO()
/linux-4.1.27/include/uapi/linux/
H A Diso_fs.h162 #define ISOFS_BUFFER_SIZE(INODE) ((INODE)->i_sb->s_blocksize)
163 #define ISOFS_BUFFER_BITS(INODE) ((INODE)->i_sb->s_blocksize_bits)
/linux-4.1.27/fs/gfs2/
H A Dmeta_io.h51 return inode->i_sb->s_fs_info; gfs2_mapping2sbd()
/linux-4.1.27/fs/ubifs/
H A Ddir.c191 struct ubifs_info *c = dir->i_sb->s_fs_info; ubifs_lookup()
218 inode = ubifs_iget(dir->i_sb, le64_to_cpu(dent->inum)); ubifs_lookup()
249 struct ubifs_info *c = dir->i_sb->s_fs_info; ubifs_create()
358 struct ubifs_info *c = dir->i_sb->s_fs_info; ubifs_readdir()
501 struct ubifs_info *c = dir->i_sb->s_fs_info; ubifs_link()
556 struct ubifs_info *c = dir->i_sb->s_fs_info; ubifs_unlink()
648 struct ubifs_info *c = dir->i_sb->s_fs_info; ubifs_rmdir()
712 struct ubifs_info *c = dir->i_sb->s_fs_info; ubifs_mkdir()
775 struct ubifs_info *c = dir->i_sb->s_fs_info; ubifs_mknod()
855 struct ubifs_info *c = dir->i_sb->s_fs_info; ubifs_symlink()
972 struct ubifs_info *c = old_dir->i_sb->s_fs_info; ubifs_rename()
1107 err = old_inode->i_sb->s_op->write_inode(old_inode, NULL); ubifs_rename()
H A Dfile.c60 struct ubifs_info *c = inode->i_sb->s_fs_info; read_block()
163 struct ubifs_info *c = inode->i_sb->s_fs_info; do_readpage()
226 struct ubifs_info *c = inode->i_sb->s_fs_info; write_begin_slow()
430 struct ubifs_info *c = inode->i_sb->s_fs_info; ubifs_write_begin()
546 struct ubifs_info *c = inode->i_sb->s_fs_info; ubifs_write_end()
825 struct ubifs_info *c = inode->i_sb->s_fs_info; ubifs_bulk_read()
904 struct ubifs_info *c = inode->i_sb->s_fs_info; do_writepage()
1026 err = inode->i_sb->s_op->write_inode(inode, NULL); ubifs_writepage()
1054 err = inode->i_sb->s_op->write_inode(inode, NULL); ubifs_writepage()
1079 inode->i_sb->s_time_gran); do_attr_changes()
1082 inode->i_sb->s_time_gran); do_attr_changes()
1085 inode->i_sb->s_time_gran); do_attr_changes()
1253 err = inode->i_sb->s_op->write_inode(inode, NULL); do_setattr()
1261 struct ubifs_info *c = inode->i_sb->s_fs_info; ubifs_setattr()
1286 struct ubifs_info *c = inode->i_sb->s_fs_info; ubifs_invalidatepage()
1314 struct ubifs_info *c = inode->i_sb->s_fs_info; ubifs_fsync()
1333 err = inode->i_sb->s_op->write_inode(inode, NULL); ubifs_fsync()
1378 struct ubifs_info *c = inode->i_sb->s_fs_info; update_mctime()
1447 struct ubifs_info *c = inode->i_sb->s_fs_info; ubifs_vm_page_mkwrite()
/linux-4.1.27/fs/ceph/
H A Dioctl.c66 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc; ceph_ioctl_set_layout()
141 struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc; ceph_ioctl_set_layout_policy()
184 &ceph_sb_to_client(inode->i_sb)->client->osdc; ceph_ioctl_get_dataloc()
/linux-4.1.27/fs/configfs/
H A Dinode.c93 inode->i_sb->s_time_gran); configfs_setattr()
96 inode->i_sb->s_time_gran); configfs_setattr()
99 inode->i_sb->s_time_gran); configfs_setattr()
/linux-4.1.27/fs/cramfs/
H A Dinode.c373 struct super_block *sb = inode->i_sb; cramfs_readdir()
440 sorted = CRAMFS_SB(dir->i_sb)->flags & CRAMFS_FLAG_SORTED_DIRS; cramfs_lookup()
447 de = cramfs_read(dir->i_sb, dir_off, sizeof(*de)+CRAMFS_MAXPATHLEN); cramfs_lookup()
476 inode = get_cramfs_inode(dir->i_sb, de, dir_off); cramfs_lookup()
503 struct super_block *sb = inode->i_sb; cramfs_readpage()
/linux-4.1.27/fs/autofs4/
H A Droot.c509 sbi = autofs4_sbi(dir->i_sb); autofs4_lookup()
550 struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb); autofs4_dir_symlink()
574 inode = autofs4_get_inode(dir->i_sb, S_IFLNK | 0555); autofs4_dir_symlink()
613 struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb); autofs4_dir_unlink()
695 struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb); autofs4_dir_rmdir()
733 struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb); autofs4_dir_mkdir()
749 inode = autofs4_get_inode(dir->i_sb, S_IFDIR | 0555); autofs4_dir_mkdir()
854 struct autofs_sb_info *sbi = autofs4_sbi(inode->i_sb); autofs4_root_ioctl_unlocked()
891 return autofs4_expire_run(inode->i_sb,filp->f_path.mnt,sbi, p); autofs4_root_ioctl_unlocked()
894 return autofs4_expire_multi(inode->i_sb,filp->f_path.mnt,sbi, p); autofs4_root_ioctl_unlocked()
/linux-4.1.27/security/
H A Dlsm_audit.c243 audit_log_untrustedstring(ab, inode->i_sb->s_id); dump_common_audit_data()
257 audit_log_untrustedstring(ab, inode->i_sb->s_id); dump_common_audit_data()
275 audit_log_untrustedstring(ab, inode->i_sb->s_id); dump_common_audit_data()
/linux-4.1.27/fs/proc/
H A Dnamespaces.c88 inode = proc_pid_make_inode(dir->i_sb, task); proc_ns_instantiate()
H A Dnommu.c49 dev = inode->i_sb->s_dev; nommu_region_show()

Completed in 2145 milliseconds

123