+1 -1

arch/ia64/kernel/perfmon.c

reviewed

··· 2159 2159 static char *pfmfs_dname(struct dentry *dentry, char *buffer, int buflen) 2160 2160 { 2161 2161 return dynamic_dname(dentry, buffer, buflen, "pfm:[%lu]", 2162 2162 - dentry->d_inode->i_ino); 2162 2162 + d_inode(dentry)->i_ino); 2163 2163 } 2164 2164 2165 2165 static const struct dentry_operations pfmfs_dentry_operations = {

+11 -11

arch/powerpc/platforms/cell/spufs/inode.c

reviewed

··· 111 111 static int 112 112 spufs_setattr(struct dentry *dentry, struct iattr *attr) 113 113 { 114 114 - struct inode *inode = dentry->d_inode; 114 114 + struct inode *inode = d_inode(dentry); 115 115 116 116 if ((attr->ia_valid & ATTR_SIZE) && 117 117 (attr->ia_size != inode->i_size)) ··· 163 163 { 164 164 struct dentry *dentry, *tmp; 165 165 166 166 - mutex_lock(&dir->d_inode->i_mutex); 166 166 + mutex_lock(&d_inode(dir)->i_mutex); 167 167 list_for_each_entry_safe(dentry, tmp, &dir->d_subdirs, d_child) { 168 168 spin_lock(&dentry->d_lock); 169 169 - if (!(d_unhashed(dentry)) && dentry->d_inode) { 169 169 + if (!(d_unhashed(dentry)) && d_really_is_positive(dentry)) { 170 170 dget_dlock(dentry); 171 171 __d_drop(dentry); 172 172 spin_unlock(&dentry->d_lock); 173 173 - simple_unlink(dir->d_inode, dentry); 173 173 + simple_unlink(d_inode(dir), dentry); 174 174 /* XXX: what was dcache_lock protecting here? Other 175 175 * filesystems (IB, configfs) release dcache_lock 176 176 * before unlink */ ··· 180 180 } 181 181 } 182 182 shrink_dcache_parent(dir); 183 183 - mutex_unlock(&dir->d_inode->i_mutex); 183 183 + mutex_unlock(&d_inode(dir)->i_mutex); 184 184 } 185 185 186 186 /* Caller must hold parent->i_mutex */ ··· 192 192 d_drop(dir); 193 193 res = simple_rmdir(parent, dir); 194 194 /* We have to give up the mm_struct */ 195 195 - spu_forget(SPUFS_I(dir->d_inode)->i_ctx); 195 195 + spu_forget(SPUFS_I(d_inode(dir))->i_ctx); 196 196 return res; 197 197 } 198 198 ··· 222 222 int ret; 223 223 224 224 dir = file->f_path.dentry; 225 225 - parent = dir->d_parent->d_inode; 226 226 - ctx = SPUFS_I(dir->d_inode)->i_ctx; 225 225 + parent = d_inode(dir->d_parent); 226 226 + ctx = SPUFS_I(d_inode(dir))->i_ctx; 227 227 228 228 mutex_lock_nested(&parent->i_mutex, I_MUTEX_PARENT); 229 229 ret = spufs_rmdir(parent, dir); ··· 460 460 goto out_aff_unlock; 461 461 462 462 if (affinity) { 463 463 - spufs_set_affinity(flags, SPUFS_I(dentry->d_inode)->i_ctx, 463 463 + spufs_set_affinity(flags, SPUFS_I(d_inode(dentry))->i_ctx, 464 464 neighbor); 465 465 if (neighbor) 466 466 put_spu_context(neighbor); ··· 504 504 505 505 d_instantiate(dentry, inode); 506 506 inc_nlink(dir); 507 507 - inc_nlink(dentry->d_inode); 507 507 + inc_nlink(d_inode(dentry)); 508 508 return ret; 509 509 510 510 out_iput: ··· 561 561 long spufs_create(struct path *path, struct dentry *dentry, 562 562 unsigned int flags, umode_t mode, struct file *filp) 563 563 { 564 564 - struct inode *dir = path->dentry->d_inode; 564 564 + struct inode *dir = d_inode(path->dentry); 565 565 int ret; 566 566 567 567 /* check if we are on spufs */

+9 -9

arch/s390/hypfs/inode.c

reviewed

··· 48 48 static void hypfs_update_update(struct super_block *sb) 49 49 { 50 50 struct hypfs_sb_info *sb_info = sb->s_fs_info; 51 51 - struct inode *inode = sb_info->update_file->d_inode; 51 51 + struct inode *inode = d_inode(sb_info->update_file); 52 52 53 53 sb_info->last_update = get_seconds(); 54 54 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME; ··· 64 64 65 65 static inline int hypfs_positive(struct dentry *dentry) 66 66 { 67 67 - return dentry->d_inode && !d_unhashed(dentry); 67 67 + return d_really_is_positive(dentry) && !d_unhashed(dentry); 68 68 } 69 69 70 70 static void hypfs_remove(struct dentry *dentry) ··· 72 72 struct dentry *parent; 73 73 74 74 parent = dentry->d_parent; 75 75 - mutex_lock(&parent->d_inode->i_mutex); 75 75 + mutex_lock(&d_inode(parent)->i_mutex); 76 76 if (hypfs_positive(dentry)) { 77 77 if (d_is_dir(dentry)) 78 78 - simple_rmdir(parent->d_inode, dentry); 78 78 + simple_rmdir(d_inode(parent), dentry); 79 79 else 80 80 - simple_unlink(parent->d_inode, dentry); 80 80 + simple_unlink(d_inode(parent), dentry); 81 81 } 82 82 d_delete(dentry); 83 83 dput(dentry); 84 84 - mutex_unlock(&parent->d_inode->i_mutex); 84 84 + mutex_unlock(&d_inode(parent)->i_mutex); 85 85 } 86 86 87 87 static void hypfs_delete_tree(struct dentry *root) ··· 336 336 struct dentry *dentry; 337 337 struct inode *inode; 338 338 339 339 - mutex_lock(&parent->d_inode->i_mutex); 339 339 + mutex_lock(&d_inode(parent)->i_mutex); 340 340 dentry = lookup_one_len(name, parent, strlen(name)); 341 341 if (IS_ERR(dentry)) { 342 342 dentry = ERR_PTR(-ENOMEM); ··· 357 357 } else if (S_ISDIR(mode)) { 358 358 inode->i_op = &simple_dir_inode_operations; 359 359 inode->i_fop = &simple_dir_operations; 360 360 - inc_nlink(parent->d_inode); 360 360 + inc_nlink(d_inode(parent)); 361 361 } else 362 362 BUG(); 363 363 inode->i_private = data; 364 364 d_instantiate(dentry, inode); 365 365 dget(dentry); 366 366 fail: 367 367 - mutex_unlock(&parent->d_inode->i_mutex); 367 367 + mutex_unlock(&d_inode(parent)->i_mutex); 368 368 return dentry; 369 369 } 370 370

+1 -1

arch/x86/kvm/assigned-dev.c

reviewed

··· 666 666 if (r) 667 667 return r; 668 668 669 669 - inode = path.dentry->d_inode; 669 669 + inode = d_backing_inode(path.dentry); 670 670 671 671 r = inode_permission(inode, MAY_READ | MAY_WRITE | MAY_ACCESS); 672 672 path_put(&path);

+16 -16

drivers/base/devtmpfs.c

reviewed

··· 157 157 if (IS_ERR(dentry)) 158 158 return PTR_ERR(dentry); 159 159 160 160 - err = vfs_mkdir(path.dentry->d_inode, dentry, mode); 160 160 + err = vfs_mkdir(d_inode(path.dentry), dentry, mode); 161 161 if (!err) 162 162 /* mark as kernel-created inode */ 163 163 - dentry->d_inode->i_private = &thread; 163 163 + d_inode(dentry)->i_private = &thread; 164 164 done_path_create(&path, dentry); 165 165 return err; 166 166 } ··· 207 207 if (IS_ERR(dentry)) 208 208 return PTR_ERR(dentry); 209 209 210 210 - err = vfs_mknod(path.dentry->d_inode, dentry, mode, dev->devt); 210 210 + err = vfs_mknod(d_inode(path.dentry), dentry, mode, dev->devt); 211 211 if (!err) { 212 212 struct iattr newattrs; 213 213 ··· 215 215 newattrs.ia_uid = uid; 216 216 newattrs.ia_gid = gid; 217 217 newattrs.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID; 218 218 - mutex_lock(&dentry->d_inode->i_mutex); 218 218 + mutex_lock(&d_inode(dentry)->i_mutex); 219 219 notify_change(dentry, &newattrs, NULL); 220 220 - mutex_unlock(&dentry->d_inode->i_mutex); 220 220 + mutex_unlock(&d_inode(dentry)->i_mutex); 221 221 222 222 /* mark as kernel-created inode */ 223 223 - dentry->d_inode->i_private = &thread; 223 223 + d_inode(dentry)->i_private = &thread; 224 224 } 225 225 done_path_create(&path, dentry); 226 226 return err; ··· 235 235 dentry = kern_path_locked(name, &parent); 236 236 if (IS_ERR(dentry)) 237 237 return PTR_ERR(dentry); 238 238 - if (dentry->d_inode) { 239 239 - if (dentry->d_inode->i_private == &thread) 240 240 - err = vfs_rmdir(parent.dentry->d_inode, dentry); 238 238 + if (d_really_is_positive(dentry)) { 239 239 + if (d_inode(dentry)->i_private == &thread) 240 240 + err = vfs_rmdir(d_inode(parent.dentry), dentry); 241 241 else 242 242 err = -EPERM; 243 243 } else { 244 244 err = -ENOENT; 245 245 } 246 246 dput(dentry); 247 247 - mutex_unlock(&parent.dentry->d_inode->i_mutex); 247 247 + mutex_unlock(&d_inode(parent.dentry)->i_mutex); 248 248 path_put(&parent); 249 249 return err; 250 250 } ··· 306 306 if (IS_ERR(dentry)) 307 307 return PTR_ERR(dentry); 308 308 309 309 - if (dentry->d_inode) { 309 309 + if (d_really_is_positive(dentry)) { 310 310 struct kstat stat; 311 311 struct path p = {.mnt = parent.mnt, .dentry = dentry}; 312 312 err = vfs_getattr(&p, &stat); 313 313 - if (!err && dev_mynode(dev, dentry->d_inode, &stat)) { 313 313 + if (!err && dev_mynode(dev, d_inode(dentry), &stat)) { 314 314 struct iattr newattrs; 315 315 /* 316 316 * before unlinking this node, reset permissions ··· 321 321 newattrs.ia_mode = stat.mode & ~0777; 322 322 newattrs.ia_valid = 323 323 ATTR_UID|ATTR_GID|ATTR_MODE; 324 324 - mutex_lock(&dentry->d_inode->i_mutex); 324 324 + mutex_lock(&d_inode(dentry)->i_mutex); 325 325 notify_change(dentry, &newattrs, NULL); 326 326 - mutex_unlock(&dentry->d_inode->i_mutex); 327 327 - err = vfs_unlink(parent.dentry->d_inode, dentry, NULL); 326 326 + mutex_unlock(&d_inode(dentry)->i_mutex); 327 327 + err = vfs_unlink(d_inode(parent.dentry), dentry, NULL); 328 328 if (!err || err == -ENOENT) 329 329 deleted = 1; 330 330 } ··· 332 332 err = -ENOENT; 333 333 } 334 334 dput(dentry); 335 335 - mutex_unlock(&parent.dentry->d_inode->i_mutex); 335 335 + mutex_unlock(&d_inode(parent.dentry)->i_mutex); 336 336 337 337 path_put(&parent); 338 338 if (deleted && strchr(nodename, '/'))

+4 -4

drivers/block/drbd/drbd_debugfs.c

reviewed

··· 424 424 * So we have our own inline version of it above. :-( */ 425 425 static inline int debugfs_positive(struct dentry *dentry) 426 426 { 427 427 - return dentry->d_inode && !d_unhashed(dentry); 427 427 + return d_really_is_positive(dentry) && !d_unhashed(dentry); 428 428 } 429 429 430 430 /* make sure at *open* time that the respective object won't go away. */ ··· 439 439 * or has debugfs_remove() already been called? */ 440 440 parent = file->f_path.dentry->d_parent; 441 441 /* not sure if this can happen: */ 442 442 - if (!parent || !parent->d_inode) 442 442 + if (!parent || d_really_is_negative(parent)) 443 443 goto out; 444 444 /* serialize with d_delete() */ 445 445 - mutex_lock(&parent->d_inode->i_mutex); 445 445 + mutex_lock(&d_inode(parent)->i_mutex); 446 446 /* Make sure the object is still alive */ 447 447 if (debugfs_positive(file->f_path.dentry) 448 448 && kref_get_unless_zero(kref)) 449 449 ret = 0; 450 450 - mutex_unlock(&parent->d_inode->i_mutex); 450 450 + mutex_unlock(&d_inode(parent)->i_mutex); 451 451 if (!ret) { 452 452 ret = single_open(file, show, data); 453 453 if (ret)

+8 -8

drivers/infiniband/hw/ipath/ipath_fs.c

reviewed

··· 82 82 { 83 83 int error; 84 84 85 85 - mutex_lock(&parent->d_inode->i_mutex); 85 85 + mutex_lock(&d_inode(parent)->i_mutex); 86 86 *dentry = lookup_one_len(name, parent, strlen(name)); 87 87 if (!IS_ERR(*dentry)) 88 88 - error = ipathfs_mknod(parent->d_inode, *dentry, 88 88 + error = ipathfs_mknod(d_inode(parent), *dentry, 89 89 mode, fops, data); 90 90 else 91 91 error = PTR_ERR(*dentry); 92 92 - mutex_unlock(&parent->d_inode->i_mutex); 92 92 + mutex_unlock(&d_inode(parent)->i_mutex); 93 93 94 94 return error; 95 95 } ··· 277 277 } 278 278 279 279 spin_lock(&tmp->d_lock); 280 280 - if (!d_unhashed(tmp) && tmp->d_inode) { 280 280 + if (!d_unhashed(tmp) && d_really_is_positive(tmp)) { 281 281 dget_dlock(tmp); 282 282 __d_drop(tmp); 283 283 spin_unlock(&tmp->d_lock); 284 284 - simple_unlink(parent->d_inode, tmp); 284 284 + simple_unlink(d_inode(parent), tmp); 285 285 } else 286 286 spin_unlock(&tmp->d_lock); 287 287 ··· 302 302 int ret; 303 303 304 304 root = dget(sb->s_root); 305 305 - mutex_lock(&root->d_inode->i_mutex); 305 305 + mutex_lock(&d_inode(root)->i_mutex); 306 306 snprintf(unit, sizeof unit, "%02d", dd->ipath_unit); 307 307 dir = lookup_one_len(unit, root, strlen(unit)); 308 308 ··· 315 315 remove_file(dir, "flash"); 316 316 remove_file(dir, "atomic_counters"); 317 317 d_delete(dir); 318 318 - ret = simple_rmdir(root->d_inode, dir); 318 318 + ret = simple_rmdir(d_inode(root), dir); 319 319 320 320 bail: 321 321 - mutex_unlock(&root->d_inode->i_mutex); 321 321 + mutex_unlock(&d_inode(root)->i_mutex); 322 322 dput(root); 323 323 return ret; 324 324 }

+10 -10

drivers/infiniband/hw/qib/qib_fs.c

reviewed

··· 89 89 { 90 90 int error; 91 91 92 92 - mutex_lock(&parent->d_inode->i_mutex); 92 92 + mutex_lock(&d_inode(parent)->i_mutex); 93 93 *dentry = lookup_one_len(name, parent, strlen(name)); 94 94 if (!IS_ERR(*dentry)) 95 95 - error = qibfs_mknod(parent->d_inode, *dentry, 95 95 + error = qibfs_mknod(d_inode(parent), *dentry, 96 96 mode, fops, data); 97 97 else 98 98 error = PTR_ERR(*dentry); 99 99 - mutex_unlock(&parent->d_inode->i_mutex); 99 99 + mutex_unlock(&d_inode(parent)->i_mutex); 100 100 101 101 return error; 102 102 } ··· 455 455 } 456 456 457 457 spin_lock(&tmp->d_lock); 458 458 - if (!d_unhashed(tmp) && tmp->d_inode) { 458 458 + if (!d_unhashed(tmp) && d_really_is_positive(tmp)) { 459 459 __d_drop(tmp); 460 460 spin_unlock(&tmp->d_lock); 461 461 - simple_unlink(parent->d_inode, tmp); 461 461 + simple_unlink(d_inode(parent), tmp); 462 462 } else { 463 463 spin_unlock(&tmp->d_lock); 464 464 } ··· 481 481 int ret, i; 482 482 483 483 root = dget(sb->s_root); 484 484 - mutex_lock(&root->d_inode->i_mutex); 484 484 + mutex_lock(&d_inode(root)->i_mutex); 485 485 snprintf(unit, sizeof(unit), "%u", dd->unit); 486 486 dir = lookup_one_len(unit, root, strlen(unit)); 487 487 ··· 491 491 goto bail; 492 492 } 493 493 494 494 - mutex_lock(&dir->d_inode->i_mutex); 494 494 + mutex_lock(&d_inode(dir)->i_mutex); 495 495 remove_file(dir, "counters"); 496 496 remove_file(dir, "counter_names"); 497 497 remove_file(dir, "portcounter_names"); ··· 506 506 } 507 507 } 508 508 remove_file(dir, "flash"); 509 509 - mutex_unlock(&dir->d_inode->i_mutex); 510 510 - ret = simple_rmdir(root->d_inode, dir); 509 509 + mutex_unlock(&d_inode(dir)->i_mutex); 510 510 + ret = simple_rmdir(d_inode(root), dir); 511 511 d_delete(dir); 512 512 dput(dir); 513 513 514 514 bail: 515 515 - mutex_unlock(&root->d_inode->i_mutex); 515 515 + mutex_unlock(&d_inode(root)->i_mutex); 516 516 dput(root); 517 517 return ret; 518 518 }

+3 -3

drivers/mtd/ubi/build.c

reviewed

··· 1169 1169 return ERR_PTR(err); 1170 1170 1171 1171 /* MTD device number is defined by the major / minor numbers */ 1172 1172 - major = imajor(path.dentry->d_inode); 1173 1173 - minor = iminor(path.dentry->d_inode); 1174 1174 - mode = path.dentry->d_inode->i_mode; 1172 1172 + major = imajor(d_backing_inode(path.dentry)); 1173 1173 + minor = iminor(d_backing_inode(path.dentry)); 1174 1174 + mode = d_backing_inode(path.dentry)->i_mode; 1175 1175 path_put(&path); 1176 1176 if (major != MTD_CHAR_MAJOR || !S_ISCHR(mode)) 1177 1177 return ERR_PTR(-EINVAL);

+1 -1

drivers/mtd/ubi/kapi.c

reviewed

··· 314 314 if (error) 315 315 return ERR_PTR(error); 316 316 317 317 - inode = path.dentry->d_inode; 317 317 + inode = d_backing_inode(path.dentry); 318 318 mod = inode->i_mode; 319 319 ubi_num = ubi_major2num(imajor(inode)); 320 320 vol_id = iminor(inode) - 1;

+7 -14

drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.c

reviewed

··· 538 538 char s[32]; 539 539 unsigned long val; 540 540 size_t size = min(sizeof(s) - 1, count); 541 541 - struct adapter *adap = FILE_DATA(file)->i_private; 541 541 + struct adapter *adap = file_inode(file)->i_private; 542 542 543 543 if (copy_from_user(s, buf, size)) 544 544 return -EFAULT; ··· 647 647 static ssize_t pm_stats_clear(struct file *file, const char __user *buf, 648 648 size_t count, loff_t *pos) 649 649 { 650 650 - struct adapter *adap = FILE_DATA(file)->i_private; 650 650 + struct adapter *adap = file_inode(file)->i_private; 651 651 652 652 t4_write_reg(adap, PM_RX_STAT_CONFIG_A, 0); 653 653 t4_write_reg(adap, PM_TX_STAT_CONFIG_A, 0); ··· 1005 1005 &data[7], &c) < 8 || c != '\n') 1006 1006 return -EINVAL; 1007 1007 1008 1008 - ino = FILE_DATA(file); 1008 1008 + ino = file_inode(file); 1009 1009 mbox = (uintptr_t)ino->i_private & 7; 1010 1010 adap = ino->i_private - mbox; 1011 1011 addr = adap->regs + PF_REG(mbox, CIM_PF_MAILBOX_DATA_A); ··· 1034 1034 loff_t *ppos) 1035 1035 { 1036 1036 loff_t pos = *ppos; 1037 1037 - loff_t avail = FILE_DATA(file)->i_size; 1037 1037 + loff_t avail = file_inode(file)->i_size; 1038 1038 struct adapter *adap = file->private_data; 1039 1039 1040 1040 if (pos < 0) ··· 1479 1479 int i, j; 1480 1480 u32 key[10]; 1481 1481 char s[100], *p; 1482 1482 - struct adapter *adap = FILE_DATA(file)->i_private; 1482 1482 + struct adapter *adap = file_inode(file)->i_private; 1483 1483 1484 1484 if (count > sizeof(s) - 1) 1485 1485 return -EINVAL; ··· 1951 1951 .llseek = default_llseek, 1952 1952 }; 1953 1953 1954 1954 - static void set_debugfs_file_size(struct dentry *de, loff_t size) 1955 1955 - { 1956 1956 - if (!IS_ERR(de) && de->d_inode) 1957 1957 - de->d_inode->i_size = size; 1958 1958 - } 1959 1959 - 1960 1954 static void add_debugfs_mem(struct adapter *adap, const char *name, 1961 1955 unsigned int idx, unsigned int size_mb) 1962 1956 { ··· 2066 2072 } 2067 2073 } 2068 2074 2069 2069 - de = debugfs_create_file("flash", S_IRUSR, adap->debugfs_root, adap, 2070 2070 - &flash_debugfs_fops); 2071 2071 - set_debugfs_file_size(de, adap->params.sf_size); 2075 2075 + de = debugfs_create_file_size("flash", S_IRUSR, adap->debugfs_root, adap, 2076 2076 + &flash_debugfs_fops, adap->params.sf_size); 2072 2077 2073 2078 return 0; 2074 2079 }

-2

drivers/net/ethernet/chelsio/cxgb4/cxgb4_debugfs.h

reviewed

··· 37 37 38 38 #include <linux/export.h> 39 39 40 40 - #define FILE_DATA(_file) ((_file)->f_path.dentry->d_inode) 41 41 - 42 40 #define DEFINE_SIMPLE_DEBUGFS_FILE(name) \ 43 41 static int name##_open(struct inode *inode, struct file *file) \ 44 42 { \

+8 -8

drivers/oprofile/oprofilefs.c

reviewed

··· 138 138 struct dentry *dentry; 139 139 struct inode *inode; 140 140 141 141 - mutex_lock(&root->d_inode->i_mutex); 141 141 + mutex_lock(&d_inode(root)->i_mutex); 142 142 dentry = d_alloc_name(root, name); 143 143 if (!dentry) { 144 144 - mutex_unlock(&root->d_inode->i_mutex); 144 144 + mutex_unlock(&d_inode(root)->i_mutex); 145 145 return -ENOMEM; 146 146 } 147 147 inode = oprofilefs_get_inode(root->d_sb, S_IFREG | perm); 148 148 if (!inode) { 149 149 dput(dentry); 150 150 - mutex_unlock(&root->d_inode->i_mutex); 150 150 + mutex_unlock(&d_inode(root)->i_mutex); 151 151 return -ENOMEM; 152 152 } 153 153 inode->i_fop = fops; 154 154 inode->i_private = priv; 155 155 d_add(dentry, inode); 156 156 - mutex_unlock(&root->d_inode->i_mutex); 156 156 + mutex_unlock(&d_inode(root)->i_mutex); 157 157 return 0; 158 158 } 159 159 ··· 215 215 struct dentry *dentry; 216 216 struct inode *inode; 217 217 218 218 - mutex_lock(&parent->d_inode->i_mutex); 218 218 + mutex_lock(&d_inode(parent)->i_mutex); 219 219 dentry = d_alloc_name(parent, name); 220 220 if (!dentry) { 221 221 - mutex_unlock(&parent->d_inode->i_mutex); 221 221 + mutex_unlock(&d_inode(parent)->i_mutex); 222 222 return NULL; 223 223 } 224 224 inode = oprofilefs_get_inode(parent->d_sb, S_IFDIR | 0755); 225 225 if (!inode) { 226 226 dput(dentry); 227 227 - mutex_unlock(&parent->d_inode->i_mutex); 227 227 + mutex_unlock(&d_inode(parent)->i_mutex); 228 228 return NULL; 229 229 } 230 230 inode->i_op = &simple_dir_inode_operations; 231 231 inode->i_fop = &simple_dir_operations; 232 232 d_add(dentry, inode); 233 233 - mutex_unlock(&parent->d_inode->i_mutex); 233 233 + mutex_unlock(&d_inode(parent)->i_mutex); 234 234 return dentry; 235 235 } 236 236

+7 -7

drivers/staging/lustre/lustre/llite/dcache.c

reviewed

··· 153 153 154 154 CDEBUG(D_DENTRY, "%s dentry %pd (%p, parent %p, inode %p) %s%s\n", 155 155 d_lustre_invalid((struct dentry *)de) ? "deleting" : "keeping", 156 156 - de, de, de->d_parent, de->d_inode, 156 156 + de, de, de->d_parent, d_inode(de), 157 157 d_unhashed(de) ? "" : "hashed,", 158 158 list_empty(&de->d_subdirs) ? "" : "subdirs"); 159 159 ··· 167 167 #if 0 168 168 /* if not ldlm lock for this inode, set i_nlink to 0 so that 169 169 * this inode can be recycled later b=20433 */ 170 170 - if (de->d_inode && !find_cbdata(de->d_inode)) 171 171 - clear_nlink(de->d_inode); 170 170 + if (d_really_is_positive(de) && !find_cbdata(d_inode(de))) 171 171 + clear_nlink(d_inode(de)); 172 172 #endif 173 173 174 174 if (d_lustre_invalid((struct dentry *)de)) ··· 181 181 LASSERT(de != NULL); 182 182 183 183 CDEBUG(D_DENTRY, "ldd on dentry %pd (%p) parent %p inode %p refc %d\n", 184 184 - de, de, de->d_parent, de->d_inode, 184 184 + de, de, de->d_parent, d_inode(de), 185 185 d_count(de)); 186 186 187 187 if (de->d_fsdata == NULL) { ··· 261 261 ll_d_hlist_for_each_entry(dentry, p, &inode->i_dentry, d_u.d_alias) { 262 262 CDEBUG(D_DENTRY, "dentry in drop %pd (%p) parent %p inode %p flags %d\n", 263 263 dentry, dentry, dentry->d_parent, 264 264 - dentry->d_inode, dentry->d_flags); 264 264 + d_inode(dentry), dentry->d_flags); 265 265 266 266 d_lustre_invalidate(dentry, 0); 267 267 } ··· 309 309 static int ll_revalidate_dentry(struct dentry *dentry, 310 310 unsigned int lookup_flags) 311 311 { 312 312 - struct inode *dir = dentry->d_parent->d_inode; 312 312 + struct inode *dir = d_inode(dentry->d_parent); 313 313 314 314 /* 315 315 * if open&create is set, talk to MDS to make sure file is created if ··· 329 329 if (lookup_flags & LOOKUP_RCU) 330 330 return -ECHILD; 331 331 332 332 - do_statahead_enter(dir, &dentry, dentry->d_inode == NULL); 332 332 + do_statahead_enter(dir, &dentry, d_inode(dentry) == NULL); 333 333 ll_statahead_mark(dir, dentry); 334 334 return 1; 335 335 }

+8 -8

drivers/staging/lustre/lustre/llite/file.c

reviewed

··· 388 388 static int ll_intent_file_open(struct dentry *dentry, void *lmm, 389 389 int lmmsize, struct lookup_intent *itp) 390 390 { 391 391 - struct inode *inode = dentry->d_inode; 391 391 + struct inode *inode = d_inode(dentry); 392 392 struct ll_sb_info *sbi = ll_i2sbi(inode); 393 393 struct dentry *parent = dentry->d_parent; 394 394 const char *name = dentry->d_name.name; ··· 413 413 opc = LUSTRE_OPC_CREATE; 414 414 } 415 415 416 416 - op_data = ll_prep_md_op_data(NULL, parent->d_inode, 416 416 + op_data = ll_prep_md_op_data(NULL, d_inode(parent), 417 417 inode, name, len, 418 418 O_RDWR, opc, NULL); 419 419 if (IS_ERR(op_data)) ··· 2896 2896 2897 2897 static int __ll_inode_revalidate(struct dentry *dentry, __u64 ibits) 2898 2898 { 2899 2899 - struct inode *inode = dentry->d_inode; 2899 2899 + struct inode *inode = d_inode(dentry); 2900 2900 struct ptlrpc_request *req = NULL; 2901 2901 struct obd_export *exp; 2902 2902 int rc = 0; ··· 2948 2948 do_lookup() -> ll_revalidate_it(). We cannot use d_drop 2949 2949 here to preserve get_cwd functionality on 2.6. 2950 2950 Bug 10503 */ 2951 2951 - if (!dentry->d_inode->i_nlink) 2951 2951 + if (!d_inode(dentry)->i_nlink) 2952 2952 d_lustre_invalidate(dentry, 0); 2953 2953 2954 2954 ll_lookup_finish_locks(&oit, inode); 2955 2955 - } else if (!ll_have_md_lock(dentry->d_inode, &ibits, LCK_MINMODE)) { 2956 2956 - struct ll_sb_info *sbi = ll_i2sbi(dentry->d_inode); 2955 2955 + } else if (!ll_have_md_lock(d_inode(dentry), &ibits, LCK_MINMODE)) { 2956 2956 + struct ll_sb_info *sbi = ll_i2sbi(d_inode(dentry)); 2957 2957 u64 valid = OBD_MD_FLGETATTR; 2958 2958 struct md_op_data *op_data; 2959 2959 int ealen = 0; ··· 2991 2991 2992 2992 static int ll_inode_revalidate(struct dentry *dentry, __u64 ibits) 2993 2993 { 2994 2994 - struct inode *inode = dentry->d_inode; 2994 2994 + struct inode *inode = d_inode(dentry); 2995 2995 int rc; 2996 2996 2997 2997 rc = __ll_inode_revalidate(dentry, ibits); ··· 3019 3019 3020 3020 int ll_getattr(struct vfsmount *mnt, struct dentry *de, struct kstat *stat) 3021 3021 { 3022 3022 - struct inode *inode = de->d_inode; 3022 3022 + struct inode *inode = d_inode(de); 3023 3023 struct ll_sb_info *sbi = ll_i2sbi(inode); 3024 3024 struct ll_inode_info *lli = ll_i2info(inode); 3025 3025 int res = 0;

+1 -1

drivers/staging/lustre/lustre/llite/llite_internal.h

reviewed

··· 1488 1488 { 1489 1489 CDEBUG(D_DENTRY, "invalidate dentry %pd (%p) parent %p inode %p refc %d\n", 1490 1490 dentry, dentry, 1491 1491 - dentry->d_parent, dentry->d_inode, d_count(dentry)); 1491 1491 + dentry->d_parent, d_inode(dentry), d_count(dentry)); 1492 1492 1493 1493 spin_lock_nested(&dentry->d_lock, 1494 1494 nested ? DENTRY_D_LOCK_NESTED : DENTRY_D_LOCK_NORMAL);

+3 -3

drivers/staging/lustre/lustre/llite/llite_lib.c

reviewed

··· 1166 1166 struct md_open_data **mod) 1167 1167 { 1168 1168 struct lustre_md md; 1169 1169 - struct inode *inode = dentry->d_inode; 1169 1169 + struct inode *inode = d_inode(dentry); 1170 1170 struct ll_sb_info *sbi = ll_i2sbi(inode); 1171 1171 struct ptlrpc_request *request = NULL; 1172 1172 int rc, ia_valid; ··· 1290 1290 */ 1291 1291 int ll_setattr_raw(struct dentry *dentry, struct iattr *attr, bool hsm_import) 1292 1292 { 1293 1293 - struct inode *inode = dentry->d_inode; 1293 1293 + struct inode *inode = d_inode(dentry); 1294 1294 struct ll_inode_info *lli = ll_i2info(inode); 1295 1295 struct md_op_data *op_data = NULL; 1296 1296 struct md_open_data *mod = NULL; ··· 1465 1465 1466 1466 int ll_setattr(struct dentry *de, struct iattr *attr) 1467 1467 { 1468 1468 - int mode = de->d_inode->i_mode; 1468 1468 + int mode = d_inode(de)->i_mode; 1469 1469 1470 1470 if ((attr->ia_valid & (ATTR_CTIME|ATTR_SIZE|ATTR_MODE)) == 1471 1471 (ATTR_CTIME|ATTR_SIZE|ATTR_MODE))

+3 -3

drivers/staging/lustre/lustre/llite/llite_nfs.c

reviewed

··· 230 230 static int ll_get_name(struct dentry *dentry, char *name, 231 231 struct dentry *child) 232 232 { 233 233 - struct inode *dir = dentry->d_inode; 233 233 + struct inode *dir = d_inode(dentry); 234 234 int rc; 235 235 struct ll_getname_data lgd = { 236 236 .lgd_name = name, 237 237 - .lgd_fid = ll_i2info(child->d_inode)->lli_fid, 237 237 + .lgd_fid = ll_i2info(d_inode(child))->lli_fid, 238 238 .ctx.actor = ll_nfs_get_name_filldir, 239 239 }; 240 240 ··· 282 282 static struct dentry *ll_get_parent(struct dentry *dchild) 283 283 { 284 284 struct ptlrpc_request *req = NULL; 285 285 - struct inode *dir = dchild->d_inode; 285 285 + struct inode *dir = d_inode(dchild); 286 286 struct ll_sb_info *sbi; 287 287 struct dentry *result = NULL; 288 288 struct mdt_body *body;

+10 -10

drivers/staging/lustre/lustre/llite/namei.c

reviewed

··· 155 155 list_for_each_entry_safe(child, tmp_subdir, 156 156 &dentry->d_subdirs, 157 157 d_child) { 158 158 - if (child->d_inode == NULL) 158 158 + if (d_really_is_negative(child)) 159 159 d_lustre_invalidate(child, 1); 160 160 } 161 161 } ··· 392 392 iput(inode); 393 393 CDEBUG(D_DENTRY, 394 394 "Reuse dentry %p inode %p refc %d flags %#x\n", 395 395 - new, new->d_inode, d_count(new), new->d_flags); 395 395 + new, d_inode(new), d_count(new), new->d_flags); 396 396 return new; 397 397 } 398 398 } ··· 401 401 return ERR_PTR(rc); 402 402 d_add(de, inode); 403 403 CDEBUG(D_DENTRY, "Add dentry %p inode %p refc %d flags %#x\n", 404 404 - de, de->d_inode, d_count(de), de->d_flags); 404 404 + de, d_inode(de), d_count(de), de->d_flags); 405 405 return de; 406 406 } 407 407 ··· 448 448 !it_disposition(it, DISP_OPEN_CREATE)) { 449 449 /* With DISP_OPEN_CREATE dentry will 450 450 instantiated in ll_create_it. */ 451 451 - LASSERT((*de)->d_inode == NULL); 451 451 + LASSERT(d_inode(*de) == NULL); 452 452 d_instantiate(*de, inode); 453 453 } 454 454 ··· 541 541 goto out; 542 542 } 543 543 544 544 - inode = dentry->d_inode; 544 544 + inode = d_inode(dentry); 545 545 if ((it->it_op & IT_OPEN) && inode && 546 546 !S_ISREG(inode->i_mode) && 547 547 !S_ISDIR(inode->i_mode)) { ··· 638 638 639 639 *opened |= FILE_CREATED; 640 640 } 641 641 - if (dentry->d_inode && it_disposition(it, DISP_OPEN_OPEN)) { 641 641 + if (d_really_is_positive(dentry) && it_disposition(it, DISP_OPEN_OPEN)) { 642 642 /* Open dentry. */ 643 643 - if (S_ISFIFO(dentry->d_inode->i_mode)) { 643 643 + if (S_ISFIFO(d_inode(dentry)->i_mode)) { 644 644 /* We cannot call open here as it would 645 645 * deadlock. 646 646 */ ··· 862 862 863 863 static inline void ll_get_child_fid(struct dentry *child, struct lu_fid *fid) 864 864 { 865 865 - if (child->d_inode) 866 866 - *fid = *ll_inode2fid(child->d_inode); 865 865 + if (d_really_is_positive(child)) 866 866 + *fid = *ll_inode2fid(d_inode(child)); 867 867 } 868 868 869 869 /** ··· 1076 1076 static int ll_link(struct dentry *old_dentry, struct inode *dir, 1077 1077 struct dentry *new_dentry) 1078 1078 { 1079 1079 - struct inode *src = old_dentry->d_inode; 1079 1079 + struct inode *src = d_inode(old_dentry); 1080 1080 struct ll_sb_info *sbi = ll_i2sbi(dir); 1081 1081 struct ptlrpc_request *request = NULL; 1082 1082 struct md_op_data *op_data;

+14 -14

drivers/staging/lustre/lustre/llite/statahead.c

reviewed

··· 880 880 static int do_sa_revalidate(struct inode *dir, struct ll_sa_entry *entry, 881 881 struct dentry *dentry) 882 882 { 883 883 - struct inode *inode = dentry->d_inode; 883 883 + struct inode *inode = d_inode(dentry); 884 884 struct lookup_intent it = { .it_op = IT_GETATTR, 885 885 .d.lustre.it_lock_handle = 0 }; 886 886 struct md_enqueue_info *minfo; ··· 926 926 static void ll_statahead_one(struct dentry *parent, const char *entry_name, 927 927 int entry_name_len) 928 928 { 929 929 - struct inode *dir = parent->d_inode; 929 929 + struct inode *dir = d_inode(parent); 930 930 struct ll_inode_info *lli = ll_i2info(dir); 931 931 struct ll_statahead_info *sai = lli->lli_sai; 932 932 struct dentry *dentry = NULL; ··· 944 944 rc = do_sa_lookup(dir, entry); 945 945 } else { 946 946 rc = do_sa_revalidate(dir, entry, dentry); 947 947 - if (rc == 1 && agl_should_run(sai, dentry->d_inode)) 948 948 - ll_agl_add(sai, dentry->d_inode, entry->se_index); 947 947 + if (rc == 1 && agl_should_run(sai, d_inode(dentry))) 948 948 + ll_agl_add(sai, d_inode(dentry), entry->se_index); 949 949 } 950 950 951 951 if (dentry != NULL) ··· 968 968 static int ll_agl_thread(void *arg) 969 969 { 970 970 struct dentry *parent = (struct dentry *)arg; 971 971 - struct inode *dir = parent->d_inode; 971 971 + struct inode *dir = d_inode(parent); 972 972 struct ll_inode_info *plli = ll_i2info(dir); 973 973 struct ll_inode_info *clli; 974 974 struct ll_sb_info *sbi = ll_i2sbi(dir); ··· 1042 1042 CDEBUG(D_READA, "start agl thread: sai %p, parent %pd\n", 1043 1043 sai, parent); 1044 1044 1045 1045 - plli = ll_i2info(parent->d_inode); 1045 1045 + plli = ll_i2info(d_inode(parent)); 1046 1046 task = kthread_run(ll_agl_thread, parent, 1047 1047 "ll_agl_%u", plli->lli_opendir_pid); 1048 1048 if (IS_ERR(task)) { ··· 1059 1059 static int ll_statahead_thread(void *arg) 1060 1060 { 1061 1061 struct dentry *parent = (struct dentry *)arg; 1062 1062 - struct inode *dir = parent->d_inode; 1062 1062 + struct inode *dir = d_inode(parent); 1063 1063 struct ll_inode_info *plli = ll_i2info(dir); 1064 1064 struct ll_inode_info *clli; 1065 1065 struct ll_sb_info *sbi = ll_i2sbi(dir); ··· 1604 1604 rc = md_revalidate_lock(ll_i2mdexp(dir), &it, 1605 1605 ll_inode2fid(inode), &bits); 1606 1606 if (rc == 1) { 1607 1607 - if ((*dentryp)->d_inode == NULL) { 1607 1607 + if (d_inode(*dentryp) == NULL) { 1608 1608 struct dentry *alias; 1609 1609 1610 1610 alias = ll_splice_alias(inode, ··· 1614 1614 return PTR_ERR(alias); 1615 1615 } 1616 1616 *dentryp = alias; 1617 1617 - } else if ((*dentryp)->d_inode != inode) { 1617 1617 + } else if (d_inode(*dentryp) != inode) { 1618 1618 /* revalidate, but inode is recreated */ 1619 1619 CDEBUG(D_READA, 1620 1620 "stale dentry %pd inode %lu/%u, statahead inode %lu/%u\n", 1621 1621 *dentryp, 1622 1622 - (*dentryp)->d_inode->i_ino, 1623 1623 - (*dentryp)->d_inode->i_generation, 1622 1622 + d_inode(*dentryp)->i_ino, 1623 1623 + d_inode(*dentryp)->i_generation, 1624 1624 inode->i_ino, 1625 1625 inode->i_generation); 1626 1626 ll_sai_unplug(sai, entry); ··· 1666 1666 1667 1667 /* get parent reference count here, and put it in ll_statahead_thread */ 1668 1668 parent = dget((*dentryp)->d_parent); 1669 1669 - if (unlikely(sai->sai_inode != parent->d_inode)) { 1670 1670 - struct ll_inode_info *nlli = ll_i2info(parent->d_inode); 1669 1669 + if (unlikely(sai->sai_inode != d_inode(parent))) { 1670 1670 + struct ll_inode_info *nlli = ll_i2info(d_inode(parent)); 1671 1671 1672 1672 CWARN("Race condition, someone changed %pd just now: old parent "DFID", new parent "DFID"\n", 1673 1673 *dentryp, ··· 1689 1689 ll_sai_get(sai); 1690 1690 lli->lli_sai = sai; 1691 1691 1692 1692 - plli = ll_i2info(parent->d_inode); 1692 1692 + plli = ll_i2info(d_inode(parent)); 1693 1693 rc = PTR_ERR(kthread_run(ll_statahead_thread, parent, 1694 1694 "ll_sa_%u", plli->lli_opendir_pid)); 1695 1695 thread = &sai->sai_thread;

+1 -1

drivers/staging/lustre/lustre/llite/symlink.c

reviewed

··· 120 120 121 121 static void *ll_follow_link(struct dentry *dentry, struct nameidata *nd) 122 122 { 123 123 - struct inode *inode = dentry->d_inode; 123 123 + struct inode *inode = d_inode(dentry); 124 124 struct ptlrpc_request *request = NULL; 125 125 int rc; 126 126 char *symname = NULL;

+4 -4

drivers/staging/lustre/lustre/llite/xattr.c

reviewed

··· 214 214 int ll_setxattr(struct dentry *dentry, const char *name, 215 215 const void *value, size_t size, int flags) 216 216 { 217 217 - struct inode *inode = dentry->d_inode; 217 217 + struct inode *inode = d_inode(dentry); 218 218 219 219 LASSERT(inode); 220 220 LASSERT(name); ··· 267 267 268 268 int ll_removexattr(struct dentry *dentry, const char *name) 269 269 { 270 270 - struct inode *inode = dentry->d_inode; 270 270 + struct inode *inode = d_inode(dentry); 271 271 272 272 LASSERT(inode); 273 273 LASSERT(name); ··· 457 457 ssize_t ll_getxattr(struct dentry *dentry, const char *name, 458 458 void *buffer, size_t size) 459 459 { 460 460 - struct inode *inode = dentry->d_inode; 460 460 + struct inode *inode = d_inode(dentry); 461 461 462 462 LASSERT(inode); 463 463 LASSERT(name); ··· 545 545 546 546 ssize_t ll_listxattr(struct dentry *dentry, char *buffer, size_t size) 547 547 { 548 548 - struct inode *inode = dentry->d_inode; 548 548 + struct inode *inode = d_inode(dentry); 549 549 int rc = 0, rc2 = 0; 550 550 struct lov_mds_md *lmm = NULL; 551 551 struct ptlrpc_request *request = NULL;

+1 -1

drivers/usb/gadget/legacy/inode.c

reviewed

··· 1505 1505 list_del_init (&ep->epfiles); 1506 1506 dentry = ep->dentry; 1507 1507 ep->dentry = NULL; 1508 1508 - parent = dentry->d_parent->d_inode; 1508 1508 + parent = d_inode(dentry->d_parent); 1509 1509 1510 1510 /* break link to controller */ 1511 1511 if (ep->state == STATE_EP_ENABLED)

+2 -2

fs/9p/acl.c

reviewed

··· 247 247 if ((v9ses->flags & V9FS_ACCESS_MASK) != V9FS_ACCESS_CLIENT) 248 248 return v9fs_remote_get_acl(dentry, name, buffer, size, type); 249 249 250 250 - acl = v9fs_get_cached_acl(dentry->d_inode, type); 250 250 + acl = v9fs_get_cached_acl(d_inode(dentry), type); 251 251 if (IS_ERR(acl)) 252 252 return PTR_ERR(acl); 253 253 if (acl == NULL) ··· 285 285 int retval; 286 286 struct posix_acl *acl; 287 287 struct v9fs_session_info *v9ses; 288 288 - struct inode *inode = dentry->d_inode; 288 288 + struct inode *inode = d_inode(dentry); 289 289 290 290 if (strcmp(name, "") != 0) 291 291 return -EINVAL;

+2 -2

fs/9p/vfs_dentry.c

reviewed

··· 53 53 dentry, dentry); 54 54 55 55 /* Don't cache negative dentries */ 56 56 - if (!dentry->d_inode) 56 56 + if (d_really_is_negative(dentry)) 57 57 return 1; 58 58 return 0; 59 59 } ··· 83 83 if (flags & LOOKUP_RCU) 84 84 return -ECHILD; 85 85 86 86 - inode = dentry->d_inode; 86 86 + inode = d_inode(dentry); 87 87 if (!inode) 88 88 goto out_valid; 89 89

+2

fs/9p/vfs_dir.c

reviewed

··· 138 138 &err); 139 139 if (err) 140 140 return err; 141 141 + if (n == 0) 142 142 + return 0; 141 143 142 144 rdir->head = 0; 143 145 rdir->tail = n;

+17 -17

fs/9p/vfs_inode.c

reviewed

··· 595 595 dir, dentry, flags); 596 596 597 597 v9ses = v9fs_inode2v9ses(dir); 598 598 - inode = dentry->d_inode; 598 598 + inode = d_inode(dentry); 599 599 dfid = v9fs_fid_lookup(dentry->d_parent); 600 600 if (IS_ERR(dfid)) { 601 601 retval = PTR_ERR(dfid); ··· 864 864 } 865 865 866 866 /* Only creates */ 867 867 - if (!(flags & O_CREAT) || dentry->d_inode) 867 867 + if (!(flags & O_CREAT) || d_really_is_positive(dentry)) 868 868 return finish_no_open(file, res); 869 869 870 870 err = 0; ··· 881 881 } 882 882 883 883 v9fs_invalidate_inode_attr(dir); 884 884 - v9inode = V9FS_I(dentry->d_inode); 884 884 + v9inode = V9FS_I(d_inode(dentry)); 885 885 mutex_lock(&v9inode->v_mutex); 886 886 if ((v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) && 887 887 !v9inode->writeback_fid && ··· 908 908 909 909 file->private_data = fid; 910 910 if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) 911 911 - v9fs_cache_inode_set_cookie(dentry->d_inode, file); 911 911 + v9fs_cache_inode_set_cookie(d_inode(dentry), file); 912 912 913 913 *opened |= FILE_CREATED; 914 914 out: ··· 969 969 970 970 p9_debug(P9_DEBUG_VFS, "\n"); 971 971 retval = 0; 972 972 - old_inode = old_dentry->d_inode; 973 973 - new_inode = new_dentry->d_inode; 972 972 + old_inode = d_inode(old_dentry); 973 973 + new_inode = d_inode(new_dentry); 974 974 v9ses = v9fs_inode2v9ses(old_inode); 975 975 oldfid = v9fs_fid_lookup(old_dentry); 976 976 if (IS_ERR(oldfid)) ··· 1061 1061 p9_debug(P9_DEBUG_VFS, "dentry: %p\n", dentry); 1062 1062 v9ses = v9fs_dentry2v9ses(dentry); 1063 1063 if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) { 1064 1064 - generic_fillattr(dentry->d_inode, stat); 1064 1064 + generic_fillattr(d_inode(dentry), stat); 1065 1065 return 0; 1066 1066 } 1067 1067 fid = v9fs_fid_lookup(dentry); ··· 1072 1072 if (IS_ERR(st)) 1073 1073 return PTR_ERR(st); 1074 1074 1075 1075 - v9fs_stat2inode(st, dentry->d_inode, dentry->d_inode->i_sb); 1076 1076 - generic_fillattr(dentry->d_inode, stat); 1075 1075 + v9fs_stat2inode(st, d_inode(dentry), d_inode(dentry)->i_sb); 1076 1076 + generic_fillattr(d_inode(dentry), stat); 1077 1077 1078 1078 p9stat_free(st); 1079 1079 kfree(st); ··· 1095 1095 struct p9_wstat wstat; 1096 1096 1097 1097 p9_debug(P9_DEBUG_VFS, "\n"); 1098 1098 - retval = inode_change_ok(dentry->d_inode, iattr); 1098 1098 + retval = inode_change_ok(d_inode(dentry), iattr); 1099 1099 if (retval) 1100 1100 return retval; 1101 1101 ··· 1128 1128 1129 1129 /* Write all dirty data */ 1130 1130 if (d_is_reg(dentry)) 1131 1131 - filemap_write_and_wait(dentry->d_inode->i_mapping); 1131 1131 + filemap_write_and_wait(d_inode(dentry)->i_mapping); 1132 1132 1133 1133 retval = p9_client_wstat(fid, &wstat); 1134 1134 if (retval < 0) 1135 1135 return retval; 1136 1136 1137 1137 if ((iattr->ia_valid & ATTR_SIZE) && 1138 1138 - iattr->ia_size != i_size_read(dentry->d_inode)) 1139 1139 - truncate_setsize(dentry->d_inode, iattr->ia_size); 1138 1138 + iattr->ia_size != i_size_read(d_inode(dentry))) 1139 1139 + truncate_setsize(d_inode(dentry), iattr->ia_size); 1140 1140 1141 1141 - v9fs_invalidate_inode_attr(dentry->d_inode); 1141 1141 + v9fs_invalidate_inode_attr(d_inode(dentry)); 1142 1142 1143 1143 - setattr_copy(dentry->d_inode, iattr); 1144 1144 - mark_inode_dirty(dentry->d_inode); 1143 1143 + setattr_copy(d_inode(dentry), iattr); 1144 1144 + mark_inode_dirty(d_inode(dentry)); 1145 1145 return 0; 1146 1146 } 1147 1147 ··· 1403 1403 retval = v9fs_vfs_mkspecial(dir, dentry, P9_DMLINK, name); 1404 1404 __putname(name); 1405 1405 if (!retval) { 1406 1406 - v9fs_refresh_inode(oldfid, old_dentry->d_inode); 1406 1406 + v9fs_refresh_inode(oldfid, d_inode(old_dentry)); 1407 1407 v9fs_invalidate_inode_attr(dir); 1408 1408 } 1409 1409 clunk_fid:

+8 -8

fs/9p/vfs_inode_dotl.c

reviewed

··· 265 265 } 266 266 267 267 /* Only creates */ 268 268 - if (!(flags & O_CREAT) || dentry->d_inode) 268 268 + if (!(flags & O_CREAT) || d_really_is_positive(dentry)) 269 269 return finish_no_open(file, res); 270 270 271 271 v9ses = v9fs_inode2v9ses(dir); ··· 481 481 p9_debug(P9_DEBUG_VFS, "dentry: %p\n", dentry); 482 482 v9ses = v9fs_dentry2v9ses(dentry); 483 483 if (v9ses->cache == CACHE_LOOSE || v9ses->cache == CACHE_FSCACHE) { 484 484 - generic_fillattr(dentry->d_inode, stat); 484 484 + generic_fillattr(d_inode(dentry), stat); 485 485 return 0; 486 486 } 487 487 fid = v9fs_fid_lookup(dentry); ··· 496 496 if (IS_ERR(st)) 497 497 return PTR_ERR(st); 498 498 499 499 - v9fs_stat2inode_dotl(st, dentry->d_inode); 500 500 - generic_fillattr(dentry->d_inode, stat); 499 499 + v9fs_stat2inode_dotl(st, d_inode(dentry)); 500 500 + generic_fillattr(d_inode(dentry), stat); 501 501 /* Change block size to what the server returned */ 502 502 stat->blksize = st->st_blksize; 503 503 ··· 557 557 int retval; 558 558 struct p9_fid *fid; 559 559 struct p9_iattr_dotl p9attr; 560 560 - struct inode *inode = dentry->d_inode; 560 560 + struct inode *inode = d_inode(dentry); 561 561 562 562 p9_debug(P9_DEBUG_VFS, "\n"); 563 563 ··· 795 795 if (IS_ERR(fid)) 796 796 return PTR_ERR(fid); 797 797 798 798 - v9fs_refresh_inode_dotl(fid, old_dentry->d_inode); 798 798 + v9fs_refresh_inode_dotl(fid, d_inode(old_dentry)); 799 799 } 800 800 - ihold(old_dentry->d_inode); 801 801 - d_instantiate(dentry, old_dentry->d_inode); 800 800 + ihold(d_inode(old_dentry)); 801 801 + d_instantiate(dentry, d_inode(old_dentry)); 802 802 803 803 return err; 804 804 }

+4 -4

fs/9p/vfs_super.c

reviewed

··· 168 168 retval = PTR_ERR(st); 169 169 goto release_sb; 170 170 } 171 171 - root->d_inode->i_ino = v9fs_qid2ino(&st->qid); 172 172 - v9fs_stat2inode_dotl(st, root->d_inode); 171 171 + d_inode(root)->i_ino = v9fs_qid2ino(&st->qid); 172 172 + v9fs_stat2inode_dotl(st, d_inode(root)); 173 173 kfree(st); 174 174 } else { 175 175 struct p9_wstat *st = NULL; ··· 179 179 goto release_sb; 180 180 } 181 181 182 182 - root->d_inode->i_ino = v9fs_qid2ino(&st->qid); 183 183 - v9fs_stat2inode(st, root->d_inode, sb); 182 182 + d_inode(root)->i_ino = v9fs_qid2ino(&st->qid); 183 183 + v9fs_stat2inode(st, d_inode(root), sb); 184 184 185 185 p9stat_free(st); 186 186 kfree(st);

+1 -1

fs/adfs/inode.c

reviewed

··· 298 298 int 299 299 adfs_notify_change(struct dentry *dentry, struct iattr *attr) 300 300 { 301 301 - struct inode *inode = dentry->d_inode; 301 301 + struct inode *inode = d_inode(dentry); 302 302 struct super_block *sb = inode->i_sb; 303 303 unsigned int ia_valid = attr->ia_valid; 304 304 int error;

+4 -5

fs/affs/amigaffs.c

reviewed

··· 138 138 static int 139 139 affs_remove_link(struct dentry *dentry) 140 140 { 141 141 - struct inode *dir, *inode = dentry->d_inode; 141 141 + struct inode *dir, *inode = d_inode(dentry); 142 142 struct super_block *sb = inode->i_sb; 143 143 struct buffer_head *bh = NULL, *link_bh = NULL; 144 144 u32 link_ino, ino; ··· 268 268 struct buffer_head *bh = NULL; 269 269 int retval; 270 270 271 271 - dir = dentry->d_parent->d_inode; 271 271 + dir = d_inode(dentry->d_parent); 272 272 sb = dir->i_sb; 273 273 274 274 retval = -ENOENT; 275 275 - inode = dentry->d_inode; 275 275 + inode = d_inode(dentry); 276 276 if (!inode) 277 277 goto done; 278 278 ··· 471 471 bool 472 472 affs_nofilenametruncate(const struct dentry *dentry) 473 473 { 474 474 - struct inode *inode = dentry->d_inode; 474 474 + struct inode *inode = d_inode(dentry); 475 475 476 476 return affs_test_opt(AFFS_SB(inode->i_sb)->s_flags, SF_NO_TRUNCATE); 477 477 - 478 477 } 479 478 480 479 /* Check if the name is valid for a affs object. */

+1 -1

fs/affs/inode.c

reviewed

··· 213 213 int 214 214 affs_notify_change(struct dentry *dentry, struct iattr *attr) 215 215 { 216 216 - struct inode *inode = dentry->d_inode; 216 216 + struct inode *inode = d_inode(dentry); 217 217 int error; 218 218 219 219 pr_debug("notify_change(%lu,0x%x)\n", inode->i_ino, attr->ia_valid);

+5 -5

fs/affs/namei.c

reviewed

··· 251 251 affs_unlink(struct inode *dir, struct dentry *dentry) 252 252 { 253 253 pr_debug("%s(dir=%lu, %lu \"%pd\")\n", __func__, dir->i_ino, 254 254 - dentry->d_inode->i_ino, dentry); 254 254 + d_inode(dentry)->i_ino, dentry); 255 255 256 256 return affs_remove_header(dentry); 257 257 } ··· 320 320 affs_rmdir(struct inode *dir, struct dentry *dentry) 321 321 { 322 322 pr_debug("%s(dir=%lu, %lu \"%pd\")\n", __func__, dir->i_ino, 323 323 - dentry->d_inode->i_ino, dentry); 323 323 + d_inode(dentry)->i_ino, dentry); 324 324 325 325 return affs_remove_header(dentry); 326 326 } ··· 403 403 int 404 404 affs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry) 405 405 { 406 406 - struct inode *inode = old_dentry->d_inode; 406 406 + struct inode *inode = d_inode(old_dentry); 407 407 408 408 pr_debug("%s(%lu, %lu, \"%pd\")\n", __func__, inode->i_ino, dir->i_ino, 409 409 dentry); ··· 430 430 return retval; 431 431 432 432 /* Unlink destination if it already exists */ 433 433 - if (new_dentry->d_inode) { 433 433 + if (d_really_is_positive(new_dentry)) { 434 434 retval = affs_remove_header(new_dentry); 435 435 if (retval) 436 436 return retval; 437 437 } 438 438 439 439 - bh = affs_bread(sb, old_dentry->d_inode->i_ino); 439 439 + bh = affs_bread(sb, d_inode(old_dentry)->i_ino); 440 440 if (!bh) 441 441 return -EIO; 442 442

+21 -21

fs/afs/dir.c

reviewed

··· 505 505 _enter("{%x:%u},%p{%pd},", 506 506 vnode->fid.vid, vnode->fid.vnode, dentry, dentry); 507 507 508 508 - ASSERTCMP(dentry->d_inode, ==, NULL); 508 508 + ASSERTCMP(d_inode(dentry), ==, NULL); 509 509 510 510 if (dentry->d_name.len >= AFSNAMEMAX) { 511 511 _leave(" = -ENAMETOOLONG"); ··· 563 563 _leave(" = 0 { vn=%u u=%u } -> { ino=%lu v=%u }", 564 564 fid.vnode, 565 565 fid.unique, 566 566 - dentry->d_inode->i_ino, 567 567 - dentry->d_inode->i_generation); 566 566 + d_inode(dentry)->i_ino, 567 567 + d_inode(dentry)->i_generation); 568 568 569 569 return NULL; 570 570 } ··· 586 586 if (flags & LOOKUP_RCU) 587 587 return -ECHILD; 588 588 589 589 - vnode = AFS_FS_I(dentry->d_inode); 589 589 + vnode = AFS_FS_I(d_inode(dentry)); 590 590 591 591 - if (dentry->d_inode) 591 591 + if (d_really_is_positive(dentry)) 592 592 _enter("{v={%x:%u} n=%pd fl=%lx},", 593 593 vnode->fid.vid, vnode->fid.vnode, dentry, 594 594 vnode->flags); ··· 601 601 602 602 /* lock down the parent dentry so we can peer at it */ 603 603 parent = dget_parent(dentry); 604 604 - dir = AFS_FS_I(parent->d_inode); 604 604 + dir = AFS_FS_I(d_inode(parent)); 605 605 606 606 /* validate the parent directory */ 607 607 if (test_bit(AFS_VNODE_MODIFIED, &dir->flags)) ··· 623 623 switch (ret) { 624 624 case 0: 625 625 /* the filename maps to something */ 626 626 - if (!dentry->d_inode) 626 626 + if (d_really_is_negative(dentry)) 627 627 goto out_bad; 628 628 - if (is_bad_inode(dentry->d_inode)) { 628 628 + if (is_bad_inode(d_inode(dentry))) { 629 629 printk("kAFS: afs_d_revalidate: %pd2 has bad inode\n", 630 630 dentry); 631 631 goto out_bad; ··· 647 647 _debug("%pd: file deleted (uq %u -> %u I:%u)", 648 648 dentry, fid.unique, 649 649 vnode->fid.unique, 650 650 - dentry->d_inode->i_generation); 650 650 + d_inode(dentry)->i_generation); 651 651 spin_lock(&vnode->lock); 652 652 set_bit(AFS_VNODE_DELETED, &vnode->flags); 653 653 spin_unlock(&vnode->lock); ··· 658 658 case -ENOENT: 659 659 /* the filename is unknown */ 660 660 _debug("%pd: dirent not found", dentry); 661 661 - if (dentry->d_inode) 661 661 + if (d_really_is_positive(dentry)) 662 662 goto not_found; 663 663 goto out_valid; 664 664 ··· 703 703 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) 704 704 goto zap; 705 705 706 706 - if (dentry->d_inode && 707 707 - (test_bit(AFS_VNODE_DELETED, &AFS_FS_I(dentry->d_inode)->flags) || 708 708 - test_bit(AFS_VNODE_PSEUDODIR, &AFS_FS_I(dentry->d_inode)->flags))) 706 706 + if (d_really_is_positive(dentry) && 707 707 + (test_bit(AFS_VNODE_DELETED, &AFS_FS_I(d_inode(dentry))->flags) || 708 708 + test_bit(AFS_VNODE_PSEUDODIR, &AFS_FS_I(d_inode(dentry))->flags))) 709 709 goto zap; 710 710 711 711 _leave(" = 0 [keep]"); ··· 814 814 if (ret < 0) 815 815 goto rmdir_error; 816 816 817 817 - if (dentry->d_inode) { 818 818 - vnode = AFS_FS_I(dentry->d_inode); 817 817 + if (d_really_is_positive(dentry)) { 818 818 + vnode = AFS_FS_I(d_inode(dentry)); 819 819 clear_nlink(&vnode->vfs_inode); 820 820 set_bit(AFS_VNODE_DELETED, &vnode->flags); 821 821 afs_discard_callback_on_delete(vnode); ··· 856 856 goto error; 857 857 } 858 858 859 859 - if (dentry->d_inode) { 860 860 - vnode = AFS_FS_I(dentry->d_inode); 859 859 + if (d_really_is_positive(dentry)) { 860 860 + vnode = AFS_FS_I(d_inode(dentry)); 861 861 862 862 /* make sure we have a callback promise on the victim */ 863 863 ret = afs_validate(vnode, key); ··· 869 869 if (ret < 0) 870 870 goto remove_error; 871 871 872 872 - if (dentry->d_inode) { 872 872 + if (d_really_is_positive(dentry)) { 873 873 /* if the file wasn't deleted due to excess hard links, the 874 874 * fileserver will break the callback promise on the file - if 875 875 * it had one - before it returns to us, and if it was deleted, ··· 879 879 * or it was outstanding on a different server, then it won't 880 880 * break it either... 881 881 */ 882 882 - vnode = AFS_FS_I(dentry->d_inode); 882 882 + vnode = AFS_FS_I(d_inode(dentry)); 883 883 if (test_bit(AFS_VNODE_DELETED, &vnode->flags)) 884 884 _debug("AFS_VNODE_DELETED"); 885 885 if (test_bit(AFS_VNODE_CB_BROKEN, &vnode->flags)) ··· 977 977 struct key *key; 978 978 int ret; 979 979 980 980 - vnode = AFS_FS_I(from->d_inode); 980 980 + vnode = AFS_FS_I(d_inode(from)); 981 981 dvnode = AFS_FS_I(dir); 982 982 983 983 _enter("{%x:%u},{%x:%u},{%pd}", ··· 1089 1089 struct key *key; 1090 1090 int ret; 1091 1091 1092 1092 - vnode = AFS_FS_I(old_dentry->d_inode); 1092 1092 + vnode = AFS_FS_I(d_inode(old_dentry)); 1093 1093 orig_dvnode = AFS_FS_I(old_dir); 1094 1094 new_dvnode = AFS_FS_I(new_dir); 1095 1095

+2 -2

fs/afs/inode.c

reviewed

··· 379 379 { 380 380 struct inode *inode; 381 381 382 382 - inode = dentry->d_inode; 382 382 + inode = d_inode(dentry); 383 383 384 384 _enter("{ ino=%lu v=%u }", inode->i_ino, inode->i_generation); 385 385 ··· 458 458 */ 459 459 int afs_setattr(struct dentry *dentry, struct iattr *attr) 460 460 { 461 461 - struct afs_vnode *vnode = AFS_FS_I(dentry->d_inode); 461 461 + struct afs_vnode *vnode = AFS_FS_I(d_inode(dentry)); 462 462 struct key *key; 463 463 int ret; 464 464

+4 -4

fs/afs/mntpt.c

reviewed

··· 134 134 135 135 _enter("{%pd}", mntpt); 136 136 137 137 - BUG_ON(!mntpt->d_inode); 137 137 + BUG_ON(!d_inode(mntpt)); 138 138 139 139 ret = -ENOMEM; 140 140 devname = (char *) get_zeroed_page(GFP_KERNEL); ··· 145 145 if (!options) 146 146 goto error_no_options; 147 147 148 148 - vnode = AFS_FS_I(mntpt->d_inode); 148 148 + vnode = AFS_FS_I(d_inode(mntpt)); 149 149 if (test_bit(AFS_VNODE_PSEUDODIR, &vnode->flags)) { 150 150 /* if the directory is a pseudo directory, use the d_name */ 151 151 static const char afs_root_cell[] = ":root.cell."; ··· 169 169 } 170 170 } else { 171 171 /* read the contents of the AFS special symlink */ 172 172 - loff_t size = i_size_read(mntpt->d_inode); 172 172 + loff_t size = i_size_read(d_inode(mntpt)); 173 173 char *buf; 174 174 175 175 ret = -EINVAL; 176 176 if (size > PAGE_SIZE - 1) 177 177 goto error_no_page; 178 178 179 179 - page = read_mapping_page(mntpt->d_inode->i_mapping, 0, NULL); 179 179 + page = read_mapping_page(d_inode(mntpt)->i_mapping, 0, NULL); 180 180 if (IS_ERR(page)) { 181 181 ret = PTR_ERR(page); 182 182 goto error_no_page;

+1 -1

fs/afs/super.c

reviewed

··· 529 529 static int afs_statfs(struct dentry *dentry, struct kstatfs *buf) 530 530 { 531 531 struct afs_volume_status vs; 532 532 - struct afs_vnode *vnode = AFS_FS_I(dentry->d_inode); 532 532 + struct afs_vnode *vnode = AFS_FS_I(d_inode(dentry)); 533 533 struct key *key; 534 534 int ret; 535 535

+2 -2

fs/autofs4/autofs_i.h

reviewed

··· 235 235 236 236 static inline u64 autofs4_get_ino(struct autofs_sb_info *sbi) 237 237 { 238 238 - return sbi->sb->s_root->d_inode->i_ino; 238 238 + return d_inode(sbi->sb->s_root)->i_ino; 239 239 } 240 240 241 241 static inline int simple_positive(struct dentry *dentry) 242 242 { 243 243 - return dentry->d_inode && !d_unhashed(dentry); 243 243 + return d_really_is_positive(dentry) && !d_unhashed(dentry); 244 244 } 245 245 246 246 static inline void __autofs4_add_expiring(struct dentry *dentry)

+1 -1

fs/autofs4/expire.c

reviewed

··· 374 374 return NULL; 375 375 } 376 376 377 377 - if (dentry->d_inode && d_is_symlink(dentry)) { 377 377 + if (d_really_is_positive(dentry) && d_is_symlink(dentry)) { 378 378 DPRINTK("checking symlink %p %pd", dentry, dentry); 379 379 /* 380 380 * A symlink can't be "busy" in the usual sense so

+3 -3

fs/autofs4/inode.c

reviewed

··· 71 71 static int autofs4_show_options(struct seq_file *m, struct dentry *root) 72 72 { 73 73 struct autofs_sb_info *sbi = autofs4_sbi(root->d_sb); 74 74 - struct inode *root_inode = root->d_sb->s_root->d_inode; 74 74 + struct inode *root_inode = d_inode(root->d_sb->s_root); 75 75 76 76 if (!sbi) 77 77 return 0; ··· 352 352 353 353 inode->i_mode = mode; 354 354 if (sb->s_root) { 355 355 - inode->i_uid = sb->s_root->d_inode->i_uid; 356 356 - inode->i_gid = sb->s_root->d_inode->i_gid; 355 355 + inode->i_uid = d_inode(sb->s_root)->i_uid; 356 356 + inode->i_gid = d_inode(sb->s_root)->i_gid; 357 357 } 358 358 inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME; 359 359 inode->i_ino = get_next_ino();

+9 -9

fs/autofs4/root.c

reviewed

··· 240 240 spin_lock(&expiring->d_lock); 241 241 242 242 /* We've already been dentry_iput or unlinked */ 243 243 - if (!expiring->d_inode) 243 243 + if (d_really_is_negative(expiring)) 244 244 goto next; 245 245 246 246 qstr = &expiring->d_name; ··· 371 371 * having d_mountpoint() true, so there's no need to call back 372 372 * to the daemon. 373 373 */ 374 374 - if (dentry->d_inode && d_is_symlink(dentry)) { 374 374 + if (d_really_is_positive(dentry) && d_is_symlink(dentry)) { 375 375 spin_unlock(&sbi->fs_lock); 376 376 goto done; 377 377 } ··· 459 459 return 0; 460 460 if (d_mountpoint(dentry)) 461 461 return 0; 462 462 - inode = ACCESS_ONCE(dentry->d_inode); 462 462 + inode = d_inode_rcu(dentry); 463 463 if (inode && S_ISLNK(inode->i_mode)) 464 464 return -EISDIR; 465 465 if (list_empty(&dentry->d_subdirs)) ··· 485 485 * an incorrect ELOOP error return. 486 486 */ 487 487 if ((!d_mountpoint(dentry) && !simple_empty(dentry)) || 488 488 - (dentry->d_inode && d_is_symlink(dentry))) 488 488 + (d_really_is_positive(dentry) && d_is_symlink(dentry))) 489 489 status = -EISDIR; 490 490 } 491 491 spin_unlock(&sbi->fs_lock); ··· 625 625 } 626 626 dput(ino->dentry); 627 627 628 628 - dentry->d_inode->i_size = 0; 629 629 - clear_nlink(dentry->d_inode); 628 628 + d_inode(dentry)->i_size = 0; 629 629 + clear_nlink(d_inode(dentry)); 630 630 631 631 dir->i_mtime = CURRENT_TIME; 632 632 ··· 719 719 atomic_dec(&p_ino->count); 720 720 } 721 721 dput(ino->dentry); 722 722 - dentry->d_inode->i_size = 0; 723 723 - clear_nlink(dentry->d_inode); 722 722 + d_inode(dentry)->i_size = 0; 723 723 + clear_nlink(d_inode(dentry)); 724 724 725 725 if (dir->i_nlink) 726 726 drop_nlink(dir); ··· 839 839 */ 840 840 int is_autofs4_dentry(struct dentry *dentry) 841 841 { 842 842 - return dentry && dentry->d_inode && 842 842 + return dentry && d_really_is_positive(dentry) && 843 843 dentry->d_op == &autofs4_dentry_operations && 844 844 dentry->d_fsdata != NULL; 845 845 }

+1 -1

fs/autofs4/symlink.c

reviewed

··· 18 18 struct autofs_info *ino = autofs4_dentry_ino(dentry); 19 19 if (ino && !autofs4_oz_mode(sbi)) 20 20 ino->last_used = jiffies; 21 21 - nd_set_link(nd, dentry->d_inode->i_private); 21 21 + nd_set_link(nd, d_inode(dentry)->i_private); 22 22 return NULL; 23 23 } 24 24

+2 -2

fs/autofs4/waitq.c

reviewed

··· 322 322 * continue on and create a new request. 323 323 */ 324 324 if (!IS_ROOT(dentry)) { 325 325 - if (dentry->d_inode && d_unhashed(dentry)) { 325 325 + if (d_really_is_positive(dentry) && d_unhashed(dentry)) { 326 326 struct dentry *parent = dentry->d_parent; 327 327 new = d_lookup(parent, &dentry->d_name); 328 328 if (new) ··· 364 364 if (pid == 0 || tgid == 0) 365 365 return -ENOENT; 366 366 367 367 - if (!dentry->d_inode) { 367 367 + if (d_really_is_negative(dentry)) { 368 368 /* 369 369 * A wait for a negative dentry is invalid for certain 370 370 * cases. A direct or offset mount "always" has its mount

+2 -2

fs/befs/linuxvfs.c

reviewed

··· 471 471 befs_follow_link(struct dentry *dentry, struct nameidata *nd) 472 472 { 473 473 struct super_block *sb = dentry->d_sb; 474 474 - struct befs_inode_info *befs_ino = BEFS_I(dentry->d_inode); 474 474 + struct befs_inode_info *befs_ino = BEFS_I(d_inode(dentry)); 475 475 befs_data_stream *data = &befs_ino->i_data.ds; 476 476 befs_off_t len = data->size; 477 477 char *link; ··· 501 501 static void * 502 502 befs_fast_follow_link(struct dentry *dentry, struct nameidata *nd) 503 503 { 504 504 - struct befs_inode_info *befs_ino = BEFS_I(dentry->d_inode); 504 504 + struct befs_inode_info *befs_ino = BEFS_I(d_inode(dentry)); 505 505 506 506 nd_set_link(nd, befs_ino->i_data.symlink); 507 507 return NULL;

+4 -4

fs/bfs/dir.c

reviewed

··· 153 153 static int bfs_link(struct dentry *old, struct inode *dir, 154 154 struct dentry *new) 155 155 { 156 156 - struct inode *inode = old->d_inode; 156 156 + struct inode *inode = d_inode(old); 157 157 struct bfs_sb_info *info = BFS_SB(inode->i_sb); 158 158 int err; 159 159 ··· 176 176 static int bfs_unlink(struct inode *dir, struct dentry *dentry) 177 177 { 178 178 int error = -ENOENT; 179 179 - struct inode *inode = dentry->d_inode; 179 179 + struct inode *inode = d_inode(dentry); 180 180 struct buffer_head *bh; 181 181 struct bfs_dirent *de; 182 182 struct bfs_sb_info *info = BFS_SB(inode->i_sb); ··· 216 216 int error = -ENOENT; 217 217 218 218 old_bh = new_bh = NULL; 219 219 - old_inode = old_dentry->d_inode; 219 219 + old_inode = d_inode(old_dentry); 220 220 if (S_ISDIR(old_inode->i_mode)) 221 221 return -EINVAL; 222 222 ··· 231 231 goto end_rename; 232 232 233 233 error = -EPERM; 234 234 - new_inode = new_dentry->d_inode; 234 234 + new_inode = d_inode(new_dentry); 235 235 new_bh = bfs_find_entry(new_dir, 236 236 new_dentry->d_name.name, 237 237 new_dentry->d_name.len, &new_de);

+8 -8

fs/binfmt_misc.c

reviewed

··· 591 591 write_unlock(&entries_lock); 592 592 593 593 if (dentry) { 594 594 - drop_nlink(dentry->d_inode); 594 594 + drop_nlink(d_inode(dentry)); 595 595 d_drop(dentry); 596 596 dput(dentry); 597 597 simple_release_fs(&bm_mnt, &entry_count); ··· 638 638 case 3: 639 639 /* Delete this handler. */ 640 640 root = dget(file->f_path.dentry->d_sb->s_root); 641 641 - mutex_lock(&root->d_inode->i_mutex); 641 641 + mutex_lock(&d_inode(root)->i_mutex); 642 642 643 643 kill_node(e); 644 644 645 645 - mutex_unlock(&root->d_inode->i_mutex); 645 645 + mutex_unlock(&d_inode(root)->i_mutex); 646 646 dput(root); 647 647 break; 648 648 default: ··· 675 675 return PTR_ERR(e); 676 676 677 677 root = dget(sb->s_root); 678 678 - mutex_lock(&root->d_inode->i_mutex); 678 678 + mutex_lock(&d_inode(root)->i_mutex); 679 679 dentry = lookup_one_len(e->name, root, strlen(e->name)); 680 680 err = PTR_ERR(dentry); 681 681 if (IS_ERR(dentry)) 682 682 goto out; 683 683 684 684 err = -EEXIST; 685 685 - if (dentry->d_inode) 685 685 + if (d_really_is_positive(dentry)) 686 686 goto out2; 687 687 688 688 inode = bm_get_inode(sb, S_IFREG | 0644); ··· 711 711 out2: 712 712 dput(dentry); 713 713 out: 714 714 - mutex_unlock(&root->d_inode->i_mutex); 714 714 + mutex_unlock(&d_inode(root)->i_mutex); 715 715 dput(root); 716 716 717 717 if (err) { ··· 754 754 case 3: 755 755 /* Delete all handlers. */ 756 756 root = dget(file->f_path.dentry->d_sb->s_root); 757 757 - mutex_lock(&root->d_inode->i_mutex); 757 757 + mutex_lock(&d_inode(root)->i_mutex); 758 758 759 759 while (!list_empty(&entries)) 760 760 kill_node(list_entry(entries.next, Node, list)); 761 761 762 762 - mutex_unlock(&root->d_inode->i_mutex); 762 762 + mutex_unlock(&d_inode(root)->i_mutex); 763 763 dput(root); 764 764 break; 765 765 default:

+3 -2

fs/block_dev.c

reviewed

··· 152 152 struct inode *inode = file->f_mapping->host; 153 153 154 154 return __blockdev_direct_IO(iocb, inode, I_BDEV(inode), iter, offset, 155 155 - blkdev_get_block, NULL, NULL, 0); 155 155 + blkdev_get_block, NULL, NULL, 156 156 + DIO_SKIP_DIO_COUNT); 156 157 } 157 158 158 159 int __sync_blockdev(struct block_device *bdev, int wait) ··· 1717 1716 if (error) 1718 1717 return ERR_PTR(error); 1719 1718 1720 1720 - inode = path.dentry->d_inode; 1719 1719 + inode = d_backing_inode(path.dentry); 1721 1720 error = -ENOTBLK; 1722 1721 if (!S_ISBLK(inode->i_mode)) 1723 1722 goto fail;

+3 -3

fs/btrfs/export.c

reviewed

··· 152 152 153 153 static struct dentry *btrfs_get_parent(struct dentry *child) 154 154 { 155 155 - struct inode *dir = child->d_inode; 155 155 + struct inode *dir = d_inode(child); 156 156 struct btrfs_root *root = BTRFS_I(dir)->root; 157 157 struct btrfs_path *path; 158 158 struct extent_buffer *leaf; ··· 220 220 static int btrfs_get_name(struct dentry *parent, char *name, 221 221 struct dentry *child) 222 222 { 223 223 - struct inode *inode = child->d_inode; 224 224 - struct inode *dir = parent->d_inode; 223 223 + struct inode *inode = d_inode(child); 224 224 + struct inode *dir = d_inode(parent); 225 225 struct btrfs_path *path; 226 226 struct btrfs_root *root = BTRFS_I(dir)->root; 227 227 struct btrfs_inode_ref *iref;

+1 -1

fs/btrfs/file.c

reviewed

··· 1862 1862 int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync) 1863 1863 { 1864 1864 struct dentry *dentry = file->f_path.dentry; 1865 1865 - struct inode *inode = dentry->d_inode; 1865 1865 + struct inode *inode = d_inode(dentry); 1866 1866 struct btrfs_root *root = BTRFS_I(inode)->root; 1867 1867 struct btrfs_trans_handle *trans; 1868 1868 struct btrfs_log_ctx ctx;

+18 -18

fs/btrfs/inode.c

reviewed

··· 4020 4020 { 4021 4021 struct btrfs_root *root = BTRFS_I(dir)->root; 4022 4022 struct btrfs_trans_handle *trans; 4023 4023 - struct inode *inode = dentry->d_inode; 4023 4023 + struct inode *inode = d_inode(dentry); 4024 4024 int ret; 4025 4025 4026 4026 trans = __unlink_start_trans(dir); 4027 4027 if (IS_ERR(trans)) 4028 4028 return PTR_ERR(trans); 4029 4029 4030 4030 - btrfs_record_unlink_dir(trans, dir, dentry->d_inode, 0); 4030 4030 + btrfs_record_unlink_dir(trans, dir, d_inode(dentry), 0); 4031 4031 4032 4032 - ret = btrfs_unlink_inode(trans, root, dir, dentry->d_inode, 4032 4032 + ret = btrfs_unlink_inode(trans, root, dir, d_inode(dentry), 4033 4033 dentry->d_name.name, dentry->d_name.len); 4034 4034 if (ret) 4035 4035 goto out; ··· 4128 4128 4129 4129 static int btrfs_rmdir(struct inode *dir, struct dentry *dentry) 4130 4130 { 4131 4131 - struct inode *inode = dentry->d_inode; 4131 4131 + struct inode *inode = d_inode(dentry); 4132 4132 int err = 0; 4133 4133 struct btrfs_root *root = BTRFS_I(dir)->root; 4134 4134 struct btrfs_trans_handle *trans; ··· 4155 4155 goto out; 4156 4156 4157 4157 /* now the directory is empty */ 4158 4158 - err = btrfs_unlink_inode(trans, root, dir, dentry->d_inode, 4158 4158 + err = btrfs_unlink_inode(trans, root, dir, d_inode(dentry), 4159 4159 dentry->d_name.name, dentry->d_name.len); 4160 4160 if (!err) 4161 4161 btrfs_i_size_write(inode, 0); ··· 4915 4915 4916 4916 static int btrfs_setattr(struct dentry *dentry, struct iattr *attr) 4917 4917 { 4918 4918 - struct inode *inode = dentry->d_inode; 4918 4918 + struct inode *inode = d_inode(dentry); 4919 4919 struct btrfs_root *root = BTRFS_I(inode)->root; 4920 4920 int err; 4921 4921 ··· 5547 5547 static int btrfs_dentry_delete(const struct dentry *dentry) 5548 5548 { 5549 5549 struct btrfs_root *root; 5550 5550 - struct inode *inode = dentry->d_inode; 5550 5550 + struct inode *inode = d_inode(dentry); 5551 5551 5552 5552 if (!inode && !IS_ROOT(dentry)) 5553 5553 - inode = dentry->d_parent->d_inode; 5553 5553 + inode = d_inode(dentry->d_parent); 5554 5554 5555 5555 if (inode) { 5556 5556 root = BTRFS_I(inode)->root; ··· 6357 6357 { 6358 6358 struct btrfs_trans_handle *trans; 6359 6359 struct btrfs_root *root = BTRFS_I(dir)->root; 6360 6360 - struct inode *inode = old_dentry->d_inode; 6360 6360 + struct inode *inode = d_inode(old_dentry); 6361 6361 u64 index; 6362 6362 int err; 6363 6363 int drop_inode = 0; ··· 8260 8260 if (check_direct_IO(BTRFS_I(inode)->root, iocb, iter, offset)) 8261 8261 return 0; 8262 8262 8263 8263 - atomic_inc(&inode->i_dio_count); 8263 8263 + inode_dio_begin(inode); 8264 8264 smp_mb__after_atomic(); 8265 8265 8266 8266 /* ··· 8300 8300 current->journal_info = &outstanding_extents; 8301 8301 } else if (test_bit(BTRFS_INODE_READDIO_NEED_LOCK, 8302 8302 &BTRFS_I(inode)->runtime_flags)) { 8303 8303 - inode_dio_done(inode); 8303 8303 + inode_dio_end(inode); 8304 8304 flags = DIO_LOCKING | DIO_SKIP_HOLES; 8305 8305 wakeup = false; 8306 8306 } ··· 8319 8319 } 8320 8320 out: 8321 8321 if (wakeup) 8322 8322 - inode_dio_done(inode); 8322 8322 + inode_dio_end(inode); 8323 8323 if (relock) 8324 8324 mutex_lock(&inode->i_mutex); 8325 8325 ··· 9006 9006 struct dentry *dentry, struct kstat *stat) 9007 9007 { 9008 9008 u64 delalloc_bytes; 9009 9009 - struct inode *inode = dentry->d_inode; 9009 9009 + struct inode *inode = d_inode(dentry); 9010 9010 u32 blocksize = inode->i_sb->s_blocksize; 9011 9011 9012 9012 generic_fillattr(inode, stat); ··· 9027 9027 struct btrfs_trans_handle *trans; 9028 9028 struct btrfs_root *root = BTRFS_I(old_dir)->root; 9029 9029 struct btrfs_root *dest = BTRFS_I(new_dir)->root; 9030 9030 - struct inode *new_inode = new_dentry->d_inode; 9031 9031 - struct inode *old_inode = old_dentry->d_inode; 9030 9030 + struct inode *new_inode = d_inode(new_dentry); 9031 9031 + struct inode *old_inode = d_inode(old_dentry); 9032 9032 struct timespec ctime = CURRENT_TIME; 9033 9033 u64 index = 0; 9034 9034 u64 root_objectid; ··· 9140 9140 old_dentry->d_name.len); 9141 9141 } else { 9142 9142 ret = __btrfs_unlink_inode(trans, root, old_dir, 9143 9143 - old_dentry->d_inode, 9143 9143 + d_inode(old_dentry), 9144 9144 old_dentry->d_name.name, 9145 9145 old_dentry->d_name.len); 9146 9146 if (!ret) ··· 9164 9164 BUG_ON(new_inode->i_nlink == 0); 9165 9165 } else { 9166 9166 ret = btrfs_unlink_inode(trans, dest, new_dir, 9167 9167 - new_dentry->d_inode, 9167 9167 + d_inode(new_dentry), 9168 9168 new_dentry->d_name.name, 9169 9169 new_dentry->d_name.len); 9170 9170 } 9171 9171 if (!ret && new_inode->i_nlink == 0) 9172 9172 - ret = btrfs_orphan_add(trans, new_dentry->d_inode); 9172 9172 + ret = btrfs_orphan_add(trans, d_inode(new_dentry)); 9173 9173 if (ret) { 9174 9174 btrfs_abort_transaction(trans, root, ret); 9175 9175 goto out_fail;

+11 -11

fs/btrfs/ioctl.c

reviewed

··· 724 724 if (ret) 725 725 goto fail; 726 726 727 727 - inode = btrfs_lookup_dentry(dentry->d_parent->d_inode, dentry); 727 727 + inode = btrfs_lookup_dentry(d_inode(dentry->d_parent), dentry); 728 728 if (IS_ERR(inode)) { 729 729 ret = PTR_ERR(inode); 730 730 goto fail; ··· 768 768 { 769 769 int error; 770 770 771 771 - if (!victim->d_inode) 771 771 + if (d_really_is_negative(victim)) 772 772 return -ENOENT; 773 773 774 774 - BUG_ON(victim->d_parent->d_inode != dir); 774 774 + BUG_ON(d_inode(victim->d_parent) != dir); 775 775 audit_inode_child(dir, victim, AUDIT_TYPE_CHILD_DELETE); 776 776 777 777 error = inode_permission(dir, MAY_WRITE | MAY_EXEC); ··· 779 779 return error; 780 780 if (IS_APPEND(dir)) 781 781 return -EPERM; 782 782 - if (check_sticky(dir, victim->d_inode) || IS_APPEND(victim->d_inode) || 783 783 - IS_IMMUTABLE(victim->d_inode) || IS_SWAPFILE(victim->d_inode)) 782 782 + if (check_sticky(dir, d_inode(victim)) || IS_APPEND(d_inode(victim)) || 783 783 + IS_IMMUTABLE(d_inode(victim)) || IS_SWAPFILE(d_inode(victim))) 784 784 return -EPERM; 785 785 if (isdir) { 786 786 if (!d_is_dir(victim)) ··· 799 799 /* copy of may_create in fs/namei.c() */ 800 800 static inline int btrfs_may_create(struct inode *dir, struct dentry *child) 801 801 { 802 802 - if (child->d_inode) 802 802 + if (d_really_is_positive(child)) 803 803 return -EEXIST; 804 804 if (IS_DEADDIR(dir)) 805 805 return -ENOENT; ··· 817 817 u64 *async_transid, bool readonly, 818 818 struct btrfs_qgroup_inherit *inherit) 819 819 { 820 820 - struct inode *dir = parent->dentry->d_inode; 820 820 + struct inode *dir = d_inode(parent->dentry); 821 821 struct dentry *dentry; 822 822 int error; 823 823 ··· 831 831 goto out_unlock; 832 832 833 833 error = -EEXIST; 834 834 - if (dentry->d_inode) 834 834 + if (d_really_is_positive(dentry)) 835 835 goto out_dput; 836 836 837 837 error = btrfs_may_create(dir, dentry); ··· 2301 2301 { 2302 2302 struct dentry *parent = file->f_path.dentry; 2303 2303 struct dentry *dentry; 2304 2304 - struct inode *dir = parent->d_inode; 2304 2304 + struct inode *dir = d_inode(parent); 2305 2305 struct inode *inode; 2306 2306 struct btrfs_root *root = BTRFS_I(dir)->root; 2307 2307 struct btrfs_root *dest = NULL; ··· 2340 2340 goto out_unlock_dir; 2341 2341 } 2342 2342 2343 2343 - if (!dentry->d_inode) { 2343 2343 + if (d_really_is_negative(dentry)) { 2344 2344 err = -ENOENT; 2345 2345 goto out_dput; 2346 2346 } 2347 2347 2348 2348 - inode = dentry->d_inode; 2348 2348 + inode = d_inode(dentry); 2349 2349 dest = BTRFS_I(inode)->root; 2350 2350 if (!capable(CAP_SYS_ADMIN)) { 2351 2351 /*

+4 -4

fs/btrfs/super.c

reviewed

··· 925 925 * a reference to the dentry. We will have already gotten a reference 926 926 * to the inode in btrfs_fill_super so we're good to go. 927 927 */ 928 928 - if (!new && sb->s_root->d_inode == inode) { 928 928 + if (!new && d_inode(sb->s_root) == inode) { 929 929 iput(inode); 930 930 return dget(sb->s_root); 931 931 } ··· 1230 1230 1231 1231 root = mount_subtree(mnt, subvol_name); 1232 1232 1233 1233 - if (!IS_ERR(root) && !is_subvolume_inode(root->d_inode)) { 1233 1233 + if (!IS_ERR(root) && !is_subvolume_inode(d_inode(root))) { 1234 1234 struct super_block *s = root->d_sb; 1235 1235 dput(root); 1236 1236 root = ERR_PTR(-EINVAL); ··· 1895 1895 buf->f_fsid.val[0] = be32_to_cpu(fsid[0]) ^ be32_to_cpu(fsid[2]); 1896 1896 buf->f_fsid.val[1] = be32_to_cpu(fsid[1]) ^ be32_to_cpu(fsid[3]); 1897 1897 /* Mask in the root object ID too, to disambiguate subvols */ 1898 1898 - buf->f_fsid.val[0] ^= BTRFS_I(dentry->d_inode)->root->objectid >> 32; 1899 1899 - buf->f_fsid.val[1] ^= BTRFS_I(dentry->d_inode)->root->objectid; 1898 1898 + buf->f_fsid.val[0] ^= BTRFS_I(d_inode(dentry))->root->objectid >> 32; 1899 1899 + buf->f_fsid.val[1] ^= BTRFS_I(d_inode(dentry))->root->objectid; 1900 1900 1901 1901 return 0; 1902 1902 }

+7 -7

fs/btrfs/tree-log.c

reviewed

··· 4474 4474 goto out; 4475 4475 4476 4476 if (!S_ISDIR(inode->i_mode)) { 4477 4477 - if (!parent || !parent->d_inode || sb != parent->d_inode->i_sb) 4477 4477 + if (!parent || d_really_is_negative(parent) || sb != d_inode(parent)->i_sb) 4478 4478 goto out; 4479 4479 - inode = parent->d_inode; 4479 4479 + inode = d_inode(parent); 4480 4480 } 4481 4481 4482 4482 while (1) { ··· 4502 4502 break; 4503 4503 } 4504 4504 4505 4505 - if (!parent || !parent->d_inode || sb != parent->d_inode->i_sb) 4505 4505 + if (!parent || d_really_is_negative(parent) || sb != d_inode(parent)->i_sb) 4506 4506 break; 4507 4507 4508 4508 if (IS_ROOT(parent)) ··· 4511 4511 parent = dget_parent(parent); 4512 4512 dput(old_parent); 4513 4513 old_parent = parent; 4514 4514 - inode = parent->d_inode; 4514 4514 + inode = d_inode(parent); 4515 4515 4516 4516 } 4517 4517 dput(old_parent); ··· 4777 4777 log_dentries = true; 4778 4778 4779 4779 while (1) { 4780 4780 - if (!parent || !parent->d_inode || sb != parent->d_inode->i_sb) 4780 4780 + if (!parent || d_really_is_negative(parent) || sb != d_inode(parent)->i_sb) 4781 4781 break; 4782 4782 4783 4783 - inode = parent->d_inode; 4783 4783 + inode = d_inode(parent); 4784 4784 if (root != BTRFS_I(inode)->root) 4785 4785 break; 4786 4786 ··· 4845 4845 struct dentry *parent = dget_parent(dentry); 4846 4846 int ret; 4847 4847 4848 4848 - ret = btrfs_log_inode_parent(trans, root, dentry->d_inode, parent, 4848 4848 + ret = btrfs_log_inode_parent(trans, root, d_inode(dentry), parent, 4849 4849 start, end, 0, ctx); 4850 4850 dput(parent); 4851 4851

+8 -8

fs/btrfs/xattr.c

reviewed

··· 261 261 ssize_t btrfs_listxattr(struct dentry *dentry, char *buffer, size_t size) 262 262 { 263 263 struct btrfs_key key, found_key; 264 264 - struct inode *inode = dentry->d_inode; 264 264 + struct inode *inode = d_inode(dentry); 265 265 struct btrfs_root *root = BTRFS_I(inode)->root; 266 266 struct btrfs_path *path; 267 267 struct extent_buffer *leaf; ··· 411 411 ret = btrfs_is_valid_xattr(name); 412 412 if (ret) 413 413 return ret; 414 414 - return __btrfs_getxattr(dentry->d_inode, name, buffer, size); 414 414 + return __btrfs_getxattr(d_inode(dentry), name, buffer, size); 415 415 } 416 416 417 417 int btrfs_setxattr(struct dentry *dentry, const char *name, const void *value, 418 418 size_t size, int flags) 419 419 { 420 420 - struct btrfs_root *root = BTRFS_I(dentry->d_inode)->root; 420 420 + struct btrfs_root *root = BTRFS_I(d_inode(dentry))->root; 421 421 int ret; 422 422 423 423 /* ··· 440 440 return ret; 441 441 442 442 if (!strncmp(name, XATTR_BTRFS_PREFIX, XATTR_BTRFS_PREFIX_LEN)) 443 443 - return btrfs_set_prop(dentry->d_inode, name, 443 443 + return btrfs_set_prop(d_inode(dentry), name, 444 444 value, size, flags); 445 445 446 446 if (size == 0) 447 447 value = ""; /* empty EA, do not remove */ 448 448 449 449 - return __btrfs_setxattr(NULL, dentry->d_inode, name, value, size, 449 449 + return __btrfs_setxattr(NULL, d_inode(dentry), name, value, size, 450 450 flags); 451 451 } 452 452 453 453 int btrfs_removexattr(struct dentry *dentry, const char *name) 454 454 { 455 455 - struct btrfs_root *root = BTRFS_I(dentry->d_inode)->root; 455 455 + struct btrfs_root *root = BTRFS_I(d_inode(dentry))->root; 456 456 int ret; 457 457 458 458 /* ··· 475 475 return ret; 476 476 477 477 if (!strncmp(name, XATTR_BTRFS_PREFIX, XATTR_BTRFS_PREFIX_LEN)) 478 478 - return btrfs_set_prop(dentry->d_inode, name, 478 478 + return btrfs_set_prop(d_inode(dentry), name, 479 479 NULL, 0, XATTR_REPLACE); 480 480 481 481 - return __btrfs_setxattr(NULL, dentry->d_inode, name, NULL, 0, 481 481 + return __btrfs_setxattr(NULL, d_inode(dentry), name, NULL, 0, 482 482 XATTR_REPLACE); 483 483 } 484 484

+5 -5

fs/cachefiles/bind.c

reviewed

··· 123 123 124 124 /* check parameters */ 125 125 ret = -EOPNOTSUPP; 126 126 - if (!root->d_inode || 127 127 - !root->d_inode->i_op->lookup || 128 128 - !root->d_inode->i_op->mkdir || 129 129 - !root->d_inode->i_op->setxattr || 130 130 - !root->d_inode->i_op->getxattr || 126 126 + if (d_is_negative(root) || 127 127 + !d_backing_inode(root)->i_op->lookup || 128 128 + !d_backing_inode(root)->i_op->mkdir || 129 129 + !d_backing_inode(root)->i_op->setxattr || 130 130 + !d_backing_inode(root)->i_op->getxattr || 131 131 !root->d_sb->s_op->statfs || 132 132 !root->d_sb->s_op->sync_fs) 133 133 goto error_unsupported;

+3 -3

fs/cachefiles/interface.c

reviewed

··· 441 441 442 442 fscache_set_store_limit(&object->fscache, ni_size); 443 443 444 444 - oi_size = i_size_read(object->backer->d_inode); 444 444 + oi_size = i_size_read(d_backing_inode(object->backer)); 445 445 if (oi_size == ni_size) 446 446 return 0; 447 447 448 448 cachefiles_begin_secure(cache, &saved_cred); 449 449 - mutex_lock(&object->backer->d_inode->i_mutex); 449 449 + mutex_lock(&d_inode(object->backer)->i_mutex); 450 450 451 451 /* if there's an extension to a partial page at the end of the backing 452 452 * file, we need to discard the partial page so that we pick up new ··· 465 465 ret = notify_change(object->backer, &newattrs, NULL); 466 466 467 467 truncate_failed: 468 468 - mutex_unlock(&object->backer->d_inode->i_mutex); 468 468 + mutex_unlock(&d_inode(object->backer)->i_mutex); 469 469 cachefiles_end_secure(cache, saved_cred); 470 470 471 471 if (ret == -EIO) {

+61 -61

fs/cachefiles/namei.c

reviewed

··· 286 286 if (ret < 0) { 287 287 cachefiles_io_error(cache, "Unlink security error"); 288 288 } else { 289 289 - ret = vfs_unlink(dir->d_inode, rep, NULL); 289 289 + ret = vfs_unlink(d_inode(dir), rep, NULL); 290 290 291 291 if (preemptive) 292 292 cachefiles_mark_object_buried(cache, rep); 293 293 } 294 294 295 295 - mutex_unlock(&dir->d_inode->i_mutex); 295 295 + mutex_unlock(&d_inode(dir)->i_mutex); 296 296 297 297 if (ret == -EIO) 298 298 cachefiles_io_error(cache, "Unlink failed"); ··· 303 303 304 304 /* directories have to be moved to the graveyard */ 305 305 _debug("move stale object to graveyard"); 306 306 - mutex_unlock(&dir->d_inode->i_mutex); 306 306 + mutex_unlock(&d_inode(dir)->i_mutex); 307 307 308 308 try_again: 309 309 /* first step is to make up a grave dentry in the graveyard */ ··· 355 355 return -EIO; 356 356 } 357 357 358 358 - if (grave->d_inode) { 358 358 + if (d_is_positive(grave)) { 359 359 unlock_rename(cache->graveyard, dir); 360 360 dput(grave); 361 361 grave = NULL; ··· 387 387 if (ret < 0) { 388 388 cachefiles_io_error(cache, "Rename security error %d", ret); 389 389 } else { 390 390 - ret = vfs_rename(dir->d_inode, rep, 391 391 - cache->graveyard->d_inode, grave, NULL, 0); 390 390 + ret = vfs_rename(d_inode(dir), rep, 391 391 + d_inode(cache->graveyard), grave, NULL, 0); 392 392 if (ret != 0 && ret != -ENOMEM) 393 393 cachefiles_io_error(cache, 394 394 "Rename failed with error %d", ret); ··· 415 415 _enter(",OBJ%x{%p}", object->fscache.debug_id, object->dentry); 416 416 417 417 ASSERT(object->dentry); 418 418 - ASSERT(object->dentry->d_inode); 418 418 + ASSERT(d_backing_inode(object->dentry)); 419 419 ASSERT(object->dentry->d_parent); 420 420 421 421 dir = dget_parent(object->dentry); 422 422 423 423 - mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT); 423 423 + mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_PARENT); 424 424 425 425 if (test_bit(CACHEFILES_OBJECT_BURIED, &object->flags)) { 426 426 /* object allocation for the same key preemptively deleted this 427 427 * object's file so that it could create its own file */ 428 428 _debug("object preemptively buried"); 429 429 - mutex_unlock(&dir->d_inode->i_mutex); 429 429 + mutex_unlock(&d_inode(dir)->i_mutex); 430 430 ret = 0; 431 431 } else { 432 432 /* we need to check that our parent is _still_ our parent - it ··· 438 438 /* it got moved, presumably by cachefilesd culling it, 439 439 * so it's no longer in the key path and we can ignore 440 440 * it */ 441 441 - mutex_unlock(&dir->d_inode->i_mutex); 441 441 + mutex_unlock(&d_inode(dir)->i_mutex); 442 442 ret = 0; 443 443 } 444 444 } ··· 473 473 path.mnt = cache->mnt; 474 474 475 475 ASSERT(parent->dentry); 476 476 - ASSERT(parent->dentry->d_inode); 476 476 + ASSERT(d_backing_inode(parent->dentry)); 477 477 478 478 if (!(d_is_dir(parent->dentry))) { 479 479 // TODO: convert file to dir ··· 497 497 /* search the current directory for the element name */ 498 498 _debug("lookup '%s'", name); 499 499 500 500 - mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT); 500 500 + mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_PARENT); 501 501 502 502 start = jiffies; 503 503 next = lookup_one_len(name, dir, nlen); ··· 505 505 if (IS_ERR(next)) 506 506 goto lookup_error; 507 507 508 508 - _debug("next -> %p %s", next, next->d_inode ? "positive" : "negative"); 508 508 + _debug("next -> %p %s", next, d_backing_inode(next) ? "positive" : "negative"); 509 509 510 510 if (!key) 511 511 - object->new = !next->d_inode; 511 511 + object->new = !d_backing_inode(next); 512 512 513 513 /* if this element of the path doesn't exist, then the lookup phase 514 514 * failed, and we can release any readers in the certain knowledge that 515 515 * there's nothing for them to actually read */ 516 516 - if (!next->d_inode) 516 516 + if (d_is_negative(next)) 517 517 fscache_object_lookup_negative(&object->fscache); 518 518 519 519 /* we need to create the object if it's negative */ 520 520 if (key || object->type == FSCACHE_COOKIE_TYPE_INDEX) { 521 521 /* index objects and intervening tree levels must be subdirs */ 522 522 - if (!next->d_inode) { 522 522 + if (d_is_negative(next)) { 523 523 ret = cachefiles_has_space(cache, 1, 0); 524 524 if (ret < 0) 525 525 goto create_error; ··· 529 529 if (ret < 0) 530 530 goto create_error; 531 531 start = jiffies; 532 532 - ret = vfs_mkdir(dir->d_inode, next, 0); 532 532 + ret = vfs_mkdir(d_inode(dir), next, 0); 533 533 cachefiles_hist(cachefiles_mkdir_histogram, start); 534 534 if (ret < 0) 535 535 goto create_error; 536 536 537 537 - ASSERT(next->d_inode); 537 537 + ASSERT(d_backing_inode(next)); 538 538 539 539 _debug("mkdir -> %p{%p{ino=%lu}}", 540 540 - next, next->d_inode, next->d_inode->i_ino); 540 540 + next, d_backing_inode(next), d_backing_inode(next)->i_ino); 541 541 542 542 } else if (!d_can_lookup(next)) { 543 543 pr_err("inode %lu is not a directory\n", 544 544 - next->d_inode->i_ino); 544 544 + d_backing_inode(next)->i_ino); 545 545 ret = -ENOBUFS; 546 546 goto error; 547 547 } 548 548 549 549 } else { 550 550 /* non-index objects start out life as files */ 551 551 - if (!next->d_inode) { 551 551 + if (d_is_negative(next)) { 552 552 ret = cachefiles_has_space(cache, 1, 0); 553 553 if (ret < 0) 554 554 goto create_error; ··· 558 558 if (ret < 0) 559 559 goto create_error; 560 560 start = jiffies; 561 561 - ret = vfs_create(dir->d_inode, next, S_IFREG, true); 561 561 + ret = vfs_create(d_inode(dir), next, S_IFREG, true); 562 562 cachefiles_hist(cachefiles_create_histogram, start); 563 563 if (ret < 0) 564 564 goto create_error; 565 565 566 566 - ASSERT(next->d_inode); 566 566 + ASSERT(d_backing_inode(next)); 567 567 568 568 _debug("create -> %p{%p{ino=%lu}}", 569 569 - next, next->d_inode, next->d_inode->i_ino); 569 569 + next, d_backing_inode(next), d_backing_inode(next)->i_ino); 570 570 571 571 } else if (!d_can_lookup(next) && 572 572 !d_is_reg(next) 573 573 ) { 574 574 pr_err("inode %lu is not a file or directory\n", 575 575 - next->d_inode->i_ino); 575 575 + d_backing_inode(next)->i_ino); 576 576 ret = -ENOBUFS; 577 577 goto error; 578 578 } ··· 581 581 /* process the next component */ 582 582 if (key) { 583 583 _debug("advance"); 584 584 - mutex_unlock(&dir->d_inode->i_mutex); 584 584 + mutex_unlock(&d_inode(dir)->i_mutex); 585 585 dput(dir); 586 586 dir = next; 587 587 next = NULL; ··· 617 617 /* note that we're now using this object */ 618 618 ret = cachefiles_mark_object_active(cache, object); 619 619 620 620 - mutex_unlock(&dir->d_inode->i_mutex); 620 620 + mutex_unlock(&d_inode(dir)->i_mutex); 621 621 dput(dir); 622 622 dir = NULL; 623 623 ··· 646 646 const struct address_space_operations *aops; 647 647 648 648 ret = -EPERM; 649 649 - aops = object->dentry->d_inode->i_mapping->a_ops; 649 649 + aops = d_backing_inode(object->dentry)->i_mapping->a_ops; 650 650 if (!aops->bmap) 651 651 goto check_error; 652 652 ··· 659 659 object->new = 0; 660 660 fscache_obtained_object(&object->fscache); 661 661 662 662 - _leave(" = 0 [%lu]", object->dentry->d_inode->i_ino); 662 662 + _leave(" = 0 [%lu]", d_backing_inode(object->dentry)->i_ino); 663 663 return 0; 664 664 665 665 create_error: ··· 695 695 cachefiles_io_error(cache, "Lookup failed"); 696 696 next = NULL; 697 697 error: 698 698 - mutex_unlock(&dir->d_inode->i_mutex); 698 698 + mutex_unlock(&d_inode(dir)->i_mutex); 699 699 dput(next); 700 700 error_out2: 701 701 dput(dir); ··· 719 719 _enter(",,%s", dirname); 720 720 721 721 /* search the current directory for the element name */ 722 722 - mutex_lock(&dir->d_inode->i_mutex); 722 722 + mutex_lock(&d_inode(dir)->i_mutex); 723 723 724 724 start = jiffies; 725 725 subdir = lookup_one_len(dirname, dir, strlen(dirname)); ··· 731 731 } 732 732 733 733 _debug("subdir -> %p %s", 734 734 - subdir, subdir->d_inode ? "positive" : "negative"); 734 734 + subdir, d_backing_inode(subdir) ? "positive" : "negative"); 735 735 736 736 /* we need to create the subdir if it doesn't exist yet */ 737 737 - if (!subdir->d_inode) { 737 737 + if (d_is_negative(subdir)) { 738 738 ret = cachefiles_has_space(cache, 1, 0); 739 739 if (ret < 0) 740 740 goto mkdir_error; ··· 746 746 ret = security_path_mkdir(&path, subdir, 0700); 747 747 if (ret < 0) 748 748 goto mkdir_error; 749 749 - ret = vfs_mkdir(dir->d_inode, subdir, 0700); 749 749 + ret = vfs_mkdir(d_inode(dir), subdir, 0700); 750 750 if (ret < 0) 751 751 goto mkdir_error; 752 752 753 753 - ASSERT(subdir->d_inode); 753 753 + ASSERT(d_backing_inode(subdir)); 754 754 755 755 _debug("mkdir -> %p{%p{ino=%lu}}", 756 756 subdir, 757 757 - subdir->d_inode, 758 758 - subdir->d_inode->i_ino); 757 757 + d_backing_inode(subdir), 758 758 + d_backing_inode(subdir)->i_ino); 759 759 } 760 760 761 761 - mutex_unlock(&dir->d_inode->i_mutex); 761 761 + mutex_unlock(&d_inode(dir)->i_mutex); 762 762 763 763 /* we need to make sure the subdir is a directory */ 764 764 - ASSERT(subdir->d_inode); 764 764 + ASSERT(d_backing_inode(subdir)); 765 765 766 766 if (!d_can_lookup(subdir)) { 767 767 pr_err("%s is not a directory\n", dirname); ··· 770 770 } 771 771 772 772 ret = -EPERM; 773 773 - if (!subdir->d_inode->i_op->setxattr || 774 774 - !subdir->d_inode->i_op->getxattr || 775 775 - !subdir->d_inode->i_op->lookup || 776 776 - !subdir->d_inode->i_op->mkdir || 777 777 - !subdir->d_inode->i_op->create || 778 778 - (!subdir->d_inode->i_op->rename && 779 779 - !subdir->d_inode->i_op->rename2) || 780 780 - !subdir->d_inode->i_op->rmdir || 781 781 - !subdir->d_inode->i_op->unlink) 773 773 + if (!d_backing_inode(subdir)->i_op->setxattr || 774 774 + !d_backing_inode(subdir)->i_op->getxattr || 775 775 + !d_backing_inode(subdir)->i_op->lookup || 776 776 + !d_backing_inode(subdir)->i_op->mkdir || 777 777 + !d_backing_inode(subdir)->i_op->create || 778 778 + (!d_backing_inode(subdir)->i_op->rename && 779 779 + !d_backing_inode(subdir)->i_op->rename2) || 780 780 + !d_backing_inode(subdir)->i_op->rmdir || 781 781 + !d_backing_inode(subdir)->i_op->unlink) 782 782 goto check_error; 783 783 784 784 - _leave(" = [%lu]", subdir->d_inode->i_ino); 784 784 + _leave(" = [%lu]", d_backing_inode(subdir)->i_ino); 785 785 return subdir; 786 786 787 787 check_error: ··· 790 790 return ERR_PTR(ret); 791 791 792 792 mkdir_error: 793 793 - mutex_unlock(&dir->d_inode->i_mutex); 793 793 + mutex_unlock(&d_inode(dir)->i_mutex); 794 794 dput(subdir); 795 795 pr_err("mkdir %s failed with error %d\n", dirname, ret); 796 796 return ERR_PTR(ret); 797 797 798 798 lookup_error: 799 799 - mutex_unlock(&dir->d_inode->i_mutex); 799 799 + mutex_unlock(&d_inode(dir)->i_mutex); 800 800 ret = PTR_ERR(subdir); 801 801 pr_err("Lookup %s failed with error %d\n", dirname, ret); 802 802 return ERR_PTR(ret); 803 803 804 804 nomem_d_alloc: 805 805 - mutex_unlock(&dir->d_inode->i_mutex); 805 805 + mutex_unlock(&d_inode(dir)->i_mutex); 806 806 _leave(" = -ENOMEM"); 807 807 return ERR_PTR(-ENOMEM); 808 808 } ··· 827 827 // dir, filename); 828 828 829 829 /* look up the victim */ 830 830 - mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT); 830 830 + mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_PARENT); 831 831 832 832 start = jiffies; 833 833 victim = lookup_one_len(filename, dir, strlen(filename)); ··· 836 836 goto lookup_error; 837 837 838 838 //_debug("victim -> %p %s", 839 839 - // victim, victim->d_inode ? "positive" : "negative"); 839 839 + // victim, d_backing_inode(victim) ? "positive" : "negative"); 840 840 841 841 /* if the object is no longer there then we probably retired the object 842 842 * at the netfs's request whilst the cull was in progress 843 843 */ 844 844 - if (!victim->d_inode) { 845 845 - mutex_unlock(&dir->d_inode->i_mutex); 844 844 + if (d_is_negative(victim)) { 845 845 + mutex_unlock(&d_inode(dir)->i_mutex); 846 846 dput(victim); 847 847 _leave(" = -ENOENT [absent]"); 848 848 return ERR_PTR(-ENOENT); ··· 871 871 872 872 object_in_use: 873 873 read_unlock(&cache->active_lock); 874 874 - mutex_unlock(&dir->d_inode->i_mutex); 874 874 + mutex_unlock(&d_inode(dir)->i_mutex); 875 875 dput(victim); 876 876 //_leave(" = -EBUSY [in use]"); 877 877 return ERR_PTR(-EBUSY); 878 878 879 879 lookup_error: 880 880 - mutex_unlock(&dir->d_inode->i_mutex); 880 880 + mutex_unlock(&d_inode(dir)->i_mutex); 881 881 ret = PTR_ERR(victim); 882 882 if (ret == -ENOENT) { 883 883 /* file or dir now absent - probably retired by netfs */ ··· 913 913 return PTR_ERR(victim); 914 914 915 915 _debug("victim -> %p %s", 916 916 - victim, victim->d_inode ? "positive" : "negative"); 916 916 + victim, d_backing_inode(victim) ? "positive" : "negative"); 917 917 918 918 /* okay... the victim is not being used so we can cull it 919 919 * - start by marking it as stale ··· 936 936 return 0; 937 937 938 938 error_unlock: 939 939 - mutex_unlock(&dir->d_inode->i_mutex); 939 939 + mutex_unlock(&d_inode(dir)->i_mutex); 940 940 error: 941 941 dput(victim); 942 942 if (ret == -ENOENT) { ··· 971 971 if (IS_ERR(victim)) 972 972 return PTR_ERR(victim); 973 973 974 974 - mutex_unlock(&dir->d_inode->i_mutex); 974 974 + mutex_unlock(&d_inode(dir)->i_mutex); 975 975 dput(victim); 976 976 //_leave(" = 0"); 977 977 return 0;

+7 -7

fs/cachefiles/rdwr.c

reviewed

··· 74 74 static int cachefiles_read_reissue(struct cachefiles_object *object, 75 75 struct cachefiles_one_read *monitor) 76 76 { 77 77 - struct address_space *bmapping = object->backer->d_inode->i_mapping; 77 77 + struct address_space *bmapping = d_backing_inode(object->backer)->i_mapping; 78 78 struct page *backpage = monitor->back_page, *backpage2; 79 79 int ret; 80 80 81 81 _enter("{ino=%lx},{%lx,%lx}", 82 82 - object->backer->d_inode->i_ino, 82 82 + d_backing_inode(object->backer)->i_ino, 83 83 backpage->index, backpage->flags); 84 84 85 85 /* skip if the page was truncated away completely */ ··· 157 157 object = container_of(op->op.object, 158 158 struct cachefiles_object, fscache); 159 159 160 160 - _enter("{ino=%lu}", object->backer->d_inode->i_ino); 160 160 + _enter("{ino=%lu}", d_backing_inode(object->backer)->i_ino); 161 161 162 162 max = 8; 163 163 spin_lock_irq(&object->work_lock); ··· 247 247 init_waitqueue_func_entry(&monitor->monitor, cachefiles_read_waiter); 248 248 249 249 /* attempt to get hold of the backing page */ 250 250 - bmapping = object->backer->d_inode->i_mapping; 250 250 + bmapping = d_backing_inode(object->backer)->i_mapping; 251 251 newpage = NULL; 252 252 253 253 for (;;) { ··· 408 408 if (!object->backer) 409 409 goto enobufs; 410 410 411 411 - inode = object->backer->d_inode; 411 411 + inode = d_backing_inode(object->backer); 412 412 ASSERT(S_ISREG(inode->i_mode)); 413 413 ASSERT(inode->i_mapping->a_ops->bmap); 414 414 ASSERT(inode->i_mapping->a_ops->readpages); ··· 468 468 struct list_head *list) 469 469 { 470 470 struct cachefiles_one_read *monitor = NULL; 471 471 - struct address_space *bmapping = object->backer->d_inode->i_mapping; 471 471 + struct address_space *bmapping = d_backing_inode(object->backer)->i_mapping; 472 472 struct page *newpage = NULL, *netpage, *_n, *backpage = NULL; 473 473 int ret = 0; 474 474 ··· 705 705 if (cachefiles_has_space(cache, 0, *nr_pages) < 0) 706 706 space = 0; 707 707 708 708 - inode = object->backer->d_inode; 708 708 + inode = d_backing_inode(object->backer); 709 709 ASSERT(S_ISREG(inode->i_mode)); 710 710 ASSERT(inode->i_mapping->a_ops->bmap); 711 711 ASSERT(inode->i_mapping->a_ops->readpages);

+3 -3

fs/cachefiles/security.c

reviewed

··· 55 55 { 56 56 int ret; 57 57 58 58 - ret = security_inode_mkdir(root->d_inode, root, 0); 58 58 + ret = security_inode_mkdir(d_backing_inode(root), root, 0); 59 59 if (ret < 0) { 60 60 pr_err("Security denies permission to make dirs: error %d", 61 61 ret); 62 62 return ret; 63 63 } 64 64 65 65 - ret = security_inode_create(root->d_inode, root, 0); 65 65 + ret = security_inode_create(d_backing_inode(root), root, 0); 66 66 if (ret < 0) 67 67 pr_err("Security denies permission to create files: error %d", 68 68 ret); ··· 95 95 96 96 /* use the cache root dir's security context as the basis with 97 97 * which create files */ 98 98 - ret = set_create_files_as(new, root->d_inode); 98 98 + ret = set_create_files_as(new, d_backing_inode(root)); 99 99 if (ret < 0) { 100 100 abort_creds(new); 101 101 cachefiles_begin_secure(cache, _saved_cred);

+11 -11

fs/cachefiles/xattr.c

reviewed

··· 33 33 int ret; 34 34 35 35 ASSERT(dentry); 36 36 - ASSERT(dentry->d_inode); 36 36 + ASSERT(d_backing_inode(dentry)); 37 37 38 38 if (!object->fscache.cookie) 39 39 strcpy(type, "C3"); ··· 52 52 53 53 if (ret != -EEXIST) { 54 54 pr_err("Can't set xattr on %pd [%lu] (err %d)\n", 55 55 - dentry, dentry->d_inode->i_ino, 55 55 + dentry, d_backing_inode(dentry)->i_ino, 56 56 -ret); 57 57 goto error; 58 58 } ··· 64 64 goto bad_type_length; 65 65 66 66 pr_err("Can't read xattr on %pd [%lu] (err %d)\n", 67 67 - dentry, dentry->d_inode->i_ino, 67 67 + dentry, d_backing_inode(dentry)->i_ino, 68 68 -ret); 69 69 goto error; 70 70 } ··· 84 84 85 85 bad_type_length: 86 86 pr_err("Cache object %lu type xattr length incorrect\n", 87 87 - dentry->d_inode->i_ino); 87 87 + d_backing_inode(dentry)->i_ino); 88 88 ret = -EIO; 89 89 goto error; 90 90 91 91 bad_type: 92 92 xtype[2] = 0; 93 93 pr_err("Cache object %pd [%lu] type %s not %s\n", 94 94 - dentry, dentry->d_inode->i_ino, 94 94 + dentry, d_backing_inode(dentry)->i_ino, 95 95 xtype, type); 96 96 ret = -EIO; 97 97 goto error; ··· 165 165 int ret; 166 166 167 167 ASSERT(dentry); 168 168 - ASSERT(dentry->d_inode); 168 168 + ASSERT(d_backing_inode(dentry)); 169 169 ASSERT(object->fscache.cookie->def->check_aux); 170 170 171 171 auxbuf = kmalloc(sizeof(struct cachefiles_xattr) + 512, GFP_KERNEL); ··· 204 204 _enter("%p,#%d", object, auxdata->len); 205 205 206 206 ASSERT(dentry); 207 207 - ASSERT(dentry->d_inode); 207 207 + ASSERT(d_backing_inode(dentry)); 208 208 209 209 auxbuf = kmalloc(sizeof(struct cachefiles_xattr) + 512, cachefiles_gfp); 210 210 if (!auxbuf) { ··· 225 225 226 226 cachefiles_io_error_obj(object, 227 227 "Can't read xattr on %lu (err %d)", 228 228 - dentry->d_inode->i_ino, -ret); 228 228 + d_backing_inode(dentry)->i_ino, -ret); 229 229 goto error; 230 230 } 231 231 ··· 276 276 cachefiles_io_error_obj(object, 277 277 "Can't update xattr on %lu" 278 278 " (error %d)", 279 279 - dentry->d_inode->i_ino, -ret); 279 279 + d_backing_inode(dentry)->i_ino, -ret); 280 280 goto error; 281 281 } 282 282 } ··· 291 291 292 292 bad_type_length: 293 293 pr_err("Cache object %lu xattr length incorrect\n", 294 294 - dentry->d_inode->i_ino); 294 294 + d_backing_inode(dentry)->i_ino); 295 295 ret = -EIO; 296 296 goto error; 297 297 ··· 316 316 cachefiles_io_error(cache, 317 317 "Can't remove xattr from %lu" 318 318 " (error %d)", 319 319 - dentry->d_inode->i_ino, -ret); 319 319 + d_backing_inode(dentry)->i_ino, -ret); 320 320 } 321 321 322 322 _leave(" = %d", ret);

+1 -1

fs/ceph/caps.c

reviewed

··· 3422 3422 int ceph_encode_dentry_release(void **p, struct dentry *dentry, 3423 3423 int mds, int drop, int unless) 3424 3424 { 3425 3425 - struct inode *dir = dentry->d_parent->d_inode; 3425 3425 + struct inode *dir = d_inode(dentry->d_parent); 3426 3426 struct ceph_mds_request_release *rel = *p; 3427 3427 struct ceph_dentry_info *di = ceph_dentry(dentry); 3428 3428 int force = 0;

+1 -1

fs/ceph/debugfs.c

reviewed

··· 84 84 path = NULL; 85 85 spin_lock(&req->r_dentry->d_lock); 86 86 seq_printf(s, " #%llx/%pd (%s)", 87 87 - ceph_ino(req->r_dentry->d_parent->d_inode), 87 87 + ceph_ino(d_inode(req->r_dentry->d_parent)), 88 88 req->r_dentry, 89 89 path ? path : ""); 90 90 spin_unlock(&req->r_dentry->d_lock);

+30 -30

fs/ceph/dir.c

reviewed

··· 49 49 goto out_unlock; 50 50 } 51 51 52 52 - if (ceph_snap(dentry->d_parent->d_inode) == CEPH_NOSNAP) 52 52 + if (ceph_snap(d_inode(dentry->d_parent)) == CEPH_NOSNAP) 53 53 d_set_d_op(dentry, &ceph_dentry_ops); 54 54 - else if (ceph_snap(dentry->d_parent->d_inode) == CEPH_SNAPDIR) 54 54 + else if (ceph_snap(d_inode(dentry->d_parent)) == CEPH_SNAPDIR) 55 55 d_set_d_op(dentry, &ceph_snapdir_dentry_ops); 56 56 else 57 57 d_set_d_op(dentry, &ceph_snap_dentry_ops); ··· 77 77 78 78 spin_lock(&dentry->d_lock); 79 79 if (!IS_ROOT(dentry)) { 80 80 - inode = dentry->d_parent->d_inode; 80 80 + inode = d_inode(dentry->d_parent); 81 81 ihold(inode); 82 82 } 83 83 spin_unlock(&dentry->d_lock); ··· 122 122 { 123 123 struct ceph_file_info *fi = file->private_data; 124 124 struct dentry *parent = file->f_path.dentry; 125 125 - struct inode *dir = parent->d_inode; 125 125 + struct inode *dir = d_inode(parent); 126 126 struct list_head *p; 127 127 struct dentry *dentry, *last; 128 128 struct ceph_dentry_info *di; ··· 161 161 } 162 162 spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED); 163 163 if (di->lease_shared_gen == shared_gen && 164 164 - !d_unhashed(dentry) && dentry->d_inode && 165 165 - ceph_snap(dentry->d_inode) != CEPH_SNAPDIR && 166 166 - ceph_ino(dentry->d_inode) != CEPH_INO_CEPH && 164 164 + !d_unhashed(dentry) && d_really_is_positive(dentry) && 165 165 + ceph_snap(d_inode(dentry)) != CEPH_SNAPDIR && 166 166 + ceph_ino(d_inode(dentry)) != CEPH_INO_CEPH && 167 167 fpos_cmp(ctx->pos, di->offset) <= 0) 168 168 break; 169 169 dout(" skipping %p %pd at %llu (%llu)%s%s\n", dentry, 170 170 dentry, di->offset, 171 171 ctx->pos, d_unhashed(dentry) ? " unhashed" : "", 172 172 - !dentry->d_inode ? " null" : ""); 172 172 + !d_inode(dentry) ? " null" : ""); 173 173 spin_unlock(&dentry->d_lock); 174 174 p = p->prev; 175 175 dentry = list_entry(p, struct dentry, d_child); ··· 189 189 } 190 190 191 191 dout(" %llu (%llu) dentry %p %pd %p\n", di->offset, ctx->pos, 192 192 - dentry, dentry, dentry->d_inode); 192 192 + dentry, dentry, d_inode(dentry)); 193 193 if (!dir_emit(ctx, dentry->d_name.name, 194 194 dentry->d_name.len, 195 195 - ceph_translate_ino(dentry->d_sb, dentry->d_inode->i_ino), 196 196 - dentry->d_inode->i_mode >> 12)) { 195 195 + ceph_translate_ino(dentry->d_sb, d_inode(dentry)->i_ino), 196 196 + d_inode(dentry)->i_mode >> 12)) { 197 197 if (last) { 198 198 /* remember our position */ 199 199 fi->dentry = last; ··· 543 543 struct dentry *dentry, int err) 544 544 { 545 545 struct ceph_fs_client *fsc = ceph_sb_to_client(dentry->d_sb); 546 546 - struct inode *parent = dentry->d_parent->d_inode; /* we hold i_mutex */ 546 546 + struct inode *parent = d_inode(dentry->d_parent); /* we hold i_mutex */ 547 547 548 548 /* .snap dir? */ 549 549 if (err == -ENOENT && ··· 579 579 err = 0; 580 580 if (!req->r_reply_info.head->is_dentry) { 581 581 dout("ENOENT and no trace, dentry %p inode %p\n", 582 582 - dentry, dentry->d_inode); 583 583 - if (dentry->d_inode) { 582 582 + dentry, d_inode(dentry)); 583 583 + if (d_really_is_positive(dentry)) { 584 584 d_drop(dentry); 585 585 err = -ENOENT; 586 586 } else { ··· 627 627 return ERR_PTR(err); 628 628 629 629 /* can we conclude ENOENT locally? */ 630 630 - if (dentry->d_inode == NULL) { 630 630 + if (d_really_is_negative(dentry)) { 631 631 struct ceph_inode_info *ci = ceph_inode(dir); 632 632 struct ceph_dentry_info *di = ceph_dentry(dentry); 633 633 ··· 734 734 ceph_mdsc_put_request(req); 735 735 out: 736 736 if (!err) 737 737 - ceph_init_inode_acls(dentry->d_inode, &acls); 737 737 + ceph_init_inode_acls(d_inode(dentry), &acls); 738 738 else 739 739 d_drop(dentry); 740 740 ceph_release_acls_info(&acls); ··· 835 835 ceph_mdsc_put_request(req); 836 836 out: 837 837 if (!err) 838 838 - ceph_init_inode_acls(dentry->d_inode, &acls); 838 838 + ceph_init_inode_acls(d_inode(dentry), &acls); 839 839 else 840 840 d_drop(dentry); 841 841 ceph_release_acls_info(&acls); ··· 872 872 if (err) { 873 873 d_drop(dentry); 874 874 } else if (!req->r_reply_info.head->is_dentry) { 875 875 - ihold(old_dentry->d_inode); 876 876 - d_instantiate(dentry, old_dentry->d_inode); 875 875 + ihold(d_inode(old_dentry)); 876 876 + d_instantiate(dentry, d_inode(old_dentry)); 877 877 } 878 878 ceph_mdsc_put_request(req); 879 879 return err; ··· 906 906 { 907 907 struct ceph_fs_client *fsc = ceph_sb_to_client(dir->i_sb); 908 908 struct ceph_mds_client *mdsc = fsc->mdsc; 909 909 - struct inode *inode = dentry->d_inode; 909 909 + struct inode *inode = d_inode(dentry); 910 910 struct ceph_mds_request *req; 911 911 int err = -EROFS; 912 912 int op; ··· 975 975 req->r_dentry_unless = CEPH_CAP_FILE_EXCL; 976 976 /* release LINK_RDCACHE on source inode (mds will lock it) */ 977 977 req->r_old_inode_drop = CEPH_CAP_LINK_SHARED; 978 978 - if (new_dentry->d_inode) 979 979 - req->r_inode_drop = drop_caps_for_unlink(new_dentry->d_inode); 978 978 + if (d_really_is_positive(new_dentry)) 979 979 + req->r_inode_drop = drop_caps_for_unlink(d_inode(new_dentry)); 980 980 err = ceph_mdsc_do_request(mdsc, old_dir, req); 981 981 if (!err && !req->r_reply_info.head->is_dentry) { 982 982 /* ··· 1042 1042 if (di->lease_renew_after && 1043 1043 time_after(jiffies, di->lease_renew_after)) { 1044 1044 /* we should renew */ 1045 1045 - dir = dentry->d_parent->d_inode; 1045 1045 + dir = d_inode(dentry->d_parent); 1046 1046 session = ceph_get_mds_session(s); 1047 1047 seq = di->lease_seq; 1048 1048 di->lease_renew_after = 0; ··· 1092 1092 return -ECHILD; 1093 1093 1094 1094 dout("d_revalidate %p '%pd' inode %p offset %lld\n", dentry, 1095 1095 - dentry, dentry->d_inode, ceph_dentry(dentry)->offset); 1095 1095 + dentry, d_inode(dentry), ceph_dentry(dentry)->offset); 1096 1096 1097 1097 dir = ceph_get_dentry_parent_inode(dentry); 1098 1098 1099 1099 /* always trust cached snapped dentries, snapdir dentry */ 1100 1100 if (ceph_snap(dir) != CEPH_NOSNAP) { 1101 1101 dout("d_revalidate %p '%pd' inode %p is SNAPPED\n", dentry, 1102 1102 - dentry, dentry->d_inode); 1102 1102 + dentry, d_inode(dentry)); 1103 1103 valid = 1; 1104 1104 - } else if (dentry->d_inode && 1105 1105 - ceph_snap(dentry->d_inode) == CEPH_SNAPDIR) { 1104 1104 + } else if (d_really_is_positive(dentry) && 1105 1105 + ceph_snap(d_inode(dentry)) == CEPH_SNAPDIR) { 1106 1106 valid = 1; 1107 1107 } else if (dentry_lease_is_valid(dentry) || 1108 1108 dir_lease_is_valid(dir, dentry)) { 1109 1109 - if (dentry->d_inode) 1110 1110 - valid = ceph_is_any_caps(dentry->d_inode); 1109 1109 + if (d_really_is_positive(dentry)) 1110 1110 + valid = ceph_is_any_caps(d_inode(dentry)); 1111 1111 else 1112 1112 valid = 1; 1113 1113 } ··· 1169 1169 * we hold d_lock, so d_parent is stable, and d_fsdata is never 1170 1170 * cleared until d_release 1171 1171 */ 1172 1172 - ceph_dir_clear_complete(dentry->d_parent->d_inode); 1172 1172 + ceph_dir_clear_complete(d_inode(dentry->d_parent)); 1173 1173 } 1174 1174 1175 1175 /*

+14 -14

fs/ceph/export.c

reviewed

··· 136 136 return ERR_CAST(req); 137 137 138 138 if (child) { 139 139 - req->r_inode = child->d_inode; 140 140 - ihold(child->d_inode); 139 139 + req->r_inode = d_inode(child); 140 140 + ihold(d_inode(child)); 141 141 } else { 142 142 req->r_ino1 = (struct ceph_vino) { 143 143 .ino = ino, ··· 164 164 return ERR_PTR(err); 165 165 } 166 166 dout("__get_parent ino %llx parent %p ino %llx.%llx\n", 167 167 - child ? ceph_ino(child->d_inode) : ino, 167 167 + child ? ceph_ino(d_inode(child)) : ino, 168 168 dentry, ceph_vinop(inode)); 169 169 return dentry; 170 170 } ··· 172 172 static struct dentry *ceph_get_parent(struct dentry *child) 173 173 { 174 174 /* don't re-export snaps */ 175 175 - if (ceph_snap(child->d_inode) != CEPH_NOSNAP) 175 175 + if (ceph_snap(d_inode(child)) != CEPH_NOSNAP) 176 176 return ERR_PTR(-EINVAL); 177 177 178 178 dout("get_parent %p ino %llx.%llx\n", 179 179 - child, ceph_vinop(child->d_inode)); 179 179 + child, ceph_vinop(d_inode(child))); 180 180 return __get_parent(child->d_sb, child, 0); 181 181 } 182 182 ··· 209 209 struct ceph_mds_request *req; 210 210 int err; 211 211 212 212 - mdsc = ceph_inode_to_client(child->d_inode)->mdsc; 212 212 + mdsc = ceph_inode_to_client(d_inode(child))->mdsc; 213 213 req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_LOOKUPNAME, 214 214 USE_ANY_MDS); 215 215 if (IS_ERR(req)) 216 216 return PTR_ERR(req); 217 217 218 218 - mutex_lock(&parent->d_inode->i_mutex); 218 218 + mutex_lock(&d_inode(parent)->i_mutex); 219 219 220 220 - req->r_inode = child->d_inode; 221 221 - ihold(child->d_inode); 222 222 - req->r_ino2 = ceph_vino(parent->d_inode); 223 223 - req->r_locked_dir = parent->d_inode; 220 220 + req->r_inode = d_inode(child); 221 221 + ihold(d_inode(child)); 222 222 + req->r_ino2 = ceph_vino(d_inode(parent)); 223 223 + req->r_locked_dir = d_inode(parent); 224 224 req->r_num_caps = 2; 225 225 err = ceph_mdsc_do_request(mdsc, NULL, req); 226 226 227 227 - mutex_unlock(&parent->d_inode->i_mutex); 227 227 + mutex_unlock(&d_inode(parent)->i_mutex); 228 228 229 229 if (!err) { 230 230 struct ceph_mds_reply_info_parsed *rinfo = &req->r_reply_info; 231 231 memcpy(name, rinfo->dname, rinfo->dname_len); 232 232 name[rinfo->dname_len] = 0; 233 233 dout("get_name %p ino %llx.%llx name %s\n", 234 234 - child, ceph_vinop(child->d_inode), name); 234 234 + child, ceph_vinop(d_inode(child)), name); 235 235 } else { 236 236 dout("get_name %p ino %llx.%llx err %d\n", 237 237 - child, ceph_vinop(child->d_inode), err); 237 237 + child, ceph_vinop(d_inode(child)), err); 238 238 } 239 239 240 240 ceph_mdsc_put_request(req);

+2 -2

fs/ceph/file.c

reviewed

··· 291 291 } 292 292 if (err) 293 293 goto out_req; 294 294 - if (dn || dentry->d_inode == NULL || d_is_symlink(dentry)) { 294 294 + if (dn || d_really_is_negative(dentry) || d_is_symlink(dentry)) { 295 295 /* make vfs retry on splice, ENOENT, or symlink */ 296 296 dout("atomic_open finish_no_open on dn %p\n", dn); 297 297 err = finish_no_open(file, dn); 298 298 } else { 299 299 dout("atomic_open finish_open on dn %p\n", dn); 300 300 if (req->r_op == CEPH_MDS_OP_CREATE && req->r_reply_info.has_create_ino) { 301 301 - ceph_init_inode_acls(dentry->d_inode, &acls); 301 301 + ceph_init_inode_acls(d_inode(dentry), &acls); 302 302 *opened |= FILE_CREATED; 303 303 } 304 304 err = finish_open(file, dentry, ceph_open, opened);

+26 -26

fs/ceph/inode.c

reviewed

··· 940 940 dentry, duration, ttl); 941 941 942 942 /* make lease_rdcache_gen match directory */ 943 943 - dir = dentry->d_parent->d_inode; 943 943 + dir = d_inode(dentry->d_parent); 944 944 di->lease_shared_gen = ceph_inode(dir)->i_shared_gen; 945 945 946 946 if (duration == 0) ··· 980 980 { 981 981 struct dentry *realdn; 982 982 983 983 - BUG_ON(dn->d_inode); 983 983 + BUG_ON(d_inode(dn)); 984 984 985 985 /* dn must be unhashed */ 986 986 if (!d_unhashed(dn)) ··· 998 998 "inode %p ino %llx.%llx\n", 999 999 dn, d_count(dn), 1000 1000 realdn, d_count(realdn), 1001 1001 - realdn->d_inode, ceph_vinop(realdn->d_inode)); 1001 1001 + d_inode(realdn), ceph_vinop(d_inode(realdn))); 1002 1002 dput(dn); 1003 1003 dn = realdn; 1004 1004 } else { 1005 1005 BUG_ON(!ceph_dentry(dn)); 1006 1006 dout("dn %p attached to %p ino %llx.%llx\n", 1007 1007 - dn, dn->d_inode, ceph_vinop(dn->d_inode)); 1007 1007 + dn, d_inode(dn), ceph_vinop(d_inode(dn))); 1008 1008 } 1009 1009 if ((!prehash || *prehash) && d_unhashed(dn)) 1010 1010 d_rehash(dn); ··· 1125 1125 dput(parent); 1126 1126 goto done; 1127 1127 } 1128 1128 - } else if (dn->d_inode && 1129 1129 - (ceph_ino(dn->d_inode) != vino.ino || 1130 1130 - ceph_snap(dn->d_inode) != vino.snap)) { 1128 1128 + } else if (d_really_is_positive(dn) && 1129 1129 + (ceph_ino(d_inode(dn)) != vino.ino || 1130 1130 + ceph_snap(d_inode(dn)) != vino.snap)) { 1131 1131 dout(" dn %p points to wrong inode %p\n", 1132 1132 - dn, dn->d_inode); 1132 1132 + dn, d_inode(dn)); 1133 1133 d_delete(dn); 1134 1134 dput(dn); 1135 1135 goto retry_lookup; ··· 1183 1183 1184 1184 BUG_ON(!dn); 1185 1185 BUG_ON(!dir); 1186 1186 - BUG_ON(dn->d_parent->d_inode != dir); 1186 1186 + BUG_ON(d_inode(dn->d_parent) != dir); 1187 1187 BUG_ON(ceph_ino(dir) != 1188 1188 le64_to_cpu(rinfo->diri.in->ino)); 1189 1189 BUG_ON(ceph_snap(dir) != ··· 1235 1235 /* null dentry? */ 1236 1236 if (!rinfo->head->is_target) { 1237 1237 dout("fill_trace null dentry\n"); 1238 1238 - if (dn->d_inode) { 1238 1238 + if (d_really_is_positive(dn)) { 1239 1239 ceph_dir_clear_ordered(dir); 1240 1240 dout("d_delete %p\n", dn); 1241 1241 d_delete(dn); ··· 1252 1252 } 1253 1253 1254 1254 /* attach proper inode */ 1255 1255 - if (!dn->d_inode) { 1255 1255 + if (d_really_is_negative(dn)) { 1256 1256 ceph_dir_clear_ordered(dir); 1257 1257 ihold(in); 1258 1258 dn = splice_dentry(dn, in, &have_lease); ··· 1261 1261 goto done; 1262 1262 } 1263 1263 req->r_dentry = dn; /* may have spliced */ 1264 1264 - } else if (dn->d_inode && dn->d_inode != in) { 1264 1264 + } else if (d_really_is_positive(dn) && d_inode(dn) != in) { 1265 1265 dout(" %p links to %p %llx.%llx, not %llx.%llx\n", 1266 1266 - dn, dn->d_inode, ceph_vinop(dn->d_inode), 1266 1266 + dn, d_inode(dn), ceph_vinop(d_inode(dn)), 1267 1267 ceph_vinop(in)); 1268 1268 have_lease = false; 1269 1269 } ··· 1363 1363 return readdir_prepopulate_inodes_only(req, session); 1364 1364 1365 1365 if (le32_to_cpu(rinfo->head->op) == CEPH_MDS_OP_LSSNAP) { 1366 1366 - snapdir = ceph_get_snapdir(parent->d_inode); 1366 1366 + snapdir = ceph_get_snapdir(d_inode(parent)); 1367 1367 parent = d_find_alias(snapdir); 1368 1368 dout("readdir_prepopulate %d items under SNAPDIR dn %p\n", 1369 1369 rinfo->dir_nr, parent); ··· 1371 1371 dout("readdir_prepopulate %d items under dn %p\n", 1372 1372 rinfo->dir_nr, parent); 1373 1373 if (rinfo->dir_dir) 1374 1374 - ceph_fill_dirfrag(parent->d_inode, rinfo->dir_dir); 1374 1374 + ceph_fill_dirfrag(d_inode(parent), rinfo->dir_dir); 1375 1375 } 1376 1376 1377 1377 /* FIXME: release caps/leases if error occurs */ ··· 1405 1405 err = ret; 1406 1406 goto out; 1407 1407 } 1408 1408 - } else if (dn->d_inode && 1409 1409 - (ceph_ino(dn->d_inode) != vino.ino || 1410 1410 - ceph_snap(dn->d_inode) != vino.snap)) { 1408 1408 + } else if (d_really_is_positive(dn) && 1409 1409 + (ceph_ino(d_inode(dn)) != vino.ino || 1410 1410 + ceph_snap(d_inode(dn)) != vino.snap)) { 1411 1411 dout(" dn %p points to wrong inode %p\n", 1412 1412 - dn, dn->d_inode); 1412 1412 + dn, d_inode(dn)); 1413 1413 d_delete(dn); 1414 1414 dput(dn); 1415 1415 goto retry_lookup; ··· 1423 1423 } 1424 1424 1425 1425 /* inode */ 1426 1426 - if (dn->d_inode) { 1427 1427 - in = dn->d_inode; 1426 1426 + if (d_really_is_positive(dn)) { 1427 1427 + in = d_inode(dn); 1428 1428 } else { 1429 1429 in = ceph_get_inode(parent->d_sb, vino); 1430 1430 if (IS_ERR(in)) { ··· 1440 1440 req->r_request_started, -1, 1441 1441 &req->r_caps_reservation) < 0) { 1442 1442 pr_err("fill_inode badness on %p\n", in); 1443 1443 - if (!dn->d_inode) 1443 1443 + if (d_really_is_negative(dn)) 1444 1444 iput(in); 1445 1445 d_drop(dn); 1446 1446 goto next_item; 1447 1447 } 1448 1448 1449 1449 - if (!dn->d_inode) { 1449 1449 + if (d_really_is_negative(dn)) { 1450 1450 struct dentry *realdn = splice_dentry(dn, in, NULL); 1451 1451 if (IS_ERR(realdn)) { 1452 1452 err = PTR_ERR(realdn); ··· 1693 1693 */ 1694 1694 static void *ceph_sym_follow_link(struct dentry *dentry, struct nameidata *nd) 1695 1695 { 1696 1696 - struct ceph_inode_info *ci = ceph_inode(dentry->d_inode); 1696 1696 + struct ceph_inode_info *ci = ceph_inode(d_inode(dentry)); 1697 1697 nd_set_link(nd, ci->i_symlink); 1698 1698 return NULL; 1699 1699 } ··· 1714 1714 */ 1715 1715 int ceph_setattr(struct dentry *dentry, struct iattr *attr) 1716 1716 { 1717 1717 - struct inode *inode = dentry->d_inode; 1717 1717 + struct inode *inode = d_inode(dentry); 1718 1718 struct ceph_inode_info *ci = ceph_inode(inode); 1719 1719 const unsigned int ia_valid = attr->ia_valid; 1720 1720 struct ceph_mds_request *req; ··· 1990 1990 int ceph_getattr(struct vfsmount *mnt, struct dentry *dentry, 1991 1991 struct kstat *stat) 1992 1992 { 1993 1993 - struct inode *inode = dentry->d_inode; 1993 1993 + struct inode *inode = d_inode(dentry); 1994 1994 struct ceph_inode_info *ci = ceph_inode(inode); 1995 1995 int err; 1996 1996

+12 -12

fs/ceph/mds_client.c

reviewed

··· 679 679 * except to resplice to another snapdir, and either the old or new 680 680 * result is a valid result. 681 681 */ 682 682 - while (!IS_ROOT(dentry) && ceph_snap(dentry->d_inode) != CEPH_NOSNAP) 682 682 + while (!IS_ROOT(dentry) && ceph_snap(d_inode(dentry)) != CEPH_NOSNAP) 683 683 dentry = dentry->d_parent; 684 684 return dentry; 685 685 } ··· 716 716 } else if (req->r_dentry) { 717 717 /* ignore race with rename; old or new d_parent is okay */ 718 718 struct dentry *parent = req->r_dentry->d_parent; 719 719 - struct inode *dir = parent->d_inode; 719 719 + struct inode *dir = d_inode(parent); 720 720 721 721 if (dir->i_sb != mdsc->fsc->sb) { 722 722 /* not this fs! */ 723 723 - inode = req->r_dentry->d_inode; 723 723 + inode = d_inode(req->r_dentry); 724 724 } else if (ceph_snap(dir) != CEPH_NOSNAP) { 725 725 /* direct snapped/virtual snapdir requests 726 726 * based on parent dir inode */ 727 727 struct dentry *dn = get_nonsnap_parent(parent); 728 728 - inode = dn->d_inode; 728 728 + inode = d_inode(dn); 729 729 dout("__choose_mds using nonsnap parent %p\n", inode); 730 730 } else { 731 731 /* dentry target */ 732 732 - inode = req->r_dentry->d_inode; 732 732 + inode = d_inode(req->r_dentry); 733 733 if (!inode || mode == USE_AUTH_MDS) { 734 734 /* dir + name */ 735 735 inode = dir; ··· 1732 1732 seq = read_seqbegin(&rename_lock); 1733 1733 rcu_read_lock(); 1734 1734 for (temp = dentry; !IS_ROOT(temp);) { 1735 1735 - struct inode *inode = temp->d_inode; 1735 1735 + struct inode *inode = d_inode(temp); 1736 1736 if (inode && ceph_snap(inode) == CEPH_SNAPDIR) 1737 1737 len++; /* slash only */ 1738 1738 else if (stop_on_nosnap && inode && ··· 1756 1756 struct inode *inode; 1757 1757 1758 1758 spin_lock(&temp->d_lock); 1759 1759 - inode = temp->d_inode; 1759 1759 + inode = d_inode(temp); 1760 1760 if (inode && ceph_snap(inode) == CEPH_SNAPDIR) { 1761 1761 dout("build_path path+%d: %p SNAPDIR\n", 1762 1762 pos, temp); ··· 1790 1790 goto retry; 1791 1791 } 1792 1792 1793 1793 - *base = ceph_ino(temp->d_inode); 1793 1793 + *base = ceph_ino(d_inode(temp)); 1794 1794 *plen = len; 1795 1795 dout("build_path on %p %d built %llx '%.*s'\n", 1796 1796 dentry, d_count(dentry), *base, len, path); ··· 1803 1803 { 1804 1804 char *path; 1805 1805 1806 1806 - if (ceph_snap(dentry->d_parent->d_inode) == CEPH_NOSNAP) { 1807 1807 - *pino = ceph_ino(dentry->d_parent->d_inode); 1806 1806 + if (ceph_snap(d_inode(dentry->d_parent)) == CEPH_NOSNAP) { 1807 1807 + *pino = ceph_ino(d_inode(dentry->d_parent)); 1808 1808 *ppath = dentry->d_name.name; 1809 1809 *ppathlen = dentry->d_name.len; 1810 1810 return 0; ··· 1945 1945 releases = 0; 1946 1946 if (req->r_inode_drop) 1947 1947 releases += ceph_encode_inode_release(&p, 1948 1948 - req->r_inode ? req->r_inode : req->r_dentry->d_inode, 1948 1948 + req->r_inode ? req->r_inode : d_inode(req->r_dentry), 1949 1949 mds, req->r_inode_drop, req->r_inode_unless, 0); 1950 1950 if (req->r_dentry_drop) 1951 1951 releases += ceph_encode_dentry_release(&p, req->r_dentry, ··· 1955 1955 mds, req->r_old_dentry_drop, req->r_old_dentry_unless); 1956 1956 if (req->r_old_inode_drop) 1957 1957 releases += ceph_encode_inode_release(&p, 1958 1958 - req->r_old_dentry->d_inode, 1958 1958 + d_inode(req->r_old_dentry), 1959 1959 mds, req->r_old_inode_drop, req->r_old_inode_unless, 0); 1960 1960 1961 1961 if (drop_cap_releases) {

+2 -2

fs/ceph/super.c

reviewed

··· 44 44 45 45 static int ceph_statfs(struct dentry *dentry, struct kstatfs *buf) 46 46 { 47 47 - struct ceph_fs_client *fsc = ceph_inode_to_client(dentry->d_inode); 47 47 + struct ceph_fs_client *fsc = ceph_inode_to_client(d_inode(dentry)); 48 48 struct ceph_monmap *monmap = fsc->client->monc.monmap; 49 49 struct ceph_statfs st; 50 50 u64 fsid; ··· 972 972 if (IS_ERR(res)) 973 973 goto out_splat; 974 974 dout("root %p inode %p ino %llx.%llx\n", res, 975 975 - res->d_inode, ceph_vinop(res->d_inode)); 975 975 + d_inode(res), ceph_vinop(d_inode(res))); 976 976 return res; 977 977 978 978 out_splat:

+8 -8

fs/ceph/xattr.c

reviewed

··· 776 776 if (!strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN)) 777 777 return generic_getxattr(dentry, name, value, size); 778 778 779 779 - return __ceph_getxattr(dentry->d_inode, name, value, size); 779 779 + return __ceph_getxattr(d_inode(dentry), name, value, size); 780 780 } 781 781 782 782 ssize_t ceph_listxattr(struct dentry *dentry, char *names, size_t size) 783 783 { 784 784 - struct inode *inode = dentry->d_inode; 784 784 + struct inode *inode = d_inode(dentry); 785 785 struct ceph_inode_info *ci = ceph_inode(inode); 786 786 struct ceph_vxattr *vxattrs = ceph_inode_vxattrs(inode); 787 787 u32 vir_namelen = 0; ··· 847 847 const char *value, size_t size, int flags) 848 848 { 849 849 struct ceph_fs_client *fsc = ceph_sb_to_client(dentry->d_sb); 850 850 - struct inode *inode = dentry->d_inode; 850 850 + struct inode *inode = d_inode(dentry); 851 851 struct ceph_inode_info *ci = ceph_inode(inode); 852 852 struct ceph_mds_request *req; 853 853 struct ceph_mds_client *mdsc = fsc->mdsc; ··· 908 908 int __ceph_setxattr(struct dentry *dentry, const char *name, 909 909 const void *value, size_t size, int flags) 910 910 { 911 911 - struct inode *inode = dentry->d_inode; 911 911 + struct inode *inode = d_inode(dentry); 912 912 struct ceph_vxattr *vxattr; 913 913 struct ceph_inode_info *ci = ceph_inode(inode); 914 914 int issued; ··· 1002 1002 int ceph_setxattr(struct dentry *dentry, const char *name, 1003 1003 const void *value, size_t size, int flags) 1004 1004 { 1005 1005 - if (ceph_snap(dentry->d_inode) != CEPH_NOSNAP) 1005 1005 + if (ceph_snap(d_inode(dentry)) != CEPH_NOSNAP) 1006 1006 return -EROFS; 1007 1007 1008 1008 if (!strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN)) ··· 1018 1018 { 1019 1019 struct ceph_fs_client *fsc = ceph_sb_to_client(dentry->d_sb); 1020 1020 struct ceph_mds_client *mdsc = fsc->mdsc; 1021 1021 - struct inode *inode = dentry->d_inode; 1021 1021 + struct inode *inode = d_inode(dentry); 1022 1022 struct ceph_mds_request *req; 1023 1023 int err; 1024 1024 ··· 1041 1041 1042 1042 int __ceph_removexattr(struct dentry *dentry, const char *name) 1043 1043 { 1044 1044 - struct inode *inode = dentry->d_inode; 1044 1044 + struct inode *inode = d_inode(dentry); 1045 1045 struct ceph_vxattr *vxattr; 1046 1046 struct ceph_inode_info *ci = ceph_inode(inode); 1047 1047 int issued; ··· 1107 1107 1108 1108 int ceph_removexattr(struct dentry *dentry, const char *name) 1109 1109 { 1110 1110 - if (ceph_snap(dentry->d_inode) != CEPH_NOSNAP) 1110 1110 + if (ceph_snap(d_inode(dentry)) != CEPH_NOSNAP) 1111 1111 return -EROFS; 1112 1112 1113 1113 if (!strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN))

+1 -1

fs/cifs/cifs_dfs_ref.c

reviewed

··· 301 301 if (full_path == NULL) 302 302 goto cdda_exit; 303 303 304 304 - cifs_sb = CIFS_SB(mntpt->d_inode->i_sb); 304 304 + cifs_sb = CIFS_SB(d_inode(mntpt)->i_sb); 305 305 tlink = cifs_sb_tlink(cifs_sb); 306 306 if (IS_ERR(tlink)) { 307 307 mnt = ERR_CAST(tlink);

+1 -1

fs/cifs/cifsfs.c

reviewed

··· 607 607 p = s = full_path; 608 608 609 609 do { 610 610 - struct inode *dir = dentry->d_inode; 610 610 + struct inode *dir = d_inode(dentry); 611 611 struct dentry *child; 612 612 613 613 if (!dir) {

+2 -2

fs/cifs/cifssmb.c

reviewed

··· 1898 1898 cifs_writev_requeue(struct cifs_writedata *wdata) 1899 1899 { 1900 1900 int i, rc = 0; 1901 1901 - struct inode *inode = wdata->cfile->dentry->d_inode; 1901 1901 + struct inode *inode = d_inode(wdata->cfile->dentry); 1902 1902 struct TCP_Server_Info *server; 1903 1903 unsigned int rest_len; 1904 1904 ··· 1981 1981 { 1982 1982 struct cifs_writedata *wdata = container_of(work, 1983 1983 struct cifs_writedata, work); 1984 1984 - struct inode *inode = wdata->cfile->dentry->d_inode; 1984 1984 + struct inode *inode = d_inode(wdata->cfile->dentry); 1985 1985 int i = 0; 1986 1986 1987 1987 if (wdata->result == 0) {

+4 -4

fs/cifs/dir.c

reviewed

··· 745 745 goto lookup_out; 746 746 } 747 747 748 748 - if (direntry->d_inode != NULL) { 748 748 + if (d_really_is_positive(direntry)) { 749 749 cifs_dbg(FYI, "non-NULL inode in lookup\n"); 750 750 } else { 751 751 cifs_dbg(FYI, "NULL inode in lookup\n"); 752 752 } 753 753 cifs_dbg(FYI, "Full path: %s inode = 0x%p\n", 754 754 - full_path, direntry->d_inode); 754 754 + full_path, d_inode(direntry)); 755 755 756 756 if (pTcon->unix_ext) { 757 757 rc = cifs_get_inode_info_unix(&newInode, full_path, ··· 792 792 if (flags & LOOKUP_RCU) 793 793 return -ECHILD; 794 794 795 795 - if (direntry->d_inode) { 795 795 + if (d_really_is_positive(direntry)) { 796 796 if (cifs_revalidate_dentry(direntry)) 797 797 return 0; 798 798 else { ··· 803 803 * attributes will have been updated by 804 804 * cifs_revalidate_dentry(). 805 805 */ 806 806 - if (IS_AUTOMOUNT(direntry->d_inode) && 806 806 + if (IS_AUTOMOUNT(d_inode(direntry)) && 807 807 !(direntry->d_flags & DCACHE_NEED_AUTOMOUNT)) { 808 808 spin_lock(&direntry->d_lock); 809 809 direntry->d_flags |= DCACHE_NEED_AUTOMOUNT;

+24 -24

fs/cifs/file.c

reviewed

··· 273 273 struct tcon_link *tlink, __u32 oplock) 274 274 { 275 275 struct dentry *dentry = file->f_path.dentry; 276 276 - struct inode *inode = dentry->d_inode; 276 276 + struct inode *inode = d_inode(dentry); 277 277 struct cifsInodeInfo *cinode = CIFS_I(inode); 278 278 struct cifsFileInfo *cfile; 279 279 struct cifs_fid_locks *fdlocks; ··· 357 357 */ 358 358 void cifsFileInfo_put(struct cifsFileInfo *cifs_file) 359 359 { 360 360 - struct inode *inode = cifs_file->dentry->d_inode; 360 360 + struct inode *inode = d_inode(cifs_file->dentry); 361 361 struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink); 362 362 struct TCP_Server_Info *server = tcon->ses->server; 363 363 struct cifsInodeInfo *cifsi = CIFS_I(inode); ··· 386 386 387 387 if (list_empty(&cifsi->openFileList)) { 388 388 cifs_dbg(FYI, "closing last open instance for inode %p\n", 389 389 - cifs_file->dentry->d_inode); 389 389 + d_inode(cifs_file->dentry)); 390 390 /* 391 391 * In strict cache mode we need invalidate mapping on the last 392 392 * close because it may cause a error when we open this file ··· 572 572 cifs_relock_file(struct cifsFileInfo *cfile) 573 573 { 574 574 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb); 575 575 - struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode); 575 575 + struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry)); 576 576 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); 577 577 int rc = 0; 578 578 ··· 620 620 return rc; 621 621 } 622 622 623 623 - inode = cfile->dentry->d_inode; 623 623 + inode = d_inode(cfile->dentry); 624 624 cifs_sb = CIFS_SB(inode->i_sb); 625 625 tcon = tlink_tcon(cfile->tlink); 626 626 server = tcon->ses->server; ··· 874 874 { 875 875 bool rc = false; 876 876 struct cifs_fid_locks *cur; 877 877 - struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode); 877 877 + struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry)); 878 878 879 879 list_for_each_entry(cur, &cinode->llist, llist) { 880 880 rc = cifs_find_fid_lock_conflict(cur, offset, length, type, ··· 899 899 { 900 900 int rc = 0; 901 901 struct cifsLockInfo *conf_lock; 902 902 - struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode); 902 902 + struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry)); 903 903 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server; 904 904 bool exist; 905 905 ··· 927 927 static void 928 928 cifs_lock_add(struct cifsFileInfo *cfile, struct cifsLockInfo *lock) 929 929 { 930 930 - struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode); 930 930 + struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry)); 931 931 down_write(&cinode->lock_sem); 932 932 list_add_tail(&lock->llist, &cfile->llist->locks); 933 933 up_write(&cinode->lock_sem); ··· 944 944 bool wait) 945 945 { 946 946 struct cifsLockInfo *conf_lock; 947 947 - struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode); 947 947 + struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry)); 948 948 bool exist; 949 949 int rc = 0; 950 950 ··· 1125 1125 static int 1126 1126 cifs_push_posix_locks(struct cifsFileInfo *cfile) 1127 1127 { 1128 1128 - struct inode *inode = cfile->dentry->d_inode; 1128 1128 + struct inode *inode = d_inode(cfile->dentry); 1129 1129 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); 1130 1130 struct file_lock *flock; 1131 1131 struct file_lock_context *flctx = inode->i_flctx; ··· 1214 1214 cifs_push_locks(struct cifsFileInfo *cfile) 1215 1215 { 1216 1216 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb); 1217 1217 - struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode); 1217 1217 + struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry)); 1218 1218 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); 1219 1219 int rc = 0; 1220 1220 ··· 1382 1382 unsigned int max_num, num, max_buf; 1383 1383 LOCKING_ANDX_RANGE *buf, *cur; 1384 1384 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); 1385 1385 - struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode); 1385 1385 + struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry)); 1386 1386 struct cifsLockInfo *li, *tmp; 1387 1387 __u64 length = 1 + flock->fl_end - flock->fl_start; 1388 1388 struct list_head tmp_llist; ··· 1488 1488 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data; 1489 1489 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); 1490 1490 struct TCP_Server_Info *server = tcon->ses->server; 1491 1491 - struct inode *inode = cfile->dentry->d_inode; 1491 1491 + struct inode *inode = d_inode(cfile->dentry); 1492 1492 1493 1493 if (posix_lck) { 1494 1494 int posix_lock_type; ··· 1643 1643 struct TCP_Server_Info *server; 1644 1644 unsigned int xid; 1645 1645 struct dentry *dentry = open_file->dentry; 1646 1646 - struct cifsInodeInfo *cifsi = CIFS_I(dentry->d_inode); 1646 1646 + struct cifsInodeInfo *cifsi = CIFS_I(d_inode(dentry)); 1647 1647 struct cifs_io_parms io_parms; 1648 1648 1649 1649 cifs_sb = CIFS_SB(dentry->d_sb); ··· 1676 1676 break; 1677 1677 } 1678 1678 1679 1679 - len = min(server->ops->wp_retry_size(dentry->d_inode), 1679 1679 + len = min(server->ops->wp_retry_size(d_inode(dentry)), 1680 1680 (unsigned int)write_size - total_written); 1681 1681 /* iov[0] is reserved for smb header */ 1682 1682 iov[1].iov_base = (char *)write_data + total_written; ··· 1696 1696 return rc; 1697 1697 } 1698 1698 } else { 1699 1699 - spin_lock(&dentry->d_inode->i_lock); 1699 1699 + spin_lock(&d_inode(dentry)->i_lock); 1700 1700 cifs_update_eof(cifsi, *offset, bytes_written); 1701 1701 - spin_unlock(&dentry->d_inode->i_lock); 1701 1701 + spin_unlock(&d_inode(dentry)->i_lock); 1702 1702 *offset += bytes_written; 1703 1703 } 1704 1704 } ··· 1706 1706 cifs_stats_bytes_written(tcon, total_written); 1707 1707 1708 1708 if (total_written > 0) { 1709 1709 - spin_lock(&dentry->d_inode->i_lock); 1710 1710 - if (*offset > dentry->d_inode->i_size) 1711 1711 - i_size_write(dentry->d_inode, *offset); 1712 1712 - spin_unlock(&dentry->d_inode->i_lock); 1709 1709 + spin_lock(&d_inode(dentry)->i_lock); 1710 1710 + if (*offset > d_inode(dentry)->i_size) 1711 1711 + i_size_write(d_inode(dentry), *offset); 1712 1712 + spin_unlock(&d_inode(dentry)->i_lock); 1713 1713 } 1714 1714 - mark_inode_dirty_sync(dentry->d_inode); 1714 1714 + mark_inode_dirty_sync(d_inode(dentry)); 1715 1715 free_xid(xid); 1716 1716 return total_written; 1717 1717 } ··· 2406 2406 { 2407 2407 struct cifs_writedata *wdata = container_of(work, 2408 2408 struct cifs_writedata, work); 2409 2409 - struct inode *inode = wdata->cfile->dentry->d_inode; 2409 2409 + struct inode *inode = d_inode(wdata->cfile->dentry); 2410 2410 struct cifsInodeInfo *cifsi = CIFS_I(inode); 2411 2411 2412 2412 spin_lock(&inode->i_lock); ··· 3794 3794 { 3795 3795 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo, 3796 3796 oplock_break); 3797 3797 - struct inode *inode = cfile->dentry->d_inode; 3797 3797 + struct inode *inode = d_inode(cfile->dentry); 3798 3798 struct cifsInodeInfo *cinode = CIFS_I(inode); 3799 3799 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); 3800 3800 struct TCP_Server_Info *server = tcon->ses->server;

+16 -16

fs/cifs/inode.c

reviewed

··· 1067 1067 int rc; 1068 1068 struct cifs_fid fid; 1069 1069 struct cifs_open_parms oparms; 1070 1070 - struct inode *inode = dentry->d_inode; 1070 1070 + struct inode *inode = d_inode(dentry); 1071 1071 struct cifsInodeInfo *cifsInode = CIFS_I(inode); 1072 1072 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 1073 1073 struct tcon_link *tlink; ··· 1196 1196 } 1197 1197 1198 1198 /* 1199 1199 - * If dentry->d_inode is null (usually meaning the cached dentry 1199 1199 + * If d_inode(dentry) is null (usually meaning the cached dentry 1200 1200 * is a negative dentry) then we would attempt a standard SMB delete, but 1201 1201 * if that fails we can not attempt the fall back mechanisms on EACCESS 1202 1202 * but will return the EACCESS to the caller. Note that the VFS does not call ··· 1207 1207 int rc = 0; 1208 1208 unsigned int xid; 1209 1209 char *full_path = NULL; 1210 1210 - struct inode *inode = dentry->d_inode; 1210 1210 + struct inode *inode = d_inode(dentry); 1211 1211 struct cifsInodeInfo *cifs_inode; 1212 1212 struct super_block *sb = dir->i_sb; 1213 1213 struct cifs_sb_info *cifs_sb = CIFS_SB(sb); ··· 1551 1551 cifs_put_tlink(tlink); 1552 1552 1553 1553 if (!rc) { 1554 1554 - spin_lock(&direntry->d_inode->i_lock); 1555 1555 - i_size_write(direntry->d_inode, 0); 1556 1556 - clear_nlink(direntry->d_inode); 1557 1557 - spin_unlock(&direntry->d_inode->i_lock); 1554 1554 + spin_lock(&d_inode(direntry)->i_lock); 1555 1555 + i_size_write(d_inode(direntry), 0); 1556 1556 + clear_nlink(d_inode(direntry)); 1557 1557 + spin_unlock(&d_inode(direntry)->i_lock); 1558 1558 } 1559 1559 1560 1560 - cifsInode = CIFS_I(direntry->d_inode); 1560 1560 + cifsInode = CIFS_I(d_inode(direntry)); 1561 1561 /* force revalidate to go get info when needed */ 1562 1562 cifsInode->time = 0; 1563 1563 ··· 1568 1568 */ 1569 1569 cifsInode->time = 0; 1570 1570 1571 1571 - direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime = 1571 1571 + d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime = 1572 1572 current_fs_time(inode->i_sb); 1573 1573 1574 1574 rmdir_exit: ··· 1727 1727 1728 1728 unlink_target: 1729 1729 /* Try unlinking the target dentry if it's not negative */ 1730 1730 - if (target_dentry->d_inode && (rc == -EACCES || rc == -EEXIST)) { 1730 1730 + if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) { 1731 1731 if (d_is_dir(target_dentry)) 1732 1732 tmprc = cifs_rmdir(target_dir, target_dentry); 1733 1733 else ··· 1867 1867 { 1868 1868 unsigned int xid; 1869 1869 int rc = 0; 1870 1870 - struct inode *inode = dentry->d_inode; 1870 1870 + struct inode *inode = d_inode(dentry); 1871 1871 struct super_block *sb = dentry->d_sb; 1872 1872 char *full_path = NULL; 1873 1873 ··· 1919 1919 int cifs_revalidate_dentry(struct dentry *dentry) 1920 1920 { 1921 1921 int rc; 1922 1922 - struct inode *inode = dentry->d_inode; 1922 1922 + struct inode *inode = d_inode(dentry); 1923 1923 1924 1924 rc = cifs_revalidate_dentry_attr(dentry); 1925 1925 if (rc) ··· 1933 1933 { 1934 1934 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb); 1935 1935 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb); 1936 1936 - struct inode *inode = dentry->d_inode; 1936 1936 + struct inode *inode = d_inode(dentry); 1937 1937 int rc; 1938 1938 1939 1939 /* ··· 2110 2110 int rc; 2111 2111 unsigned int xid; 2112 2112 char *full_path = NULL; 2113 2113 - struct inode *inode = direntry->d_inode; 2113 2113 + struct inode *inode = d_inode(direntry); 2114 2114 struct cifsInodeInfo *cifsInode = CIFS_I(inode); 2115 2115 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 2116 2116 struct tcon_link *tlink; ··· 2251 2251 unsigned int xid; 2252 2252 kuid_t uid = INVALID_UID; 2253 2253 kgid_t gid = INVALID_GID; 2254 2254 - struct inode *inode = direntry->d_inode; 2254 2254 + struct inode *inode = d_inode(direntry); 2255 2255 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 2256 2256 struct cifsInodeInfo *cifsInode = CIFS_I(inode); 2257 2257 char *full_path = NULL; ··· 2409 2409 int 2410 2410 cifs_setattr(struct dentry *direntry, struct iattr *attrs) 2411 2411 { 2412 2412 - struct inode *inode = direntry->d_inode; 2412 2412 + struct inode *inode = d_inode(direntry); 2413 2413 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 2414 2414 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb); 2415 2415

+6 -6

fs/cifs/link.c

reviewed

··· 586 586 * if source file is cached (oplocked) revalidate will not go to server 587 587 * until the file is closed or oplock broken so update nlinks locally 588 588 */ 589 589 - if (old_file->d_inode) { 590 590 - cifsInode = CIFS_I(old_file->d_inode); 589 589 + if (d_really_is_positive(old_file)) { 590 590 + cifsInode = CIFS_I(d_inode(old_file)); 591 591 if (rc == 0) { 592 592 - spin_lock(&old_file->d_inode->i_lock); 593 593 - inc_nlink(old_file->d_inode); 594 594 - spin_unlock(&old_file->d_inode->i_lock); 592 592 + spin_lock(&d_inode(old_file)->i_lock); 593 593 + inc_nlink(d_inode(old_file)); 594 594 + spin_unlock(&d_inode(old_file)->i_lock); 595 595 596 596 /* 597 597 * parent dir timestamps will update from srv within a ··· 629 629 void * 630 630 cifs_follow_link(struct dentry *direntry, struct nameidata *nd) 631 631 { 632 632 - struct inode *inode = direntry->d_inode; 632 632 + struct inode *inode = d_inode(direntry); 633 633 int rc = -ENOMEM; 634 634 unsigned int xid; 635 635 char *full_path = NULL;

+1 -1

fs/cifs/misc.c

reviewed

··· 473 473 continue; 474 474 475 475 cifs_dbg(FYI, "file id match, oplock break\n"); 476 476 - pCifsInode = CIFS_I(netfile->dentry->d_inode); 476 476 + pCifsInode = CIFS_I(d_inode(netfile->dentry)); 477 477 478 478 set_bit(CIFS_INODE_PENDING_OPLOCK_BREAK, 479 479 &pCifsInode->flags);

+2 -2

fs/cifs/readdir.c

reviewed

··· 78 78 { 79 79 struct dentry *dentry, *alias; 80 80 struct inode *inode; 81 81 - struct super_block *sb = parent->d_inode->i_sb; 81 81 + struct super_block *sb = d_inode(parent)->i_sb; 82 82 struct cifs_sb_info *cifs_sb = CIFS_SB(sb); 83 83 84 84 cifs_dbg(FYI, "%s: for %s\n", __func__, name->name); ··· 88 88 return; 89 89 90 90 if (dentry) { 91 91 - inode = dentry->d_inode; 91 91 + inode = d_inode(dentry); 92 92 if (inode) { 93 93 /* 94 94 * If we're generating inode numbers, then we don't

+1 -1

fs/cifs/smb1ops.c

reviewed

··· 722 722 static void 723 723 cifs_set_fid(struct cifsFileInfo *cfile, struct cifs_fid *fid, __u32 oplock) 724 724 { 725 725 - struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode); 725 725 + struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry)); 726 726 cfile->fid.netfid = fid->netfid; 727 727 cifs_set_oplock_level(cinode, oplock); 728 728 cinode->can_cache_brlcks = CIFS_CACHE_WRITE(cinode);

+2 -2

fs/cifs/smb2file.c

reviewed

··· 95 95 unsigned int max_num, num = 0, max_buf; 96 96 struct smb2_lock_element *buf, *cur; 97 97 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); 98 98 - struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode); 98 98 + struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry)); 99 99 struct cifsLockInfo *li, *tmp; 100 100 __u64 length = 1 + flock->fl_end - flock->fl_start; 101 101 struct list_head tmp_llist; ··· 231 231 unsigned int xid; 232 232 unsigned int max_num, max_buf; 233 233 struct smb2_lock_element *buf; 234 234 - struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode); 234 234 + struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry)); 235 235 struct cifs_fid_locks *fdlocks; 236 236 237 237 xid = get_xid();

+2 -2

fs/cifs/smb2misc.c

reviewed

··· 453 453 454 454 list_for_each(tmp, &tcon->openFileList) { 455 455 cfile = list_entry(tmp, struct cifsFileInfo, tlist); 456 456 - cinode = CIFS_I(cfile->dentry->d_inode); 456 456 + cinode = CIFS_I(d_inode(cfile->dentry)); 457 457 458 458 if (memcmp(cinode->lease_key, rsp->LeaseKey, 459 459 SMB2_LEASE_KEY_SIZE)) ··· 590 590 continue; 591 591 592 592 cifs_dbg(FYI, "file id match, oplock break\n"); 593 593 - cinode = CIFS_I(cfile->dentry->d_inode); 593 593 + cinode = CIFS_I(d_inode(cfile->dentry)); 594 594 595 595 if (!CIFS_CACHE_WRITE(cinode) && 596 596 rsp->OplockLevel == SMB2_OPLOCK_LEVEL_NONE)

+5 -5

fs/cifs/smb2ops.c

reviewed

··· 524 524 static void 525 525 smb2_set_fid(struct cifsFileInfo *cfile, struct cifs_fid *fid, __u32 oplock) 526 526 { 527 527 - struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode); 527 527 + struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry)); 528 528 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server; 529 529 530 530 cfile->fid.persistent_fid = fid->persistent_fid; ··· 793 793 * If extending file more than one page make sparse. Many Linux fs 794 794 * make files sparse by default when extending via ftruncate 795 795 */ 796 796 - inode = cfile->dentry->d_inode; 796 796 + inode = d_inode(cfile->dentry); 797 797 798 798 if (!set_alloc && (size > inode->i_size + 8192)) { 799 799 __u8 set_sparse = 1; ··· 1032 1032 1033 1033 xid = get_xid(); 1034 1034 1035 1035 - inode = cfile->dentry->d_inode; 1035 1035 + inode = d_inode(cfile->dentry); 1036 1036 cifsi = CIFS_I(inode); 1037 1037 1038 1038 /* if file not oplocked can't be sure whether asking to extend size */ ··· 1083 1083 1084 1084 xid = get_xid(); 1085 1085 1086 1086 - inode = cfile->dentry->d_inode; 1086 1086 + inode = d_inode(cfile->dentry); 1087 1087 cifsi = CIFS_I(inode); 1088 1088 1089 1089 /* Need to make file sparse, if not already, before freeing range. */ ··· 1115 1115 1116 1116 xid = get_xid(); 1117 1117 1118 1118 - inode = cfile->dentry->d_inode; 1118 1118 + inode = d_inode(cfile->dentry); 1119 1119 cifsi = CIFS_I(inode); 1120 1120 1121 1121 /* if file not oplocked can't be sure whether asking to extend size */

+11 -11

fs/cifs/xattr.c

reviewed

··· 50 50 51 51 if (direntry == NULL) 52 52 return -EIO; 53 53 - if (direntry->d_inode == NULL) 53 53 + if (d_really_is_negative(direntry)) 54 54 return -EIO; 55 55 - sb = direntry->d_inode->i_sb; 55 55 + sb = d_inode(direntry)->i_sb; 56 56 if (sb == NULL) 57 57 return -EIO; 58 58 ··· 111 111 112 112 if (direntry == NULL) 113 113 return -EIO; 114 114 - if (direntry->d_inode == NULL) 114 114 + if (d_really_is_negative(direntry)) 115 115 return -EIO; 116 116 - sb = direntry->d_inode->i_sb; 116 116 + sb = d_inode(direntry)->i_sb; 117 117 if (sb == NULL) 118 118 return -EIO; 119 119 ··· 177 177 memcpy(pacl, ea_value, value_size); 178 178 if (pTcon->ses->server->ops->set_acl) 179 179 rc = pTcon->ses->server->ops->set_acl(pacl, 180 180 - value_size, direntry->d_inode, 180 180 + value_size, d_inode(direntry), 181 181 full_path, CIFS_ACL_DACL); 182 182 else 183 183 rc = -EOPNOTSUPP; 184 184 if (rc == 0) /* force revalidate of the inode */ 185 185 - CIFS_I(direntry->d_inode)->time = 0; 185 185 + CIFS_I(d_inode(direntry))->time = 0; 186 186 kfree(pacl); 187 187 } 188 188 #else ··· 246 246 247 247 if (direntry == NULL) 248 248 return -EIO; 249 249 - if (direntry->d_inode == NULL) 249 249 + if (d_really_is_negative(direntry)) 250 250 return -EIO; 251 251 - sb = direntry->d_inode->i_sb; 251 251 + sb = d_inode(direntry)->i_sb; 252 252 if (sb == NULL) 253 253 return -EIO; 254 254 ··· 324 324 goto get_ea_exit; /* rc already EOPNOTSUPP */ 325 325 326 326 pacl = pTcon->ses->server->ops->get_acl(cifs_sb, 327 327 - direntry->d_inode, full_path, &acllen); 327 327 + d_inode(direntry), full_path, &acllen); 328 328 if (IS_ERR(pacl)) { 329 329 rc = PTR_ERR(pacl); 330 330 cifs_dbg(VFS, "%s: error %zd getting sec desc\n", ··· 382 382 383 383 if (direntry == NULL) 384 384 return -EIO; 385 385 - if (direntry->d_inode == NULL) 385 385 + if (d_really_is_negative(direntry)) 386 386 return -EIO; 387 387 - sb = direntry->d_inode->i_sb; 387 387 + sb = d_inode(direntry)->i_sb; 388 388 if (sb == NULL) 389 389 return -EIO; 390 390

+2 -2

fs/coda/cache.c

reviewed

··· 94 94 spin_lock(&parent->d_lock); 95 95 list_for_each_entry(de, &parent->d_subdirs, d_child) { 96 96 /* don't know what to do with negative dentries */ 97 97 - if (de->d_inode ) 98 98 - coda_flag_inode(de->d_inode, flag); 97 97 + if (d_inode(de) ) 98 98 + coda_flag_inode(d_inode(de), flag); 99 99 } 100 100 spin_unlock(&parent->d_lock); 101 101 return;

+11 -11

fs/coda/dir.c

reviewed

··· 201 201 static int coda_link(struct dentry *source_de, struct inode *dir_inode, 202 202 struct dentry *de) 203 203 { 204 204 - struct inode *inode = source_de->d_inode; 204 204 + struct inode *inode = d_inode(source_de); 205 205 const char * name = de->d_name.name; 206 206 int len = de->d_name.len; 207 207 int error; ··· 266 266 return error; 267 267 268 268 coda_dir_update_mtime(dir); 269 269 - drop_nlink(de->d_inode); 269 269 + drop_nlink(d_inode(de)); 270 270 return 0; 271 271 } 272 272 ··· 279 279 error = venus_rmdir(dir->i_sb, coda_i2f(dir), name, len); 280 280 if (!error) { 281 281 /* VFS may delete the child */ 282 282 - if (de->d_inode) 283 283 - clear_nlink(de->d_inode); 282 282 + if (d_really_is_positive(de)) 283 283 + clear_nlink(d_inode(de)); 284 284 285 285 /* fix the link count of the parent */ 286 286 coda_dir_drop_nlink(dir); ··· 303 303 coda_i2f(new_dir), old_length, new_length, 304 304 (const char *) old_name, (const char *)new_name); 305 305 if (!error) { 306 306 - if (new_dentry->d_inode) { 306 306 + if (d_really_is_positive(new_dentry)) { 307 307 if (d_is_dir(new_dentry)) { 308 308 coda_dir_drop_nlink(old_dir); 309 309 coda_dir_inc_nlink(new_dir); 310 310 } 311 311 coda_dir_update_mtime(old_dir); 312 312 coda_dir_update_mtime(new_dir); 313 313 - coda_flag_inode(new_dentry->d_inode, C_VATTR); 313 313 + coda_flag_inode(d_inode(new_dentry), C_VATTR); 314 314 } else { 315 315 coda_flag_inode(old_dir, C_VATTR); 316 316 coda_flag_inode(new_dir, C_VATTR); ··· 449 449 if (flags & LOOKUP_RCU) 450 450 return -ECHILD; 451 451 452 452 - inode = de->d_inode; 452 452 + inode = d_inode(de); 453 453 if (!inode || is_root_inode(inode)) 454 454 goto out; 455 455 if (is_bad_inode(inode)) 456 456 goto bad; 457 457 458 458 - cii = ITOC(de->d_inode); 458 458 + cii = ITOC(d_inode(de)); 459 459 if (!(cii->c_flags & (C_PURGE | C_FLUSH))) 460 460 goto out; 461 461 ··· 487 487 { 488 488 int flags; 489 489 490 490 - if (!dentry->d_inode) 490 490 + if (d_really_is_negative(dentry)) 491 491 return 0; 492 492 493 493 - flags = (ITOC(dentry->d_inode)->c_flags) & C_PURGE; 494 494 - if (is_bad_inode(dentry->d_inode) || flags) { 493 493 + flags = (ITOC(d_inode(dentry))->c_flags) & C_PURGE; 494 494 + if (is_bad_inode(d_inode(dentry)) || flags) { 495 495 return 1; 496 496 } 497 497 return 0;

+3 -3

fs/coda/inode.c

reviewed

··· 257 257 258 258 int coda_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) 259 259 { 260 260 - int err = coda_revalidate_inode(dentry->d_inode); 260 260 + int err = coda_revalidate_inode(d_inode(dentry)); 261 261 if (!err) 262 262 - generic_fillattr(dentry->d_inode, stat); 262 262 + generic_fillattr(d_inode(dentry), stat); 263 263 return err; 264 264 } 265 265 266 266 int coda_setattr(struct dentry *de, struct iattr *iattr) 267 267 { 268 268 - struct inode *inode = de->d_inode; 268 268 + struct inode *inode = d_inode(de); 269 269 struct coda_vattr vattr; 270 270 int error; 271 271

+1 -1

fs/coda/pioctl.c

reviewed

··· 72 72 if (error) 73 73 return error; 74 74 75 75 - target_inode = path.dentry->d_inode; 75 75 + target_inode = d_inode(path.dentry); 76 76 77 77 /* return if it is not a Coda inode */ 78 78 if (target_inode->i_sb != inode->i_sb) {

+2 -2

fs/coda/upcall.c

reviewed

··· 820 820 case CODA_FLUSH: 821 821 coda_cache_clear_all(sb); 822 822 shrink_dcache_sb(sb); 823 823 - if (sb->s_root->d_inode) 824 824 - coda_flag_inode(sb->s_root->d_inode, C_FLUSH); 823 823 + if (d_really_is_positive(sb->s_root)) 824 824 + coda_flag_inode(d_inode(sb->s_root), C_FLUSH); 825 825 break; 826 826 827 827 case CODA_PURGEUSER:

+35 -35

fs/configfs/dir.c

reviewed

··· 289 289 configfs_set_dir_dirent_depth(p->d_fsdata, dentry->d_fsdata); 290 290 error = configfs_create(dentry, mode, init_dir); 291 291 if (!error) { 292 292 - inc_nlink(p->d_inode); 292 292 + inc_nlink(d_inode(p)); 293 293 item->ci_dentry = dentry; 294 294 } else { 295 295 struct configfs_dirent *sd = dentry->d_fsdata; ··· 375 375 list_del_init(&sd->s_sibling); 376 376 spin_unlock(&configfs_dirent_lock); 377 377 configfs_put(sd); 378 378 - if (d->d_inode) 379 379 - simple_rmdir(parent->d_inode,d); 378 378 + if (d_really_is_positive(d)) 379 379 + simple_rmdir(d_inode(parent),d); 380 380 381 381 pr_debug(" o %pd removing done (%d)\n", d, d_count(d)); 382 382 ··· 513 513 /* Abort if racing with mkdir() */ 514 514 if (sd->s_type & CONFIGFS_USET_IN_MKDIR) { 515 515 if (wait_mutex) 516 516 - *wait_mutex = &sd->s_dentry->d_inode->i_mutex; 516 516 + *wait_mutex = &d_inode(sd->s_dentry)->i_mutex; 517 517 return -EAGAIN; 518 518 } 519 519 ··· 624 624 625 625 child = sd->s_dentry; 626 626 627 627 - mutex_lock(&child->d_inode->i_mutex); 627 627 + mutex_lock(&d_inode(child)->i_mutex); 628 628 629 629 configfs_detach_group(sd->s_element); 630 630 - child->d_inode->i_flags |= S_DEAD; 630 630 + d_inode(child)->i_flags |= S_DEAD; 631 631 dont_mount(child); 632 632 633 633 - mutex_unlock(&child->d_inode->i_mutex); 633 633 + mutex_unlock(&d_inode(child)->i_mutex); 634 634 635 635 d_delete(child); 636 636 dput(child); ··· 672 672 sd = child->d_fsdata; 673 673 sd->s_type |= CONFIGFS_USET_DEFAULT; 674 674 } else { 675 675 - BUG_ON(child->d_inode); 675 675 + BUG_ON(d_inode(child)); 676 676 d_drop(child); 677 677 dput(child); 678 678 } ··· 818 818 * the VFS may already have hit and used them. Thus, 819 819 * we must lock them as rmdir() would. 820 820 */ 821 821 - mutex_lock(&dentry->d_inode->i_mutex); 821 821 + mutex_lock(&d_inode(dentry)->i_mutex); 822 822 configfs_remove_dir(item); 823 823 - dentry->d_inode->i_flags |= S_DEAD; 823 823 + d_inode(dentry)->i_flags |= S_DEAD; 824 824 dont_mount(dentry); 825 825 - mutex_unlock(&dentry->d_inode->i_mutex); 825 825 + mutex_unlock(&d_inode(dentry)->i_mutex); 826 826 d_delete(dentry); 827 827 } 828 828 } ··· 858 858 * We must also lock the inode to remove it safely in case of 859 859 * error, as rmdir() would. 860 860 */ 861 861 - mutex_lock_nested(&dentry->d_inode->i_mutex, I_MUTEX_CHILD); 861 861 + mutex_lock_nested(&d_inode(dentry)->i_mutex, I_MUTEX_CHILD); 862 862 configfs_adjust_dir_dirent_depth_before_populate(sd); 863 863 ret = populate_groups(to_config_group(item)); 864 864 if (ret) { 865 865 configfs_detach_item(item); 866 866 - dentry->d_inode->i_flags |= S_DEAD; 866 866 + d_inode(dentry)->i_flags |= S_DEAD; 867 867 dont_mount(dentry); 868 868 } 869 869 configfs_adjust_dir_dirent_depth_after_populate(sd); 870 870 - mutex_unlock(&dentry->d_inode->i_mutex); 870 870 + mutex_unlock(&d_inode(dentry)->i_mutex); 871 871 if (ret) 872 872 d_delete(dentry); 873 873 } ··· 1075 1075 * subsystem is really registered, and so we need to lock out 1076 1076 * configfs_[un]register_subsystem(). 1077 1077 */ 1078 1078 - mutex_lock(&root->d_inode->i_mutex); 1078 1078 + mutex_lock(&d_inode(root)->i_mutex); 1079 1079 1080 1080 root_sd = root->d_fsdata; 1081 1081 ··· 1111 1111 out_unlock_dirent_lock: 1112 1112 spin_unlock(&configfs_dirent_lock); 1113 1113 out_unlock_fs: 1114 1114 - mutex_unlock(&root->d_inode->i_mutex); 1114 1114 + mutex_unlock(&d_inode(root)->i_mutex); 1115 1115 1116 1116 /* 1117 1117 * If we succeeded, the fs is pinned via other methods. If not, ··· 1453 1453 down_write(&configfs_rename_sem); 1454 1454 parent = item->parent->dentry; 1455 1455 1456 1456 - mutex_lock(&parent->d_inode->i_mutex); 1456 1456 + mutex_lock(&d_inode(parent)->i_mutex); 1457 1457 1458 1458 new_dentry = lookup_one_len(new_name, parent, strlen(new_name)); 1459 1459 if (!IS_ERR(new_dentry)) { 1460 1460 - if (!new_dentry->d_inode) { 1460 1460 + if (d_really_is_negative(new_dentry)) { 1461 1461 error = config_item_set_name(item, "%s", new_name); 1462 1462 if (!error) { 1463 1463 d_add(new_dentry, NULL); ··· 1469 1469 error = -EEXIST; 1470 1470 dput(new_dentry); 1471 1471 } 1472 1472 - mutex_unlock(&parent->d_inode->i_mutex); 1472 1472 + mutex_unlock(&d_inode(parent)->i_mutex); 1473 1473 up_write(&configfs_rename_sem); 1474 1474 1475 1475 return error; ··· 1482 1482 struct configfs_dirent * parent_sd = dentry->d_fsdata; 1483 1483 int err; 1484 1484 1485 1485 - mutex_lock(&dentry->d_inode->i_mutex); 1485 1485 + mutex_lock(&d_inode(dentry)->i_mutex); 1486 1486 /* 1487 1487 * Fake invisibility if dir belongs to a group/default groups hierarchy 1488 1488 * being attached ··· 1495 1495 else 1496 1496 err = 0; 1497 1497 } 1498 1498 - mutex_unlock(&dentry->d_inode->i_mutex); 1498 1498 + mutex_unlock(&d_inode(dentry)->i_mutex); 1499 1499 1500 1500 return err; 1501 1501 } ··· 1505 1505 struct dentry * dentry = file->f_path.dentry; 1506 1506 struct configfs_dirent * cursor = file->private_data; 1507 1507 1508 1508 - mutex_lock(&dentry->d_inode->i_mutex); 1508 1508 + mutex_lock(&d_inode(dentry)->i_mutex); 1509 1509 spin_lock(&configfs_dirent_lock); 1510 1510 list_del_init(&cursor->s_sibling); 1511 1511 spin_unlock(&configfs_dirent_lock); 1512 1512 - mutex_unlock(&dentry->d_inode->i_mutex); 1512 1512 + mutex_unlock(&d_inode(dentry)->i_mutex); 1513 1513 1514 1514 release_configfs_dirent(cursor); 1515 1515 ··· 1567 1567 spin_lock(&configfs_dirent_lock); 1568 1568 dentry = next->s_dentry; 1569 1569 if (dentry) 1570 1570 - inode = dentry->d_inode; 1570 1570 + inode = d_inode(dentry); 1571 1571 if (inode) 1572 1572 ino = inode->i_ino; 1573 1573 spin_unlock(&configfs_dirent_lock); ··· 1590 1590 { 1591 1591 struct dentry * dentry = file->f_path.dentry; 1592 1592 1593 1593 - mutex_lock(&dentry->d_inode->i_mutex); 1593 1593 + mutex_lock(&d_inode(dentry)->i_mutex); 1594 1594 switch (whence) { 1595 1595 case 1: 1596 1596 offset += file->f_pos; ··· 1598 1598 if (offset >= 0) 1599 1599 break; 1600 1600 default: 1601 1601 - mutex_unlock(&dentry->d_inode->i_mutex); 1601 1601 + mutex_unlock(&d_inode(dentry)->i_mutex); 1602 1602 return -EINVAL; 1603 1603 } 1604 1604 if (offset != file->f_pos) { ··· 1624 1624 spin_unlock(&configfs_dirent_lock); 1625 1625 } 1626 1626 } 1627 1627 - mutex_unlock(&dentry->d_inode->i_mutex); 1627 1627 + mutex_unlock(&d_inode(dentry)->i_mutex); 1628 1628 return offset; 1629 1629 } 1630 1630 ··· 1654 1654 sd = root->d_fsdata; 1655 1655 link_group(to_config_group(sd->s_element), group); 1656 1656 1657 1657 - mutex_lock_nested(&root->d_inode->i_mutex, I_MUTEX_PARENT); 1657 1657 + mutex_lock_nested(&d_inode(root)->i_mutex, I_MUTEX_PARENT); 1658 1658 1659 1659 err = -ENOMEM; 1660 1660 dentry = d_alloc_name(root, group->cg_item.ci_name); ··· 1664 1664 err = configfs_attach_group(sd->s_element, &group->cg_item, 1665 1665 dentry); 1666 1666 if (err) { 1667 1667 - BUG_ON(dentry->d_inode); 1667 1667 + BUG_ON(d_inode(dentry)); 1668 1668 d_drop(dentry); 1669 1669 dput(dentry); 1670 1670 } else { ··· 1674 1674 } 1675 1675 } 1676 1676 1677 1677 - mutex_unlock(&root->d_inode->i_mutex); 1677 1677 + mutex_unlock(&d_inode(root)->i_mutex); 1678 1678 1679 1679 if (err) { 1680 1680 unlink_group(group); ··· 1695 1695 return; 1696 1696 } 1697 1697 1698 1698 - mutex_lock_nested(&root->d_inode->i_mutex, 1698 1698 + mutex_lock_nested(&d_inode(root)->i_mutex, 1699 1699 I_MUTEX_PARENT); 1700 1700 - mutex_lock_nested(&dentry->d_inode->i_mutex, I_MUTEX_CHILD); 1700 1700 + mutex_lock_nested(&d_inode(dentry)->i_mutex, I_MUTEX_CHILD); 1701 1701 mutex_lock(&configfs_symlink_mutex); 1702 1702 spin_lock(&configfs_dirent_lock); 1703 1703 if (configfs_detach_prep(dentry, NULL)) { ··· 1706 1706 spin_unlock(&configfs_dirent_lock); 1707 1707 mutex_unlock(&configfs_symlink_mutex); 1708 1708 configfs_detach_group(&group->cg_item); 1709 1709 - dentry->d_inode->i_flags |= S_DEAD; 1709 1709 + d_inode(dentry)->i_flags |= S_DEAD; 1710 1710 dont_mount(dentry); 1711 1711 - mutex_unlock(&dentry->d_inode->i_mutex); 1711 1711 + mutex_unlock(&d_inode(dentry)->i_mutex); 1712 1712 1713 1713 d_delete(dentry); 1714 1714 1715 1715 - mutex_unlock(&root->d_inode->i_mutex); 1715 1715 + mutex_unlock(&d_inode(root)->i_mutex); 1716 1716 1717 1717 dput(dentry); 1718 1718

+2 -2

fs/configfs/file.c

reviewed

··· 326 326 umode_t mode = (attr->ca_mode & S_IALLUGO) | S_IFREG; 327 327 int error = 0; 328 328 329 329 - mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_NORMAL); 329 329 + mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_NORMAL); 330 330 error = configfs_make_dirent(parent_sd, NULL, (void *) attr, mode, 331 331 CONFIGFS_ITEM_ATTR); 332 332 - mutex_unlock(&dir->d_inode->i_mutex); 332 332 + mutex_unlock(&d_inode(dir)->i_mutex); 333 333 334 334 return error; 335 335 }

+8 -8

fs/configfs/inode.c

reviewed

··· 56 56 57 57 int configfs_setattr(struct dentry * dentry, struct iattr * iattr) 58 58 { 59 59 - struct inode * inode = dentry->d_inode; 59 59 + struct inode * inode = d_inode(dentry); 60 60 struct configfs_dirent * sd = dentry->d_fsdata; 61 61 struct iattr * sd_iattr; 62 62 unsigned int ia_valid = iattr->ia_valid; ··· 186 186 if (!dentry) 187 187 return -ENOENT; 188 188 189 189 - if (dentry->d_inode) 189 189 + if (d_really_is_positive(dentry)) 190 190 return -EEXIST; 191 191 192 192 sd = dentry->d_fsdata; ··· 194 194 if (!inode) 195 195 return -ENOMEM; 196 196 197 197 - p_inode = dentry->d_parent->d_inode; 197 197 + p_inode = d_inode(dentry->d_parent); 198 198 p_inode->i_mtime = p_inode->i_ctime = CURRENT_TIME; 199 199 configfs_set_inode_lock_class(sd, inode); 200 200 ··· 236 236 237 237 if (dentry) { 238 238 spin_lock(&dentry->d_lock); 239 239 - if (!d_unhashed(dentry) && dentry->d_inode) { 239 239 + if (!d_unhashed(dentry) && d_really_is_positive(dentry)) { 240 240 dget_dlock(dentry); 241 241 __d_drop(dentry); 242 242 spin_unlock(&dentry->d_lock); 243 243 - simple_unlink(parent->d_inode, dentry); 243 243 + simple_unlink(d_inode(parent), dentry); 244 244 } else 245 245 spin_unlock(&dentry->d_lock); 246 246 } ··· 251 251 struct configfs_dirent * sd; 252 252 struct configfs_dirent * parent_sd = dir->d_fsdata; 253 253 254 254 - if (dir->d_inode == NULL) 254 254 + if (d_really_is_negative(dir)) 255 255 /* no inode means this hasn't been made visible yet */ 256 256 return; 257 257 258 258 - mutex_lock(&dir->d_inode->i_mutex); 258 258 + mutex_lock(&d_inode(dir)->i_mutex); 259 259 list_for_each_entry(sd, &parent_sd->s_children, s_sibling) { 260 260 if (!sd->s_element) 261 261 continue; ··· 268 268 break; 269 269 } 270 270 } 271 271 - mutex_unlock(&dir->d_inode->i_mutex); 271 271 + mutex_unlock(&d_inode(dir)->i_mutex); 272 272 }

+2 -2

fs/dax.c

reviewed

··· 209 209 } 210 210 211 211 /* Protects against truncate */ 212 212 - atomic_inc(&inode->i_dio_count); 212 212 + inode_dio_begin(inode); 213 213 214 214 retval = dax_io(inode, iter, pos, end, get_block, &bh); 215 215 ··· 219 219 if ((retval > 0) && end_io) 220 220 end_io(iocb, pos, retval, bh.b_private); 221 221 222 222 - inode_dio_done(inode); 222 222 + inode_dio_end(inode); 223 223 out: 224 224 return retval; 225 225 }

+1 -1

fs/debugfs/file.c

reviewed

··· 45 45 46 46 static void *debugfs_follow_link(struct dentry *dentry, struct nameidata *nd) 47 47 { 48 48 - nd_set_link(nd, dentry->d_inode->i_private); 48 48 + nd_set_link(nd, d_inode(dentry)->i_private); 49 49 return NULL; 50 50 } 51 51

+28 -28

fs/debugfs/inode.c

reviewed

··· 46 46 47 47 static inline int debugfs_positive(struct dentry *dentry) 48 48 { 49 49 - return dentry->d_inode && !d_unhashed(dentry); 49 49 + return d_really_is_positive(dentry) && !d_unhashed(dentry); 50 50 } 51 51 52 52 struct debugfs_mount_opts { ··· 124 124 static int debugfs_apply_options(struct super_block *sb) 125 125 { 126 126 struct debugfs_fs_info *fsi = sb->s_fs_info; 127 127 - struct inode *inode = sb->s_root->d_inode; 127 127 + struct inode *inode = d_inode(sb->s_root); 128 128 struct debugfs_mount_opts *opts = &fsi->mount_opts; 129 129 130 130 inode->i_mode &= ~S_IALLUGO; ··· 188 188 { 189 189 struct vfsmount *(*f)(void *); 190 190 f = (struct vfsmount *(*)(void *))path->dentry->d_fsdata; 191 191 - return f(path->dentry->d_inode->i_private); 191 191 + return f(d_inode(path->dentry)->i_private); 192 192 } 193 193 194 194 static const struct dentry_operations debugfs_dops = { ··· 270 270 if (!parent) 271 271 parent = debugfs_mount->mnt_root; 272 272 273 273 - mutex_lock(&parent->d_inode->i_mutex); 273 273 + mutex_lock(&d_inode(parent)->i_mutex); 274 274 dentry = lookup_one_len(name, parent, strlen(name)); 275 275 - if (!IS_ERR(dentry) && dentry->d_inode) { 275 275 + if (!IS_ERR(dentry) && d_really_is_positive(dentry)) { 276 276 dput(dentry); 277 277 dentry = ERR_PTR(-EEXIST); 278 278 } 279 279 if (IS_ERR(dentry)) 280 280 - mutex_unlock(&parent->d_inode->i_mutex); 280 280 + mutex_unlock(&d_inode(parent)->i_mutex); 281 281 return dentry; 282 282 } 283 283 284 284 static struct dentry *failed_creating(struct dentry *dentry) 285 285 { 286 286 - mutex_unlock(&dentry->d_parent->d_inode->i_mutex); 286 286 + mutex_unlock(&d_inode(dentry->d_parent)->i_mutex); 287 287 dput(dentry); 288 288 simple_release_fs(&debugfs_mount, &debugfs_mount_count); 289 289 return NULL; ··· 291 291 292 292 static struct dentry *end_creating(struct dentry *dentry) 293 293 { 294 294 - mutex_unlock(&dentry->d_parent->d_inode->i_mutex); 294 294 + mutex_unlock(&d_inode(dentry->d_parent)->i_mutex); 295 295 return dentry; 296 296 } 297 297 ··· 344 344 inode->i_fop = fops ? fops : &debugfs_file_operations; 345 345 inode->i_private = data; 346 346 d_instantiate(dentry, inode); 347 347 - fsnotify_create(dentry->d_parent->d_inode, dentry); 347 347 + fsnotify_create(d_inode(dentry->d_parent), dentry); 348 348 return end_creating(dentry); 349 349 } 350 350 EXPORT_SYMBOL_GPL(debugfs_create_file); ··· 384 384 struct dentry *de = debugfs_create_file(name, mode, parent, data, fops); 385 385 386 386 if (de) 387 387 - de->d_inode->i_size = file_size; 387 387 + d_inode(de)->i_size = file_size; 388 388 return de; 389 389 } 390 390 EXPORT_SYMBOL_GPL(debugfs_create_file_size); ··· 426 426 /* directory inodes start off with i_nlink == 2 (for "." entry) */ 427 427 inc_nlink(inode); 428 428 d_instantiate(dentry, inode); 429 429 - inc_nlink(dentry->d_parent->d_inode); 430 430 - fsnotify_mkdir(dentry->d_parent->d_inode, dentry); 429 429 + inc_nlink(d_inode(dentry->d_parent)); 430 430 + fsnotify_mkdir(d_inode(dentry->d_parent), dentry); 431 431 return end_creating(dentry); 432 432 } 433 433 EXPORT_SYMBOL_GPL(debugfs_create_dir); ··· 525 525 if (debugfs_positive(dentry)) { 526 526 dget(dentry); 527 527 if (d_is_dir(dentry)) 528 528 - ret = simple_rmdir(parent->d_inode, dentry); 528 528 + ret = simple_rmdir(d_inode(parent), dentry); 529 529 else 530 530 - simple_unlink(parent->d_inode, dentry); 530 530 + simple_unlink(d_inode(parent), dentry); 531 531 if (!ret) 532 532 d_delete(dentry); 533 533 dput(dentry); ··· 557 557 return; 558 558 559 559 parent = dentry->d_parent; 560 560 - if (!parent || !parent->d_inode) 560 560 + if (!parent || d_really_is_negative(parent)) 561 561 return; 562 562 563 563 - mutex_lock(&parent->d_inode->i_mutex); 563 563 + mutex_lock(&d_inode(parent)->i_mutex); 564 564 ret = __debugfs_remove(dentry, parent); 565 565 - mutex_unlock(&parent->d_inode->i_mutex); 565 565 + mutex_unlock(&d_inode(parent)->i_mutex); 566 566 if (!ret) 567 567 simple_release_fs(&debugfs_mount, &debugfs_mount_count); 568 568 } ··· 588 588 return; 589 589 590 590 parent = dentry->d_parent; 591 591 - if (!parent || !parent->d_inode) 591 591 + if (!parent || d_really_is_negative(parent)) 592 592 return; 593 593 594 594 parent = dentry; 595 595 down: 596 596 - mutex_lock(&parent->d_inode->i_mutex); 596 596 + mutex_lock(&d_inode(parent)->i_mutex); 597 597 loop: 598 598 /* 599 599 * The parent->d_subdirs is protected by the d_lock. Outside that ··· 608 608 /* perhaps simple_empty(child) makes more sense */ 609 609 if (!list_empty(&child->d_subdirs)) { 610 610 spin_unlock(&parent->d_lock); 611 611 - mutex_unlock(&parent->d_inode->i_mutex); 611 611 + mutex_unlock(&d_inode(parent)->i_mutex); 612 612 parent = child; 613 613 goto down; 614 614 } ··· 629 629 } 630 630 spin_unlock(&parent->d_lock); 631 631 632 632 - mutex_unlock(&parent->d_inode->i_mutex); 632 632 + mutex_unlock(&d_inode(parent)->i_mutex); 633 633 child = parent; 634 634 parent = parent->d_parent; 635 635 - mutex_lock(&parent->d_inode->i_mutex); 635 635 + mutex_lock(&d_inode(parent)->i_mutex); 636 636 637 637 if (child != dentry) 638 638 /* go up */ ··· 640 640 641 641 if (!__debugfs_remove(child, parent)) 642 642 simple_release_fs(&debugfs_mount, &debugfs_mount_count); 643 643 - mutex_unlock(&parent->d_inode->i_mutex); 643 643 + mutex_unlock(&d_inode(parent)->i_mutex); 644 644 } 645 645 EXPORT_SYMBOL_GPL(debugfs_remove_recursive); 646 646 ··· 672 672 673 673 trap = lock_rename(new_dir, old_dir); 674 674 /* Source or destination directories don't exist? */ 675 675 - if (!old_dir->d_inode || !new_dir->d_inode) 675 675 + if (d_really_is_negative(old_dir) || d_really_is_negative(new_dir)) 676 676 goto exit; 677 677 /* Source does not exist, cyclic rename, or mountpoint? */ 678 678 - if (!old_dentry->d_inode || old_dentry == trap || 678 678 + if (d_really_is_negative(old_dentry) || old_dentry == trap || 679 679 d_mountpoint(old_dentry)) 680 680 goto exit; 681 681 dentry = lookup_one_len(new_name, new_dir, strlen(new_name)); 682 682 /* Lookup failed, cyclic rename or target exists? */ 683 683 - if (IS_ERR(dentry) || dentry == trap || dentry->d_inode) 683 683 + if (IS_ERR(dentry) || dentry == trap || d_really_is_positive(dentry)) 684 684 goto exit; 685 685 686 686 old_name = fsnotify_oldname_init(old_dentry->d_name.name); 687 687 688 688 - error = simple_rename(old_dir->d_inode, old_dentry, new_dir->d_inode, 688 688 + error = simple_rename(d_inode(old_dir), old_dentry, d_inode(new_dir), 689 689 dentry); 690 690 if (error) { 691 691 fsnotify_oldname_free(old_name); 692 692 goto exit; 693 693 } 694 694 d_move(old_dentry, dentry); 695 695 - fsnotify_move(old_dir->d_inode, new_dir->d_inode, old_name, 695 695 + fsnotify_move(d_inode(old_dir), d_inode(new_dir), old_name, 696 696 d_is_dir(old_dentry), 697 697 NULL, old_dentry); 698 698 fsnotify_oldname_free(old_name);

+8 -8

fs/devpts/inode.c

reviewed

··· 253 253 if (!uid_valid(root_uid) || !gid_valid(root_gid)) 254 254 return -EINVAL; 255 255 256 256 - mutex_lock(&root->d_inode->i_mutex); 256 256 + mutex_lock(&d_inode(root)->i_mutex); 257 257 258 258 /* If we have already created ptmx node, return */ 259 259 if (fsi->ptmx_dentry) { ··· 290 290 fsi->ptmx_dentry = dentry; 291 291 rc = 0; 292 292 out: 293 293 - mutex_unlock(&root->d_inode->i_mutex); 293 293 + mutex_unlock(&d_inode(root)->i_mutex); 294 294 return rc; 295 295 } 296 296 ··· 298 298 { 299 299 struct inode *inode; 300 300 if (fsi->ptmx_dentry) { 301 301 - inode = fsi->ptmx_dentry->d_inode; 301 301 + inode = d_inode(fsi->ptmx_dentry); 302 302 inode->i_mode = S_IFCHR|fsi->mount_opts.ptmxmode; 303 303 } 304 304 } ··· 602 602 603 603 sprintf(s, "%d", index); 604 604 605 605 - mutex_lock(&root->d_inode->i_mutex); 605 605 + mutex_lock(&d_inode(root)->i_mutex); 606 606 607 607 dentry = d_alloc_name(root, s); 608 608 if (dentry) { 609 609 d_add(dentry, inode); 610 610 - fsnotify_create(root->d_inode, dentry); 610 610 + fsnotify_create(d_inode(root), dentry); 611 611 } else { 612 612 iput(inode); 613 613 inode = ERR_PTR(-ENOMEM); 614 614 } 615 615 616 616 - mutex_unlock(&root->d_inode->i_mutex); 616 616 + mutex_unlock(&d_inode(root)->i_mutex); 617 617 618 618 return inode; 619 619 } ··· 658 658 659 659 BUG_ON(inode->i_rdev == MKDEV(TTYAUX_MAJOR, PTMX_MINOR)); 660 660 661 661 - mutex_lock(&root->d_inode->i_mutex); 661 661 + mutex_lock(&d_inode(root)->i_mutex); 662 662 663 663 dentry = d_find_alias(inode); 664 664 ··· 667 667 dput(dentry); /* d_alloc_name() in devpts_pty_new() */ 668 668 dput(dentry); /* d_find_alias above */ 669 669 670 670 - mutex_unlock(&root->d_inode->i_mutex); 670 670 + mutex_unlock(&d_inode(root)->i_mutex); 671 671 } 672 672 673 673 static int __init init_devpts_fs(void)

+5 -2

fs/direct-io.c

reviewed

··· 253 253 if (dio->end_io && dio->result) 254 254 dio->end_io(dio->iocb, offset, transferred, dio->private); 255 255 256 256 - inode_dio_done(dio->inode); 256 256 + if (!(dio->flags & DIO_SKIP_DIO_COUNT)) 257 257 + inode_dio_end(dio->inode); 258 258 + 257 259 if (is_async) { 258 260 if (dio->rw & WRITE) { 259 261 int err; ··· 1197 1195 /* 1198 1196 * Will be decremented at I/O completion time. 1199 1197 */ 1200 1200 - atomic_inc(&inode->i_dio_count); 1198 1198 + if (!(dio->flags & DIO_SKIP_DIO_COUNT)) 1199 1199 + inode_dio_begin(inode); 1201 1200 1202 1201 retval = 0; 1203 1202 sdio.blkbits = blkbits;

+2 -2

fs/ecryptfs/crypto.c

reviewed

··· 1326 1326 if (rc) 1327 1327 goto out; 1328 1328 if (!(crypt_stat->flags & ECRYPTFS_I_SIZE_INITIALIZED)) 1329 1329 - ecryptfs_i_size_init(page_virt, ecryptfs_dentry->d_inode); 1329 1329 + ecryptfs_i_size_init(page_virt, d_inode(ecryptfs_dentry)); 1330 1330 offset += MAGIC_ECRYPTFS_MARKER_SIZE_BYTES; 1331 1331 rc = ecryptfs_process_flags(crypt_stat, (page_virt + offset), 1332 1332 &bytes_read); ··· 1425 1425 { 1426 1426 int rc; 1427 1427 char *page_virt; 1428 1428 - struct inode *ecryptfs_inode = ecryptfs_dentry->d_inode; 1428 1428 + struct inode *ecryptfs_inode = d_inode(ecryptfs_dentry); 1429 1429 struct ecryptfs_crypt_stat *crypt_stat = 1430 1430 &ecryptfs_inode_to_private(ecryptfs_inode)->crypt_stat; 1431 1431 struct ecryptfs_mount_crypt_stat *mount_crypt_stat =

+3 -3

fs/ecryptfs/dentry.c

reviewed

··· 54 54 return -ECHILD; 55 55 56 56 rc = lower_dentry->d_op->d_revalidate(lower_dentry, flags); 57 57 - if (dentry->d_inode) { 57 57 + if (d_really_is_positive(dentry)) { 58 58 struct inode *lower_inode = 59 59 - ecryptfs_inode_to_lower(dentry->d_inode); 59 59 + ecryptfs_inode_to_lower(d_inode(dentry)); 60 60 61 61 - fsstack_copy_attr_all(dentry->d_inode, lower_inode); 61 61 + fsstack_copy_attr_all(d_inode(dentry), lower_inode); 62 62 } 63 63 return rc; 64 64 }

+1 -1

fs/ecryptfs/file.c

reviewed

··· 130 130 131 131 static int read_or_initialize_metadata(struct dentry *dentry) 132 132 { 133 133 - struct inode *inode = dentry->d_inode; 133 133 + struct inode *inode = d_inode(dentry); 134 134 struct ecryptfs_mount_crypt_stat *mount_crypt_stat; 135 135 struct ecryptfs_crypt_stat *crypt_stat; 136 136 int rc;

+82 -82

fs/ecryptfs/inode.c

reviewed

··· 41 41 struct dentry *dir; 42 42 43 43 dir = dget_parent(dentry); 44 44 - mutex_lock_nested(&(dir->d_inode->i_mutex), I_MUTEX_PARENT); 44 44 + mutex_lock_nested(&(d_inode(dir)->i_mutex), I_MUTEX_PARENT); 45 45 return dir; 46 46 } 47 47 48 48 static void unlock_dir(struct dentry *dir) 49 49 { 50 50 - mutex_unlock(&dir->d_inode->i_mutex); 50 50 + mutex_unlock(&d_inode(dir)->i_mutex); 51 51 dput(dir); 52 52 } 53 53 ··· 131 131 static int ecryptfs_interpose(struct dentry *lower_dentry, 132 132 struct dentry *dentry, struct super_block *sb) 133 133 { 134 134 - struct inode *inode = ecryptfs_get_inode(lower_dentry->d_inode, sb); 134 134 + struct inode *inode = ecryptfs_get_inode(d_inode(lower_dentry), sb); 135 135 136 136 if (IS_ERR(inode)) 137 137 return PTR_ERR(inode); ··· 189 189 190 190 lower_dentry = ecryptfs_dentry_to_lower(ecryptfs_dentry); 191 191 lower_dir_dentry = lock_parent(lower_dentry); 192 192 - rc = vfs_create(lower_dir_dentry->d_inode, lower_dentry, mode, true); 192 192 + rc = vfs_create(d_inode(lower_dir_dentry), lower_dentry, mode, true); 193 193 if (rc) { 194 194 printk(KERN_ERR "%s: Failure to create dentry in lower fs; " 195 195 "rc = [%d]\n", __func__, rc); 196 196 inode = ERR_PTR(rc); 197 197 goto out_lock; 198 198 } 199 199 - inode = __ecryptfs_get_inode(lower_dentry->d_inode, 199 199 + inode = __ecryptfs_get_inode(d_inode(lower_dentry), 200 200 directory_inode->i_sb); 201 201 if (IS_ERR(inode)) { 202 202 - vfs_unlink(lower_dir_dentry->d_inode, lower_dentry, NULL); 202 202 + vfs_unlink(d_inode(lower_dir_dentry), lower_dentry, NULL); 203 203 goto out_lock; 204 204 } 205 205 - fsstack_copy_attr_times(directory_inode, lower_dir_dentry->d_inode); 206 206 - fsstack_copy_inode_size(directory_inode, lower_dir_dentry->d_inode); 205 205 + fsstack_copy_attr_times(directory_inode, d_inode(lower_dir_dentry)); 206 206 + fsstack_copy_inode_size(directory_inode, d_inode(lower_dir_dentry)); 207 207 out_lock: 208 208 unlock_dir(lower_dir_dentry); 209 209 return inode; ··· 332 332 struct dentry *lower_dentry, 333 333 struct inode *dir_inode) 334 334 { 335 335 - struct inode *inode, *lower_inode = lower_dentry->d_inode; 335 335 + struct inode *inode, *lower_inode = d_inode(lower_dentry); 336 336 struct ecryptfs_dentry_info *dentry_info; 337 337 struct vfsmount *lower_mnt; 338 338 int rc = 0; ··· 347 347 } 348 348 349 349 lower_mnt = mntget(ecryptfs_dentry_to_lower_mnt(dentry->d_parent)); 350 350 - fsstack_copy_attr_atime(dir_inode, lower_dentry->d_parent->d_inode); 350 350 + fsstack_copy_attr_atime(dir_inode, d_inode(lower_dentry->d_parent)); 351 351 BUG_ON(!d_count(lower_dentry)); 352 352 353 353 ecryptfs_set_dentry_private(dentry, dentry_info); 354 354 dentry_info->lower_path.mnt = lower_mnt; 355 355 dentry_info->lower_path.dentry = lower_dentry; 356 356 357 357 - if (!lower_dentry->d_inode) { 357 357 + if (d_really_is_negative(lower_dentry)) { 358 358 /* We want to add because we couldn't find in lower */ 359 359 d_add(dentry, NULL); 360 360 return 0; ··· 400 400 int rc = 0; 401 401 402 402 lower_dir_dentry = ecryptfs_dentry_to_lower(ecryptfs_dentry->d_parent); 403 403 - mutex_lock(&lower_dir_dentry->d_inode->i_mutex); 403 403 + mutex_lock(&d_inode(lower_dir_dentry)->i_mutex); 404 404 lower_dentry = lookup_one_len(ecryptfs_dentry->d_name.name, 405 405 lower_dir_dentry, 406 406 ecryptfs_dentry->d_name.len); 407 407 - mutex_unlock(&lower_dir_dentry->d_inode->i_mutex); 407 407 + mutex_unlock(&d_inode(lower_dir_dentry)->i_mutex); 408 408 if (IS_ERR(lower_dentry)) { 409 409 rc = PTR_ERR(lower_dentry); 410 410 ecryptfs_printk(KERN_DEBUG, "%s: lookup_one_len() returned " ··· 412 412 ecryptfs_dentry); 413 413 goto out; 414 414 } 415 415 - if (lower_dentry->d_inode) 415 415 + if (d_really_is_positive(lower_dentry)) 416 416 goto interpose; 417 417 mount_crypt_stat = &ecryptfs_superblock_to_private( 418 418 ecryptfs_dentry->d_sb)->mount_crypt_stat; ··· 429 429 "filename; rc = [%d]\n", __func__, rc); 430 430 goto out; 431 431 } 432 432 - mutex_lock(&lower_dir_dentry->d_inode->i_mutex); 432 432 + mutex_lock(&d_inode(lower_dir_dentry)->i_mutex); 433 433 lower_dentry = lookup_one_len(encrypted_and_encoded_name, 434 434 lower_dir_dentry, 435 435 encrypted_and_encoded_name_size); 436 436 - mutex_unlock(&lower_dir_dentry->d_inode->i_mutex); 436 436 + mutex_unlock(&d_inode(lower_dir_dentry)->i_mutex); 437 437 if (IS_ERR(lower_dentry)) { 438 438 rc = PTR_ERR(lower_dentry); 439 439 ecryptfs_printk(KERN_DEBUG, "%s: lookup_one_len() returned " ··· 458 458 u64 file_size_save; 459 459 int rc; 460 460 461 461 - file_size_save = i_size_read(old_dentry->d_inode); 461 461 + file_size_save = i_size_read(d_inode(old_dentry)); 462 462 lower_old_dentry = ecryptfs_dentry_to_lower(old_dentry); 463 463 lower_new_dentry = ecryptfs_dentry_to_lower(new_dentry); 464 464 dget(lower_old_dentry); 465 465 dget(lower_new_dentry); 466 466 lower_dir_dentry = lock_parent(lower_new_dentry); 467 467 - rc = vfs_link(lower_old_dentry, lower_dir_dentry->d_inode, 467 467 + rc = vfs_link(lower_old_dentry, d_inode(lower_dir_dentry), 468 468 lower_new_dentry, NULL); 469 469 - if (rc || !lower_new_dentry->d_inode) 469 469 + if (rc || d_really_is_negative(lower_new_dentry)) 470 470 goto out_lock; 471 471 rc = ecryptfs_interpose(lower_new_dentry, new_dentry, dir->i_sb); 472 472 if (rc) 473 473 goto out_lock; 474 474 - fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode); 475 475 - fsstack_copy_inode_size(dir, lower_dir_dentry->d_inode); 476 476 - set_nlink(old_dentry->d_inode, 477 477 - ecryptfs_inode_to_lower(old_dentry->d_inode)->i_nlink); 478 478 - i_size_write(new_dentry->d_inode, file_size_save); 474 474 + fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry)); 475 475 + fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry)); 476 476 + set_nlink(d_inode(old_dentry), 477 477 + ecryptfs_inode_to_lower(d_inode(old_dentry))->i_nlink); 478 478 + i_size_write(d_inode(new_dentry), file_size_save); 479 479 out_lock: 480 480 unlock_dir(lower_dir_dentry); 481 481 dput(lower_new_dentry); ··· 485 485 486 486 static int ecryptfs_unlink(struct inode *dir, struct dentry *dentry) 487 487 { 488 488 - return ecryptfs_do_unlink(dir, dentry, dentry->d_inode); 488 488 + return ecryptfs_do_unlink(dir, dentry, d_inode(dentry)); 489 489 } 490 490 491 491 static int ecryptfs_symlink(struct inode *dir, struct dentry *dentry, ··· 510 510 strlen(symname)); 511 511 if (rc) 512 512 goto out_lock; 513 513 - rc = vfs_symlink(lower_dir_dentry->d_inode, lower_dentry, 513 513 + rc = vfs_symlink(d_inode(lower_dir_dentry), lower_dentry, 514 514 encoded_symname); 515 515 kfree(encoded_symname); 516 516 - if (rc || !lower_dentry->d_inode) 516 516 + if (rc || d_really_is_negative(lower_dentry)) 517 517 goto out_lock; 518 518 rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb); 519 519 if (rc) 520 520 goto out_lock; 521 521 - fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode); 522 522 - fsstack_copy_inode_size(dir, lower_dir_dentry->d_inode); 521 521 + fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry)); 522 522 + fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry)); 523 523 out_lock: 524 524 unlock_dir(lower_dir_dentry); 525 525 dput(lower_dentry); 526 526 - if (!dentry->d_inode) 526 526 + if (d_really_is_negative(dentry)) 527 527 d_drop(dentry); 528 528 return rc; 529 529 } ··· 536 536 537 537 lower_dentry = ecryptfs_dentry_to_lower(dentry); 538 538 lower_dir_dentry = lock_parent(lower_dentry); 539 539 - rc = vfs_mkdir(lower_dir_dentry->d_inode, lower_dentry, mode); 540 540 - if (rc || !lower_dentry->d_inode) 539 539 + rc = vfs_mkdir(d_inode(lower_dir_dentry), lower_dentry, mode); 540 540 + if (rc || d_really_is_negative(lower_dentry)) 541 541 goto out; 542 542 rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb); 543 543 if (rc) 544 544 goto out; 545 545 - fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode); 546 546 - fsstack_copy_inode_size(dir, lower_dir_dentry->d_inode); 547 547 - set_nlink(dir, lower_dir_dentry->d_inode->i_nlink); 545 545 + fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry)); 546 546 + fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry)); 547 547 + set_nlink(dir, d_inode(lower_dir_dentry)->i_nlink); 548 548 out: 549 549 unlock_dir(lower_dir_dentry); 550 550 - if (!dentry->d_inode) 550 550 + if (d_really_is_negative(dentry)) 551 551 d_drop(dentry); 552 552 return rc; 553 553 } ··· 562 562 dget(dentry); 563 563 lower_dir_dentry = lock_parent(lower_dentry); 564 564 dget(lower_dentry); 565 565 - rc = vfs_rmdir(lower_dir_dentry->d_inode, lower_dentry); 565 565 + rc = vfs_rmdir(d_inode(lower_dir_dentry), lower_dentry); 566 566 dput(lower_dentry); 567 567 - if (!rc && dentry->d_inode) 568 568 - clear_nlink(dentry->d_inode); 569 569 - fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode); 570 570 - set_nlink(dir, lower_dir_dentry->d_inode->i_nlink); 567 567 + if (!rc && d_really_is_positive(dentry)) 568 568 + clear_nlink(d_inode(dentry)); 569 569 + fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry)); 570 570 + set_nlink(dir, d_inode(lower_dir_dentry)->i_nlink); 571 571 unlock_dir(lower_dir_dentry); 572 572 if (!rc) 573 573 d_drop(dentry); ··· 584 584 585 585 lower_dentry = ecryptfs_dentry_to_lower(dentry); 586 586 lower_dir_dentry = lock_parent(lower_dentry); 587 587 - rc = vfs_mknod(lower_dir_dentry->d_inode, lower_dentry, mode, dev); 588 588 - if (rc || !lower_dentry->d_inode) 587 587 + rc = vfs_mknod(d_inode(lower_dir_dentry), lower_dentry, mode, dev); 588 588 + if (rc || d_really_is_negative(lower_dentry)) 589 589 goto out; 590 590 rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb); 591 591 if (rc) 592 592 goto out; 593 593 - fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode); 594 594 - fsstack_copy_inode_size(dir, lower_dir_dentry->d_inode); 593 593 + fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry)); 594 594 + fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry)); 595 595 out: 596 596 unlock_dir(lower_dir_dentry); 597 597 - if (!dentry->d_inode) 597 597 + if (d_really_is_negative(dentry)) 598 598 d_drop(dentry); 599 599 return rc; 600 600 } ··· 617 617 dget(lower_new_dentry); 618 618 lower_old_dir_dentry = dget_parent(lower_old_dentry); 619 619 lower_new_dir_dentry = dget_parent(lower_new_dentry); 620 620 - target_inode = new_dentry->d_inode; 620 620 + target_inode = d_inode(new_dentry); 621 621 trap = lock_rename(lower_old_dir_dentry, lower_new_dir_dentry); 622 622 /* source should not be ancestor of target */ 623 623 if (trap == lower_old_dentry) { ··· 629 629 rc = -ENOTEMPTY; 630 630 goto out_lock; 631 631 } 632 632 - rc = vfs_rename(lower_old_dir_dentry->d_inode, lower_old_dentry, 633 633 - lower_new_dir_dentry->d_inode, lower_new_dentry, 632 632 + rc = vfs_rename(d_inode(lower_old_dir_dentry), lower_old_dentry, 633 633 + d_inode(lower_new_dir_dentry), lower_new_dentry, 634 634 NULL, 0); 635 635 if (rc) 636 636 goto out_lock; 637 637 if (target_inode) 638 638 fsstack_copy_attr_all(target_inode, 639 639 ecryptfs_inode_to_lower(target_inode)); 640 640 - fsstack_copy_attr_all(new_dir, lower_new_dir_dentry->d_inode); 640 640 + fsstack_copy_attr_all(new_dir, d_inode(lower_new_dir_dentry)); 641 641 if (new_dir != old_dir) 642 642 - fsstack_copy_attr_all(old_dir, lower_old_dir_dentry->d_inode); 642 642 + fsstack_copy_attr_all(old_dir, d_inode(lower_old_dir_dentry)); 643 643 out_lock: 644 644 unlock_rename(lower_old_dir_dentry, lower_new_dir_dentry); 645 645 dput(lower_new_dir_dentry); ··· 662 662 return ERR_PTR(-ENOMEM); 663 663 old_fs = get_fs(); 664 664 set_fs(get_ds()); 665 665 - rc = lower_dentry->d_inode->i_op->readlink(lower_dentry, 665 665 + rc = d_inode(lower_dentry)->i_op->readlink(lower_dentry, 666 666 (char __user *)lower_buf, 667 667 PATH_MAX); 668 668 set_fs(old_fs); ··· 681 681 char *buf = ecryptfs_readlink_lower(dentry, &len); 682 682 if (IS_ERR(buf)) 683 683 goto out; 684 684 - fsstack_copy_attr_atime(dentry->d_inode, 685 685 - ecryptfs_dentry_to_lower(dentry)->d_inode); 684 684 + fsstack_copy_attr_atime(d_inode(dentry), 685 685 + d_inode(ecryptfs_dentry_to_lower(dentry))); 686 686 buf[len] = '\0'; 687 687 out: 688 688 nd_set_link(nd, buf); ··· 738 738 struct iattr *lower_ia) 739 739 { 740 740 int rc = 0; 741 741 - struct inode *inode = dentry->d_inode; 741 741 + struct inode *inode = d_inode(dentry); 742 742 struct ecryptfs_crypt_stat *crypt_stat; 743 743 loff_t i_size = i_size_read(inode); 744 744 loff_t lower_size_before_truncate; ··· 751 751 rc = ecryptfs_get_lower_file(dentry, inode); 752 752 if (rc) 753 753 return rc; 754 754 - crypt_stat = &ecryptfs_inode_to_private(dentry->d_inode)->crypt_stat; 754 754 + crypt_stat = &ecryptfs_inode_to_private(d_inode(dentry))->crypt_stat; 755 755 /* Switch on growing or shrinking file */ 756 756 if (ia->ia_size > i_size) { 757 757 char zero[] = { 0x00 }; ··· 858 858 struct iattr lower_ia = { .ia_valid = 0 }; 859 859 int rc; 860 860 861 861 - rc = ecryptfs_inode_newsize_ok(dentry->d_inode, new_length); 861 861 + rc = ecryptfs_inode_newsize_ok(d_inode(dentry), new_length); 862 862 if (rc) 863 863 return rc; 864 864 ··· 866 866 if (!rc && lower_ia.ia_valid & ATTR_SIZE) { 867 867 struct dentry *lower_dentry = ecryptfs_dentry_to_lower(dentry); 868 868 869 869 - mutex_lock(&lower_dentry->d_inode->i_mutex); 869 869 + mutex_lock(&d_inode(lower_dentry)->i_mutex); 870 870 rc = notify_change(lower_dentry, &lower_ia, NULL); 871 871 - mutex_unlock(&lower_dentry->d_inode->i_mutex); 871 871 + mutex_unlock(&d_inode(lower_dentry)->i_mutex); 872 872 } 873 873 return rc; 874 874 } ··· 900 900 struct inode *lower_inode; 901 901 struct ecryptfs_crypt_stat *crypt_stat; 902 902 903 903 - crypt_stat = &ecryptfs_inode_to_private(dentry->d_inode)->crypt_stat; 903 903 + crypt_stat = &ecryptfs_inode_to_private(d_inode(dentry))->crypt_stat; 904 904 if (!(crypt_stat->flags & ECRYPTFS_STRUCT_INITIALIZED)) 905 905 ecryptfs_init_crypt_stat(crypt_stat); 906 906 - inode = dentry->d_inode; 906 906 + inode = d_inode(dentry); 907 907 lower_inode = ecryptfs_inode_to_lower(inode); 908 908 lower_dentry = ecryptfs_dentry_to_lower(dentry); 909 909 mutex_lock(&crypt_stat->cs_mutex); ··· 967 967 if (lower_ia.ia_valid & (ATTR_KILL_SUID | ATTR_KILL_SGID)) 968 968 lower_ia.ia_valid &= ~ATTR_MODE; 969 969 970 970 - mutex_lock(&lower_dentry->d_inode->i_mutex); 970 970 + mutex_lock(&d_inode(lower_dentry)->i_mutex); 971 971 rc = notify_change(lower_dentry, &lower_ia, NULL); 972 972 - mutex_unlock(&lower_dentry->d_inode->i_mutex); 972 972 + mutex_unlock(&d_inode(lower_dentry)->i_mutex); 973 973 out: 974 974 fsstack_copy_attr_all(inode, lower_inode); 975 975 return rc; ··· 983 983 984 984 mount_crypt_stat = &ecryptfs_superblock_to_private( 985 985 dentry->d_sb)->mount_crypt_stat; 986 986 - generic_fillattr(dentry->d_inode, stat); 986 986 + generic_fillattr(d_inode(dentry), stat); 987 987 if (mount_crypt_stat->flags & ECRYPTFS_GLOBAL_ENCRYPT_FILENAMES) { 988 988 char *target; 989 989 size_t targetsiz; ··· 1007 1007 1008 1008 rc = vfs_getattr(ecryptfs_dentry_to_lower_path(dentry), &lower_stat); 1009 1009 if (!rc) { 1010 1010 - fsstack_copy_attr_all(dentry->d_inode, 1011 1011 - ecryptfs_inode_to_lower(dentry->d_inode)); 1012 1012 - generic_fillattr(dentry->d_inode, stat); 1010 1010 + fsstack_copy_attr_all(d_inode(dentry), 1011 1011 + ecryptfs_inode_to_lower(d_inode(dentry))); 1012 1012 + generic_fillattr(d_inode(dentry), stat); 1013 1013 stat->blocks = lower_stat.blocks; 1014 1014 } 1015 1015 return rc; ··· 1023 1023 struct dentry *lower_dentry; 1024 1024 1025 1025 lower_dentry = ecryptfs_dentry_to_lower(dentry); 1026 1026 - if (!lower_dentry->d_inode->i_op->setxattr) { 1026 1026 + if (!d_inode(lower_dentry)->i_op->setxattr) { 1027 1027 rc = -EOPNOTSUPP; 1028 1028 goto out; 1029 1029 } 1030 1030 1031 1031 rc = vfs_setxattr(lower_dentry, name, value, size, flags); 1032 1032 - if (!rc && dentry->d_inode) 1033 1033 - fsstack_copy_attr_all(dentry->d_inode, lower_dentry->d_inode); 1032 1032 + if (!rc && d_really_is_positive(dentry)) 1033 1033 + fsstack_copy_attr_all(d_inode(dentry), d_inode(lower_dentry)); 1034 1034 out: 1035 1035 return rc; 1036 1036 } ··· 1041 1041 { 1042 1042 int rc = 0; 1043 1043 1044 1044 - if (!lower_dentry->d_inode->i_op->getxattr) { 1044 1044 + if (!d_inode(lower_dentry)->i_op->getxattr) { 1045 1045 rc = -EOPNOTSUPP; 1046 1046 goto out; 1047 1047 } 1048 1048 - mutex_lock(&lower_dentry->d_inode->i_mutex); 1049 1049 - rc = lower_dentry->d_inode->i_op->getxattr(lower_dentry, name, value, 1048 1048 + mutex_lock(&d_inode(lower_dentry)->i_mutex); 1049 1049 + rc = d_inode(lower_dentry)->i_op->getxattr(lower_dentry, name, value, 1050 1050 size); 1051 1051 - mutex_unlock(&lower_dentry->d_inode->i_mutex); 1051 1051 + mutex_unlock(&d_inode(lower_dentry)->i_mutex); 1052 1052 out: 1053 1053 return rc; 1054 1054 } ··· 1068 1068 struct dentry *lower_dentry; 1069 1069 1070 1070 lower_dentry = ecryptfs_dentry_to_lower(dentry); 1071 1071 - if (!lower_dentry->d_inode->i_op->listxattr) { 1071 1071 + if (!d_inode(lower_dentry)->i_op->listxattr) { 1072 1072 rc = -EOPNOTSUPP; 1073 1073 goto out; 1074 1074 } 1075 1075 - mutex_lock(&lower_dentry->d_inode->i_mutex); 1076 1076 - rc = lower_dentry->d_inode->i_op->listxattr(lower_dentry, list, size); 1077 1077 - mutex_unlock(&lower_dentry->d_inode->i_mutex); 1075 1075 + mutex_lock(&d_inode(lower_dentry)->i_mutex); 1076 1076 + rc = d_inode(lower_dentry)->i_op->listxattr(lower_dentry, list, size); 1077 1077 + mutex_unlock(&d_inode(lower_dentry)->i_mutex); 1078 1078 out: 1079 1079 return rc; 1080 1080 } ··· 1085 1085 struct dentry *lower_dentry; 1086 1086 1087 1087 lower_dentry = ecryptfs_dentry_to_lower(dentry); 1088 1088 - if (!lower_dentry->d_inode->i_op->removexattr) { 1088 1088 + if (!d_inode(lower_dentry)->i_op->removexattr) { 1089 1089 rc = -EOPNOTSUPP; 1090 1090 goto out; 1091 1091 } 1092 1092 - mutex_lock(&lower_dentry->d_inode->i_mutex); 1093 1093 - rc = lower_dentry->d_inode->i_op->removexattr(lower_dentry, name); 1094 1094 - mutex_unlock(&lower_dentry->d_inode->i_mutex); 1092 1092 + mutex_lock(&d_inode(lower_dentry)->i_mutex); 1093 1093 + rc = d_inode(lower_dentry)->i_op->removexattr(lower_dentry, name); 1094 1094 + mutex_unlock(&d_inode(lower_dentry)->i_mutex); 1095 1095 out: 1096 1096 return rc; 1097 1097 }

+1 -1

fs/ecryptfs/kthread.c

reviewed

··· 144 144 /* Corresponding dput() and mntput() are done when the 145 145 * lower file is fput() when all eCryptfs files for the inode are 146 146 * released. */ 147 147 - flags |= IS_RDONLY(lower_dentry->d_inode) ? O_RDONLY : O_RDWR; 147 147 + flags |= IS_RDONLY(d_inode(lower_dentry)) ? O_RDONLY : O_RDWR; 148 148 (*lower_file) = dentry_open(&req.path, flags, cred); 149 149 if (!IS_ERR(*lower_file)) 150 150 goto out;

+3 -3

fs/ecryptfs/main.c

reviewed

··· 546 546 goto out_free; 547 547 } 548 548 549 549 - if (check_ruid && !uid_eq(path.dentry->d_inode->i_uid, current_uid())) { 549 549 + if (check_ruid && !uid_eq(d_inode(path.dentry)->i_uid, current_uid())) { 550 550 rc = -EPERM; 551 551 printk(KERN_ERR "Mount of device (uid: %d) not owned by " 552 552 "requested user (uid: %d)\n", 553 553 - i_uid_read(path.dentry->d_inode), 553 553 + i_uid_read(d_inode(path.dentry)), 554 554 from_kuid(&init_user_ns, current_uid())); 555 555 goto out_free; 556 556 } ··· 584 584 goto out_free; 585 585 } 586 586 587 587 - inode = ecryptfs_get_inode(path.dentry->d_inode, s); 587 587 + inode = ecryptfs_get_inode(d_inode(path.dentry), s); 588 588 rc = PTR_ERR(inode); 589 589 if (IS_ERR(inode)) 590 590 goto out_free;

+1 -1

fs/ecryptfs/mmap.c

reviewed

··· 420 420 void *xattr_virt; 421 421 struct dentry *lower_dentry = 422 422 ecryptfs_inode_to_private(ecryptfs_inode)->lower_file->f_path.dentry; 423 423 - struct inode *lower_inode = lower_dentry->d_inode; 423 423 + struct inode *lower_inode = d_inode(lower_dentry); 424 424 int rc; 425 425 426 426 if (!lower_inode->i_op->getxattr || !lower_inode->i_op->setxattr) {

+2 -2

fs/efivarfs/inode.c

reviewed

··· 145 145 146 146 static int efivarfs_unlink(struct inode *dir, struct dentry *dentry) 147 147 { 148 148 - struct efivar_entry *var = dentry->d_inode->i_private; 148 148 + struct efivar_entry *var = d_inode(dentry)->i_private; 149 149 150 150 if (efivar_entry_delete(var)) 151 151 return -EINVAL; 152 152 153 153 - drop_nlink(dentry->d_inode); 153 153 + drop_nlink(d_inode(dentry)); 154 154 dput(dentry); 155 155 return 0; 156 156 };

+1 -1

fs/efivarfs/super.c

reviewed

··· 144 144 145 145 name[len + EFI_VARIABLE_GUID_LEN+1] = '\0'; 146 146 147 147 - inode = efivarfs_get_inode(sb, root->d_inode, S_IFREG | 0644, 0); 147 147 + inode = efivarfs_get_inode(sb, d_inode(root), S_IFREG | 0644, 0); 148 148 if (!inode) 149 149 goto fail_name; 150 150

+2 -2

fs/efs/namei.c

reviewed

··· 111 111 struct dentry *parent = ERR_PTR(-ENOENT); 112 112 efs_ino_t ino; 113 113 114 114 - ino = efs_find_entry(child->d_inode, "..", 2); 114 114 + ino = efs_find_entry(d_inode(child), "..", 2); 115 115 if (ino) 116 116 - parent = d_obtain_alias(efs_iget(child->d_inode->i_sb, ino)); 116 116 + parent = d_obtain_alias(efs_iget(d_inode(child)->i_sb, ino)); 117 117 118 118 return parent; 119 119 }

+2 -2

fs/exofs/dir.c

reviewed

··· 379 379 struct exofs_dir_entry *de; 380 380 ino_t ino; 381 381 382 382 - de = exofs_dotdot(child->d_inode, &page); 382 382 + de = exofs_dotdot(d_inode(child), &page); 383 383 if (!de) 384 384 return 0; 385 385 ··· 429 429 430 430 int exofs_add_link(struct dentry *dentry, struct inode *inode) 431 431 { 432 432 - struct inode *dir = dentry->d_parent->d_inode; 432 432 + struct inode *dir = d_inode(dentry->d_parent); 433 433 const unsigned char *name = dentry->d_name.name; 434 434 int namelen = dentry->d_name.len; 435 435 unsigned chunk_size = exofs_chunk_size(dir);

+1 -1

fs/exofs/inode.c

reviewed

··· 1028 1028 */ 1029 1029 int exofs_setattr(struct dentry *dentry, struct iattr *iattr) 1030 1030 { 1031 1031 - struct inode *inode = dentry->d_inode; 1031 1031 + struct inode *inode = d_inode(dentry); 1032 1032 int error; 1033 1033 1034 1034 /* if we are about to modify an object, and it hasn't been

+5 -5

fs/exofs/namei.c

reviewed

··· 141 141 static int exofs_link(struct dentry *old_dentry, struct inode *dir, 142 142 struct dentry *dentry) 143 143 { 144 144 - struct inode *inode = old_dentry->d_inode; 144 144 + struct inode *inode = d_inode(old_dentry); 145 145 146 146 inode->i_ctime = CURRENT_TIME; 147 147 inode_inc_link_count(inode); ··· 191 191 192 192 static int exofs_unlink(struct inode *dir, struct dentry *dentry) 193 193 { 194 194 - struct inode *inode = dentry->d_inode; 194 194 + struct inode *inode = d_inode(dentry); 195 195 struct exofs_dir_entry *de; 196 196 struct page *page; 197 197 int err = -ENOENT; ··· 213 213 214 214 static int exofs_rmdir(struct inode *dir, struct dentry *dentry) 215 215 { 216 216 - struct inode *inode = dentry->d_inode; 216 216 + struct inode *inode = d_inode(dentry); 217 217 int err = -ENOTEMPTY; 218 218 219 219 if (exofs_empty_dir(inode)) { ··· 230 230 static int exofs_rename(struct inode *old_dir, struct dentry *old_dentry, 231 231 struct inode *new_dir, struct dentry *new_dentry) 232 232 { 233 233 - struct inode *old_inode = old_dentry->d_inode; 234 234 - struct inode *new_inode = new_dentry->d_inode; 233 233 + struct inode *old_inode = d_inode(old_dentry); 234 234 + struct inode *new_inode = d_inode(new_dentry); 235 235 struct page *dir_page = NULL; 236 236 struct exofs_dir_entry *dir_de = NULL; 237 237 struct page *old_page;

+1 -1

fs/exofs/super.c

reviewed

··· 958 958 if (!ino) 959 959 return ERR_PTR(-ESTALE); 960 960 961 961 - return d_obtain_alias(exofs_iget(child->d_inode->i_sb, ino)); 961 961 + return d_obtain_alias(exofs_iget(d_inode(child)->i_sb, ino)); 962 962 } 963 963 964 964 static struct inode *exofs_nfs_get_inode(struct super_block *sb,

+1 -1

fs/exofs/symlink.c

reviewed

··· 37 37 38 38 static void *exofs_follow_link(struct dentry *dentry, struct nameidata *nd) 39 39 { 40 40 - struct exofs_i_info *oi = exofs_i(dentry->d_inode); 40 40 + struct exofs_i_info *oi = exofs_i(d_inode(dentry)); 41 41 42 42 nd_set_link(nd, (char *)oi->i_data); 43 43 return NULL;

+1 -1

fs/ext2/dir.c

reviewed

··· 486 486 */ 487 487 int ext2_add_link (struct dentry *dentry, struct inode *inode) 488 488 { 489 489 - struct inode *dir = dentry->d_parent->d_inode; 489 489 + struct inode *dir = d_inode(dentry->d_parent); 490 490 const char *name = dentry->d_name.name; 491 491 int namelen = dentry->d_name.len; 492 492 unsigned chunk_size = ext2_chunk_size(dir);

+1 -1

fs/ext2/ialloc.c

reviewed

··· 278 278 avefreeb = free_blocks / ngroups; 279 279 ndirs = percpu_counter_read_positive(&sbi->s_dirs_counter); 280 280 281 281 - if ((parent == sb->s_root->d_inode) || 281 281 + if ((parent == d_inode(sb->s_root)) || 282 282 (EXT2_I(parent)->i_flags & EXT2_TOPDIR_FL)) { 283 283 struct ext2_group_desc *best_desc = NULL; 284 284 int best_ndir = inodes_per_group;

+1 -1

fs/ext2/inode.c

reviewed

··· 1544 1544 1545 1545 int ext2_setattr(struct dentry *dentry, struct iattr *iattr) 1546 1546 { 1547 1547 - struct inode *inode = dentry->d_inode; 1547 1547 + struct inode *inode = d_inode(dentry); 1548 1548 int error; 1549 1549 1550 1550 error = inode_change_ok(inode, iattr);

+7 -7

fs/ext2/namei.c

reviewed

··· 79 79 struct dentry *ext2_get_parent(struct dentry *child) 80 80 { 81 81 struct qstr dotdot = QSTR_INIT("..", 2); 82 82 - unsigned long ino = ext2_inode_by_name(child->d_inode, &dotdot); 82 82 + unsigned long ino = ext2_inode_by_name(d_inode(child), &dotdot); 83 83 if (!ino) 84 84 return ERR_PTR(-ENOENT); 85 85 - return d_obtain_alias(ext2_iget(child->d_inode->i_sb, ino)); 85 85 + return d_obtain_alias(ext2_iget(d_inode(child)->i_sb, ino)); 86 86 } 87 87 88 88 /* ··· 208 208 static int ext2_link (struct dentry * old_dentry, struct inode * dir, 209 209 struct dentry *dentry) 210 210 { 211 211 - struct inode *inode = old_dentry->d_inode; 211 211 + struct inode *inode = d_inode(old_dentry); 212 212 int err; 213 213 214 214 dquot_initialize(dir); ··· 275 275 276 276 static int ext2_unlink(struct inode * dir, struct dentry *dentry) 277 277 { 278 278 - struct inode * inode = dentry->d_inode; 278 278 + struct inode * inode = d_inode(dentry); 279 279 struct ext2_dir_entry_2 * de; 280 280 struct page * page; 281 281 int err = -ENOENT; ··· 299 299 300 300 static int ext2_rmdir (struct inode * dir, struct dentry *dentry) 301 301 { 302 302 - struct inode * inode = dentry->d_inode; 302 302 + struct inode * inode = d_inode(dentry); 303 303 int err = -ENOTEMPTY; 304 304 305 305 if (ext2_empty_dir(inode)) { ··· 316 316 static int ext2_rename (struct inode * old_dir, struct dentry * old_dentry, 317 317 struct inode * new_dir, struct dentry * new_dentry ) 318 318 { 319 319 - struct inode * old_inode = old_dentry->d_inode; 320 320 - struct inode * new_inode = new_dentry->d_inode; 319 319 + struct inode * old_inode = d_inode(old_dentry); 320 320 + struct inode * new_inode = d_inode(new_dentry); 321 321 struct page * dir_page = NULL; 322 322 struct ext2_dir_entry_2 * dir_de = NULL; 323 323 struct page * old_page;

+1 -1

fs/ext2/symlink.c

reviewed

··· 23 23 24 24 static void *ext2_follow_link(struct dentry *dentry, struct nameidata *nd) 25 25 { 26 26 - struct ext2_inode_info *ei = EXT2_I(dentry->d_inode); 26 26 + struct ext2_inode_info *ei = EXT2_I(d_inode(dentry)); 27 27 nd_set_link(nd, (char *)ei->i_data); 28 28 return NULL; 29 29 }

+2 -2

fs/ext2/xattr.c

reviewed

··· 243 243 static int 244 244 ext2_xattr_list(struct dentry *dentry, char *buffer, size_t buffer_size) 245 245 { 246 246 - struct inode *inode = dentry->d_inode; 246 246 + struct inode *inode = d_inode(dentry); 247 247 struct buffer_head *bh = NULL; 248 248 struct ext2_xattr_entry *entry; 249 249 char *end; ··· 319 319 /* 320 320 * Inode operation listxattr() 321 321 * 322 322 - * dentry->d_inode->i_mutex: don't care 322 322 + * d_inode(dentry)->i_mutex: don't care 323 323 */ 324 324 ssize_t 325 325 ext2_listxattr(struct dentry *dentry, char *buffer, size_t size)

+2 -2

fs/ext2/xattr_security.c

reviewed

··· 28 28 { 29 29 if (strcmp(name, "") == 0) 30 30 return -EINVAL; 31 31 - return ext2_xattr_get(dentry->d_inode, EXT2_XATTR_INDEX_SECURITY, name, 31 31 + return ext2_xattr_get(d_inode(dentry), EXT2_XATTR_INDEX_SECURITY, name, 32 32 buffer, size); 33 33 } 34 34 ··· 38 38 { 39 39 if (strcmp(name, "") == 0) 40 40 return -EINVAL; 41 41 - return ext2_xattr_set(dentry->d_inode, EXT2_XATTR_INDEX_SECURITY, name, 41 41 + return ext2_xattr_set(d_inode(dentry), EXT2_XATTR_INDEX_SECURITY, name, 42 42 value, size, flags); 43 43 } 44 44

+2 -2

fs/ext2/xattr_trusted.c

reviewed

··· 32 32 { 33 33 if (strcmp(name, "") == 0) 34 34 return -EINVAL; 35 35 - return ext2_xattr_get(dentry->d_inode, EXT2_XATTR_INDEX_TRUSTED, name, 35 35 + return ext2_xattr_get(d_inode(dentry), EXT2_XATTR_INDEX_TRUSTED, name, 36 36 buffer, size); 37 37 } 38 38 ··· 42 42 { 43 43 if (strcmp(name, "") == 0) 44 44 return -EINVAL; 45 45 - return ext2_xattr_set(dentry->d_inode, EXT2_XATTR_INDEX_TRUSTED, name, 45 45 + return ext2_xattr_set(d_inode(dentry), EXT2_XATTR_INDEX_TRUSTED, name, 46 46 value, size, flags); 47 47 } 48 48

+2 -2

fs/ext2/xattr_user.c

reviewed

··· 36 36 return -EINVAL; 37 37 if (!test_opt(dentry->d_sb, XATTR_USER)) 38 38 return -EOPNOTSUPP; 39 39 - return ext2_xattr_get(dentry->d_inode, EXT2_XATTR_INDEX_USER, 39 39 + return ext2_xattr_get(d_inode(dentry), EXT2_XATTR_INDEX_USER, 40 40 name, buffer, size); 41 41 } 42 42 ··· 49 49 if (!test_opt(dentry->d_sb, XATTR_USER)) 50 50 return -EOPNOTSUPP; 51 51 52 52 - return ext2_xattr_set(dentry->d_inode, EXT2_XATTR_INDEX_USER, 52 52 + return ext2_xattr_set(d_inode(dentry), EXT2_XATTR_INDEX_USER, 53 53 name, value, size, flags); 54 54 } 55 55

+1 -1

fs/ext3/ialloc.c

reviewed

··· 210 210 avefreeb = freeb / ngroups; 211 211 ndirs = percpu_counter_read_positive(&sbi->s_dirs_counter); 212 212 213 213 - if ((parent == sb->s_root->d_inode) || 213 213 + if ((parent == d_inode(sb->s_root)) || 214 214 (EXT3_I(parent)->i_flags & EXT3_TOPDIR_FL)) { 215 215 int best_ndir = inodes_per_group; 216 216 int best_group = -1;

+1 -1

fs/ext3/inode.c

reviewed

··· 3240 3240 */ 3241 3241 int ext3_setattr(struct dentry *dentry, struct iattr *attr) 3242 3242 { 3243 3243 - struct inode *inode = dentry->d_inode; 3243 3243 + struct inode *inode = d_inode(dentry); 3244 3244 int error, rc = 0; 3245 3245 const unsigned int ia_valid = attr->ia_valid; 3246 3246

+17 -17

fs/ext3/namei.c

reviewed

··· 1049 1049 struct ext3_dir_entry_2 * de; 1050 1050 struct buffer_head *bh; 1051 1051 1052 1052 - bh = ext3_find_entry(child->d_inode, &dotdot, &de); 1052 1052 + bh = ext3_find_entry(d_inode(child), &dotdot, &de); 1053 1053 if (!bh) 1054 1054 return ERR_PTR(-ENOENT); 1055 1055 ino = le32_to_cpu(de->inode); 1056 1056 brelse(bh); 1057 1057 1058 1058 - if (!ext3_valid_inum(child->d_inode->i_sb, ino)) { 1059 1059 - ext3_error(child->d_inode->i_sb, "ext3_get_parent", 1058 1058 + if (!ext3_valid_inum(d_inode(child)->i_sb, ino)) { 1059 1059 + ext3_error(d_inode(child)->i_sb, "ext3_get_parent", 1060 1060 "bad inode number: %lu", ino); 1061 1061 return ERR_PTR(-EIO); 1062 1062 } 1063 1063 1064 1064 - return d_obtain_alias(ext3_iget(child->d_inode->i_sb, ino)); 1064 1064 + return d_obtain_alias(ext3_iget(d_inode(child)->i_sb, ino)); 1065 1065 } 1066 1066 1067 1067 #define S_SHIFT 12 ··· 1243 1243 struct inode *inode, struct ext3_dir_entry_2 *de, 1244 1244 struct buffer_head * bh) 1245 1245 { 1246 1246 - struct inode *dir = dentry->d_parent->d_inode; 1246 1246 + struct inode *dir = d_inode(dentry->d_parent); 1247 1247 const char *name = dentry->d_name.name; 1248 1248 int namelen = dentry->d_name.len; 1249 1249 unsigned long offset = 0; ··· 1330 1330 static int make_indexed_dir(handle_t *handle, struct dentry *dentry, 1331 1331 struct inode *inode, struct buffer_head *bh) 1332 1332 { 1333 1333 - struct inode *dir = dentry->d_parent->d_inode; 1333 1333 + struct inode *dir = d_inode(dentry->d_parent); 1334 1334 const char *name = dentry->d_name.name; 1335 1335 int namelen = dentry->d_name.len; 1336 1336 struct buffer_head *bh2; ··· 1435 1435 static int ext3_add_entry (handle_t *handle, struct dentry *dentry, 1436 1436 struct inode *inode) 1437 1437 { 1438 1438 - struct inode *dir = dentry->d_parent->d_inode; 1438 1438 + struct inode *dir = d_inode(dentry->d_parent); 1439 1439 struct buffer_head * bh; 1440 1440 struct ext3_dir_entry_2 *de; 1441 1441 struct super_block * sb; ··· 1489 1489 struct dx_entry *entries, *at; 1490 1490 struct dx_hash_info hinfo; 1491 1491 struct buffer_head * bh; 1492 1492 - struct inode *dir = dentry->d_parent->d_inode; 1492 1492 + struct inode *dir = d_inode(dentry->d_parent); 1493 1493 struct super_block * sb = dir->i_sb; 1494 1494 struct ext3_dir_entry_2 *de; 1495 1495 int err; ··· 2111 2111 /* Initialize quotas before so that eventual writes go in 2112 2112 * separate transaction */ 2113 2113 dquot_initialize(dir); 2114 2114 - dquot_initialize(dentry->d_inode); 2114 2114 + dquot_initialize(d_inode(dentry)); 2115 2115 2116 2116 handle = ext3_journal_start(dir, EXT3_DELETE_TRANS_BLOCKS(dir->i_sb)); 2117 2117 if (IS_ERR(handle)) ··· 2125 2125 if (IS_DIRSYNC(dir)) 2126 2126 handle->h_sync = 1; 2127 2127 2128 2128 - inode = dentry->d_inode; 2128 2128 + inode = d_inode(dentry); 2129 2129 2130 2130 retval = -EIO; 2131 2131 if (le32_to_cpu(de->inode) != inode->i_ino) ··· 2173 2173 /* Initialize quotas before so that eventual writes go 2174 2174 * in separate transaction */ 2175 2175 dquot_initialize(dir); 2176 2176 - dquot_initialize(dentry->d_inode); 2176 2176 + dquot_initialize(d_inode(dentry)); 2177 2177 2178 2178 handle = ext3_journal_start(dir, EXT3_DELETE_TRANS_BLOCKS(dir->i_sb)); 2179 2179 if (IS_ERR(handle)) ··· 2187 2187 if (!bh) 2188 2188 goto end_unlink; 2189 2189 2190 2190 - inode = dentry->d_inode; 2190 2190 + inode = d_inode(dentry); 2191 2191 2192 2192 retval = -EIO; 2193 2193 if (le32_to_cpu(de->inode) != inode->i_ino) ··· 2328 2328 struct inode * dir, struct dentry *dentry) 2329 2329 { 2330 2330 handle_t *handle; 2331 2331 - struct inode *inode = old_dentry->d_inode; 2331 2331 + struct inode *inode = d_inode(old_dentry); 2332 2332 int err, retries = 0; 2333 2333 2334 2334 if (inode->i_nlink >= EXT3_LINK_MAX) ··· 2391 2391 2392 2392 /* Initialize quotas before so that eventual writes go 2393 2393 * in separate transaction */ 2394 2394 - if (new_dentry->d_inode) 2395 2395 - dquot_initialize(new_dentry->d_inode); 2394 2394 + if (d_really_is_positive(new_dentry)) 2395 2395 + dquot_initialize(d_inode(new_dentry)); 2396 2396 handle = ext3_journal_start(old_dir, 2 * 2397 2397 EXT3_DATA_TRANS_BLOCKS(old_dir->i_sb) + 2398 2398 EXT3_INDEX_EXTRA_TRANS_BLOCKS + 2); ··· 2409 2409 * and merrily kill the link to whatever was created under the 2410 2410 * same name. Goodbye sticky bit ;-< 2411 2411 */ 2412 2412 - old_inode = old_dentry->d_inode; 2412 2412 + old_inode = d_inode(old_dentry); 2413 2413 retval = -ENOENT; 2414 2414 if (!old_bh || le32_to_cpu(old_de->inode) != old_inode->i_ino) 2415 2415 goto end_rename; 2416 2416 2417 2417 - new_inode = new_dentry->d_inode; 2417 2417 + new_inode = d_inode(new_dentry); 2418 2418 new_bh = ext3_find_entry(new_dir, &new_dentry->d_name, &new_de); 2419 2419 if (new_bh) { 2420 2420 if (!new_inode) {

+3 -3

fs/ext3/super.c

reviewed

··· 1170 1170 return 0; 1171 1171 } 1172 1172 1173 1173 - journal_inode = path.dentry->d_inode; 1173 1173 + journal_inode = d_inode(path.dentry); 1174 1174 if (!S_ISBLK(journal_inode->i_mode)) { 1175 1175 ext3_msg(sb, KERN_ERR, "error: journal path %s " 1176 1176 "is not a block device", journal_path); ··· 2947 2947 handle_t *handle; 2948 2948 2949 2949 /* Data block + inode block */ 2950 2950 - handle = ext3_journal_start(sb->s_root->d_inode, 2); 2950 2950 + handle = ext3_journal_start(d_inode(sb->s_root), 2); 2951 2951 if (IS_ERR(handle)) 2952 2952 return PTR_ERR(handle); 2953 2953 ret = dquot_commit_info(sb, type); ··· 2994 2994 * When we journal data on quota file, we have to flush journal to see 2995 2995 * all updates to the file when we bypass pagecache... 2996 2996 */ 2997 2997 - if (ext3_should_journal_data(path->dentry->d_inode)) { 2997 2997 + if (ext3_should_journal_data(d_inode(path->dentry))) { 2998 2998 /* 2999 2999 * We don't need to lock updates but journal_flush() could 3000 3000 * otherwise be livelocked...

+1 -1

fs/ext3/symlink.c

reviewed

··· 23 23 24 24 static void * ext3_follow_link(struct dentry *dentry, struct nameidata *nd) 25 25 { 26 26 - struct ext3_inode_info *ei = EXT3_I(dentry->d_inode); 26 26 + struct ext3_inode_info *ei = EXT3_I(d_inode(dentry)); 27 27 nd_set_link(nd, (char*)ei->i_data); 28 28 return NULL; 29 29 }

+5 -5

fs/ext3/xattr.c

reviewed

··· 137 137 /* 138 138 * Inode operation listxattr() 139 139 * 140 140 - * dentry->d_inode->i_mutex: don't care 140 140 + * d_inode(dentry)->i_mutex: don't care 141 141 */ 142 142 ssize_t 143 143 ext3_listxattr(struct dentry *dentry, char *buffer, size_t size) ··· 355 355 static int 356 356 ext3_xattr_block_list(struct dentry *dentry, char *buffer, size_t buffer_size) 357 357 { 358 358 - struct inode *inode = dentry->d_inode; 358 358 + struct inode *inode = d_inode(dentry); 359 359 struct buffer_head *bh = NULL; 360 360 int error; 361 361 ··· 391 391 static int 392 392 ext3_xattr_ibody_list(struct dentry *dentry, char *buffer, size_t buffer_size) 393 393 { 394 394 - struct inode *inode = dentry->d_inode; 394 394 + struct inode *inode = d_inode(dentry); 395 395 struct ext3_xattr_ibody_header *header; 396 396 struct ext3_inode *raw_inode; 397 397 struct ext3_iloc iloc; ··· 432 432 { 433 433 int i_error, b_error; 434 434 435 435 - down_read(&EXT3_I(dentry->d_inode)->xattr_sem); 435 435 + down_read(&EXT3_I(d_inode(dentry))->xattr_sem); 436 436 i_error = ext3_xattr_ibody_list(dentry, buffer, buffer_size); 437 437 if (i_error < 0) { 438 438 b_error = 0; ··· 445 445 if (b_error < 0) 446 446 i_error = 0; 447 447 } 448 448 - up_read(&EXT3_I(dentry->d_inode)->xattr_sem); 448 448 + up_read(&EXT3_I(d_inode(dentry))->xattr_sem); 449 449 return i_error + b_error; 450 450 } 451 451

+2 -2

fs/ext3/xattr_security.c

reviewed

··· 29 29 { 30 30 if (strcmp(name, "") == 0) 31 31 return -EINVAL; 32 32 - return ext3_xattr_get(dentry->d_inode, EXT3_XATTR_INDEX_SECURITY, 32 32 + return ext3_xattr_get(d_inode(dentry), EXT3_XATTR_INDEX_SECURITY, 33 33 name, buffer, size); 34 34 } 35 35 ··· 39 39 { 40 40 if (strcmp(name, "") == 0) 41 41 return -EINVAL; 42 42 - return ext3_xattr_set(dentry->d_inode, EXT3_XATTR_INDEX_SECURITY, 42 42 + return ext3_xattr_set(d_inode(dentry), EXT3_XATTR_INDEX_SECURITY, 43 43 name, value, size, flags); 44 44 } 45 45

+2 -2

fs/ext3/xattr_trusted.c

reviewed

··· 32 32 { 33 33 if (strcmp(name, "") == 0) 34 34 return -EINVAL; 35 35 - return ext3_xattr_get(dentry->d_inode, EXT3_XATTR_INDEX_TRUSTED, 35 35 + return ext3_xattr_get(d_inode(dentry), EXT3_XATTR_INDEX_TRUSTED, 36 36 name, buffer, size); 37 37 } 38 38 ··· 42 42 { 43 43 if (strcmp(name, "") == 0) 44 44 return -EINVAL; 45 45 - return ext3_xattr_set(dentry->d_inode, EXT3_XATTR_INDEX_TRUSTED, name, 45 45 + return ext3_xattr_set(d_inode(dentry), EXT3_XATTR_INDEX_TRUSTED, name, 46 46 value, size, flags); 47 47 } 48 48

+2 -2

fs/ext3/xattr_user.c

reviewed

··· 34 34 return -EINVAL; 35 35 if (!test_opt(dentry->d_sb, XATTR_USER)) 36 36 return -EOPNOTSUPP; 37 37 - return ext3_xattr_get(dentry->d_inode, EXT3_XATTR_INDEX_USER, 37 37 + return ext3_xattr_get(d_inode(dentry), EXT3_XATTR_INDEX_USER, 38 38 name, buffer, size); 39 39 } 40 40 ··· 46 46 return -EINVAL; 47 47 if (!test_opt(dentry->d_sb, XATTR_USER)) 48 48 return -EOPNOTSUPP; 49 49 - return ext3_xattr_set(dentry->d_inode, EXT3_XATTR_INDEX_USER, 49 49 + return ext3_xattr_set(d_inode(dentry), EXT3_XATTR_INDEX_USER, 50 50 name, value, size, flags); 51 51 } 52 52

+1 -1

fs/ext4/fsync.c

reviewed

··· 55 55 dentry = d_find_any_alias(inode); 56 56 if (!dentry) 57 57 break; 58 58 - next = igrab(dentry->d_parent->d_inode); 58 58 + next = igrab(d_inode(dentry->d_parent)); 59 59 dput(dentry); 60 60 if (!next) 61 61 break;

+1 -1

fs/ext4/ialloc.c

reviewed

··· 443 443 ndirs = percpu_counter_read_positive(&sbi->s_dirs_counter); 444 444 445 445 if (S_ISDIR(mode) && 446 446 - ((parent == sb->s_root->d_inode) || 446 446 + ((parent == d_inode(sb->s_root)) || 447 447 (ext4_test_inode_flag(parent, EXT4_INODE_TOPDIR)))) { 448 448 int best_ndir = inodes_per_group; 449 449 int ret = -1;

+3 -3

fs/ext4/indirect.c

reviewed

··· 682 682 * via ext4_inode_block_unlocked_dio(). Check inode's state 683 683 * while holding extra i_dio_count ref. 684 684 */ 685 685 - atomic_inc(&inode->i_dio_count); 685 685 + inode_dio_begin(inode); 686 686 smp_mb(); 687 687 if (unlikely(ext4_test_inode_state(inode, 688 688 EXT4_STATE_DIOREAD_LOCK))) { 689 689 - inode_dio_done(inode); 689 689 + inode_dio_end(inode); 690 690 goto locked; 691 691 } 692 692 if (IS_DAX(inode)) ··· 697 697 inode->i_sb->s_bdev, iter, 698 698 offset, ext4_get_block, NULL, 699 699 NULL, 0); 700 700 - inode_dio_done(inode); 700 700 + inode_dio_end(inode); 701 701 } else { 702 702 locked: 703 703 if (IS_DAX(inode))

+2 -2

fs/ext4/inline.c

reviewed

··· 1000 1000 struct ext4_iloc *iloc, 1001 1001 void *inline_start, int inline_size) 1002 1002 { 1003 1003 - struct inode *dir = dentry->d_parent->d_inode; 1003 1003 + struct inode *dir = d_inode(dentry->d_parent); 1004 1004 const char *name = dentry->d_name.name; 1005 1005 int namelen = dentry->d_name.len; 1006 1006 int err; ··· 1254 1254 int ret, inline_size; 1255 1255 void *inline_start; 1256 1256 struct ext4_iloc iloc; 1257 1257 - struct inode *dir = dentry->d_parent->d_inode; 1257 1257 + struct inode *dir = d_inode(dentry->d_parent); 1258 1258 1259 1259 ret = ext4_get_inode_loc(dir, &iloc); 1260 1260 if (ret)

+4 -4

fs/ext4/inode.c

reviewed

··· 3077 3077 * overwrite DIO as i_dio_count needs to be incremented under i_mutex. 3078 3078 */ 3079 3079 if (iov_iter_rw(iter) == WRITE) 3080 3080 - atomic_inc(&inode->i_dio_count); 3080 3080 + inode_dio_begin(inode); 3081 3081 3082 3082 /* If we do a overwrite dio, i_mutex locking can be released */ 3083 3083 overwrite = *((int *)iocb->private); ··· 3182 3182 3183 3183 retake_lock: 3184 3184 if (iov_iter_rw(iter) == WRITE) 3185 3185 - inode_dio_done(inode); 3185 3185 + inode_dio_end(inode); 3186 3186 /* take i_mutex locking again if we do a ovewrite dio */ 3187 3187 if (overwrite) { 3188 3188 up_read(&EXT4_I(inode)->i_data_sem); ··· 4637 4637 */ 4638 4638 int ext4_setattr(struct dentry *dentry, struct iattr *attr) 4639 4639 { 4640 4640 - struct inode *inode = dentry->d_inode; 4640 4640 + struct inode *inode = d_inode(dentry); 4641 4641 int error, rc = 0; 4642 4642 int orphan = 0; 4643 4643 const unsigned int ia_valid = attr->ia_valid; ··· 4785 4785 struct inode *inode; 4786 4786 unsigned long long delalloc_blocks; 4787 4787 4788 4788 - inode = dentry->d_inode; 4788 4788 + inode = d_inode(dentry); 4789 4789 generic_fillattr(inode, stat); 4790 4790 4791 4791 /*

+1 -1

fs/ext4/migrate.c

reviewed

··· 475 475 EXT4_INODES_PER_GROUP(inode->i_sb)) + 1; 476 476 owner[0] = i_uid_read(inode); 477 477 owner[1] = i_gid_read(inode); 478 478 - tmp_inode = ext4_new_inode(handle, inode->i_sb->s_root->d_inode, 478 478 + tmp_inode = ext4_new_inode(handle, d_inode(inode->i_sb->s_root), 479 479 S_IFREG, NULL, goal, owner); 480 480 if (IS_ERR(tmp_inode)) { 481 481 retval = PTR_ERR(tmp_inode);

+17 -17

fs/ext4/namei.c

reviewed

··· 1664 1664 struct ext4_dir_entry_2 * de; 1665 1665 struct buffer_head *bh; 1666 1666 1667 1667 - bh = ext4_find_entry(child->d_inode, &dotdot, &de, NULL); 1667 1667 + bh = ext4_find_entry(d_inode(child), &dotdot, &de, NULL); 1668 1668 if (IS_ERR(bh)) 1669 1669 return (struct dentry *) bh; 1670 1670 if (!bh) ··· 1672 1672 ino = le32_to_cpu(de->inode); 1673 1673 brelse(bh); 1674 1674 1675 1675 - if (!ext4_valid_inum(child->d_inode->i_sb, ino)) { 1676 1676 - EXT4_ERROR_INODE(child->d_inode, 1675 1675 + if (!ext4_valid_inum(d_inode(child)->i_sb, ino)) { 1676 1676 + EXT4_ERROR_INODE(d_inode(child), 1677 1677 "bad parent inode number: %u", ino); 1678 1678 return ERR_PTR(-EIO); 1679 1679 } 1680 1680 1681 1681 - return d_obtain_alias(ext4_iget_normal(child->d_inode->i_sb, ino)); 1681 1681 + return d_obtain_alias(ext4_iget_normal(d_inode(child)->i_sb, ino)); 1682 1682 } 1683 1683 1684 1684 /* ··· 1988 1988 struct inode *inode, struct ext4_dir_entry_2 *de, 1989 1989 struct buffer_head *bh) 1990 1990 { 1991 1991 - struct inode *dir = dentry->d_parent->d_inode; 1991 1991 + struct inode *dir = d_inode(dentry->d_parent); 1992 1992 const char *name = dentry->d_name.name; 1993 1993 int namelen = dentry->d_name.len; 1994 1994 unsigned int blocksize = dir->i_sb->s_blocksize; ··· 2048 2048 static int make_indexed_dir(handle_t *handle, struct dentry *dentry, 2049 2049 struct inode *inode, struct buffer_head *bh) 2050 2050 { 2051 2051 - struct inode *dir = dentry->d_parent->d_inode; 2051 2051 + struct inode *dir = d_inode(dentry->d_parent); 2052 2052 #ifdef CONFIG_EXT4_FS_ENCRYPTION 2053 2053 struct ext4_fname_crypto_ctx *ctx = NULL; 2054 2054 int res; ··· 2202 2202 static int ext4_add_entry(handle_t *handle, struct dentry *dentry, 2203 2203 struct inode *inode) 2204 2204 { 2205 2205 - struct inode *dir = dentry->d_parent->d_inode; 2205 2205 + struct inode *dir = d_inode(dentry->d_parent); 2206 2206 struct buffer_head *bh = NULL; 2207 2207 struct ext4_dir_entry_2 *de; 2208 2208 struct ext4_dir_entry_tail *t; ··· 2287 2287 struct dx_entry *entries, *at; 2288 2288 struct dx_hash_info hinfo; 2289 2289 struct buffer_head *bh; 2290 2290 - struct inode *dir = dentry->d_parent->d_inode; 2290 2290 + struct inode *dir = d_inode(dentry->d_parent); 2291 2291 struct super_block *sb = dir->i_sb; 2292 2292 struct ext4_dir_entry_2 *de; 2293 2293 int err; ··· 3063 3063 /* Initialize quotas before so that eventual writes go in 3064 3064 * separate transaction */ 3065 3065 dquot_initialize(dir); 3066 3066 - dquot_initialize(dentry->d_inode); 3066 3066 + dquot_initialize(d_inode(dentry)); 3067 3067 3068 3068 retval = -ENOENT; 3069 3069 bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL); ··· 3072 3072 if (!bh) 3073 3073 goto end_rmdir; 3074 3074 3075 3075 - inode = dentry->d_inode; 3075 3075 + inode = d_inode(dentry); 3076 3076 3077 3077 retval = -EIO; 3078 3078 if (le32_to_cpu(de->inode) != inode->i_ino) ··· 3132 3132 /* Initialize quotas before so that eventual writes go 3133 3133 * in separate transaction */ 3134 3134 dquot_initialize(dir); 3135 3135 - dquot_initialize(dentry->d_inode); 3135 3135 + dquot_initialize(d_inode(dentry)); 3136 3136 3137 3137 retval = -ENOENT; 3138 3138 bh = ext4_find_entry(dir, &dentry->d_name, &de, NULL); ··· 3141 3141 if (!bh) 3142 3142 goto end_unlink; 3143 3143 3144 3144 - inode = dentry->d_inode; 3144 3144 + inode = d_inode(dentry); 3145 3145 3146 3146 retval = -EIO; 3147 3147 if (le32_to_cpu(de->inode) != inode->i_ino) ··· 3339 3339 struct inode *dir, struct dentry *dentry) 3340 3340 { 3341 3341 handle_t *handle; 3342 3342 - struct inode *inode = old_dentry->d_inode; 3342 3342 + struct inode *inode = d_inode(old_dentry); 3343 3343 int err, retries = 0; 3344 3344 3345 3345 if (inode->i_nlink >= EXT4_LINK_MAX) ··· 3613 3613 struct ext4_renament old = { 3614 3614 .dir = old_dir, 3615 3615 .dentry = old_dentry, 3616 3616 - .inode = old_dentry->d_inode, 3616 3616 + .inode = d_inode(old_dentry), 3617 3617 }; 3618 3618 struct ext4_renament new = { 3619 3619 .dir = new_dir, 3620 3620 .dentry = new_dentry, 3621 3621 - .inode = new_dentry->d_inode, 3621 3621 + .inode = d_inode(new_dentry), 3622 3622 }; 3623 3623 int force_reread; 3624 3624 int retval; ··· 3809 3809 struct ext4_renament old = { 3810 3810 .dir = old_dir, 3811 3811 .dentry = old_dentry, 3812 3812 - .inode = old_dentry->d_inode, 3812 3812 + .inode = d_inode(old_dentry), 3813 3813 }; 3814 3814 struct ext4_renament new = { 3815 3815 .dir = new_dir, 3816 3816 .dentry = new_dentry, 3817 3817 - .inode = new_dentry->d_inode, 3817 3817 + .inode = d_inode(new_dentry), 3818 3818 }; 3819 3819 u8 new_file_type; 3820 3820 int retval;

+3 -3

fs/ext4/super.c

reviewed

··· 1556 1556 return -1; 1557 1557 } 1558 1558 1559 1559 - journal_inode = path.dentry->d_inode; 1559 1559 + journal_inode = d_inode(path.dentry); 1560 1560 if (!S_ISBLK(journal_inode->i_mode)) { 1561 1561 ext4_msg(sb, KERN_ERR, "error: journal path %s " 1562 1562 "is not a block device", journal_path); ··· 5217 5217 handle_t *handle; 5218 5218 5219 5219 /* Data block + inode block */ 5220 5220 - handle = ext4_journal_start(sb->s_root->d_inode, EXT4_HT_QUOTA, 2); 5220 5220 + handle = ext4_journal_start(d_inode(sb->s_root), EXT4_HT_QUOTA, 2); 5221 5221 if (IS_ERR(handle)) 5222 5222 return PTR_ERR(handle); 5223 5223 ret = dquot_commit_info(sb, type); ··· 5265 5265 * all updates to the file when we bypass pagecache... 5266 5266 */ 5267 5267 if (EXT4_SB(sb)->s_journal && 5268 5268 - ext4_should_journal_data(path->dentry->d_inode)) { 5268 5268 + ext4_should_journal_data(d_inode(path->dentry))) { 5269 5269 /* 5270 5270 * We don't need to lock updates but journal_flush() could 5271 5271 * otherwise be livelocked...

+4 -4

fs/ext4/symlink.c

reviewed

··· 28 28 struct page *cpage = NULL; 29 29 char *caddr, *paddr = NULL; 30 30 struct ext4_str cstr, pstr; 31 31 - struct inode *inode = dentry->d_inode; 31 31 + struct inode *inode = d_inode(dentry); 32 32 struct ext4_fname_crypto_ctx *ctx = NULL; 33 33 struct ext4_encrypted_symlink_data *sd; 34 34 loff_t size = min_t(loff_t, i_size_read(inode), PAGE_SIZE - 1); ··· 43 43 return ctx; 44 44 45 45 if (ext4_inode_is_fast_symlink(inode)) { 46 46 - caddr = (char *) EXT4_I(dentry->d_inode)->i_data; 47 47 - max_size = sizeof(EXT4_I(dentry->d_inode)->i_data); 46 46 + caddr = (char *) EXT4_I(inode)->i_data; 47 47 + max_size = sizeof(EXT4_I(inode)->i_data); 48 48 } else { 49 49 cpage = read_mapping_page(inode->i_mapping, 0, NULL); 50 50 if (IS_ERR(cpage)) { ··· 113 113 114 114 static void *ext4_follow_fast_link(struct dentry *dentry, struct nameidata *nd) 115 115 { 116 116 - struct ext4_inode_info *ei = EXT4_I(dentry->d_inode); 116 116 + struct ext4_inode_info *ei = EXT4_I(d_inode(dentry)); 117 117 nd_set_link(nd, (char *) ei->i_data); 118 118 return NULL; 119 119 }

+5 -5

fs/ext4/xattr.c

reviewed

··· 178 178 /* 179 179 * Inode operation listxattr() 180 180 * 181 181 - * dentry->d_inode->i_mutex: don't care 181 181 + * d_inode(dentry)->i_mutex: don't care 182 182 */ 183 183 ssize_t 184 184 ext4_listxattr(struct dentry *dentry, char *buffer, size_t size) ··· 423 423 static int 424 424 ext4_xattr_block_list(struct dentry *dentry, char *buffer, size_t buffer_size) 425 425 { 426 426 - struct inode *inode = dentry->d_inode; 426 426 + struct inode *inode = d_inode(dentry); 427 427 struct buffer_head *bh = NULL; 428 428 int error; 429 429 struct mb_cache *ext4_mb_cache = EXT4_GET_MB_CACHE(inode); ··· 460 460 static int 461 461 ext4_xattr_ibody_list(struct dentry *dentry, char *buffer, size_t buffer_size) 462 462 { 463 463 - struct inode *inode = dentry->d_inode; 463 463 + struct inode *inode = d_inode(dentry); 464 464 struct ext4_xattr_ibody_header *header; 465 465 struct ext4_inode *raw_inode; 466 466 struct ext4_iloc iloc; ··· 501 501 { 502 502 int ret, ret2; 503 503 504 504 - down_read(&EXT4_I(dentry->d_inode)->xattr_sem); 504 504 + down_read(&EXT4_I(d_inode(dentry))->xattr_sem); 505 505 ret = ret2 = ext4_xattr_ibody_list(dentry, buffer, buffer_size); 506 506 if (ret < 0) 507 507 goto errout; ··· 514 514 goto errout; 515 515 ret += ret2; 516 516 errout: 517 517 - up_read(&EXT4_I(dentry->d_inode)->xattr_sem); 517 517 + up_read(&EXT4_I(d_inode(dentry))->xattr_sem); 518 518 return ret; 519 519 } 520 520

+2 -2

fs/ext4/xattr_security.c

reviewed

··· 33 33 { 34 34 if (strcmp(name, "") == 0) 35 35 return -EINVAL; 36 36 - return ext4_xattr_get(dentry->d_inode, EXT4_XATTR_INDEX_SECURITY, 36 36 + return ext4_xattr_get(d_inode(dentry), EXT4_XATTR_INDEX_SECURITY, 37 37 name, buffer, size); 38 38 } 39 39 ··· 43 43 { 44 44 if (strcmp(name, "") == 0) 45 45 return -EINVAL; 46 46 - return ext4_xattr_set(dentry->d_inode, EXT4_XATTR_INDEX_SECURITY, 46 46 + return ext4_xattr_set(d_inode(dentry), EXT4_XATTR_INDEX_SECURITY, 47 47 name, value, size, flags); 48 48 } 49 49

+2 -2

fs/ext4/xattr_trusted.c

reviewed

··· 36 36 { 37 37 if (strcmp(name, "") == 0) 38 38 return -EINVAL; 39 39 - return ext4_xattr_get(dentry->d_inode, EXT4_XATTR_INDEX_TRUSTED, 39 39 + return ext4_xattr_get(d_inode(dentry), EXT4_XATTR_INDEX_TRUSTED, 40 40 name, buffer, size); 41 41 } 42 42 ··· 46 46 { 47 47 if (strcmp(name, "") == 0) 48 48 return -EINVAL; 49 49 - return ext4_xattr_set(dentry->d_inode, EXT4_XATTR_INDEX_TRUSTED, 49 49 + return ext4_xattr_set(d_inode(dentry), EXT4_XATTR_INDEX_TRUSTED, 50 50 name, value, size, flags); 51 51 } 52 52

+2 -2

fs/ext4/xattr_user.c

reviewed

··· 37 37 return -EINVAL; 38 38 if (!test_opt(dentry->d_sb, XATTR_USER)) 39 39 return -EOPNOTSUPP; 40 40 - return ext4_xattr_get(dentry->d_inode, EXT4_XATTR_INDEX_USER, 40 40 + return ext4_xattr_get(d_inode(dentry), EXT4_XATTR_INDEX_USER, 41 41 name, buffer, size); 42 42 } 43 43 ··· 49 49 return -EINVAL; 50 50 if (!test_opt(dentry->d_sb, XATTR_USER)) 51 51 return -EOPNOTSUPP; 52 52 - return ext4_xattr_set(dentry->d_inode, EXT4_XATTR_INDEX_USER, 52 52 + return ext4_xattr_set(d_inode(dentry), EXT4_XATTR_INDEX_USER, 53 53 name, value, size, flags); 54 54 } 55 55

+1 -1

fs/f2fs/f2fs.h

reviewed

··· 1482 1482 1483 1483 static inline int f2fs_add_link(struct dentry *dentry, struct inode *inode) 1484 1484 { 1485 1485 - return __f2fs_add_link(dentry->d_parent->d_inode, &dentry->d_name, 1485 1485 + return __f2fs_add_link(d_inode(dentry->d_parent), &dentry->d_name, 1486 1486 inode, inode->i_ino, inode->i_mode); 1487 1487 } 1488 1488

+2 -2

fs/f2fs/file.c

reviewed

··· 574 574 int f2fs_getattr(struct vfsmount *mnt, 575 575 struct dentry *dentry, struct kstat *stat) 576 576 { 577 577 - struct inode *inode = dentry->d_inode; 577 577 + struct inode *inode = d_inode(dentry); 578 578 generic_fillattr(inode, stat); 579 579 stat->blocks <<= 3; 580 580 return 0; ··· 613 613 614 614 int f2fs_setattr(struct dentry *dentry, struct iattr *attr) 615 615 { 616 616 - struct inode *inode = dentry->d_inode; 616 616 + struct inode *inode = d_inode(dentry); 617 617 struct f2fs_inode_info *fi = F2FS_I(inode); 618 618 int err; 619 619

+9 -9

fs/f2fs/namei.c

reviewed

··· 151 151 static int f2fs_link(struct dentry *old_dentry, struct inode *dir, 152 152 struct dentry *dentry) 153 153 { 154 154 - struct inode *inode = old_dentry->d_inode; 154 154 + struct inode *inode = d_inode(old_dentry); 155 155 struct f2fs_sb_info *sbi = F2FS_I_SB(dir); 156 156 int err; 157 157 ··· 182 182 struct dentry *f2fs_get_parent(struct dentry *child) 183 183 { 184 184 struct qstr dotdot = QSTR_INIT("..", 2); 185 185 - unsigned long ino = f2fs_inode_by_name(child->d_inode, &dotdot); 185 185 + unsigned long ino = f2fs_inode_by_name(d_inode(child), &dotdot); 186 186 if (!ino) 187 187 return ERR_PTR(-ENOENT); 188 188 - return d_obtain_alias(f2fs_iget(child->d_inode->i_sb, ino)); 188 188 + return d_obtain_alias(f2fs_iget(d_inode(child)->i_sb, ino)); 189 189 } 190 190 191 191 static int __recover_dot_dentries(struct inode *dir, nid_t pino) ··· 263 263 static int f2fs_unlink(struct inode *dir, struct dentry *dentry) 264 264 { 265 265 struct f2fs_sb_info *sbi = F2FS_I_SB(dir); 266 266 - struct inode *inode = dentry->d_inode; 266 266 + struct inode *inode = d_inode(dentry); 267 267 struct f2fs_dir_entry *de; 268 268 struct page *page; 269 269 int err = -ENOENT; ··· 403 403 404 404 static int f2fs_rmdir(struct inode *dir, struct dentry *dentry) 405 405 { 406 406 - struct inode *inode = dentry->d_inode; 406 406 + struct inode *inode = d_inode(dentry); 407 407 if (f2fs_empty_dir(inode)) 408 408 return f2fs_unlink(dir, dentry); 409 409 return -ENOTEMPTY; ··· 451 451 struct inode *new_dir, struct dentry *new_dentry) 452 452 { 453 453 struct f2fs_sb_info *sbi = F2FS_I_SB(old_dir); 454 454 - struct inode *old_inode = old_dentry->d_inode; 455 455 - struct inode *new_inode = new_dentry->d_inode; 454 454 + struct inode *old_inode = d_inode(old_dentry); 455 455 + struct inode *new_inode = d_inode(new_dentry); 456 456 struct page *old_dir_page; 457 457 struct page *old_page, *new_page; 458 458 struct f2fs_dir_entry *old_dir_entry = NULL; ··· 578 578 struct inode *new_dir, struct dentry *new_dentry) 579 579 { 580 580 struct f2fs_sb_info *sbi = F2FS_I_SB(old_dir); 581 581 - struct inode *old_inode = old_dentry->d_inode; 582 582 - struct inode *new_inode = new_dentry->d_inode; 581 581 + struct inode *old_inode = d_inode(old_dentry); 582 582 + struct inode *new_inode = d_inode(new_dentry); 583 583 struct page *old_dir_page, *new_dir_page; 584 584 struct page *old_page, *new_page; 585 585 struct f2fs_dir_entry *old_dir_entry = NULL, *new_dir_entry = NULL;

+5 -5

fs/f2fs/xattr.c

reviewed

··· 83 83 } 84 84 if (strcmp(name, "") == 0) 85 85 return -EINVAL; 86 86 - return f2fs_getxattr(dentry->d_inode, type, name, buffer, size, NULL); 86 86 + return f2fs_getxattr(d_inode(dentry), type, name, buffer, size, NULL); 87 87 } 88 88 89 89 static int f2fs_xattr_generic_set(struct dentry *dentry, const char *name, ··· 108 108 if (strcmp(name, "") == 0) 109 109 return -EINVAL; 110 110 111 111 - return f2fs_setxattr(dentry->d_inode, type, name, 111 111 + return f2fs_setxattr(d_inode(dentry), type, name, 112 112 value, size, NULL, flags); 113 113 } 114 114 ··· 130 130 static int f2fs_xattr_advise_get(struct dentry *dentry, const char *name, 131 131 void *buffer, size_t size, int type) 132 132 { 133 133 - struct inode *inode = dentry->d_inode; 133 133 + struct inode *inode = d_inode(dentry); 134 134 135 135 if (strcmp(name, "") != 0) 136 136 return -EINVAL; ··· 143 143 static int f2fs_xattr_advise_set(struct dentry *dentry, const char *name, 144 144 const void *value, size_t size, int flags, int type) 145 145 { 146 146 - struct inode *inode = dentry->d_inode; 146 146 + struct inode *inode = d_inode(dentry); 147 147 148 148 if (strcmp(name, "") != 0) 149 149 return -EINVAL; ··· 444 444 445 445 ssize_t f2fs_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size) 446 446 { 447 447 - struct inode *inode = dentry->d_inode; 447 447 + struct inode *inode = d_inode(dentry); 448 448 struct f2fs_xattr_entry *entry; 449 449 void *base_addr; 450 450 int error = 0;

+2 -2

fs/fat/file.c

reviewed

··· 305 305 306 306 int fat_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) 307 307 { 308 308 - struct inode *inode = dentry->d_inode; 308 308 + struct inode *inode = d_inode(dentry); 309 309 generic_fillattr(inode, stat); 310 310 stat->blksize = MSDOS_SB(inode->i_sb)->cluster_size; 311 311 ··· 377 377 int fat_setattr(struct dentry *dentry, struct iattr *attr) 378 378 { 379 379 struct msdos_sb_info *sbi = MSDOS_SB(dentry->d_sb); 380 380 - struct inode *inode = dentry->d_inode; 380 380 + struct inode *inode = d_inode(dentry); 381 381 unsigned int ia_valid; 382 382 int error; 383 383

+4 -4

fs/fat/namei_msdos.c

reviewed

··· 308 308 static int msdos_rmdir(struct inode *dir, struct dentry *dentry) 309 309 { 310 310 struct super_block *sb = dir->i_sb; 311 311 - struct inode *inode = dentry->d_inode; 311 311 + struct inode *inode = d_inode(dentry); 312 312 struct fat_slot_info sinfo; 313 313 int err; 314 314 ··· 402 402 /***** Unlink a file */ 403 403 static int msdos_unlink(struct inode *dir, struct dentry *dentry) 404 404 { 405 405 - struct inode *inode = dentry->d_inode; 405 405 + struct inode *inode = d_inode(dentry); 406 406 struct super_block *sb = inode->i_sb; 407 407 struct fat_slot_info sinfo; 408 408 int err; ··· 440 440 int err, old_attrs, is_dir, update_dotdot, corrupt = 0; 441 441 442 442 old_sinfo.bh = sinfo.bh = dotdot_bh = NULL; 443 443 - old_inode = old_dentry->d_inode; 444 444 - new_inode = new_dentry->d_inode; 443 443 + old_inode = d_inode(old_dentry); 444 444 + new_inode = d_inode(new_dentry); 445 445 446 446 err = fat_scan(old_dir, old_name, &old_sinfo); 447 447 if (err) {

+7 -7

fs/fat/namei_vfat.c

reviewed

··· 33 33 { 34 34 int ret = 1; 35 35 spin_lock(&dentry->d_lock); 36 36 - if (dentry->d_time != dentry->d_parent->d_inode->i_version) 36 36 + if (dentry->d_time != d_inode(dentry->d_parent)->i_version) 37 37 ret = 0; 38 38 spin_unlock(&dentry->d_lock); 39 39 return ret; ··· 45 45 return -ECHILD; 46 46 47 47 /* This is not negative dentry. Always valid. */ 48 48 - if (dentry->d_inode) 48 48 + if (d_really_is_positive(dentry)) 49 49 return 1; 50 50 return vfat_revalidate_shortname(dentry); 51 51 } ··· 65 65 * positive dentry isn't good idea. So it's unsupported like 66 66 * rename("filename", "FILENAME") for now. 67 67 */ 68 68 - if (dentry->d_inode) 68 68 + if (d_really_is_positive(dentry)) 69 69 return 1; 70 70 71 71 /* ··· 801 801 802 802 static int vfat_rmdir(struct inode *dir, struct dentry *dentry) 803 803 { 804 804 - struct inode *inode = dentry->d_inode; 804 804 + struct inode *inode = d_inode(dentry); 805 805 struct super_block *sb = dir->i_sb; 806 806 struct fat_slot_info sinfo; 807 807 int err; ··· 832 832 833 833 static int vfat_unlink(struct inode *dir, struct dentry *dentry) 834 834 { 835 835 - struct inode *inode = dentry->d_inode; 835 835 + struct inode *inode = d_inode(dentry); 836 836 struct super_block *sb = dir->i_sb; 837 837 struct fat_slot_info sinfo; 838 838 int err; ··· 915 915 struct super_block *sb = old_dir->i_sb; 916 916 917 917 old_sinfo.bh = sinfo.bh = dotdot_bh = NULL; 918 918 - old_inode = old_dentry->d_inode; 919 919 - new_inode = new_dentry->d_inode; 918 918 + old_inode = d_inode(old_dentry); 919 919 + new_inode = d_inode(new_dentry); 920 920 mutex_lock(&MSDOS_SB(sb)->s_lock); 921 921 err = vfat_find(old_dir, &old_dentry->d_name, &old_sinfo); 922 922 if (err)

+2 -2

fs/fat/nfs.c

reviewed

··· 266 266 * Find the parent for a directory that is not currently connected to 267 267 * the filesystem root. 268 268 * 269 269 - * On entry, the caller holds child_dir->d_inode->i_mutex. 269 269 + * On entry, the caller holds d_inode(child_dir)->i_mutex. 270 270 */ 271 271 static struct dentry *fat_get_parent(struct dentry *child_dir) 272 272 { ··· 276 276 struct inode *parent_inode = NULL; 277 277 struct msdos_sb_info *sbi = MSDOS_SB(sb); 278 278 279 279 - if (!fat_get_dotdot_entry(child_dir->d_inode, &bh, &de)) { 279 279 + if (!fat_get_dotdot_entry(d_inode(child_dir), &bh, &de)) { 280 280 int parent_logstart = fat_get_start(sbi, de); 281 281 parent_inode = fat_dget(sb, parent_logstart); 282 282 if (!parent_inode && sbi->options.nfs == FAT_NFS_NOSTALE_RO)

+1 -1

fs/freevxfs/vxfs_immed.c

reviewed

··· 76 76 static void * 77 77 vxfs_immed_follow_link(struct dentry *dp, struct nameidata *np) 78 78 { 79 79 - struct vxfs_inode_info *vip = VXFS_INO(dp->d_inode); 79 79 + struct vxfs_inode_info *vip = VXFS_INO(d_inode(dp)); 80 80 nd_set_link(np, vip->vii_immed.vi_immed); 81 81 return NULL; 82 82 }

+3 -3

fs/fuse/control.c

reviewed

··· 244 244 return 0; 245 245 246 246 parent = fuse_control_sb->s_root; 247 247 - inc_nlink(parent->d_inode); 247 247 + inc_nlink(d_inode(parent)); 248 248 sprintf(name, "%u", fc->dev); 249 249 parent = fuse_ctl_add_dentry(parent, fc, name, S_IFDIR | 0500, 2, 250 250 &simple_dir_inode_operations, ··· 283 283 284 284 for (i = fc->ctl_ndents - 1; i >= 0; i--) { 285 285 struct dentry *dentry = fc->ctl_dentry[i]; 286 286 - dentry->d_inode->i_private = NULL; 286 286 + d_inode(dentry)->i_private = NULL; 287 287 d_drop(dentry); 288 288 dput(dentry); 289 289 } 290 290 - drop_nlink(fuse_control_sb->s_root->d_inode); 290 290 + drop_nlink(d_inode(fuse_control_sb->s_root)); 291 291 } 292 292 293 293 static int fuse_ctl_fill_super(struct super_block *sb, void *data, int silent)

+30 -30

fs/fuse/dir.c

reviewed

··· 192 192 struct fuse_inode *fi; 193 193 int ret; 194 194 195 195 - inode = ACCESS_ONCE(entry->d_inode); 195 195 + inode = d_inode_rcu(entry); 196 196 if (inode && is_bad_inode(inode)) 197 197 goto invalid; 198 198 else if (time_before64(fuse_dentry_time(entry), get_jiffies_64()) || ··· 220 220 attr_version = fuse_get_attr_version(fc); 221 221 222 222 parent = dget_parent(entry); 223 223 - fuse_lookup_init(fc, &args, get_node_id(parent->d_inode), 223 223 + fuse_lookup_init(fc, &args, get_node_id(d_inode(parent)), 224 224 &entry->d_name, &outarg); 225 225 ret = fuse_simple_request(fc, &args); 226 226 dput(parent); ··· 254 254 return -ECHILD; 255 255 } else if (test_and_clear_bit(FUSE_I_INIT_RDPLUS, &fi->state)) { 256 256 parent = dget_parent(entry); 257 257 - fuse_advise_use_readdirplus(parent->d_inode); 257 257 + fuse_advise_use_readdirplus(d_inode(parent)); 258 258 dput(parent); 259 259 } 260 260 } ··· 487 487 entry = res; 488 488 } 489 489 490 490 - if (!(flags & O_CREAT) || entry->d_inode) 490 490 + if (!(flags & O_CREAT) || d_really_is_positive(entry)) 491 491 goto no_open; 492 492 493 493 /* Only creates */ ··· 653 653 args.in.args[0].value = entry->d_name.name; 654 654 err = fuse_simple_request(fc, &args); 655 655 if (!err) { 656 656 - struct inode *inode = entry->d_inode; 656 656 + struct inode *inode = d_inode(entry); 657 657 struct fuse_inode *fi = get_fuse_inode(inode); 658 658 659 659 spin_lock(&fc->lock); ··· 689 689 args.in.args[0].value = entry->d_name.name; 690 690 err = fuse_simple_request(fc, &args); 691 691 if (!err) { 692 692 - clear_nlink(entry->d_inode); 692 692 + clear_nlink(d_inode(entry)); 693 693 fuse_invalidate_attr(dir); 694 694 fuse_invalidate_entry_cache(entry); 695 695 } else if (err == -EINTR) ··· 721 721 err = fuse_simple_request(fc, &args); 722 722 if (!err) { 723 723 /* ctime changes */ 724 724 - fuse_invalidate_attr(oldent->d_inode); 725 725 - fuse_update_ctime(oldent->d_inode); 724 724 + fuse_invalidate_attr(d_inode(oldent)); 725 725 + fuse_update_ctime(d_inode(oldent)); 726 726 727 727 if (flags & RENAME_EXCHANGE) { 728 728 - fuse_invalidate_attr(newent->d_inode); 729 729 - fuse_update_ctime(newent->d_inode); 728 728 + fuse_invalidate_attr(d_inode(newent)); 729 729 + fuse_update_ctime(d_inode(newent)); 730 730 } 731 731 732 732 fuse_invalidate_attr(olddir); ··· 734 734 fuse_invalidate_attr(newdir); 735 735 736 736 /* newent will end up negative */ 737 737 - if (!(flags & RENAME_EXCHANGE) && newent->d_inode) { 738 738 - fuse_invalidate_attr(newent->d_inode); 737 737 + if (!(flags & RENAME_EXCHANGE) && d_really_is_positive(newent)) { 738 738 + fuse_invalidate_attr(d_inode(newent)); 739 739 fuse_invalidate_entry_cache(newent); 740 740 - fuse_update_ctime(newent->d_inode); 740 740 + fuse_update_ctime(d_inode(newent)); 741 741 } 742 742 } else if (err == -EINTR) { 743 743 /* If request was interrupted, DEITY only knows if the ··· 746 746 directory), then there can be inconsistency between 747 747 the dcache and the real filesystem. Tough luck. */ 748 748 fuse_invalidate_entry(oldent); 749 749 - if (newent->d_inode) 749 749 + if (d_really_is_positive(newent)) 750 750 fuse_invalidate_entry(newent); 751 751 } 752 752 ··· 788 788 { 789 789 int err; 790 790 struct fuse_link_in inarg; 791 791 - struct inode *inode = entry->d_inode; 791 791 + struct inode *inode = d_inode(entry); 792 792 struct fuse_conn *fc = get_fuse_conn(inode); 793 793 FUSE_ARGS(args); 794 794 ··· 961 961 fuse_invalidate_attr(parent); 962 962 fuse_invalidate_entry(entry); 963 963 964 964 - if (child_nodeid != 0 && entry->d_inode) { 965 965 - mutex_lock(&entry->d_inode->i_mutex); 966 966 - if (get_node_id(entry->d_inode) != child_nodeid) { 964 964 + if (child_nodeid != 0 && d_really_is_positive(entry)) { 965 965 + mutex_lock(&d_inode(entry)->i_mutex); 966 966 + if (get_node_id(d_inode(entry)) != child_nodeid) { 967 967 err = -ENOENT; 968 968 goto badentry; 969 969 } ··· 977 977 err = -ENOTEMPTY; 978 978 goto badentry; 979 979 } 980 980 - entry->d_inode->i_flags |= S_DEAD; 980 980 + d_inode(entry)->i_flags |= S_DEAD; 981 981 } 982 982 dont_mount(entry); 983 983 - clear_nlink(entry->d_inode); 983 983 + clear_nlink(d_inode(entry)); 984 984 err = 0; 985 985 badentry: 986 986 - mutex_unlock(&entry->d_inode->i_mutex); 986 986 + mutex_unlock(&d_inode(entry)->i_mutex); 987 987 if (!err) 988 988 d_delete(entry); 989 989 } else { ··· 1169 1169 struct qstr name = QSTR_INIT(dirent->name, dirent->namelen); 1170 1170 struct dentry *dentry; 1171 1171 struct dentry *alias; 1172 1172 - struct inode *dir = parent->d_inode; 1172 1172 + struct inode *dir = d_inode(parent); 1173 1173 struct fuse_conn *fc; 1174 1174 struct inode *inode; 1175 1175 ··· 1205 1205 name.hash = full_name_hash(name.name, name.len); 1206 1206 dentry = d_lookup(parent, &name); 1207 1207 if (dentry) { 1208 1208 - inode = dentry->d_inode; 1208 1208 + inode = d_inode(dentry); 1209 1209 if (!inode) { 1210 1210 d_drop(dentry); 1211 1211 } else if (get_node_id(inode) != o->nodeid || ··· 1367 1367 1368 1368 static char *read_link(struct dentry *dentry) 1369 1369 { 1370 1370 - struct inode *inode = dentry->d_inode; 1370 1370 + struct inode *inode = d_inode(dentry); 1371 1371 struct fuse_conn *fc = get_fuse_conn(inode); 1372 1372 FUSE_ARGS(args); 1373 1373 char *link; ··· 1712 1712 1713 1713 static int fuse_setattr(struct dentry *entry, struct iattr *attr) 1714 1714 { 1715 1715 - struct inode *inode = entry->d_inode; 1715 1715 + struct inode *inode = d_inode(entry); 1716 1716 1717 1717 if (!fuse_allow_current_process(get_fuse_conn(inode))) 1718 1718 return -EACCES; ··· 1726 1726 static int fuse_getattr(struct vfsmount *mnt, struct dentry *entry, 1727 1727 struct kstat *stat) 1728 1728 { 1729 1729 - struct inode *inode = entry->d_inode; 1729 1729 + struct inode *inode = d_inode(entry); 1730 1730 struct fuse_conn *fc = get_fuse_conn(inode); 1731 1731 1732 1732 if (!fuse_allow_current_process(fc)) ··· 1738 1738 static int fuse_setxattr(struct dentry *entry, const char *name, 1739 1739 const void *value, size_t size, int flags) 1740 1740 { 1741 1741 - struct inode *inode = entry->d_inode; 1741 1741 + struct inode *inode = d_inode(entry); 1742 1742 struct fuse_conn *fc = get_fuse_conn(inode); 1743 1743 FUSE_ARGS(args); 1744 1744 struct fuse_setxattr_in inarg; ··· 1774 1774 static ssize_t fuse_getxattr(struct dentry *entry, const char *name, 1775 1775 void *value, size_t size) 1776 1776 { 1777 1777 - struct inode *inode = entry->d_inode; 1777 1777 + struct inode *inode = d_inode(entry); 1778 1778 struct fuse_conn *fc = get_fuse_conn(inode); 1779 1779 FUSE_ARGS(args); 1780 1780 struct fuse_getxattr_in inarg; ··· 1815 1815 1816 1816 static ssize_t fuse_listxattr(struct dentry *entry, char *list, size_t size) 1817 1817 { 1818 1818 - struct inode *inode = entry->d_inode; 1818 1818 + struct inode *inode = d_inode(entry); 1819 1819 struct fuse_conn *fc = get_fuse_conn(inode); 1820 1820 FUSE_ARGS(args); 1821 1821 struct fuse_getxattr_in inarg; ··· 1857 1857 1858 1858 static int fuse_removexattr(struct dentry *entry, const char *name) 1859 1859 { 1860 1860 - struct inode *inode = entry->d_inode; 1860 1860 + struct inode *inode = d_inode(entry); 1861 1861 struct fuse_conn *fc = get_fuse_conn(inode); 1862 1862 FUSE_ARGS(args); 1863 1863 int err;

+2 -2

fs/fuse/inode.c

reviewed

··· 421 421 memset(&outarg, 0, sizeof(outarg)); 422 422 args.in.numargs = 0; 423 423 args.in.h.opcode = FUSE_STATFS; 424 424 - args.in.h.nodeid = get_node_id(dentry->d_inode); 424 424 + args.in.h.nodeid = get_node_id(d_inode(dentry)); 425 425 args.out.numargs = 1; 426 426 args.out.args[0].size = sizeof(outarg); 427 427 args.out.args[0].value = &outarg; ··· 740 740 741 741 static struct dentry *fuse_get_parent(struct dentry *child) 742 742 { 743 743 - struct inode *child_inode = child->d_inode; 743 743 + struct inode *child_inode = d_inode(child); 744 744 struct fuse_conn *fc = get_fuse_conn(child_inode); 745 745 struct inode *inode; 746 746 struct dentry *parent;

+6 -6

fs/gfs2/dentry.c

reviewed

··· 48 48 return -ECHILD; 49 49 50 50 parent = dget_parent(dentry); 51 51 - sdp = GFS2_SB(parent->d_inode); 52 52 - dip = GFS2_I(parent->d_inode); 53 53 - inode = dentry->d_inode; 51 51 + sdp = GFS2_SB(d_inode(parent)); 52 52 + dip = GFS2_I(d_inode(parent)); 53 53 + inode = d_inode(dentry); 54 54 55 55 if (inode) { 56 56 if (is_bad_inode(inode)) ··· 68 68 goto fail; 69 69 } 70 70 71 71 - error = gfs2_dir_check(parent->d_inode, &dentry->d_name, ip); 71 71 + error = gfs2_dir_check(d_inode(parent), &dentry->d_name, ip); 72 72 switch (error) { 73 73 case 0: 74 74 if (!inode) ··· 113 113 { 114 114 struct gfs2_inode *ginode; 115 115 116 116 - if (!dentry->d_inode) 116 116 + if (d_really_is_negative(dentry)) 117 117 return 0; 118 118 119 119 - ginode = GFS2_I(dentry->d_inode); 119 119 + ginode = GFS2_I(d_inode(dentry)); 120 120 if (!ginode->i_iopen_gh.gh_gl) 121 121 return 0; 122 122

+4 -4

fs/gfs2/export.c

reviewed

··· 49 49 fh[3] = cpu_to_be32(ip->i_no_addr & 0xFFFFFFFF); 50 50 *len = GFS2_SMALL_FH_SIZE; 51 51 52 52 - if (!parent || inode == sb->s_root->d_inode) 52 52 + if (!parent || inode == d_inode(sb->s_root)) 53 53 return *len; 54 54 55 55 ip = GFS2_I(parent); ··· 88 88 static int gfs2_get_name(struct dentry *parent, char *name, 89 89 struct dentry *child) 90 90 { 91 91 - struct inode *dir = parent->d_inode; 92 92 - struct inode *inode = child->d_inode; 91 91 + struct inode *dir = d_inode(parent); 92 92 + struct inode *inode = d_inode(child); 93 93 struct gfs2_inode *dip, *ip; 94 94 struct get_name_filldir gnfd = { 95 95 .ctx.actor = get_name_filldir, ··· 128 128 129 129 static struct dentry *gfs2_get_parent(struct dentry *child) 130 130 { 131 131 - return d_obtain_alias(gfs2_lookupi(child->d_inode, &gfs2_qdotdot, 1)); 131 131 + return d_obtain_alias(gfs2_lookupi(d_inode(child), &gfs2_qdotdot, 1)); 132 132 } 133 133 134 134 static struct dentry *gfs2_get_dentry(struct super_block *sb,

+17 -17

fs/gfs2/inode.c

reviewed

··· 295 295 296 296 if ((name->len == 1 && memcmp(name->name, ".", 1) == 0) || 297 297 (name->len == 2 && memcmp(name->name, "..", 2) == 0 && 298 298 - dir == sb->s_root->d_inode)) { 298 298 + dir == d_inode(sb->s_root))) { 299 299 igrab(dir); 300 300 return dir; 301 301 } ··· 687 687 } 688 688 gfs2_set_inode_flags(inode); 689 689 690 690 - if ((GFS2_I(sdp->sd_root_dir->d_inode) == dip) || 690 690 + if ((GFS2_I(d_inode(sdp->sd_root_dir)) == dip) || 691 691 (dip->i_diskflags & GFS2_DIF_TOPDIR)) 692 692 aflags |= GFS2_AF_ORLOV; 693 693 ··· 888 888 { 889 889 struct gfs2_inode *dip = GFS2_I(dir); 890 890 struct gfs2_sbd *sdp = GFS2_SB(dir); 891 891 - struct inode *inode = old_dentry->d_inode; 891 891 + struct inode *inode = d_inode(old_dentry); 892 892 struct gfs2_inode *ip = GFS2_I(inode); 893 893 struct gfs2_holder ghs[2]; 894 894 struct buffer_head *dibh; ··· 1055 1055 static int gfs2_unlink_inode(struct gfs2_inode *dip, 1056 1056 const struct dentry *dentry) 1057 1057 { 1058 1058 - struct inode *inode = dentry->d_inode; 1058 1058 + struct inode *inode = d_inode(dentry); 1059 1059 struct gfs2_inode *ip = GFS2_I(inode); 1060 1060 int error; 1061 1061 ··· 1091 1091 { 1092 1092 struct gfs2_inode *dip = GFS2_I(dir); 1093 1093 struct gfs2_sbd *sdp = GFS2_SB(dir); 1094 1094 - struct inode *inode = dentry->d_inode; 1094 1094 + struct inode *inode = d_inode(dentry); 1095 1095 struct gfs2_inode *ip = GFS2_I(inode); 1096 1096 struct gfs2_holder ghs[3]; 1097 1097 struct gfs2_rgrpd *rgd; ··· 1241 1241 return PTR_ERR(d); 1242 1242 if (d != NULL) 1243 1243 dentry = d; 1244 1244 - if (dentry->d_inode) { 1244 1244 + if (d_really_is_positive(dentry)) { 1245 1245 if (!(*opened & FILE_OPENED)) 1246 1246 return finish_no_open(file, d); 1247 1247 dput(d); ··· 1282 1282 error = -EINVAL; 1283 1283 break; 1284 1284 } 1285 1285 - if (dir == sb->s_root->d_inode) { 1285 1285 + if (dir == d_inode(sb->s_root)) { 1286 1286 error = 0; 1287 1287 break; 1288 1288 } ··· 1321 1321 { 1322 1322 struct gfs2_inode *odip = GFS2_I(odir); 1323 1323 struct gfs2_inode *ndip = GFS2_I(ndir); 1324 1324 - struct gfs2_inode *ip = GFS2_I(odentry->d_inode); 1324 1324 + struct gfs2_inode *ip = GFS2_I(d_inode(odentry)); 1325 1325 struct gfs2_inode *nip = NULL; 1326 1326 struct gfs2_sbd *sdp = GFS2_SB(odir); 1327 1327 struct gfs2_holder ghs[5], r_gh = { .gh_gl = NULL, }; ··· 1332 1332 unsigned int x; 1333 1333 int error; 1334 1334 1335 1335 - if (ndentry->d_inode) { 1336 1336 - nip = GFS2_I(ndentry->d_inode); 1335 1335 + if (d_really_is_positive(ndentry)) { 1336 1336 + nip = GFS2_I(d_inode(ndentry)); 1337 1337 if (ip == nip) 1338 1338 return 0; 1339 1339 } ··· 1457 1457 /* Check out the dir to be renamed */ 1458 1458 1459 1459 if (dir_rename) { 1460 1460 - error = gfs2_permission(odentry->d_inode, MAY_WRITE); 1460 1460 + error = gfs2_permission(d_inode(odentry), MAY_WRITE); 1461 1461 if (error) 1462 1462 goto out_gunlock; 1463 1463 } ··· 1550 1550 1551 1551 static void *gfs2_follow_link(struct dentry *dentry, struct nameidata *nd) 1552 1552 { 1553 1553 - struct gfs2_inode *ip = GFS2_I(dentry->d_inode); 1553 1553 + struct gfs2_inode *ip = GFS2_I(d_inode(dentry)); 1554 1554 struct gfs2_holder i_gh; 1555 1555 struct buffer_head *dibh; 1556 1556 unsigned int size; ··· 1742 1742 1743 1743 static int gfs2_setattr(struct dentry *dentry, struct iattr *attr) 1744 1744 { 1745 1745 - struct inode *inode = dentry->d_inode; 1745 1745 + struct inode *inode = d_inode(dentry); 1746 1746 struct gfs2_inode *ip = GFS2_I(inode); 1747 1747 struct gfs2_holder i_gh; 1748 1748 int error; ··· 1798 1798 static int gfs2_getattr(struct vfsmount *mnt, struct dentry *dentry, 1799 1799 struct kstat *stat) 1800 1800 { 1801 1801 - struct inode *inode = dentry->d_inode; 1801 1801 + struct inode *inode = d_inode(dentry); 1802 1802 struct gfs2_inode *ip = GFS2_I(inode); 1803 1803 struct gfs2_holder gh; 1804 1804 int error; ··· 1821 1821 static int gfs2_setxattr(struct dentry *dentry, const char *name, 1822 1822 const void *data, size_t size, int flags) 1823 1823 { 1824 1824 - struct inode *inode = dentry->d_inode; 1824 1824 + struct inode *inode = d_inode(dentry); 1825 1825 struct gfs2_inode *ip = GFS2_I(inode); 1826 1826 struct gfs2_holder gh; 1827 1827 int ret; ··· 1841 1841 static ssize_t gfs2_getxattr(struct dentry *dentry, const char *name, 1842 1842 void *data, size_t size) 1843 1843 { 1844 1844 - struct inode *inode = dentry->d_inode; 1844 1844 + struct inode *inode = d_inode(dentry); 1845 1845 struct gfs2_inode *ip = GFS2_I(inode); 1846 1846 struct gfs2_holder gh; 1847 1847 int ret; ··· 1862 1862 1863 1863 static int gfs2_removexattr(struct dentry *dentry, const char *name) 1864 1864 { 1865 1865 - struct inode *inode = dentry->d_inode; 1865 1865 + struct inode *inode = d_inode(dentry); 1866 1866 struct gfs2_inode *ip = GFS2_I(inode); 1867 1867 struct gfs2_holder gh; 1868 1868 int ret;

+4 -4

fs/gfs2/ops_fstype.c

reviewed

··· 647 647 648 648 static int init_journal(struct gfs2_sbd *sdp, int undo) 649 649 { 650 650 - struct inode *master = sdp->sd_master_dir->d_inode; 650 650 + struct inode *master = d_inode(sdp->sd_master_dir); 651 651 struct gfs2_holder ji_gh; 652 652 struct gfs2_inode *ip; 653 653 int jindex = 1; ··· 782 782 static int init_inodes(struct gfs2_sbd *sdp, int undo) 783 783 { 784 784 int error = 0; 785 785 - struct inode *master = sdp->sd_master_dir->d_inode; 785 785 + struct inode *master = d_inode(sdp->sd_master_dir); 786 786 787 787 if (undo) 788 788 goto fail_qinode; ··· 848 848 char buf[30]; 849 849 int error = 0; 850 850 struct gfs2_inode *ip; 851 851 - struct inode *master = sdp->sd_master_dir->d_inode; 851 851 + struct inode *master = d_inode(sdp->sd_master_dir); 852 852 853 853 if (sdp->sd_args.ar_spectator) 854 854 return 0; ··· 1357 1357 return ERR_PTR(error); 1358 1358 } 1359 1359 s = sget(&gfs2_fs_type, test_gfs2_super, set_meta_super, flags, 1360 1360 - path.dentry->d_inode->i_sb->s_bdev); 1360 1360 + d_inode(path.dentry)->i_sb->s_bdev); 1361 1361 path_put(&path); 1362 1362 if (IS_ERR(s)) { 1363 1363 pr_warn("gfs2 mount does not exist\n");

+1 -1

fs/gfs2/super.c

reviewed

··· 1171 1171 1172 1172 static int gfs2_statfs(struct dentry *dentry, struct kstatfs *buf) 1173 1173 { 1174 1174 - struct super_block *sb = dentry->d_inode->i_sb; 1174 1174 + struct super_block *sb = d_inode(dentry)->i_sb; 1175 1175 struct gfs2_sbd *sdp = sb->s_fs_info; 1176 1176 struct gfs2_statfs_change_host sc; 1177 1177 int error;

+3 -3

fs/gfs2/xattr.c

reviewed

··· 420 420 421 421 ssize_t gfs2_listxattr(struct dentry *dentry, char *buffer, size_t size) 422 422 { 423 423 - struct gfs2_inode *ip = GFS2_I(dentry->d_inode); 423 423 + struct gfs2_inode *ip = GFS2_I(d_inode(dentry)); 424 424 struct gfs2_ea_request er; 425 425 struct gfs2_holder i_gh; 426 426 int error; ··· 586 586 static int gfs2_xattr_get(struct dentry *dentry, const char *name, 587 587 void *buffer, size_t size, int type) 588 588 { 589 589 - struct gfs2_inode *ip = GFS2_I(dentry->d_inode); 589 589 + struct gfs2_inode *ip = GFS2_I(d_inode(dentry)); 590 590 struct gfs2_ea_location el; 591 591 int error; 592 592 ··· 1230 1230 static int gfs2_xattr_set(struct dentry *dentry, const char *name, 1231 1231 const void *value, size_t size, int flags, int type) 1232 1232 { 1233 1233 - return __gfs2_xattr_set(dentry->d_inode, name, value, 1233 1233 + return __gfs2_xattr_set(d_inode(dentry), name, value, 1234 1234 size, flags, type); 1235 1235 } 1236 1236

+3 -3

fs/hfs/attr.c

reviewed

··· 16 16 int hfs_setxattr(struct dentry *dentry, const char *name, 17 17 const void *value, size_t size, int flags) 18 18 { 19 19 - struct inode *inode = dentry->d_inode; 19 19 + struct inode *inode = d_inode(dentry); 20 20 struct hfs_find_data fd; 21 21 hfs_cat_rec rec; 22 22 struct hfs_cat_file *file; ··· 59 59 ssize_t hfs_getxattr(struct dentry *dentry, const char *name, 60 60 void *value, size_t size) 61 61 { 62 62 - struct inode *inode = dentry->d_inode; 62 62 + struct inode *inode = d_inode(dentry); 63 63 struct hfs_find_data fd; 64 64 hfs_cat_rec rec; 65 65 struct hfs_cat_file *file; ··· 105 105 106 106 ssize_t hfs_listxattr(struct dentry *dentry, char *buffer, size_t size) 107 107 { 108 108 - struct inode *inode = dentry->d_inode; 108 108 + struct inode *inode = d_inode(dentry); 109 109 110 110 if (!S_ISREG(inode->i_mode) || HFS_IS_RSRC(inode)) 111 111 return -EOPNOTSUPP;

+4 -4

fs/hfs/dir.c

reviewed

··· 253 253 */ 254 254 static int hfs_remove(struct inode *dir, struct dentry *dentry) 255 255 { 256 256 - struct inode *inode = dentry->d_inode; 256 256 + struct inode *inode = d_inode(dentry); 257 257 int res; 258 258 259 259 if (S_ISDIR(inode->i_mode) && inode->i_size != 2) ··· 285 285 int res; 286 286 287 287 /* Unlink destination if it already exists */ 288 288 - if (new_dentry->d_inode) { 288 288 + if (d_really_is_positive(new_dentry)) { 289 289 res = hfs_remove(new_dir, new_dentry); 290 290 if (res) 291 291 return res; 292 292 } 293 293 294 294 - res = hfs_cat_move(old_dentry->d_inode->i_ino, 294 294 + res = hfs_cat_move(d_inode(old_dentry)->i_ino, 295 295 old_dir, &old_dentry->d_name, 296 296 new_dir, &new_dentry->d_name); 297 297 if (!res) 298 298 hfs_cat_build_key(old_dir->i_sb, 299 299 - (btree_key *)&HFS_I(old_dentry->d_inode)->cat_key, 299 299 + (btree_key *)&HFS_I(d_inode(old_dentry))->cat_key, 300 300 new_dir->i_ino, &new_dentry->d_name); 301 301 return res; 302 302 }

+1 -1

fs/hfs/inode.c

reviewed

··· 600 600 601 601 int hfs_inode_setattr(struct dentry *dentry, struct iattr * attr) 602 602 { 603 603 - struct inode *inode = dentry->d_inode; 603 603 + struct inode *inode = d_inode(dentry); 604 604 struct hfs_sb_info *hsb = HFS_SB(inode->i_sb); 605 605 int error; 606 606

+1 -1

fs/hfs/sysdep.c

reviewed

··· 21 21 if (flags & LOOKUP_RCU) 22 22 return -ECHILD; 23 23 24 24 - inode = dentry->d_inode; 24 24 + inode = d_inode(dentry); 25 25 if(!inode) 26 26 return 1; 27 27

+6 -6

fs/hfsplus/dir.c

reviewed

··· 81 81 HFSPLUS_I(HFSPLUS_SB(sb)->hidden_dir)-> 82 82 create_date || 83 83 entry.file.create_date == 84 84 - HFSPLUS_I(sb->s_root->d_inode)-> 84 84 + HFSPLUS_I(d_inode(sb->s_root))-> 85 85 create_date) && 86 86 HFSPLUS_SB(sb)->hidden_dir) { 87 87 struct qstr str; ··· 296 296 struct dentry *dst_dentry) 297 297 { 298 298 struct hfsplus_sb_info *sbi = HFSPLUS_SB(dst_dir->i_sb); 299 299 - struct inode *inode = src_dentry->d_inode; 300 300 - struct inode *src_dir = src_dentry->d_parent->d_inode; 299 299 + struct inode *inode = d_inode(src_dentry); 300 300 + struct inode *src_dir = d_inode(src_dentry->d_parent); 301 301 struct qstr str; 302 302 char name[32]; 303 303 u32 cnid, id; ··· 353 353 static int hfsplus_unlink(struct inode *dir, struct dentry *dentry) 354 354 { 355 355 struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb); 356 356 - struct inode *inode = dentry->d_inode; 356 356 + struct inode *inode = d_inode(dentry); 357 357 struct qstr str; 358 358 char name[32]; 359 359 u32 cnid; ··· 410 410 static int hfsplus_rmdir(struct inode *dir, struct dentry *dentry) 411 411 { 412 412 struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb); 413 413 - struct inode *inode = dentry->d_inode; 413 413 + struct inode *inode = d_inode(dentry); 414 414 int res; 415 415 416 416 if (inode->i_size != 2) ··· 529 529 int res; 530 530 531 531 /* Unlink destination if it already exists */ 532 532 - if (new_dentry->d_inode) { 532 532 + if (d_really_is_positive(new_dentry)) { 533 533 if (d_is_dir(new_dentry)) 534 534 res = hfsplus_rmdir(new_dir, new_dentry); 535 535 else

+1 -1

fs/hfsplus/inode.c

reviewed

··· 243 243 244 244 static int hfsplus_setattr(struct dentry *dentry, struct iattr *attr) 245 245 { 246 246 - struct inode *inode = dentry->d_inode; 246 246 + struct inode *inode = d_inode(dentry); 247 247 int error; 248 248 249 249 error = inode_change_ok(inode, attr);

+1 -1

fs/hfsplus/ioctl.c

reviewed

··· 26 26 static int hfsplus_ioctl_bless(struct file *file, int __user *user_flags) 27 27 { 28 28 struct dentry *dentry = file->f_path.dentry; 29 29 - struct inode *inode = dentry->d_inode; 29 29 + struct inode *inode = d_inode(dentry); 30 30 struct hfsplus_sb_info *sbi = HFSPLUS_SB(inode->i_sb); 31 31 struct hfsplus_vh *vh = sbi->s_vhdr; 32 32 struct hfsplus_vh *bvh = sbi->s_backup_vhdr;

+6 -6

fs/hfsplus/xattr.c

reviewed

··· 440 440 return -ENOMEM; 441 441 strcpy(xattr_name, prefix); 442 442 strcpy(xattr_name + prefixlen, name); 443 443 - res = __hfsplus_setxattr(dentry->d_inode, xattr_name, value, size, 443 443 + res = __hfsplus_setxattr(d_inode(dentry), xattr_name, value, size, 444 444 flags); 445 445 kfree(xattr_name); 446 446 return res; ··· 600 600 strcpy(xattr_name, prefix); 601 601 strcpy(xattr_name + prefixlen, name); 602 602 603 603 - res = __hfsplus_getxattr(dentry->d_inode, xattr_name, value, size); 603 603 + res = __hfsplus_getxattr(d_inode(dentry), xattr_name, value, size); 604 604 kfree(xattr_name); 605 605 return res; 606 606 ··· 620 620 char *buffer, size_t size) 621 621 { 622 622 ssize_t res = 0; 623 623 - struct inode *inode = dentry->d_inode; 623 623 + struct inode *inode = d_inode(dentry); 624 624 struct hfs_find_data fd; 625 625 u16 entry_type; 626 626 u8 folder_finder_info[sizeof(struct DInfo) + sizeof(struct DXInfo)]; ··· 688 688 { 689 689 ssize_t err; 690 690 ssize_t res = 0; 691 691 - struct inode *inode = dentry->d_inode; 691 691 + struct inode *inode = d_inode(dentry); 692 692 struct hfs_find_data fd; 693 693 u16 key_len = 0; 694 694 struct hfsplus_attr_key attr_key; ··· 868 868 * creates), so we pass the name through unmodified (after 869 869 * ensuring it doesn't conflict with another namespace). 870 870 */ 871 871 - return __hfsplus_getxattr(dentry->d_inode, name, buffer, size); 871 871 + return __hfsplus_getxattr(d_inode(dentry), name, buffer, size); 872 872 } 873 873 874 874 static int hfsplus_osx_setxattr(struct dentry *dentry, const char *name, ··· 890 890 * creates), so we pass the name through unmodified (after 891 891 * ensuring it doesn't conflict with another namespace). 892 892 */ 893 893 - return __hfsplus_setxattr(dentry->d_inode, name, buffer, size, flags); 893 893 + return __hfsplus_setxattr(d_inode(dentry), name, buffer, size, flags); 894 894 } 895 895 896 896 static size_t hfsplus_osx_listxattr(struct dentry *dentry, char *list,

+1 -1

fs/hostfs/hostfs_kern.c

reviewed

··· 807 807 808 808 static int hostfs_setattr(struct dentry *dentry, struct iattr *attr) 809 809 { 810 810 - struct inode *inode = dentry->d_inode; 810 810 + struct inode *inode = d_inode(dentry); 811 811 struct hostfs_iattr attrs; 812 812 char *name; 813 813 int err;

+1 -1

fs/hpfs/inode.c

reviewed

··· 257 257 258 258 int hpfs_setattr(struct dentry *dentry, struct iattr *attr) 259 259 { 260 260 - struct inode *inode = dentry->d_inode; 260 260 + struct inode *inode = d_inode(dentry); 261 261 int error = -EINVAL; 262 262 263 263 hpfs_lock(inode->i_sb);

+4 -4

fs/hpfs/namei.c

reviewed

··· 359 359 unsigned len = dentry->d_name.len; 360 360 struct quad_buffer_head qbh; 361 361 struct hpfs_dirent *de; 362 362 - struct inode *inode = dentry->d_inode; 362 362 + struct inode *inode = d_inode(dentry); 363 363 dnode_secno dno; 364 364 int r; 365 365 int rep = 0; ··· 433 433 unsigned len = dentry->d_name.len; 434 434 struct quad_buffer_head qbh; 435 435 struct hpfs_dirent *de; 436 436 - struct inode *inode = dentry->d_inode; 436 436 + struct inode *inode = d_inode(dentry); 437 437 dnode_secno dno; 438 438 int n_items = 0; 439 439 int err; ··· 522 522 unsigned old_len = old_dentry->d_name.len; 523 523 const unsigned char *new_name = new_dentry->d_name.name; 524 524 unsigned new_len = new_dentry->d_name.len; 525 525 - struct inode *i = old_dentry->d_inode; 526 526 - struct inode *new_inode = new_dentry->d_inode; 525 525 + struct inode *i = d_inode(old_dentry); 526 526 + struct inode *new_inode = d_inode(new_dentry); 527 527 struct quad_buffer_head qbh, qbh1; 528 528 struct hpfs_dirent *dep, *nde; 529 529 struct hpfs_dirent de;

+10 -10

fs/hppfs/hppfs.c

reviewed

··· 153 153 return ERR_PTR(-ENOENT); 154 154 155 155 parent = HPPFS_I(ino)->proc_dentry; 156 156 - mutex_lock(&parent->d_inode->i_mutex); 156 156 + mutex_lock(&d_inode(parent)->i_mutex); 157 157 proc_dentry = lookup_one_len(name->name, parent, name->len); 158 158 - mutex_unlock(&parent->d_inode->i_mutex); 158 158 + mutex_unlock(&d_inode(parent)->i_mutex); 159 159 160 160 if (IS_ERR(proc_dentry)) 161 161 return proc_dentry; ··· 637 637 static int hppfs_readlink(struct dentry *dentry, char __user *buffer, 638 638 int buflen) 639 639 { 640 640 - struct dentry *proc_dentry = HPPFS_I(dentry->d_inode)->proc_dentry; 641 641 - return proc_dentry->d_inode->i_op->readlink(proc_dentry, buffer, 640 640 + struct dentry *proc_dentry = HPPFS_I(d_inode(dentry))->proc_dentry; 641 641 + return d_inode(proc_dentry)->i_op->readlink(proc_dentry, buffer, 642 642 buflen); 643 643 } 644 644 645 645 static void *hppfs_follow_link(struct dentry *dentry, struct nameidata *nd) 646 646 { 647 647 - struct dentry *proc_dentry = HPPFS_I(dentry->d_inode)->proc_dentry; 647 647 + struct dentry *proc_dentry = HPPFS_I(d_inode(dentry))->proc_dentry; 648 648 649 649 - return proc_dentry->d_inode->i_op->follow_link(proc_dentry, nd); 649 649 + return d_inode(proc_dentry)->i_op->follow_link(proc_dentry, nd); 650 650 } 651 651 652 652 static void hppfs_put_link(struct dentry *dentry, struct nameidata *nd, 653 653 void *cookie) 654 654 { 655 655 - struct dentry *proc_dentry = HPPFS_I(dentry->d_inode)->proc_dentry; 655 655 + struct dentry *proc_dentry = HPPFS_I(d_inode(dentry))->proc_dentry; 656 656 657 657 - if (proc_dentry->d_inode->i_op->put_link) 658 658 - proc_dentry->d_inode->i_op->put_link(proc_dentry, nd, cookie); 657 657 + if (d_inode(proc_dentry)->i_op->put_link) 658 658 + d_inode(proc_dentry)->i_op->put_link(proc_dentry, nd, cookie); 659 659 } 660 660 661 661 static const struct inode_operations hppfs_dir_iops = { ··· 670 670 671 671 static struct inode *get_inode(struct super_block *sb, struct dentry *dentry) 672 672 { 673 673 - struct inode *proc_ino = dentry->d_inode; 673 673 + struct inode *proc_ino = d_inode(dentry); 674 674 struct inode *inode = new_inode(sb); 675 675 676 676 if (!inode) {

+2 -2

fs/hugetlbfs/inode.c

reviewed

··· 393 393 394 394 static int hugetlbfs_setattr(struct dentry *dentry, struct iattr *attr) 395 395 { 396 396 - struct inode *inode = dentry->d_inode; 396 396 + struct inode *inode = d_inode(dentry); 397 397 struct hstate *h = hstate_inode(inode); 398 398 int error; 399 399 unsigned int ia_valid = attr->ia_valid; ··· 587 587 static int hugetlbfs_statfs(struct dentry *dentry, struct kstatfs *buf) 588 588 { 589 589 struct hugetlbfs_sb_info *sbinfo = HUGETLBFS_SB(dentry->d_sb); 590 590 - struct hstate *h = hstate_inode(dentry->d_inode); 590 590 + struct hstate *h = hstate_inode(d_inode(dentry)); 591 591 592 592 buf->f_type = HUGETLBFS_MAGIC; 593 593 buf->f_bsize = huge_page_size(h);

+3 -17

fs/inode.c

reviewed

··· 1587 1587 void touch_atime(const struct path *path) 1588 1588 { 1589 1589 struct vfsmount *mnt = path->mnt; 1590 1590 - struct inode *inode = path->dentry->d_inode; 1590 1590 + struct inode *inode = d_inode(path->dentry); 1591 1591 struct timespec now; 1592 1592 1593 1593 if (inode->i_flags & S_NOATIME) ··· 1639 1639 */ 1640 1640 int should_remove_suid(struct dentry *dentry) 1641 1641 { 1642 1642 - umode_t mode = dentry->d_inode->i_mode; 1642 1642 + umode_t mode = d_inode(dentry)->i_mode; 1643 1643 int kill = 0; 1644 1644 1645 1645 /* suid always must be killed */ ··· 1675 1675 int file_remove_suid(struct file *file) 1676 1676 { 1677 1677 struct dentry *dentry = file->f_path.dentry; 1678 1678 - struct inode *inode = dentry->d_inode; 1678 1678 + struct inode *inode = d_inode(dentry); 1679 1679 int killsuid; 1680 1680 int killpriv; 1681 1681 int error = 0; ··· 1944 1944 __inode_dio_wait(inode); 1945 1945 } 1946 1946 EXPORT_SYMBOL(inode_dio_wait); 1947 1947 - 1948 1948 - /* 1949 1949 - * inode_dio_done - signal finish of a direct I/O requests 1950 1950 - * @inode: inode the direct I/O happens on 1951 1951 - * 1952 1952 - * This is called once we've finished processing a direct I/O request, 1953 1953 - * and is used to wake up callers waiting for direct I/O to be quiesced. 1954 1954 - */ 1955 1955 - void inode_dio_done(struct inode *inode) 1956 1956 - { 1957 1957 - if (atomic_dec_and_test(&inode->i_dio_count)) 1958 1958 - wake_up_bit(&inode->i_state, __I_DIO_WAKEUP); 1959 1959 - } 1960 1960 - EXPORT_SYMBOL(inode_dio_done); 1961 1947 1962 1948 /* 1963 1949 * inode_set_flags - atomically set some inode flags

+1 -1

fs/isofs/export.c

reviewed

··· 44 44 { 45 45 unsigned long parent_block = 0; 46 46 unsigned long parent_offset = 0; 47 47 - struct inode *child_inode = child->d_inode; 47 47 + struct inode *child_inode = d_inode(child); 48 48 struct iso_inode_info *e_child_inode = ISOFS_I(child_inode); 49 49 struct iso_directory_record *de = NULL; 50 50 struct buffer_head * bh = NULL;

+20 -20

fs/jffs2/dir.c

reviewed

··· 224 224 { 225 225 struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb); 226 226 struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i); 227 227 - struct jffs2_inode_info *dead_f = JFFS2_INODE_INFO(dentry->d_inode); 227 227 + struct jffs2_inode_info *dead_f = JFFS2_INODE_INFO(d_inode(dentry)); 228 228 int ret; 229 229 uint32_t now = get_seconds(); 230 230 231 231 ret = jffs2_do_unlink(c, dir_f, dentry->d_name.name, 232 232 dentry->d_name.len, dead_f, now); 233 233 if (dead_f->inocache) 234 234 - set_nlink(dentry->d_inode, dead_f->inocache->pino_nlink); 234 234 + set_nlink(d_inode(dentry), dead_f->inocache->pino_nlink); 235 235 if (!ret) 236 236 dir_i->i_mtime = dir_i->i_ctime = ITIME(now); 237 237 return ret; ··· 241 241 242 242 static int jffs2_link (struct dentry *old_dentry, struct inode *dir_i, struct dentry *dentry) 243 243 { 244 244 - struct jffs2_sb_info *c = JFFS2_SB_INFO(old_dentry->d_inode->i_sb); 245 245 - struct jffs2_inode_info *f = JFFS2_INODE_INFO(old_dentry->d_inode); 244 244 + struct jffs2_sb_info *c = JFFS2_SB_INFO(d_inode(old_dentry)->i_sb); 245 245 + struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(old_dentry)); 246 246 struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i); 247 247 int ret; 248 248 uint8_t type; ··· 256 256 return -EPERM; 257 257 258 258 /* XXX: This is ugly */ 259 259 - type = (old_dentry->d_inode->i_mode & S_IFMT) >> 12; 259 259 + type = (d_inode(old_dentry)->i_mode & S_IFMT) >> 12; 260 260 if (!type) type = DT_REG; 261 261 262 262 now = get_seconds(); ··· 264 264 265 265 if (!ret) { 266 266 mutex_lock(&f->sem); 267 267 - set_nlink(old_dentry->d_inode, ++f->inocache->pino_nlink); 267 267 + set_nlink(d_inode(old_dentry), ++f->inocache->pino_nlink); 268 268 mutex_unlock(&f->sem); 269 269 - d_instantiate(dentry, old_dentry->d_inode); 269 269 + d_instantiate(dentry, d_inode(old_dentry)); 270 270 dir_i->i_mtime = dir_i->i_ctime = ITIME(now); 271 271 - ihold(old_dentry->d_inode); 271 271 + ihold(d_inode(old_dentry)); 272 272 } 273 273 return ret; 274 274 } ··· 585 585 { 586 586 struct jffs2_sb_info *c = JFFS2_SB_INFO(dir_i->i_sb); 587 587 struct jffs2_inode_info *dir_f = JFFS2_INODE_INFO(dir_i); 588 588 - struct jffs2_inode_info *f = JFFS2_INODE_INFO(dentry->d_inode); 588 588 + struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(dentry)); 589 589 struct jffs2_full_dirent *fd; 590 590 int ret; 591 591 uint32_t now = get_seconds(); ··· 599 599 dentry->d_name.len, f, now); 600 600 if (!ret) { 601 601 dir_i->i_mtime = dir_i->i_ctime = ITIME(now); 602 602 - clear_nlink(dentry->d_inode); 602 602 + clear_nlink(d_inode(dentry)); 603 603 drop_nlink(dir_i); 604 604 } 605 605 return ret; ··· 770 770 * the VFS can't check whether the victim is empty. The filesystem 771 771 * needs to do that for itself. 772 772 */ 773 773 - if (new_dentry->d_inode) { 774 774 - victim_f = JFFS2_INODE_INFO(new_dentry->d_inode); 773 773 + if (d_really_is_positive(new_dentry)) { 774 774 + victim_f = JFFS2_INODE_INFO(d_inode(new_dentry)); 775 775 if (d_is_dir(new_dentry)) { 776 776 struct jffs2_full_dirent *fd; 777 777 ··· 794 794 /* Make a hard link */ 795 795 796 796 /* XXX: This is ugly */ 797 797 - type = (old_dentry->d_inode->i_mode & S_IFMT) >> 12; 797 797 + type = (d_inode(old_dentry)->i_mode & S_IFMT) >> 12; 798 798 if (!type) type = DT_REG; 799 799 800 800 now = get_seconds(); 801 801 ret = jffs2_do_link(c, JFFS2_INODE_INFO(new_dir_i), 802 802 - old_dentry->d_inode->i_ino, type, 802 802 + d_inode(old_dentry)->i_ino, type, 803 803 new_dentry->d_name.name, new_dentry->d_name.len, now); 804 804 805 805 if (ret) ··· 808 808 if (victim_f) { 809 809 /* There was a victim. Kill it off nicely */ 810 810 if (d_is_dir(new_dentry)) 811 811 - clear_nlink(new_dentry->d_inode); 811 811 + clear_nlink(d_inode(new_dentry)); 812 812 else 813 813 - drop_nlink(new_dentry->d_inode); 813 813 + drop_nlink(d_inode(new_dentry)); 814 814 /* Don't oops if the victim was a dirent pointing to an 815 815 inode which didn't exist. */ 816 816 if (victim_f->inocache) { ··· 836 836 837 837 if (ret) { 838 838 /* Oh shit. We really ought to make a single node which can do both atomically */ 839 839 - struct jffs2_inode_info *f = JFFS2_INODE_INFO(old_dentry->d_inode); 839 839 + struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(old_dentry)); 840 840 mutex_lock(&f->sem); 841 841 - inc_nlink(old_dentry->d_inode); 841 841 + inc_nlink(d_inode(old_dentry)); 842 842 if (f->inocache && !d_is_dir(old_dentry)) 843 843 f->inocache->pino_nlink++; 844 844 mutex_unlock(&f->sem); ··· 846 846 pr_notice("%s(): Link succeeded, unlink failed (err %d). You now have a hard link\n", 847 847 __func__, ret); 848 848 /* Might as well let the VFS know */ 849 849 - d_instantiate(new_dentry, old_dentry->d_inode); 850 850 - ihold(old_dentry->d_inode); 849 849 + d_instantiate(new_dentry, d_inode(old_dentry)); 850 850 + ihold(d_inode(old_dentry)); 851 851 new_dir_i->i_mtime = new_dir_i->i_ctime = ITIME(now); 852 852 return ret; 853 853 }

+1 -1

fs/jffs2/fs.c

reviewed

··· 190 190 191 191 int jffs2_setattr(struct dentry *dentry, struct iattr *iattr) 192 192 { 193 193 - struct inode *inode = dentry->d_inode; 193 193 + struct inode *inode = d_inode(dentry); 194 194 int rc; 195 195 196 196 rc = inode_change_ok(inode, iattr);

+2 -2

fs/jffs2/security.c

reviewed

··· 54 54 if (!strcmp(name, "")) 55 55 return -EINVAL; 56 56 57 57 - return do_jffs2_getxattr(dentry->d_inode, JFFS2_XPREFIX_SECURITY, 57 57 + return do_jffs2_getxattr(d_inode(dentry), JFFS2_XPREFIX_SECURITY, 58 58 name, buffer, size); 59 59 } 60 60 ··· 64 64 if (!strcmp(name, "")) 65 65 return -EINVAL; 66 66 67 67 - return do_jffs2_setxattr(dentry->d_inode, JFFS2_XPREFIX_SECURITY, 67 67 + return do_jffs2_setxattr(d_inode(dentry), JFFS2_XPREFIX_SECURITY, 68 68 name, buffer, size, flags); 69 69 } 70 70

+2 -2

fs/jffs2/super.c

reviewed

··· 140 140 141 141 BUG_ON(!d_is_dir(child)); 142 142 143 143 - f = JFFS2_INODE_INFO(child->d_inode); 143 143 + f = JFFS2_INODE_INFO(d_inode(child)); 144 144 145 145 pino = f->inocache->pino_nlink; 146 146 147 147 JFFS2_DEBUG("Parent of directory ino #%u is #%u\n", 148 148 f->inocache->ino, pino); 149 149 150 150 - return d_obtain_alias(jffs2_iget(child->d_inode->i_sb, pino)); 150 150 + return d_obtain_alias(jffs2_iget(d_inode(child)->i_sb, pino)); 151 151 } 152 152 153 153 static const struct export_operations jffs2_export_ops = {

+1 -1

fs/jffs2/symlink.c

reviewed

··· 31 31 32 32 static void *jffs2_follow_link(struct dentry *dentry, struct nameidata *nd) 33 33 { 34 34 - struct jffs2_inode_info *f = JFFS2_INODE_INFO(dentry->d_inode); 34 34 + struct jffs2_inode_info *f = JFFS2_INODE_INFO(d_inode(dentry)); 35 35 char *p = (char *)f->target; 36 36 37 37 /*

+1 -1

fs/jffs2/xattr.c

reviewed

··· 960 960 961 961 ssize_t jffs2_listxattr(struct dentry *dentry, char *buffer, size_t size) 962 962 { 963 963 - struct inode *inode = dentry->d_inode; 963 963 + struct inode *inode = d_inode(dentry); 964 964 struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode); 965 965 struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb); 966 966 struct jffs2_inode_cache *ic = f->inocache;

+2 -2

fs/jffs2/xattr_trusted.c

reviewed

··· 21 21 { 22 22 if (!strcmp(name, "")) 23 23 return -EINVAL; 24 24 - return do_jffs2_getxattr(dentry->d_inode, JFFS2_XPREFIX_TRUSTED, 24 24 + return do_jffs2_getxattr(d_inode(dentry), JFFS2_XPREFIX_TRUSTED, 25 25 name, buffer, size); 26 26 } 27 27 ··· 30 30 { 31 31 if (!strcmp(name, "")) 32 32 return -EINVAL; 33 33 - return do_jffs2_setxattr(dentry->d_inode, JFFS2_XPREFIX_TRUSTED, 33 33 + return do_jffs2_setxattr(d_inode(dentry), JFFS2_XPREFIX_TRUSTED, 34 34 name, buffer, size, flags); 35 35 } 36 36

+2 -2

fs/jffs2/xattr_user.c

reviewed

··· 21 21 { 22 22 if (!strcmp(name, "")) 23 23 return -EINVAL; 24 24 - return do_jffs2_getxattr(dentry->d_inode, JFFS2_XPREFIX_USER, 24 24 + return do_jffs2_getxattr(d_inode(dentry), JFFS2_XPREFIX_USER, 25 25 name, buffer, size); 26 26 } 27 27 ··· 30 30 { 31 31 if (!strcmp(name, "")) 32 32 return -EINVAL; 33 33 - return do_jffs2_setxattr(dentry->d_inode, JFFS2_XPREFIX_USER, 33 33 + return do_jffs2_setxattr(d_inode(dentry), JFFS2_XPREFIX_USER, 34 34 name, buffer, size, flags); 35 35 } 36 36

+1 -1

fs/jfs/file.c

reviewed

··· 100 100 101 101 int jfs_setattr(struct dentry *dentry, struct iattr *iattr) 102 102 { 103 103 - struct inode *inode = dentry->d_inode; 103 103 + struct inode *inode = d_inode(dentry); 104 104 int rc; 105 105 106 106 rc = inode_change_ok(inode, iattr);

+9 -9

fs/jfs/namei.c

reviewed

··· 346 346 { 347 347 int rc; 348 348 tid_t tid; /* transaction id */ 349 349 - struct inode *ip = dentry->d_inode; 349 349 + struct inode *ip = d_inode(dentry); 350 350 ino_t ino; 351 351 struct component_name dname; 352 352 struct inode *iplist[2]; ··· 472 472 { 473 473 int rc; 474 474 tid_t tid; /* transaction id */ 475 475 - struct inode *ip = dentry->d_inode; 475 475 + struct inode *ip = d_inode(dentry); 476 476 ino_t ino; 477 477 struct component_name dname; /* object name */ 478 478 struct inode *iplist[2]; ··· 791 791 { 792 792 int rc; 793 793 tid_t tid; 794 794 - struct inode *ip = old_dentry->d_inode; 794 794 + struct inode *ip = d_inode(old_dentry); 795 795 ino_t ino; 796 796 struct component_name dname; 797 797 struct btstack btstack; ··· 879 879 struct component_name dname; 880 880 int ssize; /* source pathname size */ 881 881 struct btstack btstack; 882 882 - struct inode *ip = dentry->d_inode; 882 882 + struct inode *ip = d_inode(dentry); 883 883 unchar *i_fastsymlink; 884 884 s64 xlen = 0; 885 885 int bmask = 0, xsize; ··· 1086 1086 dquot_initialize(old_dir); 1087 1087 dquot_initialize(new_dir); 1088 1088 1089 1089 - old_ip = old_dentry->d_inode; 1090 1090 - new_ip = new_dentry->d_inode; 1089 1089 + old_ip = d_inode(old_dentry); 1090 1090 + new_ip = d_inode(new_dentry); 1091 1091 1092 1092 if ((rc = get_UCSname(&old_dname, old_dentry))) 1093 1093 goto out1; ··· 1500 1500 unsigned long parent_ino; 1501 1501 1502 1502 parent_ino = 1503 1503 - le32_to_cpu(JFS_IP(dentry->d_inode)->i_dtroot.header.idotdot); 1503 1503 + le32_to_cpu(JFS_IP(d_inode(dentry))->i_dtroot.header.idotdot); 1504 1504 1505 1505 - return d_obtain_alias(jfs_iget(dentry->d_inode->i_sb, parent_ino)); 1505 1505 + return d_obtain_alias(jfs_iget(d_inode(dentry)->i_sb, parent_ino)); 1506 1506 } 1507 1507 1508 1508 const struct inode_operations jfs_dir_inode_operations = { ··· 1578 1578 * positive dentry isn't good idea. So it's unsupported like 1579 1579 * rename("filename", "FILENAME") for now. 1580 1580 */ 1581 1581 - if (dentry->d_inode) 1581 1581 + if (d_really_is_positive(dentry)) 1582 1582 return 1; 1583 1583 1584 1584 /*

+1 -1

fs/jfs/symlink.c

reviewed

··· 24 24 25 25 static void *jfs_follow_link(struct dentry *dentry, struct nameidata *nd) 26 26 { 27 27 - char *s = JFS_IP(dentry->d_inode)->i_inline; 27 27 + char *s = JFS_IP(d_inode(dentry))->i_inline; 28 28 nd_set_link(nd, s); 29 29 return NULL; 30 30 }

+6 -6

fs/jfs/xattr.c

reviewed

··· 849 849 int jfs_setxattr(struct dentry *dentry, const char *name, const void *value, 850 850 size_t value_len, int flags) 851 851 { 852 852 - struct inode *inode = dentry->d_inode; 852 852 + struct inode *inode = d_inode(dentry); 853 853 struct jfs_inode_info *ji = JFS_IP(inode); 854 854 int rc; 855 855 tid_t tid; ··· 872 872 873 873 tid = txBegin(inode->i_sb, 0); 874 874 mutex_lock(&ji->commit_mutex); 875 875 - rc = __jfs_setxattr(tid, dentry->d_inode, name, value, value_len, 875 875 + rc = __jfs_setxattr(tid, d_inode(dentry), name, value, value_len, 876 876 flags); 877 877 if (!rc) 878 878 rc = txCommit(tid, 1, &inode, 0); ··· 959 959 return -EOPNOTSUPP; 960 960 } 961 961 962 962 - err = __jfs_getxattr(dentry->d_inode, name, data, buf_size); 962 962 + err = __jfs_getxattr(d_inode(dentry), name, data, buf_size); 963 963 964 964 return err; 965 965 } ··· 976 976 977 977 ssize_t jfs_listxattr(struct dentry * dentry, char *data, size_t buf_size) 978 978 { 979 979 - struct inode *inode = dentry->d_inode; 979 979 + struct inode *inode = d_inode(dentry); 980 980 char *buffer; 981 981 ssize_t size = 0; 982 982 int xattr_size; ··· 1029 1029 1030 1030 int jfs_removexattr(struct dentry *dentry, const char *name) 1031 1031 { 1032 1032 - struct inode *inode = dentry->d_inode; 1032 1032 + struct inode *inode = d_inode(dentry); 1033 1033 struct jfs_inode_info *ji = JFS_IP(inode); 1034 1034 int rc; 1035 1035 tid_t tid; ··· 1047 1047 1048 1048 tid = txBegin(inode->i_sb, 0); 1049 1049 mutex_lock(&ji->commit_mutex); 1050 1050 - rc = __jfs_setxattr(tid, dentry->d_inode, name, NULL, 0, XATTR_REPLACE); 1050 1050 + rc = __jfs_setxattr(tid, d_inode(dentry), name, NULL, 0, XATTR_REPLACE); 1051 1051 if (!rc) 1052 1052 rc = txCommit(tid, 1, &inode, 0); 1053 1053 txEnd(tid);

+1 -1

fs/kernfs/dir.c

reviewed

··· 444 444 return -ECHILD; 445 445 446 446 /* Always perform fresh lookup for negatives */ 447 447 - if (!dentry->d_inode) 447 447 + if (d_really_is_negative(dentry)) 448 448 goto out_bad_unlocked; 449 449 450 450 kn = dentry->d_fsdata;

+4 -4

fs/kernfs/inode.c

reviewed

··· 111 111 112 112 int kernfs_iop_setattr(struct dentry *dentry, struct iattr *iattr) 113 113 { 114 114 - struct inode *inode = dentry->d_inode; 114 114 + struct inode *inode = d_inode(dentry); 115 115 struct kernfs_node *kn = dentry->d_fsdata; 116 116 int error; 117 117 ··· 172 172 173 173 if (!strncmp(name, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN)) { 174 174 const char *suffix = name + XATTR_SECURITY_PREFIX_LEN; 175 175 - error = security_inode_setsecurity(dentry->d_inode, suffix, 175 175 + error = security_inode_setsecurity(d_inode(dentry), suffix, 176 176 value, size, flags); 177 177 if (error) 178 178 return error; 179 179 - error = security_inode_getsecctx(dentry->d_inode, 179 179 + error = security_inode_getsecctx(d_inode(dentry), 180 180 &secdata, &secdata_len); 181 181 if (error) 182 182 return error; ··· 271 271 struct kstat *stat) 272 272 { 273 273 struct kernfs_node *kn = dentry->d_fsdata; 274 274 - struct inode *inode = dentry->d_inode; 274 274 + struct inode *inode = d_inode(dentry); 275 275 276 276 mutex_lock(&kernfs_mutex); 277 277 kernfs_refresh_inode(kn, inode);

+13 -13

fs/libfs.c

reviewed

··· 22 22 23 23 static inline int simple_positive(struct dentry *dentry) 24 24 { 25 25 - return dentry->d_inode && !d_unhashed(dentry); 25 25 + return d_really_is_positive(dentry) && !d_unhashed(dentry); 26 26 } 27 27 28 28 int simple_getattr(struct vfsmount *mnt, struct dentry *dentry, 29 29 struct kstat *stat) 30 30 { 31 31 - struct inode *inode = dentry->d_inode; 31 31 + struct inode *inode = d_inode(dentry); 32 32 generic_fillattr(inode, stat); 33 33 stat->blocks = inode->i_mapping->nrpages << (PAGE_CACHE_SHIFT - 9); 34 34 return 0; ··· 94 94 loff_t dcache_dir_lseek(struct file *file, loff_t offset, int whence) 95 95 { 96 96 struct dentry *dentry = file->f_path.dentry; 97 97 - mutex_lock(&dentry->d_inode->i_mutex); 97 97 + mutex_lock(&d_inode(dentry)->i_mutex); 98 98 switch (whence) { 99 99 case 1: 100 100 offset += file->f_pos; ··· 102 102 if (offset >= 0) 103 103 break; 104 104 default: 105 105 - mutex_unlock(&dentry->d_inode->i_mutex); 105 105 + mutex_unlock(&d_inode(dentry)->i_mutex); 106 106 return -EINVAL; 107 107 } 108 108 if (offset != file->f_pos) { ··· 129 129 spin_unlock(&dentry->d_lock); 130 130 } 131 131 } 132 132 - mutex_unlock(&dentry->d_inode->i_mutex); 132 132 + mutex_unlock(&d_inode(dentry)->i_mutex); 133 133 return offset; 134 134 } 135 135 EXPORT_SYMBOL(dcache_dir_lseek); ··· 169 169 spin_unlock(&next->d_lock); 170 170 spin_unlock(&dentry->d_lock); 171 171 if (!dir_emit(ctx, next->d_name.name, next->d_name.len, 172 172 - next->d_inode->i_ino, dt_type(next->d_inode))) 172 172 + d_inode(next)->i_ino, dt_type(d_inode(next)))) 173 173 return 0; 174 174 spin_lock(&dentry->d_lock); 175 175 spin_lock_nested(&next->d_lock, DENTRY_D_LOCK_NESTED); ··· 270 270 271 271 int simple_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry) 272 272 { 273 273 - struct inode *inode = old_dentry->d_inode; 273 273 + struct inode *inode = d_inode(old_dentry); 274 274 275 275 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME; 276 276 inc_nlink(inode); ··· 304 304 305 305 int simple_unlink(struct inode *dir, struct dentry *dentry) 306 306 { 307 307 - struct inode *inode = dentry->d_inode; 307 307 + struct inode *inode = d_inode(dentry); 308 308 309 309 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME; 310 310 drop_nlink(inode); ··· 318 318 if (!simple_empty(dentry)) 319 319 return -ENOTEMPTY; 320 320 321 321 - drop_nlink(dentry->d_inode); 321 321 + drop_nlink(d_inode(dentry)); 322 322 simple_unlink(dir, dentry); 323 323 drop_nlink(dir); 324 324 return 0; ··· 328 328 int simple_rename(struct inode *old_dir, struct dentry *old_dentry, 329 329 struct inode *new_dir, struct dentry *new_dentry) 330 330 { 331 331 - struct inode *inode = old_dentry->d_inode; 331 331 + struct inode *inode = d_inode(old_dentry); 332 332 int they_are_dirs = d_is_dir(old_dentry); 333 333 334 334 if (!simple_empty(new_dentry)) 335 335 return -ENOTEMPTY; 336 336 337 337 - if (new_dentry->d_inode) { 337 337 + if (d_really_is_positive(new_dentry)) { 338 338 simple_unlink(new_dir, new_dentry); 339 339 if (they_are_dirs) { 340 340 - drop_nlink(new_dentry->d_inode); 340 340 + drop_nlink(d_inode(new_dentry)); 341 341 drop_nlink(old_dir); 342 342 } 343 343 } else if (they_are_dirs) { ··· 368 368 */ 369 369 int simple_setattr(struct dentry *dentry, struct iattr *iattr) 370 370 { 371 371 - struct inode *inode = dentry->d_inode; 371 371 + struct inode *inode = d_inode(dentry); 372 372 int error; 373 373 374 374 error = inode_change_ok(inode, iattr);

+7 -7

fs/logfs/dir.c

reviewed

··· 213 213 static int logfs_unlink(struct inode *dir, struct dentry *dentry) 214 214 { 215 215 struct logfs_super *super = logfs_super(dir->i_sb); 216 216 - struct inode *inode = dentry->d_inode; 216 216 + struct inode *inode = d_inode(dentry); 217 217 struct logfs_transaction *ta; 218 218 struct page *page; 219 219 pgoff_t index; ··· 271 271 272 272 static int logfs_rmdir(struct inode *dir, struct dentry *dentry) 273 273 { 274 274 - struct inode *inode = dentry->d_inode; 274 274 + struct inode *inode = d_inode(dentry); 275 275 276 276 if (!logfs_empty_dir(inode)) 277 277 return -ENOTEMPTY; ··· 537 537 static int logfs_link(struct dentry *old_dentry, struct inode *dir, 538 538 struct dentry *dentry) 539 539 { 540 540 - struct inode *inode = old_dentry->d_inode; 540 540 + struct inode *inode = d_inode(old_dentry); 541 541 542 542 inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME; 543 543 ihold(inode); ··· 607 607 /* 2. write target dd */ 608 608 mutex_lock(&super->s_dirop_mutex); 609 609 logfs_add_transaction(new_dir, ta); 610 610 - err = logfs_write_dir(new_dir, new_dentry, old_dentry->d_inode); 610 610 + err = logfs_write_dir(new_dir, new_dentry, d_inode(old_dentry)); 611 611 if (!err) 612 612 err = write_inode(new_dir); 613 613 ··· 658 658 struct inode *new_dir, struct dentry *new_dentry) 659 659 { 660 660 struct logfs_super *super = logfs_super(old_dir->i_sb); 661 661 - struct inode *old_inode = old_dentry->d_inode; 662 662 - struct inode *new_inode = new_dentry->d_inode; 661 661 + struct inode *old_inode = d_inode(old_dentry); 662 662 + struct inode *new_inode = d_inode(new_dentry); 663 663 int isdir = S_ISDIR(old_inode->i_mode); 664 664 struct logfs_disk_dentry dd; 665 665 struct logfs_transaction *ta; ··· 719 719 static int logfs_rename(struct inode *old_dir, struct dentry *old_dentry, 720 720 struct inode *new_dir, struct dentry *new_dentry) 721 721 { 722 722 - if (new_dentry->d_inode) 722 722 + if (d_really_is_positive(new_dentry)) 723 723 return logfs_rename_target(old_dir, old_dentry, 724 724 new_dir, new_dentry); 725 725 return logfs_rename_cross(old_dir, old_dentry, new_dir, new_dentry);

+1 -1

fs/logfs/file.c

reviewed

··· 241 241 242 242 static int logfs_setattr(struct dentry *dentry, struct iattr *attr) 243 243 { 244 244 - struct inode *inode = dentry->d_inode; 244 244 + struct inode *inode = d_inode(dentry); 245 245 int err = 0; 246 246 247 247 err = inode_change_ok(inode, attr);

+2 -2

fs/minix/dir.c

reviewed

··· 156 156 { 157 157 const char * name = dentry->d_name.name; 158 158 int namelen = dentry->d_name.len; 159 159 - struct inode * dir = dentry->d_parent->d_inode; 159 159 + struct inode * dir = d_inode(dentry->d_parent); 160 160 struct super_block * sb = dir->i_sb; 161 161 struct minix_sb_info * sbi = minix_sb(sb); 162 162 unsigned long n; ··· 203 203 204 204 int minix_add_link(struct dentry *dentry, struct inode *inode) 205 205 { 206 206 - struct inode *dir = dentry->d_parent->d_inode; 206 206 + struct inode *dir = d_inode(dentry->d_parent); 207 207 const char * name = dentry->d_name.name; 208 208 int namelen = dentry->d_name.len; 209 209 struct super_block * sb = dir->i_sb;

+1 -1

fs/minix/file.c

reviewed

··· 23 23 24 24 static int minix_setattr(struct dentry *dentry, struct iattr *attr) 25 25 { 26 26 - struct inode *inode = dentry->d_inode; 26 26 + struct inode *inode = d_inode(dentry); 27 27 int error; 28 28 29 29 error = inode_change_ok(inode, attr);

+2 -2

fs/minix/inode.c

reviewed

··· 626 626 int minix_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) 627 627 { 628 628 struct super_block *sb = dentry->d_sb; 629 629 - generic_fillattr(dentry->d_inode, stat); 630 630 - if (INODE_VERSION(dentry->d_inode) == MINIX_V1) 629 629 + generic_fillattr(d_inode(dentry), stat); 630 630 + if (INODE_VERSION(d_inode(dentry)) == MINIX_V1) 631 631 stat->blocks = (BLOCK_SIZE / 512) * V1_minix_blocks(stat->size, sb); 632 632 else 633 633 stat->blocks = (sb->s_blocksize / 512) * V2_minix_blocks(stat->size, sb);

+5 -5

fs/minix/namei.c

reviewed

··· 104 104 static int minix_link(struct dentry * old_dentry, struct inode * dir, 105 105 struct dentry *dentry) 106 106 { 107 107 - struct inode *inode = old_dentry->d_inode; 107 107 + struct inode *inode = d_inode(old_dentry); 108 108 109 109 inode->i_ctime = CURRENT_TIME_SEC; 110 110 inode_inc_link_count(inode); ··· 151 151 static int minix_unlink(struct inode * dir, struct dentry *dentry) 152 152 { 153 153 int err = -ENOENT; 154 154 - struct inode * inode = dentry->d_inode; 154 154 + struct inode * inode = d_inode(dentry); 155 155 struct page * page; 156 156 struct minix_dir_entry * de; 157 157 ··· 171 171 172 172 static int minix_rmdir(struct inode * dir, struct dentry *dentry) 173 173 { 174 174 - struct inode * inode = dentry->d_inode; 174 174 + struct inode * inode = d_inode(dentry); 175 175 int err = -ENOTEMPTY; 176 176 177 177 if (minix_empty_dir(inode)) { ··· 187 187 static int minix_rename(struct inode * old_dir, struct dentry *old_dentry, 188 188 struct inode * new_dir, struct dentry *new_dentry) 189 189 { 190 190 - struct inode * old_inode = old_dentry->d_inode; 191 191 - struct inode * new_inode = new_dentry->d_inode; 190 190 + struct inode * old_inode = d_inode(old_dentry); 191 191 + struct inode * new_inode = d_inode(new_dentry); 192 192 struct page * dir_page = NULL; 193 193 struct minix_dir_entry * dir_de = NULL; 194 194 struct page * old_page;

+4 -2

fs/namei.c

reviewed

··· 1590 1590 1591 1591 if (should_follow_link(path->dentry, follow)) { 1592 1592 if (nd->flags & LOOKUP_RCU) { 1593 1593 - if (unlikely(unlazy_walk(nd, path->dentry))) { 1593 1593 + if (unlikely(nd->path.mnt != path->mnt || 1594 1594 + unlazy_walk(nd, path->dentry))) { 1594 1595 err = -ECHILD; 1595 1596 goto out_err; 1596 1597 } ··· 3046 3045 3047 3046 if (should_follow_link(path->dentry, !symlink_ok)) { 3048 3047 if (nd->flags & LOOKUP_RCU) { 3049 3049 - if (unlikely(unlazy_walk(nd, path->dentry))) { 3048 3048 + if (unlikely(nd->path.mnt != path->mnt || 3049 3049 + unlazy_walk(nd, path->dentry))) { 3050 3050 error = -ECHILD; 3051 3051 goto out; 3052 3052 }

+24 -24

fs/ncpfs/dir.c

reviewed

··· 127 127 static int 128 128 ncp_hash_dentry(const struct dentry *dentry, struct qstr *this) 129 129 { 130 130 - struct inode *inode = ACCESS_ONCE(dentry->d_inode); 130 130 + struct inode *inode = d_inode_rcu(dentry); 131 131 132 132 if (!inode) 133 133 return 0; ··· 162 162 if (len != name->len) 163 163 return 1; 164 164 165 165 - pinode = ACCESS_ONCE(parent->d_inode); 165 165 + pinode = d_inode_rcu(parent); 166 166 if (!pinode) 167 167 return 1; 168 168 ··· 180 180 static int 181 181 ncp_delete_dentry(const struct dentry * dentry) 182 182 { 183 183 - struct inode *inode = dentry->d_inode; 183 183 + struct inode *inode = d_inode(dentry); 184 184 185 185 if (inode) { 186 186 if (is_bad_inode(inode)) ··· 224 224 memset(&info, 0, sizeof(info)); 225 225 226 226 /* remove the Read-Only flag on the NW server */ 227 227 - inode = dentry->d_inode; 227 227 + inode = d_inode(dentry); 228 228 229 229 old_nwattr = NCP_FINFO(inode)->nwattr; 230 230 info.attributes = old_nwattr & ~(aRONLY|aDELETEINHIBIT|aRENAMEINHIBIT); ··· 254 254 { 255 255 struct nw_modify_dos_info info; 256 256 int res=0x90,res2; 257 257 - struct inode *old_inode = old_dentry->d_inode; 257 257 + struct inode *old_inode = d_inode(old_dentry); 258 258 __le32 old_nwattr = NCP_FINFO(old_inode)->nwattr; 259 259 __le32 new_nwattr = 0; /* shut compiler warning */ 260 260 int old_nwattr_changed = 0; ··· 268 268 res2 = ncp_modify_file_or_subdir_dos_info_path(NCP_SERVER(old_inode), old_inode, NULL, DM_ATTRIBUTES, &info); 269 269 if (!res2) 270 270 old_nwattr_changed = 1; 271 271 - if (new_dentry && new_dentry->d_inode) { 272 272 - new_nwattr = NCP_FINFO(new_dentry->d_inode)->nwattr; 271 271 + if (new_dentry && d_really_is_positive(new_dentry)) { 272 272 + new_nwattr = NCP_FINFO(d_inode(new_dentry))->nwattr; 273 273 info.attributes = new_nwattr & ~(aRONLY|aRENAMEINHIBIT|aDELETEINHIBIT); 274 274 res2 = ncp_modify_file_or_subdir_dos_info_path(NCP_SERVER(new_dir), new_dir, _new_name, DM_ATTRIBUTES, &info); 275 275 if (!res2) ··· 324 324 return -ECHILD; 325 325 326 326 parent = dget_parent(dentry); 327 327 - dir = parent->d_inode; 327 327 + dir = d_inode(parent); 328 328 329 329 - if (!dentry->d_inode) 329 329 + if (d_really_is_negative(dentry)) 330 330 goto finished; 331 331 332 332 server = NCP_SERVER(dir); ··· 367 367 * what we remember, it's not valid any more. 368 368 */ 369 369 if (!res) { 370 370 - struct inode *inode = dentry->d_inode; 370 370 + struct inode *inode = d_inode(dentry); 371 371 372 372 mutex_lock(&inode->i_mutex); 373 373 if (finfo.i.dirEntNum == NCP_FINFO(inode)->dirEntNum) { ··· 388 388 389 389 static time_t ncp_obtain_mtime(struct dentry *dentry) 390 390 { 391 391 - struct inode *inode = dentry->d_inode; 391 391 + struct inode *inode = d_inode(dentry); 392 392 struct ncp_server *server = NCP_SERVER(inode); 393 393 struct nw_info_struct i; 394 394 ··· 404 404 static inline void 405 405 ncp_invalidate_dircache_entries(struct dentry *parent) 406 406 { 407 407 - struct ncp_server *server = NCP_SERVER(parent->d_inode); 407 407 + struct ncp_server *server = NCP_SERVER(d_inode(parent)); 408 408 struct dentry *dentry; 409 409 410 410 spin_lock(&parent->d_lock); ··· 418 418 static int ncp_readdir(struct file *file, struct dir_context *ctx) 419 419 { 420 420 struct dentry *dentry = file->f_path.dentry; 421 421 - struct inode *inode = dentry->d_inode; 421 421 + struct inode *inode = d_inode(dentry); 422 422 struct page *page = NULL; 423 423 struct ncp_server *server = NCP_SERVER(inode); 424 424 union ncp_dir_cache *cache = NULL; ··· 491 491 goto invalid_cache; 492 492 } 493 493 spin_unlock(&dentry->d_lock); 494 494 - if (!dent->d_inode) { 494 494 + if (d_really_is_negative(dent)) { 495 495 dput(dent); 496 496 goto invalid_cache; 497 497 } 498 498 over = !dir_emit(ctx, dent->d_name.name, 499 499 dent->d_name.len, 500 500 - dent->d_inode->i_ino, DT_UNKNOWN); 500 500 + d_inode(dent)->i_ino, DT_UNKNOWN); 501 501 dput(dent); 502 502 if (over) 503 503 goto finished; ··· 571 571 { 572 572 if (!dentry->d_fsdata) /* not referenced from page cache */ 573 573 return; 574 574 - NCP_FINFO(dentry->d_parent->d_inode)->flags &= ~NCPI_DIR_CACHE; 574 574 + NCP_FINFO(d_inode(dentry->d_parent))->flags &= ~NCPI_DIR_CACHE; 575 575 } 576 576 577 577 static int ··· 580 580 int inval_childs) 581 581 { 582 582 struct dentry *newdent, *dentry = file->f_path.dentry; 583 583 - struct inode *dir = dentry->d_inode; 583 583 + struct inode *dir = d_inode(dentry); 584 584 struct ncp_cache_control ctl = *ctrl; 585 585 struct qstr qname; 586 586 int valid = 0; ··· 621 621 dentry_update_name_case(newdent, &qname); 622 622 } 623 623 624 624 - if (!newdent->d_inode) { 624 624 + if (d_really_is_negative(newdent)) { 625 625 struct inode *inode; 626 626 627 627 entry->opened = 0; ··· 637 637 spin_unlock(&dentry->d_lock); 638 638 } 639 639 } else { 640 640 - struct inode *inode = newdent->d_inode; 640 640 + struct inode *inode = d_inode(newdent); 641 641 642 642 mutex_lock_nested(&inode->i_mutex, I_MUTEX_CHILD); 643 643 ncp_update_inode2(inode, entry); ··· 659 659 ctl.cache = kmap(ctl.page); 660 660 } 661 661 if (ctl.cache) { 662 662 - if (newdent->d_inode) { 662 662 + if (d_really_is_positive(newdent)) { 663 663 newdent->d_fsdata = newdent; 664 664 ctl.cache->dentry[ctl.idx] = newdent; 665 665 - ino = newdent->d_inode->i_ino; 665 665 + ino = d_inode(newdent)->i_ino; 666 666 ncp_new_dentry(newdent); 667 667 } 668 668 valid = 1; ··· 807 807 } 808 808 dent = sb->s_root; 809 809 if (dent) { 810 810 - struct inode* ino = dent->d_inode; 810 810 + struct inode* ino = d_inode(dent); 811 811 if (ino) { 812 812 ncp_update_known_namespace(server, volNumber, NULL); 813 813 NCP_FINFO(ino)->volNumber = volNumber; ··· 815 815 NCP_FINFO(ino)->DosDirNum = DosDirNum; 816 816 result = 0; 817 817 } else { 818 818 - ncp_dbg(1, "sb->s_root->d_inode == NULL!\n"); 818 818 + ncp_dbg(1, "d_inode(sb->s_root) == NULL!\n"); 819 819 } 820 820 } else { 821 821 ncp_dbg(1, "sb->s_root == NULL!\n"); ··· 1055 1055 1056 1056 static int ncp_unlink(struct inode *dir, struct dentry *dentry) 1057 1057 { 1058 1058 - struct inode *inode = dentry->d_inode; 1058 1058 + struct inode *inode = d_inode(dentry); 1059 1059 struct ncp_server *server; 1060 1060 int error; 1061 1061

+3 -3

fs/ncpfs/inode.c

reviewed

··· 812 812 if (!d) { 813 813 goto dflt; 814 814 } 815 815 - i = d->d_inode; 815 815 + i = d_inode(d); 816 816 if (!i) { 817 817 goto dflt; 818 818 } ··· 865 865 866 866 int ncp_notify_change(struct dentry *dentry, struct iattr *attr) 867 867 { 868 868 - struct inode *inode = dentry->d_inode; 868 868 + struct inode *inode = d_inode(dentry); 869 869 int result = 0; 870 870 __le32 info_mask; 871 871 struct nw_modify_dos_info info; ··· 878 878 goto out; 879 879 880 880 result = -EPERM; 881 881 - if (IS_DEADDIR(dentry->d_inode)) 881 881 + if (IS_DEADDIR(d_inode(dentry))) 882 882 goto out; 883 883 884 884 /* ageing the dentry to force validation */

+4 -4

fs/ncpfs/ioctl.c

reviewed

··· 376 376 struct dentry* dentry = inode->i_sb->s_root; 377 377 378 378 if (dentry) { 379 379 - struct inode* s_inode = dentry->d_inode; 379 379 + struct inode* s_inode = d_inode(dentry); 380 380 381 381 if (s_inode) { 382 382 sr.volNumber = NCP_FINFO(s_inode)->volNumber; ··· 384 384 sr.namespace = server->name_space[sr.volNumber]; 385 385 result = 0; 386 386 } else 387 387 - ncp_dbg(1, "s_root->d_inode==NULL\n"); 387 387 + ncp_dbg(1, "d_inode(s_root)==NULL\n"); 388 388 } else 389 389 ncp_dbg(1, "s_root==NULL\n"); 390 390 } else { ··· 431 431 if (result == 0) { 432 432 dentry = inode->i_sb->s_root; 433 433 if (dentry) { 434 434 - struct inode* s_inode = dentry->d_inode; 434 434 + struct inode* s_inode = d_inode(dentry); 435 435 436 436 if (s_inode) { 437 437 NCP_FINFO(s_inode)->volNumber = vnum; ··· 439 439 NCP_FINFO(s_inode)->DosDirNum = dosde; 440 440 server->root_setuped = 1; 441 441 } else { 442 442 - ncp_dbg(1, "s_root->d_inode==NULL\n"); 442 442 + ncp_dbg(1, "d_inode(s_root)==NULL\n"); 443 443 result = -EIO; 444 444 } 445 445 } else {

+1 -1

fs/ncpfs/ncplib_kernel.c

reviewed

··· 727 727 ncp_del_file_or_subdir2(struct ncp_server *server, 728 728 struct dentry *dentry) 729 729 { 730 730 - struct inode *inode = dentry->d_inode; 730 730 + struct inode *inode = d_inode(dentry); 731 731 __u8 volnum; 732 732 __le32 dirent; 733 733

+1 -1

fs/ncpfs/symlink.c

reviewed

··· 156 156 goto failfree; 157 157 } 158 158 159 159 - inode=dentry->d_inode; 159 159 + inode=d_inode(dentry); 160 160 161 161 if (ncp_make_open(inode, O_WRONLY)) 162 162 goto failfree;

+29 -30

fs/nfs/dir.c

reviewed

··· 416 416 { 417 417 struct nfs_inode *nfsi; 418 418 419 419 - if (dentry->d_inode == NULL) 420 420 - goto different; 419 419 + if (d_really_is_negative(dentry)) 420 420 + return 0; 421 421 422 422 - nfsi = NFS_I(dentry->d_inode); 422 422 + nfsi = NFS_I(d_inode(dentry)); 423 423 if (entry->fattr->fileid == nfsi->fileid) 424 424 return 1; 425 425 if (nfs_compare_fh(entry->fh, &nfsi->fh) == 0) 426 426 return 1; 427 427 - different: 428 427 return 0; 429 428 } 430 429 ··· 472 473 struct qstr filename = QSTR_INIT(entry->name, entry->len); 473 474 struct dentry *dentry; 474 475 struct dentry *alias; 475 475 - struct inode *dir = parent->d_inode; 476 476 + struct inode *dir = d_inode(parent); 476 477 struct inode *inode; 477 478 int status; 478 479 ··· 496 497 goto out; 497 498 if (nfs_same_file(dentry, entry)) { 498 499 nfs_set_verifier(dentry, nfs_save_change_attribute(dir)); 499 499 - status = nfs_refresh_inode(dentry->d_inode, entry->fattr); 500 500 + status = nfs_refresh_inode(d_inode(dentry), entry->fattr); 500 501 if (!status) 501 501 - nfs_setsecurity(dentry->d_inode, entry->fattr, entry->label); 502 502 + nfs_setsecurity(d_inode(dentry), entry->fattr, entry->label); 502 503 goto out; 503 504 } else { 504 505 d_invalidate(dentry); ··· 869 870 static int nfs_readdir(struct file *file, struct dir_context *ctx) 870 871 { 871 872 struct dentry *dentry = file->f_path.dentry; 872 872 - struct inode *inode = dentry->d_inode; 873 873 + struct inode *inode = d_inode(dentry); 873 874 nfs_readdir_descriptor_t my_desc, 874 875 *desc = &my_desc; 875 876 struct nfs_open_dir_context *dir_ctx = file->private_data; ··· 1117 1118 1118 1119 if (flags & LOOKUP_RCU) { 1119 1120 parent = ACCESS_ONCE(dentry->d_parent); 1120 1120 - dir = ACCESS_ONCE(parent->d_inode); 1121 1121 + dir = d_inode_rcu(parent); 1121 1122 if (!dir) 1122 1123 return -ECHILD; 1123 1124 } else { 1124 1125 parent = dget_parent(dentry); 1125 1125 - dir = parent->d_inode; 1126 1126 + dir = d_inode(parent); 1126 1127 } 1127 1128 nfs_inc_stats(dir, NFSIOS_DENTRYREVALIDATE); 1128 1128 - inode = dentry->d_inode; 1129 1129 + inode = d_inode(dentry); 1129 1130 1130 1131 if (!inode) { 1131 1132 if (nfs_neg_need_reval(dir, dentry, flags)) { ··· 1241 1242 } 1242 1243 1243 1244 /* 1244 1244 - * A weaker form of d_revalidate for revalidating just the dentry->d_inode 1245 1245 + * A weaker form of d_revalidate for revalidating just the d_inode(dentry) 1245 1246 * when we don't really care about the dentry name. This is called when a 1246 1247 * pathwalk ends on a dentry that was not found via a normal lookup in the 1247 1248 * parent dir (e.g.: ".", "..", procfs symlinks or mountpoint traversals). ··· 1252 1253 static int nfs_weak_revalidate(struct dentry *dentry, unsigned int flags) 1253 1254 { 1254 1255 int error; 1255 1255 - struct inode *inode = dentry->d_inode; 1256 1256 + struct inode *inode = d_inode(dentry); 1256 1257 1257 1258 /* 1258 1259 * I believe we can only get a negative dentry here in the case of a ··· 1286 1287 dentry, dentry->d_flags); 1287 1288 1288 1289 /* Unhash any dentry with a stale inode */ 1289 1289 - if (dentry->d_inode != NULL && NFS_STALE(dentry->d_inode)) 1290 1290 + if (d_really_is_positive(dentry) && NFS_STALE(d_inode(dentry))) 1290 1291 return 1; 1291 1292 1292 1293 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) { ··· 1490 1491 int err; 1491 1492 1492 1493 /* Expect a negative dentry */ 1493 1493 - BUG_ON(dentry->d_inode); 1494 1494 + BUG_ON(d_inode(dentry)); 1494 1495 1495 1496 dfprintk(VFS, "NFS: atomic_open(%s/%lu), %pd\n", 1496 1497 dir->i_sb->s_id, dir->i_ino, dentry); ··· 1586 1587 if (NFS_SB(dentry->d_sb)->caps & NFS_CAP_ATOMIC_OPEN_V1) 1587 1588 goto no_open; 1588 1589 1589 1589 - inode = dentry->d_inode; 1590 1590 + inode = d_inode(dentry); 1590 1591 1591 1592 /* We can't create new files in nfs_open_revalidate(), so we 1592 1593 * optimize away revalidation of negative dentries. ··· 1597 1598 1598 1599 if (flags & LOOKUP_RCU) { 1599 1600 parent = ACCESS_ONCE(dentry->d_parent); 1600 1600 - dir = ACCESS_ONCE(parent->d_inode); 1601 1601 + dir = d_inode_rcu(parent); 1601 1602 if (!dir) 1602 1603 return -ECHILD; 1603 1604 } else { 1604 1605 parent = dget_parent(dentry); 1605 1605 - dir = parent->d_inode; 1606 1606 + dir = d_inode(parent); 1606 1607 } 1607 1608 if (!nfs_neg_need_reval(dir, dentry, flags)) 1608 1609 ret = 1; ··· 1642 1643 struct nfs4_label *label) 1643 1644 { 1644 1645 struct dentry *parent = dget_parent(dentry); 1645 1645 - struct inode *dir = parent->d_inode; 1646 1646 + struct inode *dir = d_inode(parent); 1646 1647 struct inode *inode; 1647 1648 int error = -EACCES; 1648 1649 1649 1650 d_drop(dentry); 1650 1651 1651 1652 /* We may have been initialized further down */ 1652 1652 - if (dentry->d_inode) 1653 1653 + if (d_really_is_positive(dentry)) 1653 1654 goto out; 1654 1655 if (fhandle->size == 0) { 1655 1656 error = NFS_PROTO(dir)->lookup(dir, &dentry->d_name, fhandle, fattr, NULL); ··· 1767 1768 1768 1769 static void nfs_dentry_handle_enoent(struct dentry *dentry) 1769 1770 { 1770 1770 - if (dentry->d_inode != NULL && !d_unhashed(dentry)) 1771 1771 + if (d_really_is_positive(dentry) && !d_unhashed(dentry)) 1771 1772 d_delete(dentry); 1772 1773 } 1773 1774 ··· 1779 1780 dir->i_sb->s_id, dir->i_ino, dentry); 1780 1781 1781 1782 trace_nfs_rmdir_enter(dir, dentry); 1782 1782 - if (dentry->d_inode) { 1783 1783 + if (d_really_is_positive(dentry)) { 1783 1784 nfs_wait_on_sillyrename(dentry); 1784 1785 error = NFS_PROTO(dir)->rmdir(dir, &dentry->d_name); 1785 1786 /* Ensure the VFS deletes this inode */ 1786 1787 switch (error) { 1787 1788 case 0: 1788 1788 - clear_nlink(dentry->d_inode); 1789 1789 + clear_nlink(d_inode(dentry)); 1789 1790 break; 1790 1791 case -ENOENT: 1791 1792 nfs_dentry_handle_enoent(dentry); ··· 1807 1808 */ 1808 1809 static int nfs_safe_remove(struct dentry *dentry) 1809 1810 { 1810 1810 - struct inode *dir = dentry->d_parent->d_inode; 1811 1811 - struct inode *inode = dentry->d_inode; 1811 1811 + struct inode *dir = d_inode(dentry->d_parent); 1812 1812 + struct inode *inode = d_inode(dentry); 1812 1813 int error = -EBUSY; 1813 1814 1814 1815 dfprintk(VFS, "NFS: safe_remove(%pd2)\n", dentry); ··· 1852 1853 if (d_count(dentry) > 1) { 1853 1854 spin_unlock(&dentry->d_lock); 1854 1855 /* Start asynchronous writeout of the inode */ 1855 1855 - write_inode_now(dentry->d_inode, 0); 1856 1856 + write_inode_now(d_inode(dentry), 0); 1856 1857 error = nfs_sillyrename(dir, dentry); 1857 1858 goto out; 1858 1859 } ··· 1930 1931 * No big deal if we can't add this page to the page cache here. 1931 1932 * READLINK will get the missing page from the server if needed. 1932 1933 */ 1933 1933 - if (!add_to_page_cache_lru(page, dentry->d_inode->i_mapping, 0, 1934 1934 + if (!add_to_page_cache_lru(page, d_inode(dentry)->i_mapping, 0, 1934 1935 GFP_KERNEL)) { 1935 1936 SetPageUptodate(page); 1936 1937 unlock_page(page); ··· 1949 1950 int 1950 1951 nfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry) 1951 1952 { 1952 1952 - struct inode *inode = old_dentry->d_inode; 1953 1953 + struct inode *inode = d_inode(old_dentry); 1953 1954 int error; 1954 1955 1955 1956 dfprintk(VFS, "NFS: link(%pd2 -> %pd2)\n", ··· 1996 1997 int nfs_rename(struct inode *old_dir, struct dentry *old_dentry, 1997 1998 struct inode *new_dir, struct dentry *new_dentry) 1998 1999 { 1999 1999 - struct inode *old_inode = old_dentry->d_inode; 2000 2000 - struct inode *new_inode = new_dentry->d_inode; 2000 2000 + struct inode *old_inode = d_inode(old_dentry); 2001 2001 + struct inode *new_inode = d_inode(new_dentry); 2001 2002 struct dentry *dentry = NULL, *rehash = NULL; 2002 2003 struct rpc_task *task; 2003 2004 int error = -EBUSY;

+7 -7

fs/nfs/direct.c

reviewed

··· 386 386 if (write) 387 387 nfs_zap_mapping(inode, inode->i_mapping); 388 388 389 389 - inode_dio_done(inode); 389 389 + inode_dio_end(inode); 390 390 391 391 if (dreq->iocb) { 392 392 long res = (long) dreq->error; ··· 403 403 static void nfs_direct_readpage_release(struct nfs_page *req) 404 404 { 405 405 dprintk("NFS: direct read done (%s/%llu %d@%lld)\n", 406 406 - req->wb_context->dentry->d_inode->i_sb->s_id, 407 407 - (unsigned long long)NFS_FILEID(req->wb_context->dentry->d_inode), 406 406 + d_inode(req->wb_context->dentry)->i_sb->s_id, 407 407 + (unsigned long long)NFS_FILEID(d_inode(req->wb_context->dentry)), 408 408 req->wb_bytes, 409 409 (long long)req_offset(req)); 410 410 nfs_release_request(req); ··· 486 486 &nfs_direct_read_completion_ops); 487 487 get_dreq(dreq); 488 488 desc.pg_dreq = dreq; 489 489 - atomic_inc(&inode->i_dio_count); 489 489 + inode_dio_begin(inode); 490 490 491 491 while (iov_iter_count(iter)) { 492 492 struct page **pagevec; ··· 538 538 * generic layer handle the completion. 539 539 */ 540 540 if (requested_bytes == 0) { 541 541 - inode_dio_done(inode); 541 541 + inode_dio_end(inode); 542 542 nfs_direct_req_release(dreq); 543 543 return result < 0 ? result : -EIO; 544 544 } ··· 872 872 &nfs_direct_write_completion_ops); 873 873 desc.pg_dreq = dreq; 874 874 get_dreq(dreq); 875 875 - atomic_inc(&inode->i_dio_count); 875 875 + inode_dio_begin(inode); 876 876 877 877 NFS_I(inode)->write_io += iov_iter_count(iter); 878 878 while (iov_iter_count(iter)) { ··· 928 928 * generic layer handle the completion. 929 929 */ 930 930 if (requested_bytes == 0) { 931 931 - inode_dio_done(inode); 931 931 + inode_dio_end(inode); 932 932 nfs_direct_req_release(dreq); 933 933 return result < 0 ? result : -EIO; 934 934 }

+2 -2

fs/nfs/getroot.c

reviewed

··· 56 56 * This again causes shrink_dcache_for_umount_subtree() to 57 57 * Oops, since the test for IS_ROOT() will fail. 58 58 */ 59 59 - spin_lock(&sb->s_root->d_inode->i_lock); 59 59 + spin_lock(&d_inode(sb->s_root)->i_lock); 60 60 spin_lock(&sb->s_root->d_lock); 61 61 hlist_del_init(&sb->s_root->d_u.d_alias); 62 62 spin_unlock(&sb->s_root->d_lock); 63 63 - spin_unlock(&sb->s_root->d_inode->i_lock); 63 63 + spin_unlock(&d_inode(sb->s_root)->i_lock); 64 64 } 65 65 return 0; 66 66 }

+9 -9

fs/nfs/inode.c

reviewed

··· 495 495 int 496 496 nfs_setattr(struct dentry *dentry, struct iattr *attr) 497 497 { 498 498 - struct inode *inode = dentry->d_inode; 498 498 + struct inode *inode = d_inode(dentry); 499 499 struct nfs_fattr *fattr; 500 500 int error = -ENOMEM; 501 501 ··· 621 621 struct dentry *parent; 622 622 623 623 parent = dget_parent(dentry); 624 624 - nfs_force_use_readdirplus(parent->d_inode); 624 624 + nfs_force_use_readdirplus(d_inode(parent)); 625 625 dput(parent); 626 626 } 627 627 ··· 637 637 638 638 int nfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) 639 639 { 640 640 - struct inode *inode = dentry->d_inode; 640 640 + struct inode *inode = d_inode(dentry); 641 641 int need_atime = NFS_I(inode)->cache_validity & NFS_INO_INVALID_ATIME; 642 642 int err = 0; 643 643 ··· 708 708 struct nfs_lock_context *nfs_get_lock_context(struct nfs_open_context *ctx) 709 709 { 710 710 struct nfs_lock_context *res, *new = NULL; 711 711 - struct inode *inode = ctx->dentry->d_inode; 711 711 + struct inode *inode = d_inode(ctx->dentry); 712 712 713 713 spin_lock(&inode->i_lock); 714 714 res = __nfs_find_lock_context(ctx); ··· 736 736 void nfs_put_lock_context(struct nfs_lock_context *l_ctx) 737 737 { 738 738 struct nfs_open_context *ctx = l_ctx->open_context; 739 739 - struct inode *inode = ctx->dentry->d_inode; 739 739 + struct inode *inode = d_inode(ctx->dentry); 740 740 741 741 if (!atomic_dec_and_lock(&l_ctx->count, &inode->i_lock)) 742 742 return; ··· 763 763 return; 764 764 if (!is_sync) 765 765 return; 766 766 - inode = ctx->dentry->d_inode; 766 766 + inode = d_inode(ctx->dentry); 767 767 if (!list_empty(&NFS_I(inode)->open_files)) 768 768 return; 769 769 server = NFS_SERVER(inode); ··· 810 810 811 811 static void __put_nfs_open_context(struct nfs_open_context *ctx, int is_sync) 812 812 { 813 813 - struct inode *inode = ctx->dentry->d_inode; 813 813 + struct inode *inode = d_inode(ctx->dentry); 814 814 struct super_block *sb = ctx->dentry->d_sb; 815 815 816 816 if (!list_empty(&ctx->list)) { ··· 842 842 */ 843 843 void nfs_inode_attach_open_context(struct nfs_open_context *ctx) 844 844 { 845 845 - struct inode *inode = ctx->dentry->d_inode; 845 845 + struct inode *inode = d_inode(ctx->dentry); 846 846 struct nfs_inode *nfsi = NFS_I(inode); 847 847 848 848 spin_lock(&inode->i_lock); ··· 885 885 struct nfs_open_context *ctx = nfs_file_open_context(filp); 886 886 887 887 if (ctx) { 888 888 - struct inode *inode = ctx->dentry->d_inode; 888 888 + struct inode *inode = d_inode(ctx->dentry); 889 889 890 890 filp->private_data = NULL; 891 891 spin_lock(&inode->i_lock);

+5 -5

fs/nfs/namespace.c

reviewed

··· 139 139 struct vfsmount *nfs_d_automount(struct path *path) 140 140 { 141 141 struct vfsmount *mnt; 142 142 - struct nfs_server *server = NFS_SERVER(path->dentry->d_inode); 142 142 + struct nfs_server *server = NFS_SERVER(d_inode(path->dentry)); 143 143 struct nfs_fh *fh = NULL; 144 144 struct nfs_fattr *fattr = NULL; 145 145 ··· 180 180 static int 181 181 nfs_namespace_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) 182 182 { 183 183 - if (NFS_FH(dentry->d_inode)->size != 0) 183 183 + if (NFS_FH(d_inode(dentry))->size != 0) 184 184 return nfs_getattr(mnt, dentry, stat); 185 185 - generic_fillattr(dentry->d_inode, stat); 185 185 + generic_fillattr(d_inode(dentry), stat); 186 186 return 0; 187 187 } 188 188 189 189 static int 190 190 nfs_namespace_setattr(struct dentry *dentry, struct iattr *attr) 191 191 { 192 192 - if (NFS_FH(dentry->d_inode)->size != 0) 192 192 + if (NFS_FH(d_inode(dentry))->size != 0) 193 193 return nfs_setattr(dentry, attr); 194 194 return -EACCES; 195 195 } ··· 279 279 struct dentry *parent = dget_parent(dentry); 280 280 281 281 /* Look it up again to get its attributes */ 282 282 - err = server->nfs_client->rpc_ops->lookup(parent->d_inode, &dentry->d_name, fh, fattr, NULL); 282 282 + err = server->nfs_client->rpc_ops->lookup(d_inode(parent), &dentry->d_name, fh, fattr, NULL); 283 283 dput(parent); 284 284 if (err != 0) 285 285 return ERR_PTR(err);

+1 -1

fs/nfs/nfs3acl.c

reviewed

··· 279 279 ssize_t 280 280 nfs3_listxattr(struct dentry *dentry, char *data, size_t size) 281 281 { 282 282 - struct inode *inode = dentry->d_inode; 282 282 + struct inode *inode = d_inode(dentry); 283 283 ssize_t result = 0; 284 284 int error; 285 285

+6 -6

fs/nfs/nfs3proc.c

reviewed

··· 120 120 nfs3_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr, 121 121 struct iattr *sattr) 122 122 { 123 123 - struct inode *inode = dentry->d_inode; 123 123 + struct inode *inode = d_inode(dentry); 124 124 struct nfs3_sattrargs arg = { 125 125 .fh = NFS_FH(inode), 126 126 .sattr = sattr, ··· 386 386 * not sure this buys us anything (and I'd have 387 387 * to revamp the NFSv3 XDR code) */ 388 388 status = nfs3_proc_setattr(dentry, data->res.fattr, sattr); 389 389 - nfs_post_op_update_inode(dentry->d_inode, data->res.fattr); 389 389 + nfs_post_op_update_inode(d_inode(dentry), data->res.fattr); 390 390 dprintk("NFS reply setattr (post-create): %d\n", status); 391 391 if (status != 0) 392 392 goto out_release_acls; 393 393 } 394 394 395 395 - status = nfs3_proc_setacls(dentry->d_inode, acl, default_acl); 395 395 + status = nfs3_proc_setacls(d_inode(dentry), acl, default_acl); 396 396 397 397 out_release_acls: 398 398 posix_acl_release(acl); ··· 570 570 if (status != 0) 571 571 goto out_release_acls; 572 572 573 573 - status = nfs3_proc_setacls(dentry->d_inode, acl, default_acl); 573 573 + status = nfs3_proc_setacls(d_inode(dentry), acl, default_acl); 574 574 575 575 out_release_acls: 576 576 posix_acl_release(acl); ··· 623 623 nfs3_proc_readdir(struct dentry *dentry, struct rpc_cred *cred, 624 624 u64 cookie, struct page **pages, unsigned int count, int plus) 625 625 { 626 626 - struct inode *dir = dentry->d_inode; 626 626 + struct inode *dir = d_inode(dentry); 627 627 __be32 *verf = NFS_I(dir)->cookieverf; 628 628 struct nfs3_readdirargs arg = { 629 629 .fh = NFS_FH(dir), ··· 715 715 if (status != 0) 716 716 goto out_release_acls; 717 717 718 718 - status = nfs3_proc_setacls(dentry->d_inode, acl, default_acl); 718 718 + status = nfs3_proc_setacls(d_inode(dentry), acl, default_acl); 719 719 720 720 out_release_acls: 721 721 posix_acl_release(acl);

+1 -1

fs/nfs/nfs4client.c

reviewed

··· 1130 1130 */ 1131 1131 static int nfs_probe_destination(struct nfs_server *server) 1132 1132 { 1133 1133 - struct inode *inode = server->super->s_root->d_inode; 1133 1133 + struct inode *inode = d_inode(server->super->s_root); 1134 1134 struct nfs_fattr *fattr; 1135 1135 int error; 1136 1136

+2 -2

fs/nfs/nfs4file.c

reviewed

··· 46 46 openflags &= ~(O_CREAT|O_EXCL); 47 47 48 48 parent = dget_parent(dentry); 49 49 - dir = parent->d_inode; 49 49 + dir = d_inode(parent); 50 50 51 51 ctx = alloc_nfs_open_context(filp->f_path.dentry, filp->f_mode); 52 52 err = PTR_ERR(ctx); ··· 74 74 goto out_drop; 75 75 } 76 76 } 77 77 - if (inode != dentry->d_inode) 77 77 + if (inode != d_inode(dentry)) 78 78 goto out_drop; 79 79 80 80 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));

+2 -2

fs/nfs/nfs4namespace.c

reviewed

··· 375 375 dprintk("%s: getting locations for %pd2\n", 376 376 __func__, dentry); 377 377 378 378 - err = nfs4_proc_fs_locations(client, parent->d_inode, &dentry->d_name, fs_locations, page); 378 378 + err = nfs4_proc_fs_locations(client, d_inode(parent), &dentry->d_name, fs_locations, page); 379 379 dput(parent); 380 380 if (err != 0 || 381 381 fs_locations->nlocations <= 0 || ··· 396 396 { 397 397 rpc_authflavor_t flavor = server->client->cl_auth->au_flavor; 398 398 struct dentry *parent = dget_parent(dentry); 399 399 - struct inode *dir = parent->d_inode; 399 399 + struct inode *dir = d_inode(parent); 400 400 struct qstr *name = &dentry->d_name; 401 401 struct rpc_clnt *client; 402 402 struct vfsmount *mnt;

+30 -30

fs/nfs/nfs4proc.c

reviewed

··· 293 293 *p++ = xdr_one; /* bitmap length */ 294 294 *p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap */ 295 295 *p++ = htonl(8); /* attribute buffer length */ 296 296 - p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_inode)); 296 296 + p = xdr_encode_hyper(p, NFS_FILEID(d_inode(dentry))); 297 297 } 298 298 299 299 *p++ = xdr_one; /* next */ ··· 305 305 *p++ = xdr_one; /* bitmap length */ 306 306 *p++ = htonl(FATTR4_WORD0_FILEID); /* bitmap */ 307 307 *p++ = htonl(8); /* attribute buffer length */ 308 308 - p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_parent->d_inode)); 308 308 + p = xdr_encode_hyper(p, NFS_FILEID(d_inode(dentry->d_parent))); 309 309 310 310 readdir->pgbase = (char *)p - (char *)start; 311 311 readdir->count -= readdir->pgbase; ··· 1004 1004 gfp_t gfp_mask) 1005 1005 { 1006 1006 struct dentry *parent = dget_parent(dentry); 1007 1007 - struct inode *dir = parent->d_inode; 1007 1007 + struct inode *dir = d_inode(parent); 1008 1008 struct nfs_server *server = NFS_SERVER(dir); 1009 1009 struct nfs_seqid *(*alloc_seqid)(struct nfs_seqid_counter *, gfp_t); 1010 1010 struct nfs4_opendata *p; ··· 1057 1057 case NFS4_OPEN_CLAIM_FH: 1058 1058 case NFS4_OPEN_CLAIM_DELEG_CUR_FH: 1059 1059 case NFS4_OPEN_CLAIM_DELEG_PREV_FH: 1060 1060 - p->o_arg.fh = NFS_FH(dentry->d_inode); 1060 1060 + p->o_arg.fh = NFS_FH(d_inode(dentry)); 1061 1061 } 1062 1062 if (attrs != NULL && attrs->ia_valid != 0) { 1063 1063 __u32 verf[2]; ··· 1794 1794 */ 1795 1795 static int _nfs4_proc_open_confirm(struct nfs4_opendata *data) 1796 1796 { 1797 1797 - struct nfs_server *server = NFS_SERVER(data->dir->d_inode); 1797 1797 + struct nfs_server *server = NFS_SERVER(d_inode(data->dir)); 1798 1798 struct rpc_task *task; 1799 1799 struct rpc_message msg = { 1800 1800 .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_CONFIRM], ··· 1951 1951 1952 1952 static int nfs4_run_open_task(struct nfs4_opendata *data, int isrecover) 1953 1953 { 1954 1954 - struct inode *dir = data->dir->d_inode; 1954 1954 + struct inode *dir = d_inode(data->dir); 1955 1955 struct nfs_server *server = NFS_SERVER(dir); 1956 1956 struct nfs_openargs *o_arg = &data->o_arg; 1957 1957 struct nfs_openres *o_res = &data->o_res; ··· 1998 1998 1999 1999 static int _nfs4_recover_proc_open(struct nfs4_opendata *data) 2000 2000 { 2001 2001 - struct inode *dir = data->dir->d_inode; 2001 2001 + struct inode *dir = d_inode(data->dir); 2002 2002 struct nfs_openres *o_res = &data->o_res; 2003 2003 int status; 2004 2004 ··· 2067 2067 */ 2068 2068 static int _nfs4_proc_open(struct nfs4_opendata *data) 2069 2069 { 2070 2070 - struct inode *dir = data->dir->d_inode; 2070 2070 + struct inode *dir = d_inode(data->dir); 2071 2071 struct nfs_server *server = NFS_SERVER(dir); 2072 2072 struct nfs_openargs *o_arg = &data->o_arg; 2073 2073 struct nfs_openres *o_res = &data->o_res; ··· 2314 2314 set_bit(NFS_STATE_POSIX_LOCKS, &state->flags); 2315 2315 2316 2316 dentry = opendata->dentry; 2317 2317 - if (dentry->d_inode == NULL) { 2317 2317 + if (d_really_is_negative(dentry)) { 2318 2318 /* FIXME: Is this d_drop() ever needed? */ 2319 2319 d_drop(dentry); 2320 2320 dentry = d_add_unique(dentry, igrab(state->inode)); ··· 2325 2325 ctx->dentry = dget(dentry); 2326 2326 } 2327 2327 nfs_set_verifier(dentry, 2328 2328 - nfs_save_change_attribute(opendata->dir->d_inode)); 2328 2328 + nfs_save_change_attribute(d_inode(opendata->dir))); 2329 2329 } 2330 2330 2331 2331 ret = nfs4_opendata_access(sp->so_cred, opendata, state, fmode, flags); ··· 2333 2333 goto out; 2334 2334 2335 2335 ctx->state = state; 2336 2336 - if (dentry->d_inode == state->inode) { 2336 2336 + if (d_inode(dentry) == state->inode) { 2337 2337 nfs_inode_attach_open_context(ctx); 2338 2338 if (read_seqcount_retry(&sp->so_reclaim_seqcount, seq)) 2339 2339 nfs4_schedule_stateid_recovery(server, state); ··· 2374 2374 status = nfs4_recover_expired_lease(server); 2375 2375 if (status != 0) 2376 2376 goto err_put_state_owner; 2377 2377 - if (dentry->d_inode != NULL) 2378 2378 - nfs4_return_incompatible_delegation(dentry->d_inode, fmode); 2377 2377 + if (d_really_is_positive(dentry)) 2378 2378 + nfs4_return_incompatible_delegation(d_inode(dentry), fmode); 2379 2379 status = -ENOMEM; 2380 2380 - if (dentry->d_inode) 2380 2380 + if (d_really_is_positive(dentry)) 2381 2381 claim = NFS4_OPEN_CLAIM_FH; 2382 2382 opendata = nfs4_opendata_alloc(dentry, sp, fmode, flags, sattr, 2383 2383 label, claim, GFP_KERNEL); ··· 2400 2400 } 2401 2401 opendata->o_arg.open_bitmap = &nfs4_pnfs_open_bitmap[0]; 2402 2402 } 2403 2403 - if (dentry->d_inode != NULL) 2404 2404 - opendata->state = nfs4_get_open_state(dentry->d_inode, sp); 2403 2403 + if (d_really_is_positive(dentry)) 2404 2404 + opendata->state = nfs4_get_open_state(d_inode(dentry), sp); 2405 2405 2406 2406 status = _nfs4_open_and_get_state(opendata, fmode, flags, ctx); 2407 2407 if (status != 0) ··· 3254 3254 nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr, 3255 3255 struct iattr *sattr) 3256 3256 { 3257 3257 - struct inode *inode = dentry->d_inode; 3257 3257 + struct inode *inode = d_inode(dentry); 3258 3258 struct rpc_cred *cred = NULL; 3259 3259 struct nfs4_state *state = NULL; 3260 3260 struct nfs4_label *label = NULL; ··· 3871 3871 static int _nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred, 3872 3872 u64 cookie, struct page **pages, unsigned int count, int plus) 3873 3873 { 3874 3874 - struct inode *dir = dentry->d_inode; 3874 3874 + struct inode *dir = d_inode(dentry); 3875 3875 struct nfs4_readdir_arg args = { 3876 3876 .fh = NFS_FH(dir), 3877 3877 .pages = pages, 3878 3878 .pgbase = 0, 3879 3879 .count = count, 3880 3880 - .bitmask = NFS_SERVER(dentry->d_inode)->attr_bitmask, 3880 3880 + .bitmask = NFS_SERVER(d_inode(dentry))->attr_bitmask, 3881 3881 .plus = plus, 3882 3882 }; 3883 3883 struct nfs4_readdir_res res; ··· 3914 3914 do { 3915 3915 err = _nfs4_proc_readdir(dentry, cred, cookie, 3916 3916 pages, count, plus); 3917 3917 - trace_nfs4_readdir(dentry->d_inode, err); 3918 3918 - err = nfs4_handle_exception(NFS_SERVER(dentry->d_inode), err, 3917 3917 + trace_nfs4_readdir(d_inode(dentry), err); 3918 3918 + err = nfs4_handle_exception(NFS_SERVER(d_inode(dentry)), err, 3919 3919 &exception); 3920 3920 } while (exception.retry); 3921 3921 return err; ··· 4830 4830 struct nfs4_label ilabel, *olabel = NULL; 4831 4831 struct nfs_fattr fattr; 4832 4832 struct rpc_cred *cred; 4833 4833 - struct inode *inode = dentry->d_inode; 4833 4833 + struct inode *inode = d_inode(dentry); 4834 4834 int status; 4835 4835 4836 4836 if (!nfs_server_capable(inode, NFS_CAP_SECURITY_LABEL)) ··· 5670 5670 data->rpc_status = task->tk_status; 5671 5671 switch (task->tk_status) { 5672 5672 case 0: 5673 5673 - renew_lease(NFS_SERVER(data->ctx->dentry->d_inode), 5673 5673 + renew_lease(NFS_SERVER(d_inode(data->ctx->dentry)), 5674 5674 data->timestamp); 5675 5675 if (data->arg.new_lock) { 5676 5676 data->fl.fl_flags &= ~(FL_SLEEP | FL_ACCESS); ··· 6112 6112 if (strcmp(key, "") != 0) 6113 6113 return -EINVAL; 6114 6114 6115 6115 - return nfs4_proc_set_acl(dentry->d_inode, buf, buflen); 6115 6115 + return nfs4_proc_set_acl(d_inode(dentry), buf, buflen); 6116 6116 } 6117 6117 6118 6118 static int nfs4_xattr_get_nfs4_acl(struct dentry *dentry, const char *key, ··· 6121 6121 if (strcmp(key, "") != 0) 6122 6122 return -EINVAL; 6123 6123 6124 6124 - return nfs4_proc_get_acl(dentry->d_inode, buf, buflen); 6124 6124 + return nfs4_proc_get_acl(d_inode(dentry), buf, buflen); 6125 6125 } 6126 6126 6127 6127 static size_t nfs4_xattr_list_nfs4_acl(struct dentry *dentry, char *list, ··· 6130 6130 { 6131 6131 size_t len = sizeof(XATTR_NAME_NFSV4_ACL); 6132 6132 6133 6133 - if (!nfs4_server_supports_acls(NFS_SERVER(dentry->d_inode))) 6133 6133 + if (!nfs4_server_supports_acls(NFS_SERVER(d_inode(dentry)))) 6134 6134 return 0; 6135 6135 6136 6136 if (list && len <= list_len) ··· 6158 6158 void *buf, size_t buflen, int type) 6159 6159 { 6160 6160 if (security_ismaclabel(key)) 6161 6161 - return nfs4_get_security_label(dentry->d_inode, buf, buflen); 6161 6161 + return nfs4_get_security_label(d_inode(dentry), buf, buflen); 6162 6162 return -EOPNOTSUPP; 6163 6163 } 6164 6164 ··· 6168 6168 { 6169 6169 size_t len = 0; 6170 6170 6171 6171 - if (nfs_server_capable(dentry->d_inode, NFS_CAP_SECURITY_LABEL)) { 6172 6172 - len = security_inode_listsecurity(dentry->d_inode, NULL, 0); 6171 6171 + if (nfs_server_capable(d_inode(dentry), NFS_CAP_SECURITY_LABEL)) { 6172 6172 + len = security_inode_listsecurity(d_inode(dentry), NULL, 0); 6173 6173 if (list && len <= list_len) 6174 6174 - security_inode_listsecurity(dentry->d_inode, list, len); 6174 6174 + security_inode_listsecurity(d_inode(dentry), list, len); 6175 6175 } 6176 6176 return len; 6177 6177 }

+2 -2

fs/nfs/nfs4state.c

reviewed

··· 1902 1902 goto out; 1903 1903 } 1904 1904 1905 1905 - inode = server->super->s_root->d_inode; 1905 1905 + inode = d_inode(server->super->s_root); 1906 1906 result = nfs4_proc_get_locations(inode, locations, page, cred); 1907 1907 if (result) { 1908 1908 dprintk("<-- %s: failed to retrieve fs_locations: %d\n", ··· 2021 2021 2022 2022 rcu_read_unlock(); 2023 2023 2024 2024 - inode = server->super->s_root->d_inode; 2024 2024 + inode = d_inode(server->super->s_root); 2025 2025 status = nfs4_proc_fsid_present(inode, cred); 2026 2026 if (status != -NFS4ERR_MOVED) 2027 2027 goto restart; /* wasn't this one */

+2 -2

fs/nfs/nfs4trace.h

reviewed

··· 418 418 __entry->fileid = 0; 419 419 __entry->fhandle = 0; 420 420 } 421 421 - __entry->dir = NFS_FILEID(ctx->dentry->d_parent->d_inode); 421 421 + __entry->dir = NFS_FILEID(d_inode(ctx->dentry->d_parent)); 422 422 __assign_str(name, ctx->dentry->d_name.name); 423 423 ), 424 424 ··· 1110 1110 ), 1111 1111 1112 1112 TP_fast_assign( 1113 1113 - const struct inode *inode = ctx->dentry->d_inode; 1113 1113 + const struct inode *inode = d_inode(ctx->dentry); 1114 1114 __entry->dev = inode->i_sb->s_dev; 1115 1115 __entry->fileid = NFS_FILEID(inode); 1116 1116 __entry->fhandle = nfs_fhandle_hash(NFS_FH(inode));

+1 -1

fs/nfs/pagelist.c

reviewed

··· 938 938 if (prev) { 939 939 if (!nfs_match_open_context(req->wb_context, prev->wb_context)) 940 940 return false; 941 941 - flctx = req->wb_context->dentry->d_inode->i_flctx; 941 941 + flctx = d_inode(req->wb_context->dentry)->i_flctx; 942 942 if (flctx != NULL && 943 943 !(list_empty_careful(&flctx->flc_posix) && 944 944 list_empty_careful(&flctx->flc_flock)) &&

+2 -2

fs/nfs/pnfs.h

reviewed

··· 426 426 pnfs_mark_request_commit(struct nfs_page *req, struct pnfs_layout_segment *lseg, 427 427 struct nfs_commit_info *cinfo, u32 ds_commit_idx) 428 428 { 429 429 - struct inode *inode = req->wb_context->dentry->d_inode; 429 429 + struct inode *inode = d_inode(req->wb_context->dentry); 430 430 struct pnfs_layoutdriver_type *ld = NFS_SERVER(inode)->pnfs_curr_ld; 431 431 432 432 if (lseg == NULL || ld->mark_request_commit == NULL) ··· 438 438 static inline bool 439 439 pnfs_clear_request_commit(struct nfs_page *req, struct nfs_commit_info *cinfo) 440 440 { 441 441 - struct inode *inode = req->wb_context->dentry->d_inode; 441 441 + struct inode *inode = d_inode(req->wb_context->dentry); 442 442 struct pnfs_layoutdriver_type *ld = NFS_SERVER(inode)->pnfs_curr_ld; 443 443 444 444 if (ld == NULL || ld->clear_request_commit == NULL)

+2 -2

fs/nfs/proc.c

reviewed

··· 118 118 nfs_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr, 119 119 struct iattr *sattr) 120 120 { 121 121 - struct inode *inode = dentry->d_inode; 121 121 + struct inode *inode = d_inode(dentry); 122 122 struct nfs_sattrargs arg = { 123 123 .fh = NFS_FH(inode), 124 124 .sattr = sattr ··· 487 487 nfs_proc_readdir(struct dentry *dentry, struct rpc_cred *cred, 488 488 u64 cookie, struct page **pages, unsigned int count, int plus) 489 489 { 490 490 - struct inode *dir = dentry->d_inode; 490 490 + struct inode *dir = d_inode(dentry); 491 491 struct nfs_readdirargs arg = { 492 492 .fh = NFS_FH(dir), 493 493 .cookie = cookie,

+1 -1

fs/nfs/read.c

reviewed

··· 117 117 118 118 static void nfs_readpage_release(struct nfs_page *req) 119 119 { 120 120 - struct inode *inode = req->wb_context->dentry->d_inode; 120 120 + struct inode *inode = d_inode(req->wb_context->dentry); 121 121 122 122 dprintk("NFS: read done (%s/%llu %d@%lld)\n", inode->i_sb->s_id, 123 123 (unsigned long long)NFS_FILEID(inode), req->wb_bytes,

+3 -3

fs/nfs/super.c

reviewed

··· 433 433 struct nfs_server *server = NFS_SB(dentry->d_sb); 434 434 unsigned char blockbits; 435 435 unsigned long blockres; 436 436 - struct nfs_fh *fh = NFS_FH(dentry->d_inode); 436 436 + struct nfs_fh *fh = NFS_FH(d_inode(dentry)); 437 437 struct nfs_fsstat res; 438 438 int error = -ENOMEM; 439 439 ··· 447 447 448 448 pd_dentry = dget_parent(dentry); 449 449 if (pd_dentry != NULL) { 450 450 - nfs_zap_caches(pd_dentry->d_inode); 450 450 + nfs_zap_caches(d_inode(pd_dentry)); 451 451 dput(pd_dentry); 452 452 } 453 453 } ··· 2526 2526 struct nfs_mount_info *mount_info) 2527 2527 { 2528 2528 /* clone any lsm security options from the parent to the new sb */ 2529 2529 - if (mntroot->d_inode->i_op != NFS_SB(s)->nfs_client->rpc_ops->dir_inode_ops) 2529 2529 + if (d_inode(mntroot)->i_op != NFS_SB(s)->nfs_client->rpc_ops->dir_inode_ops) 2530 2530 return -ESTALE; 2531 2531 return security_sb_clone_mnt_opts(mount_info->cloned->sb, s); 2532 2532 }

+1 -1

fs/nfs/symlink.c

reviewed

··· 45 45 46 46 static void *nfs_follow_link(struct dentry *dentry, struct nameidata *nd) 47 47 { 48 48 - struct inode *inode = dentry->d_inode; 48 48 + struct inode *inode = d_inode(dentry); 49 49 struct page *page; 50 50 void *err; 51 51

+10 -10

fs/nfs/unlink.c

reviewed

··· 143 143 nfs_free_dname(data); 144 144 ret = nfs_copy_dname(alias, data); 145 145 spin_lock(&alias->d_lock); 146 146 - if (ret == 0 && alias->d_inode != NULL && 146 146 + if (ret == 0 && d_really_is_positive(alias) && 147 147 !(alias->d_flags & DCACHE_NFSFS_RENAMED)) { 148 148 devname_garbage = alias->d_fsdata; 149 149 alias->d_fsdata = data; ··· 190 190 parent = dget_parent(dentry); 191 191 if (parent == NULL) 192 192 goto out_free; 193 193 - dir = parent->d_inode; 193 193 + dir = d_inode(parent); 194 194 /* Non-exclusive lock protects against concurrent lookup() calls */ 195 195 spin_lock(&dir->i_lock); 196 196 if (atomic_inc_not_zero(&NFS_I(dir)->silly_count) == 0) { ··· 210 210 211 211 void nfs_wait_on_sillyrename(struct dentry *dentry) 212 212 { 213 213 - struct nfs_inode *nfsi = NFS_I(dentry->d_inode); 213 213 + struct nfs_inode *nfsi = NFS_I(d_inode(dentry)); 214 214 215 215 wait_event(nfsi->waitqueue, atomic_read(&nfsi->silly_count) <= 1); 216 216 } 217 217 218 218 void nfs_block_sillyrename(struct dentry *dentry) 219 219 { 220 220 - struct nfs_inode *nfsi = NFS_I(dentry->d_inode); 220 220 + struct nfs_inode *nfsi = NFS_I(d_inode(dentry)); 221 221 222 222 wait_event(nfsi->waitqueue, atomic_cmpxchg(&nfsi->silly_count, 1, 0) == 1); 223 223 } 224 224 225 225 void nfs_unblock_sillyrename(struct dentry *dentry) 226 226 { 227 227 - struct inode *dir = dentry->d_inode; 227 227 + struct inode *dir = d_inode(dentry); 228 228 struct nfs_inode *nfsi = NFS_I(dir); 229 229 struct nfs_unlinkdata *data; 230 230 ··· 367 367 struct nfs_renamedata *data = calldata; 368 368 struct super_block *sb = data->old_dir->i_sb; 369 369 370 370 - if (data->old_dentry->d_inode) 371 371 - nfs_mark_for_revalidate(data->old_dentry->d_inode); 370 370 + if (d_really_is_positive(data->old_dentry)) 371 371 + nfs_mark_for_revalidate(d_inode(data->old_dentry)); 372 372 373 373 dput(data->old_dentry); 374 374 dput(data->new_dentry); ··· 529 529 if (dentry->d_flags & DCACHE_NFSFS_RENAMED) 530 530 goto out; 531 531 532 532 - fileid = NFS_FILEID(dentry->d_inode); 532 532 + fileid = NFS_FILEID(d_inode(dentry)); 533 533 534 534 /* Return delegation in anticipation of the rename */ 535 535 - NFS_PROTO(dentry->d_inode)->return_delegation(dentry->d_inode); 535 535 + NFS_PROTO(d_inode(dentry))->return_delegation(d_inode(dentry)); 536 536 537 537 sdentry = NULL; 538 538 do { ··· 554 554 */ 555 555 if (IS_ERR(sdentry)) 556 556 goto out; 557 557 - } while (sdentry->d_inode != NULL); /* need negative lookup */ 557 557 + } while (d_inode(sdentry) != NULL); /* need negative lookup */ 558 558 559 559 /* queue unlink first. Can't do this from rpc_release as it 560 560 * has to allocate memory

+4 -4

fs/nfs/write.c

reviewed

··· 702 702 */ 703 703 static void nfs_inode_remove_request(struct nfs_page *req) 704 704 { 705 705 - struct inode *inode = req->wb_context->dentry->d_inode; 705 705 + struct inode *inode = d_inode(req->wb_context->dentry); 706 706 struct nfs_inode *nfsi = NFS_I(inode); 707 707 struct nfs_page *head; 708 708 ··· 861 861 nfs_clear_request_commit(struct nfs_page *req) 862 862 { 863 863 if (test_bit(PG_CLEAN, &req->wb_flags)) { 864 864 - struct inode *inode = req->wb_context->dentry->d_inode; 864 864 + struct inode *inode = d_inode(req->wb_context->dentry); 865 865 struct nfs_commit_info cinfo; 866 866 867 867 nfs_init_cinfo_from_inode(&cinfo, inode); ··· 1591 1591 struct nfs_commit_info *cinfo) 1592 1592 { 1593 1593 struct nfs_page *first = nfs_list_entry(head->next); 1594 1594 - struct inode *inode = first->wb_context->dentry->d_inode; 1594 1594 + struct inode *inode = d_inode(first->wb_context->dentry); 1595 1595 1596 1596 /* Set up the RPC argument and reply structs 1597 1597 * NB: take care not to mess about with data->commit et al. */ ··· 1690 1690 1691 1691 dprintk("NFS: commit (%s/%llu %d@%lld)", 1692 1692 req->wb_context->dentry->d_sb->s_id, 1693 1693 - (unsigned long long)NFS_FILEID(req->wb_context->dentry->d_inode), 1693 1693 + (unsigned long long)NFS_FILEID(d_inode(req->wb_context->dentry)), 1694 1694 req->wb_bytes, 1695 1695 (long long)req_offset(req)); 1696 1696 if (status < 0) {

+2 -2

fs/nfsd/export.c

reviewed

··· 599 599 goto out4; 600 600 } 601 601 602 602 - err = check_export(exp.ex_path.dentry->d_inode, &exp.ex_flags, 602 602 + err = check_export(d_inode(exp.ex_path.dentry), &exp.ex_flags, 603 603 exp.ex_uuid); 604 604 if (err) 605 605 goto out4; ··· 890 890 printk("nfsd: exp_rootfh path not found %s", name); 891 891 return err; 892 892 } 893 893 - inode = path.dentry->d_inode; 893 893 + inode = d_inode(path.dentry); 894 894 895 895 dprintk("nfsd: exp_rootfh(%s [%p] %s:%s/%ld)\n", 896 896 name, path.dentry, clp->name,

+4 -4

fs/nfsd/nfs2acl.c

reviewed

··· 42 42 if (nfserr) 43 43 RETURN_STATUS(nfserr); 44 44 45 45 - inode = fh->fh_dentry->d_inode; 45 45 + inode = d_inode(fh->fh_dentry); 46 46 47 47 if (argp->mask & ~(NFS_ACL|NFS_ACLCNT|NFS_DFACL|NFS_DFACLCNT)) 48 48 RETURN_STATUS(nfserr_inval); ··· 103 103 if (nfserr) 104 104 goto out; 105 105 106 106 - inode = fh->fh_dentry->d_inode; 106 106 + inode = d_inode(fh->fh_dentry); 107 107 if (!IS_POSIXACL(inode) || !inode->i_op->set_acl) { 108 108 error = -EOPNOTSUPP; 109 109 goto out_errno; ··· 266 266 * nfsd_dispatch actually ensures the following cannot happen. 267 267 * However, it seems fragile to depend on that. 268 268 */ 269 269 - if (dentry == NULL || dentry->d_inode == NULL) 269 269 + if (dentry == NULL || d_really_is_negative(dentry)) 270 270 return 0; 271 271 - inode = dentry->d_inode; 271 271 + inode = d_inode(dentry); 272 272 273 273 p = nfs2svc_encode_fattr(rqstp, p, &resp->fh, &resp->stat); 274 274 *p++ = htonl(resp->mask);

+4 -4

fs/nfsd/nfs3acl.c

reviewed

··· 39 39 if (nfserr) 40 40 RETURN_STATUS(nfserr); 41 41 42 42 - inode = fh->fh_dentry->d_inode; 42 42 + inode = d_inode(fh->fh_dentry); 43 43 44 44 if (argp->mask & ~(NFS_ACL|NFS_ACLCNT|NFS_DFACL|NFS_DFACLCNT)) 45 45 RETURN_STATUS(nfserr_inval); ··· 94 94 if (nfserr) 95 95 goto out; 96 96 97 97 - inode = fh->fh_dentry->d_inode; 97 97 + inode = d_inode(fh->fh_dentry); 98 98 if (!IS_POSIXACL(inode) || !inode->i_op->set_acl) { 99 99 error = -EOPNOTSUPP; 100 100 goto out_errno; ··· 174 174 struct dentry *dentry = resp->fh.fh_dentry; 175 175 176 176 p = nfs3svc_encode_post_op_attr(rqstp, p, &resp->fh); 177 177 - if (resp->status == 0 && dentry && dentry->d_inode) { 178 178 - struct inode *inode = dentry->d_inode; 177 177 + if (resp->status == 0 && dentry && d_really_is_positive(dentry)) { 178 178 + struct inode *inode = d_inode(dentry); 179 179 struct kvec *head = rqstp->rq_res.head; 180 180 unsigned int base; 181 181 int n;

+3 -3

fs/nfsd/nfs3proc.c

reviewed

··· 166 166 rqstp->rq_vec, argp->vlen, 167 167 &resp->count); 168 168 if (nfserr == 0) { 169 169 - struct inode *inode = resp->fh.fh_dentry->d_inode; 169 169 + struct inode *inode = d_inode(resp->fh.fh_dentry); 170 170 171 171 resp->eof = (argp->offset + resp->count) >= inode->i_size; 172 172 } ··· 551 551 * different read/write sizes for file systems known to have 552 552 * problems with large blocks */ 553 553 if (nfserr == 0) { 554 554 - struct super_block *sb = argp->fh.fh_dentry->d_inode->i_sb; 554 554 + struct super_block *sb = d_inode(argp->fh.fh_dentry)->i_sb; 555 555 556 556 /* Note that we don't care for remote fs's here */ 557 557 if (sb->s_magic == MSDOS_SUPER_MAGIC) { ··· 587 587 nfserr = fh_verify(rqstp, &argp->fh, 0, NFSD_MAY_NOP); 588 588 589 589 if (nfserr == 0) { 590 590 - struct super_block *sb = argp->fh.fh_dentry->d_inode->i_sb; 590 590 + struct super_block *sb = d_inode(argp->fh.fh_dentry)->i_sb; 591 591 592 592 /* Note that we don't care for remote fs's here */ 593 593 switch (sb->s_magic) {

+8 -8

fs/nfsd/nfs3xdr.c

reviewed

··· 146 146 default: 147 147 case FSIDSOURCE_DEV: 148 148 p = xdr_encode_hyper(p, (u64)huge_encode_dev 149 149 - (fhp->fh_dentry->d_inode->i_sb->s_dev)); 149 149 + (d_inode(fhp->fh_dentry)->i_sb->s_dev)); 150 150 break; 151 151 case FSIDSOURCE_FSID: 152 152 p = xdr_encode_hyper(p, (u64) fhp->fh_export->ex_fsid); ··· 203 203 encode_post_op_attr(struct svc_rqst *rqstp, __be32 *p, struct svc_fh *fhp) 204 204 { 205 205 struct dentry *dentry = fhp->fh_dentry; 206 206 - if (dentry && dentry->d_inode) { 206 206 + if (dentry && d_really_is_positive(dentry)) { 207 207 __be32 err; 208 208 struct kstat stat; 209 209 210 210 err = fh_getattr(fhp, &stat); 211 211 if (!err) { 212 212 *p++ = xdr_one; /* attributes follow */ 213 213 - lease_get_mtime(dentry->d_inode, &stat.mtime); 213 213 + lease_get_mtime(d_inode(dentry), &stat.mtime); 214 214 return encode_fattr3(rqstp, p, fhp, &stat); 215 215 } 216 216 } ··· 233 233 { 234 234 struct dentry *dentry = fhp->fh_dentry; 235 235 236 236 - if (dentry && dentry->d_inode && fhp->fh_post_saved) { 236 236 + if (dentry && d_really_is_positive(dentry) && fhp->fh_post_saved) { 237 237 if (fhp->fh_pre_saved) { 238 238 *p++ = xdr_one; 239 239 p = xdr_encode_hyper(p, (u64) fhp->fh_pre_size); ··· 260 260 printk("nfsd: inode locked twice during operation.\n"); 261 261 262 262 err = fh_getattr(fhp, &fhp->fh_post_attr); 263 263 - fhp->fh_post_change = fhp->fh_dentry->d_inode->i_version; 263 263 + fhp->fh_post_change = d_inode(fhp->fh_dentry)->i_version; 264 264 if (err) { 265 265 fhp->fh_post_saved = 0; 266 266 /* Grab the ctime anyway - set_change_info might use it */ 267 267 - fhp->fh_post_attr.ctime = fhp->fh_dentry->d_inode->i_ctime; 267 267 + fhp->fh_post_attr.ctime = d_inode(fhp->fh_dentry)->i_ctime; 268 268 } else 269 269 fhp->fh_post_saved = 1; 270 270 } ··· 628 628 struct nfsd3_attrstat *resp) 629 629 { 630 630 if (resp->status == 0) { 631 631 - lease_get_mtime(resp->fh.fh_dentry->d_inode, 631 631 + lease_get_mtime(d_inode(resp->fh.fh_dentry), 632 632 &resp->stat.mtime); 633 633 p = encode_fattr3(rqstp, p, &resp->fh, &resp->stat); 634 634 } ··· 828 828 return rv; 829 829 if (d_mountpoint(dchild)) 830 830 goto out; 831 831 - if (!dchild->d_inode) 831 831 + if (d_really_is_negative(dchild)) 832 832 goto out; 833 833 rv = fh_compose(fhp, exp, dchild, &cd->fh); 834 834 out:

+2 -2

fs/nfsd/nfs4acl.c

reviewed

··· 139 139 nfsd4_get_nfs4_acl(struct svc_rqst *rqstp, struct dentry *dentry, 140 140 struct nfs4_acl **acl) 141 141 { 142 142 - struct inode *inode = dentry->d_inode; 142 142 + struct inode *inode = d_inode(dentry); 143 143 int error = 0; 144 144 struct posix_acl *pacl = NULL, *dpacl = NULL; 145 145 unsigned int flags = 0; ··· 780 780 return error; 781 781 782 782 dentry = fhp->fh_dentry; 783 783 - inode = dentry->d_inode; 783 783 + inode = d_inode(dentry); 784 784 785 785 if (!inode->i_op->set_acl || !IS_POSIXACL(inode)) 786 786 return nfserr_attrnotsupp;

+6 -6

fs/nfsd/nfs4proc.c

reviewed

··· 52 52 static inline void 53 53 nfsd4_security_inode_setsecctx(struct svc_fh *resfh, struct xdr_netobj *label, u32 *bmval) 54 54 { 55 55 - struct inode *inode = resfh->fh_dentry->d_inode; 55 55 + struct inode *inode = d_inode(resfh->fh_dentry); 56 56 int status; 57 57 58 58 mutex_lock(&inode->i_mutex); ··· 110 110 * in current environment or not. 111 111 */ 112 112 if (bmval[0] & FATTR4_WORD0_ACL) { 113 113 - if (!IS_POSIXACL(dentry->d_inode)) 113 113 + if (!IS_POSIXACL(d_inode(dentry))) 114 114 return nfserr_attrnotsupp; 115 115 } 116 116 ··· 209 209 210 210 static __be32 nfsd_check_obj_isreg(struct svc_fh *fh) 211 211 { 212 212 - umode_t mode = fh->fh_dentry->d_inode->i_mode; 212 212 + umode_t mode = d_inode(fh->fh_dentry)->i_mode; 213 213 214 214 if (S_ISREG(mode)) 215 215 return nfs_ok; ··· 881 881 &exp, &dentry); 882 882 if (err) 883 883 return err; 884 884 - if (dentry->d_inode == NULL) { 884 884 + if (d_really_is_negative(dentry)) { 885 885 exp_put(exp); 886 886 err = nfserr_noent; 887 887 } else ··· 1312 1312 if (atomic_read(&ls->ls_stid.sc_file->fi_lo_recalls)) 1313 1313 goto out_put_stid; 1314 1314 1315 1315 - nfserr = ops->proc_layoutget(current_fh->fh_dentry->d_inode, 1315 1315 + nfserr = ops->proc_layoutget(d_inode(current_fh->fh_dentry), 1316 1316 current_fh, lgp); 1317 1317 if (nfserr) 1318 1318 goto out_put_stid; ··· 1346 1346 ops = nfsd4_layout_verify(current_fh->fh_export, lcp->lc_layout_type); 1347 1347 if (!ops) 1348 1348 goto out; 1349 1349 - inode = current_fh->fh_dentry->d_inode; 1349 1349 + inode = d_inode(current_fh->fh_dentry); 1350 1350 1351 1351 nfserr = nfserr_inval; 1352 1352 if (new_size <= seg->offset) {

+11 -11

fs/nfsd/nfs4recover.c

reviewed

··· 192 192 193 193 dir = nn->rec_file->f_path.dentry; 194 194 /* lock the parent */ 195 195 - mutex_lock(&dir->d_inode->i_mutex); 195 195 + mutex_lock(&d_inode(dir)->i_mutex); 196 196 197 197 dentry = lookup_one_len(dname, dir, HEXDIR_LEN-1); 198 198 if (IS_ERR(dentry)) { 199 199 status = PTR_ERR(dentry); 200 200 goto out_unlock; 201 201 } 202 202 - if (dentry->d_inode) 202 202 + if (d_really_is_positive(dentry)) 203 203 /* 204 204 * In the 4.1 case, where we're called from 205 205 * reclaim_complete(), records from the previous reboot ··· 209 209 * as well be forgiving and just succeed silently. 210 210 */ 211 211 goto out_put; 212 212 - status = vfs_mkdir(dir->d_inode, dentry, S_IRWXU); 212 212 + status = vfs_mkdir(d_inode(dir), dentry, S_IRWXU); 213 213 out_put: 214 214 dput(dentry); 215 215 out_unlock: 216 216 - mutex_unlock(&dir->d_inode->i_mutex); 216 216 + mutex_unlock(&d_inode(dir)->i_mutex); 217 217 if (status == 0) { 218 218 if (nn->in_grace) { 219 219 crp = nfs4_client_to_reclaim(dname, nn); ··· 285 285 } 286 286 287 287 status = iterate_dir(nn->rec_file, &ctx.ctx); 288 288 - mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT); 288 288 + mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_PARENT); 289 289 while (!list_empty(&ctx.names)) { 290 290 struct name_list *entry; 291 291 entry = list_entry(ctx.names.next, struct name_list, list); ··· 302 302 list_del(&entry->list); 303 303 kfree(entry); 304 304 } 305 305 - mutex_unlock(&dir->d_inode->i_mutex); 305 305 + mutex_unlock(&d_inode(dir)->i_mutex); 306 306 nfs4_reset_creds(original_cred); 307 307 return status; 308 308 } ··· 316 316 dprintk("NFSD: nfsd4_unlink_clid_dir. name %.*s\n", namlen, name); 317 317 318 318 dir = nn->rec_file->f_path.dentry; 319 319 - mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT); 319 319 + mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_PARENT); 320 320 dentry = lookup_one_len(name, dir, namlen); 321 321 if (IS_ERR(dentry)) { 322 322 status = PTR_ERR(dentry); 323 323 goto out_unlock; 324 324 } 325 325 status = -ENOENT; 326 326 - if (!dentry->d_inode) 326 326 + if (d_really_is_negative(dentry)) 327 327 goto out; 328 328 - status = vfs_rmdir(dir->d_inode, dentry); 328 328 + status = vfs_rmdir(d_inode(dir), dentry); 329 329 out: 330 330 dput(dentry); 331 331 out_unlock: 332 332 - mutex_unlock(&dir->d_inode->i_mutex); 332 332 + mutex_unlock(&d_inode(dir)->i_mutex); 333 333 return status; 334 334 } 335 335 ··· 385 385 if (nfs4_has_reclaimed_state(child->d_name.name, nn)) 386 386 return 0; 387 387 388 388 - status = vfs_rmdir(parent->d_inode, child); 388 388 + status = vfs_rmdir(d_inode(parent), child); 389 389 if (status) 390 390 printk("failed to remove client recovery directory %pd\n", 391 391 child);

+2 -2

fs/nfsd/nfs4state.c

reviewed

··· 4472 4472 struct nfs4_ol_stateid *stp = NULL; 4473 4473 struct nfs4_delegation *dp = NULL; 4474 4474 struct svc_fh *current_fh = &cstate->current_fh; 4475 4475 - struct inode *ino = current_fh->fh_dentry->d_inode; 4475 4475 + struct inode *ino = d_inode(current_fh->fh_dentry); 4476 4476 struct nfsd_net *nn = net_generic(net, nfsd_net_id); 4477 4477 struct file *file = NULL; 4478 4478 __be32 status; ··· 5170 5170 struct nfs4_file *fi = ost->st_stid.sc_file; 5171 5171 struct nfs4_openowner *oo = openowner(ost->st_stateowner); 5172 5172 struct nfs4_client *cl = oo->oo_owner.so_client; 5173 5173 - struct inode *inode = cstate->current_fh.fh_dentry->d_inode; 5173 5173 + struct inode *inode = d_inode(cstate->current_fh.fh_dentry); 5174 5174 struct nfs4_lockowner *lo; 5175 5175 unsigned int strhashval; 5176 5176

+5 -5

fs/nfsd/nfs4xdr.c

reviewed

··· 2292 2292 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL 2293 2293 if ((bmval[2] & FATTR4_WORD2_SECURITY_LABEL) || 2294 2294 bmval[0] & FATTR4_WORD0_SUPPORTED_ATTRS) { 2295 2295 - err = security_inode_getsecctx(dentry->d_inode, 2295 2295 + err = security_inode_getsecctx(d_inode(dentry), 2296 2296 &context, &contextlen); 2297 2297 contextsupport = (err == 0); 2298 2298 if (bmval2 & FATTR4_WORD2_SECURITY_LABEL) { ··· 2384 2384 p = xdr_reserve_space(xdr, 8); 2385 2385 if (!p) 2386 2386 goto out_resource; 2387 2387 - p = encode_change(p, &stat, dentry->d_inode); 2387 2387 + p = encode_change(p, &stat, d_inode(dentry)); 2388 2388 } 2389 2389 if (bmval0 & FATTR4_WORD0_SIZE) { 2390 2390 p = xdr_reserve_space(xdr, 8); ··· 2807 2807 dentry = lookup_one_len(name, cd->rd_fhp->fh_dentry, namlen); 2808 2808 if (IS_ERR(dentry)) 2809 2809 return nfserrno(PTR_ERR(dentry)); 2810 2810 - if (!dentry->d_inode) { 2810 2810 + if (d_really_is_negative(dentry)) { 2811 2811 /* 2812 2812 * nfsd_buffered_readdir drops the i_mutex between 2813 2813 * readdir and calling this callback, leaving a window ··· 3324 3324 } 3325 3325 3326 3326 eof = (read->rd_offset + maxcount >= 3327 3327 - read->rd_fhp->fh_dentry->d_inode->i_size); 3327 3327 + d_inode(read->rd_fhp->fh_dentry)->i_size); 3328 3328 3329 3329 *(p++) = htonl(eof); 3330 3330 *(p++) = htonl(maxcount); ··· 3401 3401 xdr_truncate_encode(xdr, starting_len + 8 + ((maxcount+3)&~3)); 3402 3402 3403 3403 eof = (read->rd_offset + maxcount >= 3404 3404 - read->rd_fhp->fh_dentry->d_inode->i_size); 3404 3404 + d_inode(read->rd_fhp->fh_dentry)->i_size); 3405 3405 3406 3406 tmp = htonl(eof); 3407 3407 write_bytes_to_xdr_buf(xdr->buf, starting_len , &tmp, 4);

+10 -10

fs/nfsd/nfsfh.c

reviewed

··· 38 38 /* make sure parents give x permission to user */ 39 39 int err; 40 40 parent = dget_parent(tdentry); 41 41 - err = inode_permission(parent->d_inode, MAY_EXEC); 41 41 + err = inode_permission(d_inode(parent), MAY_EXEC); 42 42 if (err < 0) { 43 43 dput(parent); 44 44 break; ··· 340 340 if (error) 341 341 goto out; 342 342 343 343 - error = nfsd_mode_check(rqstp, dentry->d_inode->i_mode, type); 343 343 + error = nfsd_mode_check(rqstp, d_inode(dentry)->i_mode, type); 344 344 if (error) 345 345 goto out; 346 346 ··· 412 412 struct svc_export *exp, 413 413 struct knfsd_fh *fh) 414 414 { 415 415 - fh->ofh_ino = ino_t_to_u32(dentry->d_inode->i_ino); 416 416 - fh->ofh_generation = dentry->d_inode->i_generation; 415 415 + fh->ofh_ino = ino_t_to_u32(d_inode(dentry)->i_ino); 416 416 + fh->ofh_generation = d_inode(dentry)->i_generation; 417 417 if (d_is_dir(dentry) || 418 418 (exp->ex_flags & NFSEXP_NOSUBTREECHECK)) 419 419 fh->ofh_dirino = 0; ··· 426 426 427 427 static struct super_block *exp_sb(struct svc_export *exp) 428 428 { 429 429 - return exp->ex_path.dentry->d_inode->i_sb; 429 429 + return d_inode(exp->ex_path.dentry)->i_sb; 430 430 } 431 431 432 432 static bool fsid_type_ok_for_exp(u8 fsid_type, struct svc_export *exp) ··· 520 520 * 521 521 */ 522 522 523 523 - struct inode * inode = dentry->d_inode; 523 523 + struct inode * inode = d_inode(dentry); 524 524 dev_t ex_dev = exp_sb(exp)->s_dev; 525 525 526 526 dprintk("nfsd: fh_compose(exp %02x:%02x/%ld %pd2, ino=%ld)\n", 527 527 MAJOR(ex_dev), MINOR(ex_dev), 528 528 - (long) exp->ex_path.dentry->d_inode->i_ino, 528 528 + (long) d_inode(exp->ex_path.dentry)->i_ino, 529 529 dentry, 530 530 (inode ? inode->i_ino : 0)); 531 531 ··· 558 558 fhp->fh_handle.ofh_dev = old_encode_dev(ex_dev); 559 559 fhp->fh_handle.ofh_xdev = fhp->fh_handle.ofh_dev; 560 560 fhp->fh_handle.ofh_xino = 561 561 - ino_t_to_u32(exp->ex_path.dentry->d_inode->i_ino); 561 561 + ino_t_to_u32(d_inode(exp->ex_path.dentry)->i_ino); 562 562 fhp->fh_handle.ofh_dirino = ino_t_to_u32(parent_ino(dentry)); 563 563 if (inode) 564 564 _fh_update_old(dentry, exp, &fhp->fh_handle); ··· 570 570 mk_fsid(fhp->fh_handle.fh_fsid_type, 571 571 fhp->fh_handle.fh_fsid, 572 572 ex_dev, 573 573 - exp->ex_path.dentry->d_inode->i_ino, 573 573 + d_inode(exp->ex_path.dentry)->i_ino, 574 574 exp->ex_fsid, exp->ex_uuid); 575 575 576 576 if (inode) ··· 597 597 goto out_bad; 598 598 599 599 dentry = fhp->fh_dentry; 600 600 - if (!dentry->d_inode) 600 600 + if (d_really_is_negative(dentry)) 601 601 goto out_negative; 602 602 if (fhp->fh_handle.fh_version != 1) { 603 603 _fh_update_old(dentry, fhp->fh_export, &fhp->fh_handle);

+3 -3

fs/nfsd/nfsfh.h

reviewed

··· 225 225 { 226 226 struct inode *inode; 227 227 228 228 - inode = fhp->fh_dentry->d_inode; 228 228 + inode = d_inode(fhp->fh_dentry); 229 229 if (!fhp->fh_pre_saved) { 230 230 fhp->fh_pre_mtime = inode->i_mtime; 231 231 fhp->fh_pre_ctime = inode->i_ctime; ··· 264 264 return; 265 265 } 266 266 267 267 - inode = dentry->d_inode; 267 267 + inode = d_inode(dentry); 268 268 mutex_lock_nested(&inode->i_mutex, subclass); 269 269 fill_pre_wcc(fhp); 270 270 fhp->fh_locked = 1; ··· 284 284 { 285 285 if (fhp->fh_locked) { 286 286 fill_post_wcc(fhp); 287 287 - mutex_unlock(&fhp->fh_dentry->d_inode->i_mutex); 287 287 + mutex_unlock(&d_inode(fhp->fh_dentry)->i_mutex); 288 288 fhp->fh_locked = 0; 289 289 } 290 290 }

+2 -2

fs/nfsd/nfsproc.c

reviewed

··· 223 223 } 224 224 fh_init(newfhp, NFS_FHSIZE); 225 225 nfserr = fh_compose(newfhp, dirfhp->fh_export, dchild, dirfhp); 226 226 - if (!nfserr && !dchild->d_inode) 226 226 + if (!nfserr && d_really_is_negative(dchild)) 227 227 nfserr = nfserr_noent; 228 228 dput(dchild); 229 229 if (nfserr) { ··· 241 241 } 242 242 } 243 243 244 244 - inode = newfhp->fh_dentry->d_inode; 244 244 + inode = d_inode(newfhp->fh_dentry); 245 245 246 246 /* Unfudge the mode bits */ 247 247 if (attr->ia_valid & ATTR_MODE) {

+1 -1

fs/nfsd/nfsxdr.c

reviewed

··· 187 187 *p++ = htonl((u32) stat->ino); 188 188 *p++ = htonl((u32) stat->atime.tv_sec); 189 189 *p++ = htonl(stat->atime.tv_nsec ? stat->atime.tv_nsec / 1000 : 0); 190 190 - lease_get_mtime(dentry->d_inode, &time); 190 190 + lease_get_mtime(d_inode(dentry), &time); 191 191 *p++ = htonl((u32) time.tv_sec); 192 192 *p++ = htonl(time.tv_nsec ? time.tv_nsec / 1000 : 0); 193 193 *p++ = htonl((u32) stat->ctime.tv_sec);

+31 -31

fs/nfsd/vfs.c

reviewed

··· 174 174 return 1; 175 175 if (!(exp->ex_flags & NFSEXP_V4ROOT)) 176 176 return 0; 177 177 - return dentry->d_inode != NULL; 177 177 + return d_inode(dentry) != NULL; 178 178 } 179 179 180 180 __be32 ··· 270 270 * dentry may be negative, it may need to be updated. 271 271 */ 272 272 err = fh_compose(resfh, exp, dentry, fhp); 273 273 - if (!err && !dentry->d_inode) 273 273 + if (!err && d_really_is_negative(dentry)) 274 274 err = nfserr_noent; 275 275 out: 276 276 dput(dentry); ··· 284 284 static int 285 285 commit_metadata(struct svc_fh *fhp) 286 286 { 287 287 - struct inode *inode = fhp->fh_dentry->d_inode; 287 287 + struct inode *inode = d_inode(fhp->fh_dentry); 288 288 const struct export_operations *export_ops = inode->i_sb->s_export_op; 289 289 290 290 if (!EX_ISSYNC(fhp->fh_export)) ··· 364 364 nfsd_get_write_access(struct svc_rqst *rqstp, struct svc_fh *fhp, 365 365 struct iattr *iap) 366 366 { 367 367 - struct inode *inode = fhp->fh_dentry->d_inode; 367 367 + struct inode *inode = d_inode(fhp->fh_dentry); 368 368 int host_err; 369 369 370 370 if (iap->ia_size < inode->i_size) { ··· 426 426 } 427 427 428 428 dentry = fhp->fh_dentry; 429 429 - inode = dentry->d_inode; 429 429 + inode = d_inode(dentry); 430 430 431 431 /* Ignore any mode updates on symlinks */ 432 432 if (S_ISLNK(inode->i_mode)) ··· 495 495 */ 496 496 int nfsd4_is_junction(struct dentry *dentry) 497 497 { 498 498 - struct inode *inode = dentry->d_inode; 498 498 + struct inode *inode = d_inode(dentry); 499 499 500 500 if (inode == NULL) 501 501 return 0; ··· 521 521 522 522 dentry = fhp->fh_dentry; 523 523 524 524 - mutex_lock(&dentry->d_inode->i_mutex); 524 524 + mutex_lock(&d_inode(dentry)->i_mutex); 525 525 host_error = security_inode_setsecctx(dentry, label->data, label->len); 526 526 - mutex_unlock(&dentry->d_inode->i_mutex); 526 526 + mutex_unlock(&d_inode(dentry)->i_mutex); 527 527 return nfserrno(host_error); 528 528 } 529 529 #else ··· 706 706 707 707 path.mnt = fhp->fh_export->ex_path.mnt; 708 708 path.dentry = fhp->fh_dentry; 709 709 - inode = path.dentry->d_inode; 709 709 + inode = d_inode(path.dentry); 710 710 711 711 /* Disallow write access to files with the append-only bit set 712 712 * or any access when mandatory locking enabled ··· 1211 1211 goto out; 1212 1212 1213 1213 dentry = fhp->fh_dentry; 1214 1214 - dirp = dentry->d_inode; 1214 1214 + dirp = d_inode(dentry); 1215 1215 1216 1216 err = nfserr_notdir; 1217 1217 if (!dirp->i_op->lookup) ··· 1250 1250 * Make sure the child dentry is still negative ... 1251 1251 */ 1252 1252 err = nfserr_exist; 1253 1253 - if (dchild->d_inode) { 1253 1253 + if (d_really_is_positive(dchild)) { 1254 1254 dprintk("nfsd_create: dentry %pd/%pd not negative!\n", 1255 1255 dentry, dchild); 1256 1256 goto out; ··· 1353 1353 goto out; 1354 1354 1355 1355 dentry = fhp->fh_dentry; 1356 1356 - dirp = dentry->d_inode; 1356 1356 + dirp = d_inode(dentry); 1357 1357 1358 1358 /* Get all the sanity checks out of the way before 1359 1359 * we lock the parent. */ ··· 1376 1376 goto out_nfserr; 1377 1377 1378 1378 /* If file doesn't exist, check for permissions to create one */ 1379 1379 - if (!dchild->d_inode) { 1379 1379 + if (d_really_is_negative(dchild)) { 1380 1380 err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_CREATE); 1381 1381 if (err) 1382 1382 goto out; ··· 1397 1397 v_atime = verifier[1]&0x7fffffff; 1398 1398 } 1399 1399 1400 1400 - if (dchild->d_inode) { 1400 1400 + if (d_really_is_positive(dchild)) { 1401 1401 err = 0; 1402 1402 1403 1403 switch (createmode) { ··· 1420 1420 } 1421 1421 break; 1422 1422 case NFS3_CREATE_EXCLUSIVE: 1423 1423 - if ( dchild->d_inode->i_mtime.tv_sec == v_mtime 1424 1424 - && dchild->d_inode->i_atime.tv_sec == v_atime 1425 1425 - && dchild->d_inode->i_size == 0 ) { 1423 1423 + if ( d_inode(dchild)->i_mtime.tv_sec == v_mtime 1424 1424 + && d_inode(dchild)->i_atime.tv_sec == v_atime 1425 1425 + && d_inode(dchild)->i_size == 0 ) { 1426 1426 if (created) 1427 1427 *created = 1; 1428 1428 break; 1429 1429 } 1430 1430 case NFS4_CREATE_EXCLUSIVE4_1: 1431 1431 - if ( dchild->d_inode->i_mtime.tv_sec == v_mtime 1432 1432 - && dchild->d_inode->i_atime.tv_sec == v_atime 1433 1433 - && dchild->d_inode->i_size == 0 ) { 1431 1431 + if ( d_inode(dchild)->i_mtime.tv_sec == v_mtime 1432 1432 + && d_inode(dchild)->i_atime.tv_sec == v_atime 1433 1433 + && d_inode(dchild)->i_size == 0 ) { 1434 1434 if (created) 1435 1435 *created = 1; 1436 1436 goto set_attr; ··· 1513 1513 1514 1514 path.mnt = fhp->fh_export->ex_path.mnt; 1515 1515 path.dentry = fhp->fh_dentry; 1516 1516 - inode = path.dentry->d_inode; 1516 1516 + inode = d_inode(path.dentry); 1517 1517 1518 1518 err = nfserr_inval; 1519 1519 if (!inode->i_op->readlink) ··· 1576 1576 if (IS_ERR(dnew)) 1577 1577 goto out_nfserr; 1578 1578 1579 1579 - host_err = vfs_symlink(dentry->d_inode, dnew, path); 1579 1579 + host_err = vfs_symlink(d_inode(dentry), dnew, path); 1580 1580 err = nfserrno(host_err); 1581 1581 if (!err) 1582 1582 err = nfserrno(commit_metadata(fhp)); ··· 1632 1632 1633 1633 fh_lock_nested(ffhp, I_MUTEX_PARENT); 1634 1634 ddir = ffhp->fh_dentry; 1635 1635 - dirp = ddir->d_inode; 1635 1635 + dirp = d_inode(ddir); 1636 1636 1637 1637 dnew = lookup_one_len(name, ddir, len); 1638 1638 host_err = PTR_ERR(dnew); ··· 1642 1642 dold = tfhp->fh_dentry; 1643 1643 1644 1644 err = nfserr_noent; 1645 1645 - if (!dold->d_inode) 1645 1645 + if (d_really_is_negative(dold)) 1646 1646 goto out_dput; 1647 1647 host_err = vfs_link(dold, dirp, dnew, NULL); 1648 1648 if (!host_err) { ··· 1689 1689 goto out; 1690 1690 1691 1691 fdentry = ffhp->fh_dentry; 1692 1692 - fdir = fdentry->d_inode; 1692 1692 + fdir = d_inode(fdentry); 1693 1693 1694 1694 tdentry = tfhp->fh_dentry; 1695 1695 - tdir = tdentry->d_inode; 1695 1695 + tdir = d_inode(tdentry); 1696 1696 1697 1697 err = nfserr_perm; 1698 1698 if (!flen || isdotent(fname, flen) || !tlen || isdotent(tname, tlen)) ··· 1717 1717 goto out_nfserr; 1718 1718 1719 1719 host_err = -ENOENT; 1720 1720 - if (!odentry->d_inode) 1720 1720 + if (d_really_is_negative(odentry)) 1721 1721 goto out_dput_old; 1722 1722 host_err = -EINVAL; 1723 1723 if (odentry == trap) ··· 1790 1790 1791 1791 fh_lock_nested(fhp, I_MUTEX_PARENT); 1792 1792 dentry = fhp->fh_dentry; 1793 1793 - dirp = dentry->d_inode; 1793 1793 + dirp = d_inode(dentry); 1794 1794 1795 1795 rdentry = lookup_one_len(fname, dentry, flen); 1796 1796 host_err = PTR_ERR(rdentry); 1797 1797 if (IS_ERR(rdentry)) 1798 1798 goto out_nfserr; 1799 1799 1800 1800 - if (!rdentry->d_inode) { 1800 1800 + if (d_really_is_negative(rdentry)) { 1801 1801 dput(rdentry); 1802 1802 err = nfserr_noent; 1803 1803 goto out; 1804 1804 } 1805 1805 1806 1806 if (!type) 1807 1807 - type = rdentry->d_inode->i_mode & S_IFMT; 1807 1807 + type = d_inode(rdentry)->i_mode & S_IFMT; 1808 1808 1809 1809 if (type != S_IFDIR) 1810 1810 host_err = vfs_unlink(dirp, rdentry, NULL); ··· 2015 2015 nfsd_permission(struct svc_rqst *rqstp, struct svc_export *exp, 2016 2016 struct dentry *dentry, int acc) 2017 2017 { 2018 2018 - struct inode *inode = dentry->d_inode; 2018 2018 + struct inode *inode = d_inode(dentry); 2019 2019 int err; 2020 2020 2021 2021 if ((acc & NFSD_MAY_MASK) == NFSD_MAY_NOP)

+1 -1

fs/nfsd/xdr4.h

reviewed

··· 631 631 { 632 632 BUG_ON(!fhp->fh_pre_saved); 633 633 cinfo->atomic = fhp->fh_post_saved; 634 634 - cinfo->change_supported = IS_I_VERSION(fhp->fh_dentry->d_inode); 634 634 + cinfo->change_supported = IS_I_VERSION(d_inode(fhp->fh_dentry)); 635 635 636 636 cinfo->before_change = fhp->fh_pre_change; 637 637 cinfo->after_change = fhp->fh_post_change;

+1 -1

fs/nilfs2/dir.c

reviewed

··· 435 435 */ 436 436 int nilfs_add_link(struct dentry *dentry, struct inode *inode) 437 437 { 438 438 - struct inode *dir = dentry->d_parent->d_inode; 438 438 + struct inode *dir = d_inode(dentry->d_parent); 439 439 const unsigned char *name = dentry->d_name.name; 440 440 int namelen = dentry->d_name.len; 441 441 unsigned chunk_size = nilfs_chunk_size(dir);

+1 -1

fs/nilfs2/inode.c

reviewed

··· 835 835 int nilfs_setattr(struct dentry *dentry, struct iattr *iattr) 836 836 { 837 837 struct nilfs_transaction_info ti; 838 838 - struct inode *inode = dentry->d_inode; 838 838 + struct inode *inode = d_inode(dentry); 839 839 struct super_block *sb = inode->i_sb; 840 840 int err; 841 841

+9 -9

fs/nilfs2/namei.c

reviewed

··· 192 192 static int nilfs_link(struct dentry *old_dentry, struct inode *dir, 193 193 struct dentry *dentry) 194 194 { 195 195 - struct inode *inode = old_dentry->d_inode; 195 195 + struct inode *inode = d_inode(old_dentry); 196 196 struct nilfs_transaction_info ti; 197 197 int err; 198 198 ··· 283 283 if (!de) 284 284 goto out; 285 285 286 286 - inode = dentry->d_inode; 286 286 + inode = d_inode(dentry); 287 287 err = -EIO; 288 288 if (le64_to_cpu(de->inode) != inode->i_ino) 289 289 goto out; ··· 318 318 319 319 if (!err) { 320 320 nilfs_mark_inode_dirty(dir); 321 321 - nilfs_mark_inode_dirty(dentry->d_inode); 321 321 + nilfs_mark_inode_dirty(d_inode(dentry)); 322 322 err = nilfs_transaction_commit(dir->i_sb); 323 323 } else 324 324 nilfs_transaction_abort(dir->i_sb); ··· 328 328 329 329 static int nilfs_rmdir(struct inode *dir, struct dentry *dentry) 330 330 { 331 331 - struct inode *inode = dentry->d_inode; 331 331 + struct inode *inode = d_inode(dentry); 332 332 struct nilfs_transaction_info ti; 333 333 int err; 334 334 ··· 358 358 static int nilfs_rename(struct inode *old_dir, struct dentry *old_dentry, 359 359 struct inode *new_dir, struct dentry *new_dentry) 360 360 { 361 361 - struct inode *old_inode = old_dentry->d_inode; 362 362 - struct inode *new_inode = new_dentry->d_inode; 361 361 + struct inode *old_inode = d_inode(old_dentry); 362 362 + struct inode *new_inode = d_inode(new_dentry); 363 363 struct page *dir_page = NULL; 364 364 struct nilfs_dir_entry *dir_de = NULL; 365 365 struct page *old_page; ··· 453 453 struct qstr dotdot = QSTR_INIT("..", 2); 454 454 struct nilfs_root *root; 455 455 456 456 - ino = nilfs_inode_by_name(child->d_inode, &dotdot); 456 456 + ino = nilfs_inode_by_name(d_inode(child), &dotdot); 457 457 if (!ino) 458 458 return ERR_PTR(-ENOENT); 459 459 460 460 - root = NILFS_I(child->d_inode)->i_root; 460 460 + root = NILFS_I(d_inode(child))->i_root; 461 461 462 462 - inode = nilfs_iget(child->d_inode->i_sb, root, ino); 462 462 + inode = nilfs_iget(d_inode(child)->i_sb, root, ino); 463 463 if (IS_ERR(inode)) 464 464 return ERR_CAST(inode); 465 465

+3 -3

fs/nilfs2/super.c

reviewed

··· 610 610 static int nilfs_statfs(struct dentry *dentry, struct kstatfs *buf) 611 611 { 612 612 struct super_block *sb = dentry->d_sb; 613 613 - struct nilfs_root *root = NILFS_I(dentry->d_inode)->i_root; 613 613 + struct nilfs_root *root = NILFS_I(d_inode(dentry))->i_root; 614 614 struct the_nilfs *nilfs = root->nilfs; 615 615 u64 id = huge_encode_dev(sb->s_bdev->bd_dev); 616 616 unsigned long long blocks; ··· 681 681 { 682 682 struct super_block *sb = dentry->d_sb; 683 683 struct the_nilfs *nilfs = sb->s_fs_info; 684 684 - struct nilfs_root *root = NILFS_I(dentry->d_inode)->i_root; 684 684 + struct nilfs_root *root = NILFS_I(d_inode(dentry))->i_root; 685 685 686 686 if (!nilfs_test_opt(nilfs, BARRIER)) 687 687 seq_puts(seq, ",nobarrier"); ··· 1190 1190 1191 1191 sb->s_flags &= ~MS_RDONLY; 1192 1192 1193 1193 - root = NILFS_I(sb->s_root->d_inode)->i_root; 1193 1193 + root = NILFS_I(d_inode(sb->s_root))->i_root; 1194 1194 err = nilfs_attach_log_writer(sb, root); 1195 1195 if (err) 1196 1196 goto restore_opts;

+2 -2

fs/nsfs.c

reviewed

··· 13 13 14 14 static char *ns_dname(struct dentry *dentry, char *buffer, int buflen) 15 15 { 16 16 - struct inode *inode = dentry->d_inode; 16 16 + struct inode *inode = d_inode(dentry); 17 17 const struct proc_ns_operations *ns_ops = dentry->d_fsdata; 18 18 19 19 return dynamic_dname(dentry, buffer, buflen, "%s:[%lu]", ··· 22 22 23 23 static void ns_prune_dentry(struct dentry *dentry) 24 24 { 25 25 - struct inode *inode = dentry->d_inode; 25 25 + struct inode *inode = d_inode(dentry); 26 26 if (inode) { 27 27 struct ns_common *ns = inode->i_private; 28 28 atomic_long_set(&ns->stashed, 0);

+1 -1

fs/ntfs/inode.c

reviewed

··· 2889 2889 */ 2890 2890 int ntfs_setattr(struct dentry *dentry, struct iattr *attr) 2891 2891 { 2892 2892 - struct inode *vi = dentry->d_inode; 2892 2892 + struct inode *vi = d_inode(dentry); 2893 2893 int err; 2894 2894 unsigned int ia_valid = attr->ia_valid; 2895 2895

+2 -2

fs/ntfs/namei.c

reviewed

··· 292 292 * The code is based on the ext3 ->get_parent() implementation found in 293 293 * fs/ext3/namei.c::ext3_get_parent(). 294 294 * 295 295 - * Note: ntfs_get_parent() is called with @child_dent->d_inode->i_mutex down. 295 295 + * Note: ntfs_get_parent() is called with @d_inode(child_dent)->i_mutex down. 296 296 * 297 297 * Return the dentry of the parent directory on success or the error code on 298 298 * error (IS_ERR() is true). 299 299 */ 300 300 static struct dentry *ntfs_get_parent(struct dentry *child_dent) 301 301 { 302 302 - struct inode *vi = child_dent->d_inode; 302 302 + struct inode *vi = d_inode(child_dent); 303 303 ntfs_inode *ni = NTFS_I(vi); 304 304 MFT_RECORD *mrec; 305 305 ntfs_attr_search_ctx *ctx;

+7 -7

fs/ocfs2/dcache.c

reviewed

··· 42 42 void ocfs2_dentry_attach_gen(struct dentry *dentry) 43 43 { 44 44 unsigned long gen = 45 45 - OCFS2_I(dentry->d_parent->d_inode)->ip_dir_lock_gen; 46 46 - BUG_ON(dentry->d_inode); 45 45 + OCFS2_I(d_inode(dentry->d_parent))->ip_dir_lock_gen; 46 46 + BUG_ON(d_inode(dentry)); 47 47 dentry->d_fsdata = (void *)gen; 48 48 } 49 49 ··· 57 57 if (flags & LOOKUP_RCU) 58 58 return -ECHILD; 59 59 60 60 - inode = dentry->d_inode; 60 60 + inode = d_inode(dentry); 61 61 osb = OCFS2_SB(dentry->d_sb); 62 62 63 63 trace_ocfs2_dentry_revalidate(dentry, dentry->d_name.len, ··· 71 71 unsigned long gen = (unsigned long) dentry->d_fsdata; 72 72 unsigned long pgen; 73 73 spin_lock(&dentry->d_lock); 74 74 - pgen = OCFS2_I(dentry->d_parent->d_inode)->ip_dir_lock_gen; 74 74 + pgen = OCFS2_I(d_inode(dentry->d_parent))->ip_dir_lock_gen; 75 75 spin_unlock(&dentry->d_lock); 76 76 trace_ocfs2_dentry_revalidate_negative(dentry->d_name.len, 77 77 dentry->d_name.name, ··· 146 146 if (skip_unhashed && d_unhashed(dentry)) 147 147 return 0; 148 148 149 149 - parent = dentry->d_parent->d_inode; 149 149 + parent = d_inode(dentry->d_parent); 150 150 /* Negative parent dentry? */ 151 151 if (!parent) 152 152 return 0; ··· 243 243 if (!inode) 244 244 return 0; 245 245 246 246 - if (!dentry->d_inode && dentry->d_fsdata) { 246 246 + if (d_really_is_negative(dentry) && dentry->d_fsdata) { 247 247 /* Converting a negative dentry to positive 248 248 Clear dentry->d_fsdata */ 249 249 dentry->d_fsdata = dl = NULL; ··· 446 446 { 447 447 int ret; 448 448 struct ocfs2_super *osb = OCFS2_SB(old_dir->i_sb); 449 449 - struct inode *inode = dentry->d_inode; 449 449 + struct inode *inode = d_inode(dentry); 450 450 451 451 /* 452 452 * Move within the same directory, so the actual lock info won't

+1 -1

fs/ocfs2/dir.h

reviewed

··· 72 72 struct buffer_head *parent_fe_bh, 73 73 struct ocfs2_dir_lookup_result *lookup) 74 74 { 75 75 - return __ocfs2_add_entry(handle, dentry->d_parent->d_inode, 75 75 + return __ocfs2_add_entry(handle, d_inode(dentry->d_parent), 76 76 dentry->d_name.name, dentry->d_name.len, 77 77 inode, blkno, parent_fe_bh, lookup); 78 78 }

+2 -2

fs/ocfs2/dlmfs/dlmfs.c

reviewed

··· 208 208 static int dlmfs_file_setattr(struct dentry *dentry, struct iattr *attr) 209 209 { 210 210 int error; 211 211 - struct inode *inode = dentry->d_inode; 211 211 + struct inode *inode = d_inode(dentry); 212 212 213 213 attr->ia_valid &= ~ATTR_SIZE; 214 214 error = inode_change_ok(inode, attr); ··· 549 549 struct dentry *dentry) 550 550 { 551 551 int status; 552 552 - struct inode *inode = dentry->d_inode; 552 552 + struct inode *inode = d_inode(dentry); 553 553 554 554 mlog(0, "unlink inode %lu\n", inode->i_ino); 555 555

+1 -1

fs/ocfs2/export.c

reviewed

··· 147 147 int status; 148 148 u64 blkno; 149 149 struct dentry *parent; 150 150 - struct inode *dir = child->d_inode; 150 150 + struct inode *dir = d_inode(child); 151 151 152 152 trace_ocfs2_get_parent(child, child->d_name.len, child->d_name.name, 153 153 (unsigned long long)OCFS2_I(dir)->ip_blkno);

+4 -4

fs/ocfs2/file.c

reviewed

··· 1126 1126 int ocfs2_setattr(struct dentry *dentry, struct iattr *attr) 1127 1127 { 1128 1128 int status = 0, size_change; 1129 1129 - struct inode *inode = dentry->d_inode; 1129 1129 + struct inode *inode = d_inode(dentry); 1130 1130 struct super_block *sb = inode->i_sb; 1131 1131 struct ocfs2_super *osb = OCFS2_SB(sb); 1132 1132 struct buffer_head *bh = NULL; ··· 1275 1275 struct dentry *dentry, 1276 1276 struct kstat *stat) 1277 1277 { 1278 1278 - struct inode *inode = dentry->d_inode; 1279 1279 - struct super_block *sb = dentry->d_inode->i_sb; 1278 1278 + struct inode *inode = d_inode(dentry); 1279 1279 + struct super_block *sb = d_inode(dentry)->i_sb; 1280 1280 struct ocfs2_super *osb = sb->s_fs_info; 1281 1281 int err; 1282 1282 ··· 2114 2114 { 2115 2115 int ret = 0, meta_level = 0; 2116 2116 struct dentry *dentry = file->f_path.dentry; 2117 2117 - struct inode *inode = dentry->d_inode; 2117 2117 + struct inode *inode = d_inode(dentry); 2118 2118 loff_t end; 2119 2119 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb); 2120 2120 int full_coherency = !(osb->s_mount_opt &

+1 -1

fs/ocfs2/inode.c

reviewed

··· 1209 1209 */ 1210 1210 int ocfs2_inode_revalidate(struct dentry *dentry) 1211 1211 { 1212 1212 - struct inode *inode = dentry->d_inode; 1212 1212 + struct inode *inode = d_inode(dentry); 1213 1213 int status = 0; 1214 1214 1215 1215 trace_ocfs2_inode_revalidate(inode,

+7 -7

fs/ocfs2/namei.c

reviewed

··· 689 689 struct dentry *dentry) 690 690 { 691 691 handle_t *handle; 692 692 - struct inode *inode = old_dentry->d_inode; 693 693 - struct inode *old_dir = old_dentry->d_parent->d_inode; 692 692 + struct inode *inode = d_inode(old_dentry); 693 693 + struct inode *old_dir = d_inode(old_dentry->d_parent); 694 694 int err; 695 695 struct buffer_head *fe_bh = NULL; 696 696 struct buffer_head *old_dir_bh = NULL; ··· 879 879 int status; 880 880 int child_locked = 0; 881 881 bool is_unlinkable = false; 882 882 - struct inode *inode = dentry->d_inode; 882 882 + struct inode *inode = d_inode(dentry); 883 883 struct inode *orphan_dir = NULL; 884 884 struct ocfs2_super *osb = OCFS2_SB(dir->i_sb); 885 885 u64 blkno; ··· 898 898 899 899 dquot_initialize(dir); 900 900 901 901 - BUG_ON(dentry->d_parent->d_inode != dir); 901 901 + BUG_ON(d_inode(dentry->d_parent) != dir); 902 902 903 903 if (inode == osb->root_inode) 904 904 return -EPERM; ··· 1209 1209 { 1210 1210 int status = 0, rename_lock = 0, parents_locked = 0, target_exists = 0; 1211 1211 int old_child_locked = 0, new_child_locked = 0, update_dot_dot = 0; 1212 1212 - struct inode *old_inode = old_dentry->d_inode; 1213 1213 - struct inode *new_inode = new_dentry->d_inode; 1212 1212 + struct inode *old_inode = d_inode(old_dentry); 1213 1213 + struct inode *new_inode = d_inode(new_dentry); 1214 1214 struct inode *orphan_dir = NULL; 1215 1215 struct ocfs2_dinode *newfe = NULL; 1216 1216 char orphan_name[OCFS2_ORPHAN_NAMELEN + 1]; ··· 1454 1454 should_add_orphan = true; 1455 1455 } 1456 1456 } else { 1457 1457 - BUG_ON(new_dentry->d_parent->d_inode != new_dir); 1457 1457 + BUG_ON(d_inode(new_dentry->d_parent) != new_dir); 1458 1458 1459 1459 status = ocfs2_check_dir_for_entry(new_dir, 1460 1460 new_dentry->d_name.name,

+5 -5

fs/ocfs2/refcounttree.c

reviewed

··· 4194 4194 bool preserve) 4195 4195 { 4196 4196 int ret; 4197 4197 - struct inode *inode = old_dentry->d_inode; 4197 4197 + struct inode *inode = d_inode(old_dentry); 4198 4198 struct buffer_head *new_bh = NULL; 4199 4199 4200 4200 if (OCFS2_I(inode)->ip_flags & OCFS2_INODE_SYSTEM_FILE) { ··· 4263 4263 struct dentry *new_dentry, bool preserve) 4264 4264 { 4265 4265 int error; 4266 4266 - struct inode *inode = old_dentry->d_inode; 4266 4266 + struct inode *inode = d_inode(old_dentry); 4267 4267 struct buffer_head *old_bh = NULL; 4268 4268 struct inode *new_orphan_inode = NULL; 4269 4269 struct posix_acl *default_acl, *acl; ··· 4357 4357 /* copied from may_create in VFS. */ 4358 4358 static inline int ocfs2_may_create(struct inode *dir, struct dentry *child) 4359 4359 { 4360 4360 - if (child->d_inode) 4360 4360 + if (d_really_is_positive(child)) 4361 4361 return -EEXIST; 4362 4362 if (IS_DEADDIR(dir)) 4363 4363 return -ENOENT; ··· 4375 4375 static int ocfs2_vfs_reflink(struct dentry *old_dentry, struct inode *dir, 4376 4376 struct dentry *new_dentry, bool preserve) 4377 4377 { 4378 4378 - struct inode *inode = old_dentry->d_inode; 4378 4378 + struct inode *inode = d_inode(old_dentry); 4379 4379 int error; 4380 4380 4381 4381 if (!inode) ··· 4463 4463 } 4464 4464 4465 4465 error = ocfs2_vfs_reflink(old_path.dentry, 4466 4466 - new_path.dentry->d_inode, 4466 4466 + d_inode(new_path.dentry), 4467 4467 new_dentry, preserve); 4468 4468 out_dput: 4469 4469 done_path_create(&new_path, new_dentry);

+11 -11

fs/ocfs2/xattr.c

reviewed

··· 1020 1020 int ret = 0, i_ret = 0, b_ret = 0; 1021 1021 struct buffer_head *di_bh = NULL; 1022 1022 struct ocfs2_dinode *di = NULL; 1023 1023 - struct ocfs2_inode_info *oi = OCFS2_I(dentry->d_inode); 1023 1023 + struct ocfs2_inode_info *oi = OCFS2_I(d_inode(dentry)); 1024 1024 1025 1025 if (!ocfs2_supports_xattr(OCFS2_SB(dentry->d_sb))) 1026 1026 return -EOPNOTSUPP; ··· 1028 1028 if (!(oi->ip_dyn_features & OCFS2_HAS_XATTR_FL)) 1029 1029 return ret; 1030 1030 1031 1031 - ret = ocfs2_inode_lock(dentry->d_inode, &di_bh, 0); 1031 1031 + ret = ocfs2_inode_lock(d_inode(dentry), &di_bh, 0); 1032 1032 if (ret < 0) { 1033 1033 mlog_errno(ret); 1034 1034 return ret; ··· 1037 1037 di = (struct ocfs2_dinode *)di_bh->b_data; 1038 1038 1039 1039 down_read(&oi->ip_xattr_sem); 1040 1040 - i_ret = ocfs2_xattr_ibody_list(dentry->d_inode, di, buffer, size); 1040 1040 + i_ret = ocfs2_xattr_ibody_list(d_inode(dentry), di, buffer, size); 1041 1041 if (i_ret < 0) 1042 1042 b_ret = 0; 1043 1043 else { ··· 1045 1045 buffer += i_ret; 1046 1046 size -= i_ret; 1047 1047 } 1048 1048 - b_ret = ocfs2_xattr_block_list(dentry->d_inode, di, 1048 1048 + b_ret = ocfs2_xattr_block_list(d_inode(dentry), di, 1049 1049 buffer, size); 1050 1050 if (b_ret < 0) 1051 1051 i_ret = 0; 1052 1052 } 1053 1053 up_read(&oi->ip_xattr_sem); 1054 1054 - ocfs2_inode_unlock(dentry->d_inode, 0); 1054 1054 + ocfs2_inode_unlock(d_inode(dentry), 0); 1055 1055 1056 1056 brelse(di_bh); 1057 1057 ··· 7257 7257 { 7258 7258 if (strcmp(name, "") == 0) 7259 7259 return -EINVAL; 7260 7260 - return ocfs2_xattr_get(dentry->d_inode, OCFS2_XATTR_INDEX_SECURITY, 7260 7260 + return ocfs2_xattr_get(d_inode(dentry), OCFS2_XATTR_INDEX_SECURITY, 7261 7261 name, buffer, size); 7262 7262 } 7263 7263 ··· 7267 7267 if (strcmp(name, "") == 0) 7268 7268 return -EINVAL; 7269 7269 7270 7270 - return ocfs2_xattr_set(dentry->d_inode, OCFS2_XATTR_INDEX_SECURITY, 7270 7270 + return ocfs2_xattr_set(d_inode(dentry), OCFS2_XATTR_INDEX_SECURITY, 7271 7271 name, value, size, flags); 7272 7272 } 7273 7273 ··· 7347 7347 { 7348 7348 if (strcmp(name, "") == 0) 7349 7349 return -EINVAL; 7350 7350 - return ocfs2_xattr_get(dentry->d_inode, OCFS2_XATTR_INDEX_TRUSTED, 7350 7350 + return ocfs2_xattr_get(d_inode(dentry), OCFS2_XATTR_INDEX_TRUSTED, 7351 7351 name, buffer, size); 7352 7352 } 7353 7353 ··· 7357 7357 if (strcmp(name, "") == 0) 7358 7358 return -EINVAL; 7359 7359 7360 7360 - return ocfs2_xattr_set(dentry->d_inode, OCFS2_XATTR_INDEX_TRUSTED, 7360 7360 + return ocfs2_xattr_set(d_inode(dentry), OCFS2_XATTR_INDEX_TRUSTED, 7361 7361 name, value, size, flags); 7362 7362 } 7363 7363 ··· 7399 7399 return -EINVAL; 7400 7400 if (osb->s_mount_opt & OCFS2_MOUNT_NOUSERXATTR) 7401 7401 return -EOPNOTSUPP; 7402 7402 - return ocfs2_xattr_get(dentry->d_inode, OCFS2_XATTR_INDEX_USER, name, 7402 7402 + return ocfs2_xattr_get(d_inode(dentry), OCFS2_XATTR_INDEX_USER, name, 7403 7403 buffer, size); 7404 7404 } 7405 7405 ··· 7413 7413 if (osb->s_mount_opt & OCFS2_MOUNT_NOUSERXATTR) 7414 7414 return -EOPNOTSUPP; 7415 7415 7416 7416 - return ocfs2_xattr_set(dentry->d_inode, OCFS2_XATTR_INDEX_USER, 7416 7416 + return ocfs2_xattr_set(d_inode(dentry), OCFS2_XATTR_INDEX_USER, 7417 7417 name, value, size, flags); 7418 7418 } 7419 7419

+5 -5

fs/omfs/dir.c

reviewed

··· 110 110 111 111 static int omfs_add_link(struct dentry *dentry, struct inode *inode) 112 112 { 113 113 - struct inode *dir = dentry->d_parent->d_inode; 113 113 + struct inode *dir = d_inode(dentry->d_parent); 114 114 const char *name = dentry->d_name.name; 115 115 int namelen = dentry->d_name.len; 116 116 struct omfs_inode *oi; ··· 155 155 156 156 static int omfs_delete_entry(struct dentry *dentry) 157 157 { 158 158 - struct inode *dir = dentry->d_parent->d_inode; 158 158 + struct inode *dir = d_inode(dentry->d_parent); 159 159 struct inode *dirty; 160 160 const char *name = dentry->d_name.name; 161 161 int namelen = dentry->d_name.len; ··· 237 237 238 238 static int omfs_remove(struct inode *dir, struct dentry *dentry) 239 239 { 240 240 - struct inode *inode = dentry->d_inode; 240 240 + struct inode *inode = d_inode(dentry); 241 241 int ret; 242 242 243 243 ··· 373 373 static int omfs_rename(struct inode *old_dir, struct dentry *old_dentry, 374 374 struct inode *new_dir, struct dentry *new_dentry) 375 375 { 376 376 - struct inode *new_inode = new_dentry->d_inode; 377 377 - struct inode *old_inode = old_dentry->d_inode; 376 376 + struct inode *new_inode = d_inode(new_dentry); 377 377 + struct inode *old_inode = d_inode(old_dentry); 378 378 int err; 379 379 380 380 if (new_inode) {

+1 -1

fs/omfs/file.c

reviewed

··· 346 346 347 347 static int omfs_setattr(struct dentry *dentry, struct iattr *attr) 348 348 { 349 349 - struct inode *inode = dentry->d_inode; 349 349 + struct inode *inode = d_inode(dentry); 350 350 int error; 351 351 352 352 error = inode_change_ok(inode, attr);

+1 -1

fs/pipe.c

reviewed

··· 627 627 static char *pipefs_dname(struct dentry *dentry, char *buffer, int buflen) 628 628 { 629 629 return dynamic_dname(dentry, buffer, buflen, "pipe:[%lu]", 630 630 - dentry->d_inode->i_ino); 630 630 + d_inode(dentry)->i_ino); 631 631 } 632 632 633 633 static const struct dentry_operations pipefs_dentry_operations = {

+4 -4

fs/posix_acl.c

reviewed

··· 774 774 struct posix_acl *acl; 775 775 int error; 776 776 777 777 - if (!IS_POSIXACL(dentry->d_inode)) 777 777 + if (!IS_POSIXACL(d_backing_inode(dentry))) 778 778 return -EOPNOTSUPP; 779 779 if (d_is_symlink(dentry)) 780 780 return -EOPNOTSUPP; 781 781 782 782 - acl = get_acl(dentry->d_inode, type); 782 782 + acl = get_acl(d_backing_inode(dentry), type); 783 783 if (IS_ERR(acl)) 784 784 return PTR_ERR(acl); 785 785 if (acl == NULL) ··· 795 795 posix_acl_xattr_set(struct dentry *dentry, const char *name, 796 796 const void *value, size_t size, int flags, int type) 797 797 { 798 798 - struct inode *inode = dentry->d_inode; 798 798 + struct inode *inode = d_backing_inode(dentry); 799 799 struct posix_acl *acl = NULL; 800 800 int ret; 801 801 ··· 834 834 const char *xname; 835 835 size_t size; 836 836 837 837 - if (!IS_POSIXACL(dentry->d_inode)) 837 837 + if (!IS_POSIXACL(d_backing_inode(dentry))) 838 838 return -EOPNOTSUPP; 839 839 if (d_is_symlink(dentry)) 840 840 return -EOPNOTSUPP;

+16 -16

fs/proc/base.c

reviewed

··· 169 169 170 170 static int proc_cwd_link(struct dentry *dentry, struct path *path) 171 171 { 172 172 - struct task_struct *task = get_proc_task(dentry->d_inode); 172 172 + struct task_struct *task = get_proc_task(d_inode(dentry)); 173 173 int result = -ENOENT; 174 174 175 175 if (task) { ··· 186 186 187 187 static int proc_root_link(struct dentry *dentry, struct path *path) 188 188 { 189 189 - struct task_struct *task = get_proc_task(dentry->d_inode); 189 189 + struct task_struct *task = get_proc_task(d_inode(dentry)); 190 190 int result = -ENOENT; 191 191 192 192 if (task) { ··· 514 514 int proc_setattr(struct dentry *dentry, struct iattr *attr) 515 515 { 516 516 int error; 517 517 - struct inode *inode = dentry->d_inode; 517 517 + struct inode *inode = d_inode(dentry); 518 518 519 519 if (attr->ia_valid & ATTR_MODE) 520 520 return -EPERM; ··· 1362 1362 struct mm_struct *mm; 1363 1363 struct file *exe_file; 1364 1364 1365 1365 - task = get_proc_task(dentry->d_inode); 1365 1365 + task = get_proc_task(d_inode(dentry)); 1366 1366 if (!task) 1367 1367 return -ENOENT; 1368 1368 mm = get_task_mm(task); ··· 1382 1382 1383 1383 static void *proc_pid_follow_link(struct dentry *dentry, struct nameidata *nd) 1384 1384 { 1385 1385 - struct inode *inode = dentry->d_inode; 1385 1385 + struct inode *inode = d_inode(dentry); 1386 1386 struct path path; 1387 1387 int error = -EACCES; 1388 1388 ··· 1427 1427 static int proc_pid_readlink(struct dentry * dentry, char __user * buffer, int buflen) 1428 1428 { 1429 1429 int error = -EACCES; 1430 1430 - struct inode *inode = dentry->d_inode; 1430 1430 + struct inode *inode = d_inode(dentry); 1431 1431 struct path path; 1432 1432 1433 1433 /* Are we allowed to snoop on the tasks file descriptors? */ ··· 1497 1497 1498 1498 int pid_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) 1499 1499 { 1500 1500 - struct inode *inode = dentry->d_inode; 1500 1500 + struct inode *inode = d_inode(dentry); 1501 1501 struct task_struct *task; 1502 1502 const struct cred *cred; 1503 1503 struct pid_namespace *pid = dentry->d_sb->s_fs_info; ··· 1554 1554 if (flags & LOOKUP_RCU) 1555 1555 return -ECHILD; 1556 1556 1557 1557 - inode = dentry->d_inode; 1557 1557 + inode = d_inode(dentry); 1558 1558 task = get_proc_task(inode); 1559 1559 1560 1560 if (task) { ··· 1588 1588 * If so, then don't put the dentry on the lru list, 1589 1589 * kill it immediately. 1590 1590 */ 1591 1591 - return proc_inode_is_dead(dentry->d_inode); 1591 1591 + return proc_inode_is_dead(d_inode(dentry)); 1592 1592 } 1593 1593 1594 1594 const struct dentry_operations pid_dentry_operations = ··· 1626 1626 child = d_alloc(dir, &qname); 1627 1627 if (!child) 1628 1628 goto end_instantiate; 1629 1629 - if (instantiate(dir->d_inode, child, task, ptr) < 0) { 1629 1629 + if (instantiate(d_inode(dir), child, task, ptr) < 0) { 1630 1630 dput(child); 1631 1631 goto end_instantiate; 1632 1632 } 1633 1633 } 1634 1634 - inode = child->d_inode; 1634 1634 + inode = d_inode(child); 1635 1635 ino = inode->i_ino; 1636 1636 type = inode->i_mode >> 12; 1637 1637 dput(child); ··· 1674 1674 goto out_notask; 1675 1675 } 1676 1676 1677 1677 - inode = dentry->d_inode; 1677 1677 + inode = d_inode(dentry); 1678 1678 task = get_proc_task(inode); 1679 1679 if (!task) 1680 1680 goto out_notask; ··· 1727 1727 int rc; 1728 1728 1729 1729 rc = -ENOENT; 1730 1730 - task = get_proc_task(dentry->d_inode); 1730 1730 + task = get_proc_task(d_inode(dentry)); 1731 1731 if (!task) 1732 1732 goto out; 1733 1733 ··· 2863 2863 return 0; 2864 2864 2865 2865 if (pos == TGID_OFFSET - 2) { 2866 2866 - struct inode *inode = ns->proc_self->d_inode; 2866 2866 + struct inode *inode = d_inode(ns->proc_self); 2867 2867 if (!dir_emit(ctx, "self", 4, inode->i_ino, DT_LNK)) 2868 2868 return 0; 2869 2869 ctx->pos = pos = pos + 1; 2870 2870 } 2871 2871 if (pos == TGID_OFFSET - 1) { 2872 2872 - struct inode *inode = ns->proc_thread_self->d_inode; 2872 2872 + struct inode *inode = d_inode(ns->proc_thread_self); 2873 2873 if (!dir_emit(ctx, "thread-self", 11, inode->i_ino, DT_LNK)) 2874 2874 return 0; 2875 2875 ctx->pos = pos = pos + 1; ··· 3188 3188 3189 3189 static int proc_task_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) 3190 3190 { 3191 3191 - struct inode *inode = dentry->d_inode; 3191 3191 + struct inode *inode = d_inode(dentry); 3192 3192 struct task_struct *p = get_proc_task(inode); 3193 3193 generic_fillattr(inode, stat); 3194 3194

+3 -3

fs/proc/fd.c

reviewed

··· 91 91 if (flags & LOOKUP_RCU) 92 92 return -ECHILD; 93 93 94 94 - inode = dentry->d_inode; 94 94 + inode = d_inode(dentry); 95 95 task = get_proc_task(inode); 96 96 fd = proc_fd(inode); 97 97 ··· 151 151 struct task_struct *task; 152 152 int ret = -ENOENT; 153 153 154 154 - task = get_proc_task(dentry->d_inode); 154 154 + task = get_proc_task(d_inode(dentry)); 155 155 if (task) { 156 156 files = get_files_struct(task); 157 157 put_task_struct(task); 158 158 } 159 159 160 160 if (files) { 161 161 - int fd = proc_fd(dentry->d_inode); 161 161 + int fd = proc_fd(d_inode(dentry)); 162 162 struct file *fd_file; 163 163 164 164 spin_lock(&files->file_lock);

+2 -2

fs/proc/generic.c

reviewed

··· 101 101 102 102 static int proc_notify_change(struct dentry *dentry, struct iattr *iattr) 103 103 { 104 104 - struct inode *inode = dentry->d_inode; 104 104 + struct inode *inode = d_inode(dentry); 105 105 struct proc_dir_entry *de = PDE(inode); 106 106 int error; 107 107 ··· 120 120 static int proc_getattr(struct vfsmount *mnt, struct dentry *dentry, 121 121 struct kstat *stat) 122 122 { 123 123 - struct inode *inode = dentry->d_inode; 123 123 + struct inode *inode = d_inode(dentry); 124 124 struct proc_dir_entry *de = PDE(inode); 125 125 if (de && de->nlink) 126 126 set_nlink(inode, de->nlink);

+1 -1

fs/proc/inode.c

reviewed

··· 396 396 397 397 static void *proc_follow_link(struct dentry *dentry, struct nameidata *nd) 398 398 { 399 399 - struct proc_dir_entry *pde = PDE(dentry->d_inode); 399 399 + struct proc_dir_entry *pde = PDE(d_inode(dentry)); 400 400 if (unlikely(!use_pde(pde))) 401 401 return ERR_PTR(-EINVAL); 402 402 nd_set_link(nd, pde->data);

+2 -2

fs/proc/namespaces.c

reviewed

··· 32 32 33 33 static void *proc_ns_follow_link(struct dentry *dentry, struct nameidata *nd) 34 34 { 35 35 - struct inode *inode = dentry->d_inode; 35 35 + struct inode *inode = d_inode(dentry); 36 36 const struct proc_ns_operations *ns_ops = PROC_I(inode)->ns_ops; 37 37 struct task_struct *task; 38 38 struct path ns_path; ··· 53 53 54 54 static int proc_ns_readlink(struct dentry *dentry, char __user *buffer, int buflen) 55 55 { 56 56 - struct inode *inode = dentry->d_inode; 56 56 + struct inode *inode = d_inode(dentry); 57 57 const struct proc_ns_operations *ns_ops = PROC_I(inode)->ns_ops; 58 58 struct task_struct *task; 59 59 char name[50];

+1 -1

fs/proc/proc_net.c

reviewed

··· 142 142 static int proc_tgid_net_getattr(struct vfsmount *mnt, struct dentry *dentry, 143 143 struct kstat *stat) 144 144 { 145 145 - struct inode *inode = dentry->d_inode; 145 145 + struct inode *inode = d_inode(dentry); 146 146 struct net *net; 147 147 148 148 net = get_proc_task_net(inode);

+6 -6

fs/proc/proc_sysctl.c

reviewed

··· 604 604 return false; 605 605 } 606 606 } 607 607 - inode = child->d_inode; 607 607 + inode = d_inode(child); 608 608 ino = inode->i_ino; 609 609 type = inode->i_mode >> 12; 610 610 dput(child); ··· 710 710 711 711 static int proc_sys_setattr(struct dentry *dentry, struct iattr *attr) 712 712 { 713 713 - struct inode *inode = dentry->d_inode; 713 713 + struct inode *inode = d_inode(dentry); 714 714 int error; 715 715 716 716 if (attr->ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID)) ··· 727 727 728 728 static int proc_sys_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) 729 729 { 730 730 - struct inode *inode = dentry->d_inode; 730 730 + struct inode *inode = d_inode(dentry); 731 731 struct ctl_table_header *head = grab_header(inode); 732 732 struct ctl_table *table = PROC_I(inode)->sysctl_entry; 733 733 ··· 773 773 { 774 774 if (flags & LOOKUP_RCU) 775 775 return -ECHILD; 776 776 - return !PROC_I(dentry->d_inode)->sysctl->unregistering; 776 776 + return !PROC_I(d_inode(dentry))->sysctl->unregistering; 777 777 } 778 778 779 779 static int proc_sys_delete(const struct dentry *dentry) 780 780 { 781 781 - return !!PROC_I(dentry->d_inode)->sysctl->unregistering; 781 781 + return !!PROC_I(d_inode(dentry))->sysctl->unregistering; 782 782 } 783 783 784 784 static int sysctl_is_seen(struct ctl_table_header *p) ··· 805 805 /* Although proc doesn't have negative dentries, rcu-walk means 806 806 * that inode here can be NULL */ 807 807 /* AV: can it, indeed? */ 808 808 - inode = ACCESS_ONCE(dentry->d_inode); 808 808 + inode = d_inode_rcu(dentry); 809 809 if (!inode) 810 810 return 1; 811 811 if (name->len != len)

+1 -1

fs/proc/root.c

reviewed

··· 195 195 static int proc_root_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat 196 196 ) 197 197 { 198 198 - generic_fillattr(dentry->d_inode, stat); 198 198 + generic_fillattr(d_inode(dentry), stat); 199 199 stat->nlink = proc_root.nlink + nr_processes(); 200 200 return 0; 201 201 }

+1 -1

fs/proc/self.c

reviewed

··· 46 46 47 47 int proc_setup_self(struct super_block *s) 48 48 { 49 49 - struct inode *root_inode = s->s_root->d_inode; 49 49 + struct inode *root_inode = d_inode(s->s_root); 50 50 struct pid_namespace *ns = s->s_fs_info; 51 51 struct dentry *self; 52 52

+1 -1

fs/proc/thread_self.c

reviewed

··· 47 47 48 48 int proc_setup_thread_self(struct super_block *s) 49 49 { 50 50 - struct inode *root_inode = s->s_root->d_inode; 50 50 + struct inode *root_inode = d_inode(s->s_root); 51 51 struct pid_namespace *ns = s->s_fs_info; 52 52 struct dentry *thread_self; 53 53

+5 -5

fs/pstore/inode.c

reviewed

··· 190 190 */ 191 191 static int pstore_unlink(struct inode *dir, struct dentry *dentry) 192 192 { 193 193 - struct pstore_private *p = dentry->d_inode->i_private; 193 193 + struct pstore_private *p = d_inode(dentry)->i_private; 194 194 int err; 195 195 196 196 err = pstore_check_syslog_permissions(p); ··· 199 199 200 200 if (p->psi->erase) 201 201 p->psi->erase(p->type, p->id, p->count, 202 202 - dentry->d_inode->i_ctime, p->psi); 202 202 + d_inode(dentry)->i_ctime, p->psi); 203 203 else 204 204 return -EPERM; 205 205 ··· 376 376 break; 377 377 } 378 378 379 379 - mutex_lock(&root->d_inode->i_mutex); 379 379 + mutex_lock(&d_inode(root)->i_mutex); 380 380 381 381 dentry = d_alloc_name(root, name); 382 382 if (!dentry) ··· 396 396 list_add(&private->list, &allpstore); 397 397 spin_unlock_irqrestore(&allpstore_lock, flags); 398 398 399 399 - mutex_unlock(&root->d_inode->i_mutex); 399 399 + mutex_unlock(&d_inode(root)->i_mutex); 400 400 401 401 return 0; 402 402 403 403 fail_lockedalloc: 404 404 - mutex_unlock(&root->d_inode->i_mutex); 404 404 + mutex_unlock(&d_inode(root)->i_mutex); 405 405 kfree(private); 406 406 fail_alloc: 407 407 iput(inode);

+1 -1

fs/qnx6/inode.c

reviewed

··· 182 182 static char match_root[2][3] = {".\0\0", "..\0"}; 183 183 int i, error = 0; 184 184 struct qnx6_dir_entry *dir_entry; 185 185 - struct inode *root = s->s_root->d_inode; 185 185 + struct inode *root = d_inode(s->s_root); 186 186 struct address_space *mapping = root->i_mapping; 187 187 struct page *page = read_mapping_page(mapping, 0, NULL); 188 188 if (IS_ERR(page))

+5 -5

fs/quota/dquot.c

reviewed

··· 2328 2328 if (path->dentry->d_sb != sb) 2329 2329 error = -EXDEV; 2330 2330 else 2331 2331 - error = vfs_load_quota_inode(path->dentry->d_inode, type, 2331 2331 + error = vfs_load_quota_inode(d_inode(path->dentry), type, 2332 2332 format_id, DQUOT_USAGE_ENABLED | 2333 2333 DQUOT_LIMITS_ENABLED); 2334 2334 return error; ··· 2392 2392 struct dentry *dentry; 2393 2393 int error; 2394 2394 2395 2395 - mutex_lock(&sb->s_root->d_inode->i_mutex); 2395 2395 + mutex_lock(&d_inode(sb->s_root)->i_mutex); 2396 2396 dentry = lookup_one_len(qf_name, sb->s_root, strlen(qf_name)); 2397 2397 - mutex_unlock(&sb->s_root->d_inode->i_mutex); 2397 2397 + mutex_unlock(&d_inode(sb->s_root)->i_mutex); 2398 2398 if (IS_ERR(dentry)) 2399 2399 return PTR_ERR(dentry); 2400 2400 2401 2401 - if (!dentry->d_inode) { 2401 2401 + if (d_really_is_negative(dentry)) { 2402 2402 error = -ENOENT; 2403 2403 goto out; 2404 2404 } 2405 2405 2406 2406 error = security_quota_on(dentry); 2407 2407 if (!error) 2408 2408 - error = vfs_load_quota_inode(dentry->d_inode, type, format_id, 2408 2408 + error = vfs_load_quota_inode(d_inode(dentry), type, format_id, 2409 2409 DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED); 2410 2410 2411 2411 out:

+1 -1

fs/ramfs/file-nommu.c

reviewed

··· 163 163 */ 164 164 static int ramfs_nommu_setattr(struct dentry *dentry, struct iattr *ia) 165 165 { 166 166 - struct inode *inode = dentry->d_inode; 166 166 + struct inode *inode = d_inode(dentry); 167 167 unsigned int old_ia_valid = ia->ia_valid; 168 168 int ret = 0; 169 169

+2 -2

fs/reiserfs/dir.c

reviewed

··· 53 53 static inline bool is_privroot_deh(struct inode *dir, struct reiserfs_de_head *deh) 54 54 { 55 55 struct dentry *privroot = REISERFS_SB(dir->i_sb)->priv_root; 56 56 - return (privroot->d_inode && 57 57 - deh->deh_objectid == INODE_PKEY(privroot->d_inode)->k_objectid); 56 56 + return (d_really_is_positive(privroot) && 57 57 + deh->deh_objectid == INODE_PKEY(d_inode(privroot))->k_objectid); 58 58 } 59 59 60 60 int reiserfs_readdir_inode(struct inode *inode, struct dir_context *ctx)

+1 -1

fs/reiserfs/inode.c

reviewed

··· 3308 3308 3309 3309 int reiserfs_setattr(struct dentry *dentry, struct iattr *attr) 3310 3310 { 3311 3311 - struct inode *inode = dentry->d_inode; 3311 3311 + struct inode *inode = d_inode(dentry); 3312 3312 unsigned int ia_valid; 3313 3313 int error; 3314 3314

+6 -6

fs/reiserfs/namei.c

reviewed

··· 400 400 struct inode *inode = NULL; 401 401 struct reiserfs_dir_entry de; 402 402 INITIALIZE_PATH(path_to_entry); 403 403 - struct inode *dir = child->d_inode; 403 403 + struct inode *dir = d_inode(child); 404 404 405 405 if (dir->i_nlink == 0) { 406 406 return ERR_PTR(-ENOENT); ··· 917 917 goto end_rmdir; 918 918 } 919 919 920 920 - inode = dentry->d_inode; 920 920 + inode = d_inode(dentry); 921 921 922 922 reiserfs_update_inode_transaction(inode); 923 923 reiserfs_update_inode_transaction(dir); ··· 987 987 988 988 dquot_initialize(dir); 989 989 990 990 - inode = dentry->d_inode; 990 990 + inode = d_inode(dentry); 991 991 992 992 /* 993 993 * in this transaction we can be doing at max two balancings and ··· 1174 1174 struct dentry *dentry) 1175 1175 { 1176 1176 int retval; 1177 1177 - struct inode *inode = old_dentry->d_inode; 1177 1177 + struct inode *inode = d_inode(old_dentry); 1178 1178 struct reiserfs_transaction_handle th; 1179 1179 /* 1180 1180 * We need blocks for transaction + update of quotas for ··· 1311 1311 dquot_initialize(old_dir); 1312 1312 dquot_initialize(new_dir); 1313 1313 1314 1314 - old_inode = old_dentry->d_inode; 1315 1315 - new_dentry_inode = new_dentry->d_inode; 1314 1314 + old_inode = d_inode(old_dentry); 1315 1315 + new_dentry_inode = d_inode(new_dentry); 1316 1316 1317 1317 /* 1318 1318 * make sure that oldname still exists and points to an object we

+2 -2

fs/reiserfs/super.c

reviewed

··· 1687 1687 __u32 hash = DEFAULT_HASH; 1688 1688 __u32 deh_hashval, teahash, r5hash, yurahash; 1689 1689 1690 1690 - inode = s->s_root->d_inode; 1690 1690 + inode = d_inode(s->s_root); 1691 1691 1692 1692 make_cpu_key(&key, inode, ~0, TYPE_DIRENTRY, 3); 1693 1693 retval = search_by_entry_key(s, &key, &path, &de); ··· 2347 2347 err = -EXDEV; 2348 2348 goto out; 2349 2349 } 2350 2350 - inode = path->dentry->d_inode; 2350 2350 + inode = d_inode(path->dentry); 2351 2351 /* 2352 2352 * We must not pack tails for quota files on reiserfs for quota 2353 2353 * IO to work

+63 -63

fs/reiserfs/xattr.c

reviewed

··· 87 87 88 88 BUG_ON(!mutex_is_locked(&dir->i_mutex)); 89 89 90 90 - mutex_lock_nested(&dentry->d_inode->i_mutex, I_MUTEX_CHILD); 90 90 + mutex_lock_nested(&d_inode(dentry)->i_mutex, I_MUTEX_CHILD); 91 91 error = dir->i_op->unlink(dir, dentry); 92 92 - mutex_unlock(&dentry->d_inode->i_mutex); 92 92 + mutex_unlock(&d_inode(dentry)->i_mutex); 93 93 94 94 if (!error) 95 95 d_delete(dentry); ··· 102 102 103 103 BUG_ON(!mutex_is_locked(&dir->i_mutex)); 104 104 105 105 - mutex_lock_nested(&dentry->d_inode->i_mutex, I_MUTEX_CHILD); 105 105 + mutex_lock_nested(&d_inode(dentry)->i_mutex, I_MUTEX_CHILD); 106 106 error = dir->i_op->rmdir(dir, dentry); 107 107 if (!error) 108 108 - dentry->d_inode->i_flags |= S_DEAD; 109 109 - mutex_unlock(&dentry->d_inode->i_mutex); 108 108 + d_inode(dentry)->i_flags |= S_DEAD; 109 109 + mutex_unlock(&d_inode(dentry)->i_mutex); 110 110 if (!error) 111 111 d_delete(dentry); 112 112 ··· 120 120 struct dentry *privroot = REISERFS_SB(sb)->priv_root; 121 121 struct dentry *xaroot; 122 122 123 123 - if (!privroot->d_inode) 123 123 + if (d_really_is_negative(privroot)) 124 124 return ERR_PTR(-ENODATA); 125 125 126 126 - mutex_lock_nested(&privroot->d_inode->i_mutex, I_MUTEX_XATTR); 126 126 + mutex_lock_nested(&d_inode(privroot)->i_mutex, I_MUTEX_XATTR); 127 127 128 128 xaroot = dget(REISERFS_SB(sb)->xattr_root); 129 129 if (!xaroot) 130 130 xaroot = ERR_PTR(-ENODATA); 131 131 - else if (!xaroot->d_inode) { 131 131 + else if (d_really_is_negative(xaroot)) { 132 132 int err = -ENODATA; 133 133 134 134 if (xattr_may_create(flags)) 135 135 - err = xattr_mkdir(privroot->d_inode, xaroot, 0700); 135 135 + err = xattr_mkdir(d_inode(privroot), xaroot, 0700); 136 136 if (err) { 137 137 dput(xaroot); 138 138 xaroot = ERR_PTR(err); 139 139 } 140 140 } 141 141 142 142 - mutex_unlock(&privroot->d_inode->i_mutex); 142 142 + mutex_unlock(&d_inode(privroot)->i_mutex); 143 143 return xaroot; 144 144 } 145 145 ··· 156 156 le32_to_cpu(INODE_PKEY(inode)->k_objectid), 157 157 inode->i_generation); 158 158 159 159 - mutex_lock_nested(&xaroot->d_inode->i_mutex, I_MUTEX_XATTR); 159 159 + mutex_lock_nested(&d_inode(xaroot)->i_mutex, I_MUTEX_XATTR); 160 160 161 161 xadir = lookup_one_len(namebuf, xaroot, strlen(namebuf)); 162 162 - if (!IS_ERR(xadir) && !xadir->d_inode) { 162 162 + if (!IS_ERR(xadir) && d_really_is_negative(xadir)) { 163 163 int err = -ENODATA; 164 164 165 165 if (xattr_may_create(flags)) 166 166 - err = xattr_mkdir(xaroot->d_inode, xadir, 0700); 166 166 + err = xattr_mkdir(d_inode(xaroot), xadir, 0700); 167 167 if (err) { 168 168 dput(xadir); 169 169 xadir = ERR_PTR(err); 170 170 } 171 171 } 172 172 173 173 - mutex_unlock(&xaroot->d_inode->i_mutex); 173 173 + mutex_unlock(&d_inode(xaroot)->i_mutex); 174 174 dput(xaroot); 175 175 return xadir; 176 176 } ··· 195 195 container_of(ctx, struct reiserfs_dentry_buf, ctx); 196 196 struct dentry *dentry; 197 197 198 198 - WARN_ON_ONCE(!mutex_is_locked(&dbuf->xadir->d_inode->i_mutex)); 198 198 + WARN_ON_ONCE(!mutex_is_locked(&d_inode(dbuf->xadir)->i_mutex)); 199 199 200 200 if (dbuf->count == ARRAY_SIZE(dbuf->dentries)) 201 201 return -ENOSPC; ··· 207 207 dentry = lookup_one_len(name, dbuf->xadir, namelen); 208 208 if (IS_ERR(dentry)) { 209 209 return PTR_ERR(dentry); 210 210 - } else if (!dentry->d_inode) { 210 210 + } else if (d_really_is_negative(dentry)) { 211 211 /* A directory entry exists, but no file? */ 212 212 reiserfs_error(dentry->d_sb, "xattr-20003", 213 213 "Corrupted directory: xattr %pd listed but " ··· 249 249 if (IS_ERR(dir)) { 250 250 err = PTR_ERR(dir); 251 251 goto out; 252 252 - } else if (!dir->d_inode) { 252 252 + } else if (d_really_is_negative(dir)) { 253 253 err = 0; 254 254 goto out_dir; 255 255 } 256 256 257 257 - mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_XATTR); 257 257 + mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_XATTR); 258 258 259 259 buf.xadir = dir; 260 260 while (1) { 261 261 - err = reiserfs_readdir_inode(dir->d_inode, &buf.ctx); 261 261 + err = reiserfs_readdir_inode(d_inode(dir), &buf.ctx); 262 262 if (err) 263 263 break; 264 264 if (!buf.count) ··· 276 276 break; 277 277 buf.count = 0; 278 278 } 279 279 - mutex_unlock(&dir->d_inode->i_mutex); 279 279 + mutex_unlock(&d_inode(dir)->i_mutex); 280 280 281 281 cleanup_dentry_buf(&buf); 282 282 ··· 298 298 if (!err) { 299 299 int jerror; 300 300 301 301 - mutex_lock_nested(&dir->d_parent->d_inode->i_mutex, 301 301 + mutex_lock_nested(&d_inode(dir->d_parent)->i_mutex, 302 302 I_MUTEX_XATTR); 303 303 err = action(dir, data); 304 304 reiserfs_write_lock(inode->i_sb); 305 305 jerror = journal_end(&th); 306 306 reiserfs_write_unlock(inode->i_sb); 307 307 - mutex_unlock(&dir->d_parent->d_inode->i_mutex); 307 307 + mutex_unlock(&d_inode(dir->d_parent)->i_mutex); 308 308 err = jerror ?: err; 309 309 } 310 310 } ··· 319 319 320 320 static int delete_one_xattr(struct dentry *dentry, void *data) 321 321 { 322 322 - struct inode *dir = dentry->d_parent->d_inode; 322 322 + struct inode *dir = d_inode(dentry->d_parent); 323 323 324 324 /* This is the xattr dir, handle specially. */ 325 325 if (d_is_dir(dentry)) ··· 384 384 if (IS_ERR(xadir)) 385 385 return ERR_CAST(xadir); 386 386 387 387 - mutex_lock_nested(&xadir->d_inode->i_mutex, I_MUTEX_XATTR); 387 387 + mutex_lock_nested(&d_inode(xadir)->i_mutex, I_MUTEX_XATTR); 388 388 xafile = lookup_one_len(name, xadir, strlen(name)); 389 389 if (IS_ERR(xafile)) { 390 390 err = PTR_ERR(xafile); 391 391 goto out; 392 392 } 393 393 394 394 - if (xafile->d_inode && (flags & XATTR_CREATE)) 394 394 + if (d_really_is_positive(xafile) && (flags & XATTR_CREATE)) 395 395 err = -EEXIST; 396 396 397 397 - if (!xafile->d_inode) { 397 397 + if (d_really_is_negative(xafile)) { 398 398 err = -ENODATA; 399 399 if (xattr_may_create(flags)) 400 400 - err = xattr_create(xadir->d_inode, xafile, 400 400 + err = xattr_create(d_inode(xadir), xafile, 401 401 0700|S_IFREG); 402 402 } 403 403 404 404 if (err) 405 405 dput(xafile); 406 406 out: 407 407 - mutex_unlock(&xadir->d_inode->i_mutex); 407 407 + mutex_unlock(&d_inode(xadir)->i_mutex); 408 408 dput(xadir); 409 409 if (err) 410 410 return ERR_PTR(err); ··· 469 469 if (IS_ERR(xadir)) 470 470 return PTR_ERR(xadir); 471 471 472 472 - mutex_lock_nested(&xadir->d_inode->i_mutex, I_MUTEX_XATTR); 472 472 + mutex_lock_nested(&d_inode(xadir)->i_mutex, I_MUTEX_XATTR); 473 473 dentry = lookup_one_len(name, xadir, strlen(name)); 474 474 if (IS_ERR(dentry)) { 475 475 err = PTR_ERR(dentry); 476 476 goto out_dput; 477 477 } 478 478 479 479 - if (dentry->d_inode) { 480 480 - err = xattr_unlink(xadir->d_inode, dentry); 479 479 + if (d_really_is_positive(dentry)) { 480 480 + err = xattr_unlink(d_inode(xadir), dentry); 481 481 update_ctime(inode); 482 482 } 483 483 484 484 dput(dentry); 485 485 out_dput: 486 486 - mutex_unlock(&xadir->d_inode->i_mutex); 486 486 + mutex_unlock(&d_inode(xadir)->i_mutex); 487 487 dput(xadir); 488 488 return err; 489 489 } ··· 533 533 else 534 534 chunk = buffer_size - buffer_pos; 535 535 536 536 - page = reiserfs_get_page(dentry->d_inode, file_pos); 536 536 + page = reiserfs_get_page(d_inode(dentry), file_pos); 537 537 if (IS_ERR(page)) { 538 538 err = PTR_ERR(page); 539 539 goto out_unlock; ··· 573 573 } 574 574 575 575 new_size = buffer_size + sizeof(struct reiserfs_xattr_header); 576 576 - if (!err && new_size < i_size_read(dentry->d_inode)) { 576 576 + if (!err && new_size < i_size_read(d_inode(dentry))) { 577 577 struct iattr newattrs = { 578 578 .ia_ctime = current_fs_time(inode->i_sb), 579 579 .ia_size = new_size, 580 580 .ia_valid = ATTR_SIZE | ATTR_CTIME, 581 581 }; 582 582 583 583 - mutex_lock_nested(&dentry->d_inode->i_mutex, I_MUTEX_XATTR); 584 584 - inode_dio_wait(dentry->d_inode); 583 583 + mutex_lock_nested(&d_inode(dentry)->i_mutex, I_MUTEX_XATTR); 584 584 + inode_dio_wait(d_inode(dentry)); 585 585 586 586 err = reiserfs_setattr(dentry, &newattrs); 587 587 - mutex_unlock(&dentry->d_inode->i_mutex); 587 587 + mutex_unlock(&d_inode(dentry)->i_mutex); 588 588 } else 589 589 update_ctime(inode); 590 590 out_unlock: ··· 657 657 658 658 down_read(&REISERFS_I(inode)->i_xattr_sem); 659 659 660 660 - isize = i_size_read(dentry->d_inode); 660 660 + isize = i_size_read(d_inode(dentry)); 661 661 662 662 /* Just return the size needed */ 663 663 if (buffer == NULL) { ··· 680 680 else 681 681 chunk = isize - file_pos; 682 682 683 683 - page = reiserfs_get_page(dentry->d_inode, file_pos); 683 683 + page = reiserfs_get_page(d_inode(dentry), file_pos); 684 684 if (IS_ERR(page)) { 685 685 err = PTR_ERR(page); 686 686 goto out_unlock; ··· 775 775 776 776 handler = find_xattr_handler_prefix(dentry->d_sb->s_xattr, name); 777 777 778 778 - if (!handler || get_inode_sd_version(dentry->d_inode) == STAT_DATA_V1) 778 778 + if (!handler || get_inode_sd_version(d_inode(dentry)) == STAT_DATA_V1) 779 779 return -EOPNOTSUPP; 780 780 781 781 return handler->get(dentry, name, buffer, size, handler->flags); ··· 784 784 /* 785 785 * Inode operation setxattr() 786 786 * 787 787 - * dentry->d_inode->i_mutex down 787 787 + * d_inode(dentry)->i_mutex down 788 788 */ 789 789 int 790 790 reiserfs_setxattr(struct dentry *dentry, const char *name, const void *value, ··· 794 794 795 795 handler = find_xattr_handler_prefix(dentry->d_sb->s_xattr, name); 796 796 797 797 - if (!handler || get_inode_sd_version(dentry->d_inode) == STAT_DATA_V1) 797 797 + if (!handler || get_inode_sd_version(d_inode(dentry)) == STAT_DATA_V1) 798 798 return -EOPNOTSUPP; 799 799 800 800 return handler->set(dentry, name, value, size, flags, handler->flags); ··· 803 803 /* 804 804 * Inode operation removexattr() 805 805 * 806 806 - * dentry->d_inode->i_mutex down 806 806 + * d_inode(dentry)->i_mutex down 807 807 */ 808 808 int reiserfs_removexattr(struct dentry *dentry, const char *name) 809 809 { ··· 811 811 812 812 handler = find_xattr_handler_prefix(dentry->d_sb->s_xattr, name); 813 813 814 814 - if (!handler || get_inode_sd_version(dentry->d_inode) == STAT_DATA_V1) 814 814 + if (!handler || get_inode_sd_version(d_inode(dentry)) == STAT_DATA_V1) 815 815 return -EOPNOTSUPP; 816 816 817 817 return handler->set(dentry, name, NULL, 0, XATTR_REPLACE, handler->flags); ··· 875 875 .size = buffer ? size : 0, 876 876 }; 877 877 878 878 - if (!dentry->d_inode) 878 878 + if (d_really_is_negative(dentry)) 879 879 return -EINVAL; 880 880 881 881 if (!dentry->d_sb->s_xattr || 882 882 - get_inode_sd_version(dentry->d_inode) == STAT_DATA_V1) 882 882 + get_inode_sd_version(d_inode(dentry)) == STAT_DATA_V1) 883 883 return -EOPNOTSUPP; 884 884 885 885 - dir = open_xa_dir(dentry->d_inode, XATTR_REPLACE); 885 885 + dir = open_xa_dir(d_inode(dentry), XATTR_REPLACE); 886 886 if (IS_ERR(dir)) { 887 887 err = PTR_ERR(dir); 888 888 if (err == -ENODATA) ··· 890 890 goto out; 891 891 } 892 892 893 893 - mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_XATTR); 894 894 - err = reiserfs_readdir_inode(dir->d_inode, &buf.ctx); 895 895 - mutex_unlock(&dir->d_inode->i_mutex); 893 893 + mutex_lock_nested(&d_inode(dir)->i_mutex, I_MUTEX_XATTR); 894 894 + err = reiserfs_readdir_inode(d_inode(dir), &buf.ctx); 895 895 + mutex_unlock(&d_inode(dir)->i_mutex); 896 896 897 897 if (!err) 898 898 err = buf.pos; ··· 905 905 static int create_privroot(struct dentry *dentry) 906 906 { 907 907 int err; 908 908 - struct inode *inode = dentry->d_parent->d_inode; 908 908 + struct inode *inode = d_inode(dentry->d_parent); 909 909 910 910 WARN_ON_ONCE(!mutex_is_locked(&inode->i_mutex)); 911 911 912 912 err = xattr_mkdir(inode, dentry, 0700); 913 913 - if (err || !dentry->d_inode) { 913 913 + if (err || d_really_is_negative(dentry)) { 914 914 reiserfs_warning(dentry->d_sb, "jdm-20006", 915 915 "xattrs/ACLs enabled and couldn't " 916 916 "find/create .reiserfs_priv. " ··· 918 918 return -EOPNOTSUPP; 919 919 } 920 920 921 921 - dentry->d_inode->i_flags |= S_PRIVATE; 921 921 + d_inode(dentry)->i_flags |= S_PRIVATE; 922 922 reiserfs_info(dentry->d_sb, "Created %s - reserved for xattr " 923 923 "storage.\n", PRIVROOT_NAME); 924 924 ··· 997 997 int err = 0; 998 998 999 999 /* If we don't have the privroot located yet - go find it */ 1000 1000 - mutex_lock(&s->s_root->d_inode->i_mutex); 1000 1000 + mutex_lock(&d_inode(s->s_root)->i_mutex); 1001 1001 dentry = lookup_one_len(PRIVROOT_NAME, s->s_root, 1002 1002 strlen(PRIVROOT_NAME)); 1003 1003 if (!IS_ERR(dentry)) { 1004 1004 REISERFS_SB(s)->priv_root = dentry; 1005 1005 d_set_d_op(dentry, &xattr_lookup_poison_ops); 1006 1006 - if (dentry->d_inode) 1007 1007 - dentry->d_inode->i_flags |= S_PRIVATE; 1006 1006 + if (d_really_is_positive(dentry)) 1007 1007 + d_inode(dentry)->i_flags |= S_PRIVATE; 1008 1008 } else 1009 1009 err = PTR_ERR(dentry); 1010 1010 - mutex_unlock(&s->s_root->d_inode->i_mutex); 1010 1010 + mutex_unlock(&d_inode(s->s_root)->i_mutex); 1011 1011 1012 1012 return err; 1013 1013 } ··· 1026 1026 if (err) 1027 1027 goto error; 1028 1028 1029 1029 - if (!privroot->d_inode && !(mount_flags & MS_RDONLY)) { 1030 1030 - mutex_lock(&s->s_root->d_inode->i_mutex); 1029 1029 + if (d_really_is_negative(privroot) && !(mount_flags & MS_RDONLY)) { 1030 1030 + mutex_lock(&d_inode(s->s_root)->i_mutex); 1031 1031 err = create_privroot(REISERFS_SB(s)->priv_root); 1032 1032 - mutex_unlock(&s->s_root->d_inode->i_mutex); 1032 1032 + mutex_unlock(&d_inode(s->s_root)->i_mutex); 1033 1033 } 1034 1034 1035 1035 - if (privroot->d_inode) { 1035 1035 + if (d_really_is_positive(privroot)) { 1036 1036 s->s_xattr = reiserfs_xattr_handlers; 1037 1037 - mutex_lock(&privroot->d_inode->i_mutex); 1037 1037 + mutex_lock(&d_inode(privroot)->i_mutex); 1038 1038 if (!REISERFS_SB(s)->xattr_root) { 1039 1039 struct dentry *dentry; 1040 1040 ··· 1045 1045 else 1046 1046 err = PTR_ERR(dentry); 1047 1047 } 1048 1048 - mutex_unlock(&privroot->d_inode->i_mutex); 1048 1048 + mutex_unlock(&d_inode(privroot)->i_mutex); 1049 1049 } 1050 1050 1051 1051 error:

+1 -1

fs/reiserfs/xattr.h

reviewed

··· 78 78 79 79 if ((REISERFS_I(inode)->i_flags & i_has_xattr_dir) == 0) { 80 80 nblocks += JOURNAL_BLOCKS_PER_OBJECT(inode->i_sb); 81 81 - if (!REISERFS_SB(inode->i_sb)->xattr_root->d_inode) 81 81 + if (d_really_is_negative(REISERFS_SB(inode->i_sb)->xattr_root)) 82 82 nblocks += JOURNAL_BLOCKS_PER_OBJECT(inode->i_sb); 83 83 } 84 84

+5 -5

fs/reiserfs/xattr_security.c

reviewed

··· 15 15 if (strlen(name) < sizeof(XATTR_SECURITY_PREFIX)) 16 16 return -EINVAL; 17 17 18 18 - if (IS_PRIVATE(dentry->d_inode)) 18 18 + if (IS_PRIVATE(d_inode(dentry))) 19 19 return -EPERM; 20 20 21 21 - return reiserfs_xattr_get(dentry->d_inode, name, buffer, size); 21 21 + return reiserfs_xattr_get(d_inode(dentry), name, buffer, size); 22 22 } 23 23 24 24 static int ··· 28 28 if (strlen(name) < sizeof(XATTR_SECURITY_PREFIX)) 29 29 return -EINVAL; 30 30 31 31 - if (IS_PRIVATE(dentry->d_inode)) 31 31 + if (IS_PRIVATE(d_inode(dentry))) 32 32 return -EPERM; 33 33 34 34 - return reiserfs_xattr_set(dentry->d_inode, name, buffer, size, flags); 34 34 + return reiserfs_xattr_set(d_inode(dentry), name, buffer, size, flags); 35 35 } 36 36 37 37 static size_t security_list(struct dentry *dentry, char *list, size_t list_len, ··· 39 39 { 40 40 const size_t len = namelen + 1; 41 41 42 42 - if (IS_PRIVATE(dentry->d_inode)) 42 42 + if (IS_PRIVATE(d_inode(dentry))) 43 43 return 0; 44 44 45 45 if (list && len <= list_len) {

+5 -5

fs/reiserfs/xattr_trusted.c

reviewed

··· 14 14 if (strlen(name) < sizeof(XATTR_TRUSTED_PREFIX)) 15 15 return -EINVAL; 16 16 17 17 - if (!capable(CAP_SYS_ADMIN) || IS_PRIVATE(dentry->d_inode)) 17 17 + if (!capable(CAP_SYS_ADMIN) || IS_PRIVATE(d_inode(dentry))) 18 18 return -EPERM; 19 19 20 20 - return reiserfs_xattr_get(dentry->d_inode, name, buffer, size); 20 20 + return reiserfs_xattr_get(d_inode(dentry), name, buffer, size); 21 21 } 22 22 23 23 static int ··· 27 27 if (strlen(name) < sizeof(XATTR_TRUSTED_PREFIX)) 28 28 return -EINVAL; 29 29 30 30 - if (!capable(CAP_SYS_ADMIN) || IS_PRIVATE(dentry->d_inode)) 30 30 + if (!capable(CAP_SYS_ADMIN) || IS_PRIVATE(d_inode(dentry))) 31 31 return -EPERM; 32 32 33 33 - return reiserfs_xattr_set(dentry->d_inode, name, buffer, size, flags); 33 33 + return reiserfs_xattr_set(d_inode(dentry), name, buffer, size, flags); 34 34 } 35 35 36 36 static size_t trusted_list(struct dentry *dentry, char *list, size_t list_size, ··· 38 38 { 39 39 const size_t len = name_len + 1; 40 40 41 41 - if (!capable(CAP_SYS_ADMIN) || IS_PRIVATE(dentry->d_inode)) 41 41 + if (!capable(CAP_SYS_ADMIN) || IS_PRIVATE(d_inode(dentry))) 42 42 return 0; 43 43 44 44 if (list && len <= list_size) {

+2 -2

fs/reiserfs/xattr_user.c

reviewed

··· 15 15 return -EINVAL; 16 16 if (!reiserfs_xattrs_user(dentry->d_sb)) 17 17 return -EOPNOTSUPP; 18 18 - return reiserfs_xattr_get(dentry->d_inode, name, buffer, size); 18 18 + return reiserfs_xattr_get(d_inode(dentry), name, buffer, size); 19 19 } 20 20 21 21 static int ··· 27 27 28 28 if (!reiserfs_xattrs_user(dentry->d_sb)) 29 29 return -EOPNOTSUPP; 30 30 - return reiserfs_xattr_set(dentry->d_inode, name, buffer, size, flags); 30 30 + return reiserfs_xattr_set(d_inode(dentry), name, buffer, size, flags); 31 31 } 32 32 33 33 static size_t user_list(struct dentry *dentry, char *list, size_t list_size,

+1 -1

fs/squashfs/export.c

reviewed

··· 110 110 111 111 static struct dentry *squashfs_get_parent(struct dentry *child) 112 112 { 113 113 - struct inode *inode = child->d_inode; 113 113 + struct inode *inode = d_inode(child); 114 114 unsigned int parent_ino = squashfs_i(inode)->parent; 115 115 116 116 return squashfs_export_iget(inode->i_sb, parent_ino);

+4 -4

fs/squashfs/xattr.c

reviewed

··· 39 39 ssize_t squashfs_listxattr(struct dentry *d, char *buffer, 40 40 size_t buffer_size) 41 41 { 42 42 - struct inode *inode = d->d_inode; 42 42 + struct inode *inode = d_inode(d); 43 43 struct super_block *sb = inode->i_sb; 44 44 struct squashfs_sb_info *msblk = sb->s_fs_info; 45 45 u64 start = SQUASHFS_XATTR_BLK(squashfs_i(inode)->xattr) ··· 229 229 if (name[0] == '\0') 230 230 return -EINVAL; 231 231 232 232 - return squashfs_xattr_get(d->d_inode, SQUASHFS_XATTR_USER, name, 232 232 + return squashfs_xattr_get(d_inode(d), SQUASHFS_XATTR_USER, name, 233 233 buffer, size); 234 234 } 235 235 ··· 259 259 if (name[0] == '\0') 260 260 return -EINVAL; 261 261 262 262 - return squashfs_xattr_get(d->d_inode, SQUASHFS_XATTR_TRUSTED, name, 262 262 + return squashfs_xattr_get(d_inode(d), SQUASHFS_XATTR_TRUSTED, name, 263 263 buffer, size); 264 264 } 265 265 ··· 286 286 if (name[0] == '\0') 287 287 return -EINVAL; 288 288 289 289 - return squashfs_xattr_get(d->d_inode, SQUASHFS_XATTR_SECURITY, name, 289 289 + return squashfs_xattr_get(d_inode(d), SQUASHFS_XATTR_SECURITY, name, 290 290 buffer, size); 291 291 } 292 292

+2 -2

fs/stat.c

reviewed

··· 51 51 */ 52 52 int vfs_getattr_nosec(struct path *path, struct kstat *stat) 53 53 { 54 54 - struct inode *inode = path->dentry->d_inode; 54 54 + struct inode *inode = d_backing_inode(path->dentry); 55 55 56 56 if (inode->i_op->getattr) 57 57 return inode->i_op->getattr(path->mnt, path->dentry, stat); ··· 326 326 retry: 327 327 error = user_path_at_empty(dfd, pathname, lookup_flags, &path, &empty); 328 328 if (!error) { 329 329 - struct inode *inode = path.dentry->d_inode; 329 329 + struct inode *inode = d_backing_inode(path.dentry); 330 330 331 331 error = empty ? -ENOENT : -EINVAL; 332 332 if (inode->i_op->readlink) {

+2 -2

fs/sysv/dir.c

reviewed

··· 132 132 { 133 133 const char * name = dentry->d_name.name; 134 134 int namelen = dentry->d_name.len; 135 135 - struct inode * dir = dentry->d_parent->d_inode; 135 135 + struct inode * dir = d_inode(dentry->d_parent); 136 136 unsigned long start, n; 137 137 unsigned long npages = dir_pages(dir); 138 138 struct page *page = NULL; ··· 176 176 177 177 int sysv_add_link(struct dentry *dentry, struct inode *inode) 178 178 { 179 179 - struct inode *dir = dentry->d_parent->d_inode; 179 179 + struct inode *dir = d_inode(dentry->d_parent); 180 180 const char * name = dentry->d_name.name; 181 181 int namelen = dentry->d_name.len; 182 182 struct page *page = NULL;

+1 -1

fs/sysv/file.c

reviewed

··· 30 30 31 31 static int sysv_setattr(struct dentry *dentry, struct iattr *attr) 32 32 { 33 33 - struct inode *inode = dentry->d_inode; 33 33 + struct inode *inode = d_inode(dentry); 34 34 int error; 35 35 36 36 error = inode_change_ok(inode, attr);

+1 -1

fs/sysv/itree.c

reviewed

··· 443 443 int sysv_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat) 444 444 { 445 445 struct super_block *s = dentry->d_sb; 446 446 - generic_fillattr(dentry->d_inode, stat); 446 446 + generic_fillattr(d_inode(dentry), stat); 447 447 stat->blocks = (s->s_blocksize / 512) * sysv_nblocks(s, stat->size); 448 448 stat->blksize = s->s_blocksize; 449 449 return 0;

+5 -5

fs/sysv/namei.c

reviewed

··· 118 118 static int sysv_link(struct dentry * old_dentry, struct inode * dir, 119 119 struct dentry * dentry) 120 120 { 121 121 - struct inode *inode = old_dentry->d_inode; 121 121 + struct inode *inode = d_inode(old_dentry); 122 122 123 123 inode->i_ctime = CURRENT_TIME_SEC; 124 124 inode_inc_link_count(inode); ··· 166 166 167 167 static int sysv_unlink(struct inode * dir, struct dentry * dentry) 168 168 { 169 169 - struct inode * inode = dentry->d_inode; 169 169 + struct inode * inode = d_inode(dentry); 170 170 struct page * page; 171 171 struct sysv_dir_entry * de; 172 172 int err = -ENOENT; ··· 187 187 188 188 static int sysv_rmdir(struct inode * dir, struct dentry * dentry) 189 189 { 190 190 - struct inode *inode = dentry->d_inode; 190 190 + struct inode *inode = d_inode(dentry); 191 191 int err = -ENOTEMPTY; 192 192 193 193 if (sysv_empty_dir(inode)) { ··· 208 208 static int sysv_rename(struct inode * old_dir, struct dentry * old_dentry, 209 209 struct inode * new_dir, struct dentry * new_dentry) 210 210 { 211 211 - struct inode * old_inode = old_dentry->d_inode; 212 212 - struct inode * new_inode = new_dentry->d_inode; 211 211 + struct inode * old_inode = d_inode(old_dentry); 212 212 + struct inode * new_inode = d_inode(new_dentry); 213 213 struct page * dir_page = NULL; 214 214 struct sysv_dir_entry * dir_de = NULL; 215 215 struct page * old_page;

+1 -1

fs/sysv/symlink.c

reviewed

··· 10 10 11 11 static void *sysv_follow_link(struct dentry *dentry, struct nameidata *nd) 12 12 { 13 13 - nd_set_link(nd, (char *)SYSV_I(dentry->d_inode)->i_data); 13 13 + nd_set_link(nd, (char *)SYSV_I(d_inode(dentry))->i_data); 14 14 return NULL; 15 15 } 16 16

+7 -7

fs/ubifs/dir.c

reviewed

··· 499 499 struct dentry *dentry) 500 500 { 501 501 struct ubifs_info *c = dir->i_sb->s_fs_info; 502 502 - struct inode *inode = old_dentry->d_inode; 502 502 + struct inode *inode = d_inode(old_dentry); 503 503 struct ubifs_inode *ui = ubifs_inode(inode); 504 504 struct ubifs_inode *dir_ui = ubifs_inode(dir); 505 505 int err, sz_change = CALC_DENT_SIZE(dentry->d_name.len); ··· 554 554 static int ubifs_unlink(struct inode *dir, struct dentry *dentry) 555 555 { 556 556 struct ubifs_info *c = dir->i_sb->s_fs_info; 557 557 - struct inode *inode = dentry->d_inode; 557 557 + struct inode *inode = d_inode(dentry); 558 558 struct ubifs_inode *dir_ui = ubifs_inode(dir); 559 559 int sz_change = CALC_DENT_SIZE(dentry->d_name.len); 560 560 int err, budgeted = 1; ··· 646 646 static int ubifs_rmdir(struct inode *dir, struct dentry *dentry) 647 647 { 648 648 struct ubifs_info *c = dir->i_sb->s_fs_info; 649 649 - struct inode *inode = dentry->d_inode; 649 649 + struct inode *inode = d_inode(dentry); 650 650 int sz_change = CALC_DENT_SIZE(dentry->d_name.len); 651 651 int err, budgeted = 1; 652 652 struct ubifs_inode *dir_ui = ubifs_inode(dir); ··· 662 662 inode->i_ino, dir->i_ino); 663 663 ubifs_assert(mutex_is_locked(&dir->i_mutex)); 664 664 ubifs_assert(mutex_is_locked(&inode->i_mutex)); 665 665 - err = check_dir_empty(c, dentry->d_inode); 665 665 + err = check_dir_empty(c, d_inode(dentry)); 666 666 if (err) 667 667 return err; 668 668 ··· 970 970 struct inode *new_dir, struct dentry *new_dentry) 971 971 { 972 972 struct ubifs_info *c = old_dir->i_sb->s_fs_info; 973 973 - struct inode *old_inode = old_dentry->d_inode; 974 974 - struct inode *new_inode = new_dentry->d_inode; 973 973 + struct inode *old_inode = d_inode(old_dentry); 974 974 + struct inode *new_inode = d_inode(new_dentry); 975 975 struct ubifs_inode *old_inode_ui = ubifs_inode(old_inode); 976 976 int err, release, sync = 0, move = (new_dir != old_dir); 977 977 int is_dir = S_ISDIR(old_inode->i_mode); ··· 1136 1136 struct kstat *stat) 1137 1137 { 1138 1138 loff_t size; 1139 1139 - struct inode *inode = dentry->d_inode; 1139 1139 + struct inode *inode = d_inode(dentry); 1140 1140 struct ubifs_inode *ui = ubifs_inode(inode); 1141 1141 1142 1142 mutex_lock(&ui->ui_mutex);

+2 -2

fs/ubifs/file.c

reviewed

··· 1257 1257 int ubifs_setattr(struct dentry *dentry, struct iattr *attr) 1258 1258 { 1259 1259 int err; 1260 1260 - struct inode *inode = dentry->d_inode; 1260 1260 + struct inode *inode = d_inode(dentry); 1261 1261 struct ubifs_info *c = inode->i_sb->s_fs_info; 1262 1262 1263 1263 dbg_gen("ino %lu, mode %#x, ia_valid %#x", ··· 1302 1302 1303 1303 static void *ubifs_follow_link(struct dentry *dentry, struct nameidata *nd) 1304 1304 { 1305 1305 - struct ubifs_inode *ui = ubifs_inode(dentry->d_inode); 1305 1305 + struct ubifs_inode *ui = ubifs_inode(d_inode(dentry)); 1306 1306 1307 1307 nd_set_link(nd, ui->data); 1308 1308 return NULL;

+2 -2

fs/ubifs/journal.c

reviewed

··· 930 930 union ubifs_key key; 931 931 struct ubifs_dent_node *dent, *dent2; 932 932 int err, dlen1, dlen2, ilen, lnum, offs, len; 933 933 - const struct inode *old_inode = old_dentry->d_inode; 934 934 - const struct inode *new_inode = new_dentry->d_inode; 933 933 + const struct inode *old_inode = d_inode(old_dentry); 934 934 + const struct inode *new_inode = d_inode(new_dentry); 935 935 int aligned_dlen1, aligned_dlen2, plen = UBIFS_INO_NODE_SZ; 936 936 int last_reference = !!(new_inode && new_inode->i_nlink == 0); 937 937 int move = (old_dir != new_dir);

+5 -5

fs/ubifs/xattr.c

reviewed

··· 364 364 const void *value, size_t size, int flags) 365 365 { 366 366 dbg_gen("xattr '%s', host ino %lu ('%pd'), size %zd", 367 367 - name, dentry->d_inode->i_ino, dentry, size); 367 367 + name, d_inode(dentry)->i_ino, dentry, size); 368 368 369 369 - return setxattr(dentry->d_inode, name, value, size, flags); 369 369 + return setxattr(d_inode(dentry), name, value, size, flags); 370 370 } 371 371 372 372 ssize_t ubifs_getxattr(struct dentry *dentry, const char *name, void *buf, 373 373 size_t size) 374 374 { 375 375 - struct inode *inode, *host = dentry->d_inode; 375 375 + struct inode *inode, *host = d_inode(dentry); 376 376 struct ubifs_info *c = host->i_sb->s_fs_info; 377 377 struct qstr nm = QSTR_INIT(name, strlen(name)); 378 378 struct ubifs_inode *ui; ··· 432 432 ssize_t ubifs_listxattr(struct dentry *dentry, char *buffer, size_t size) 433 433 { 434 434 union ubifs_key key; 435 435 - struct inode *host = dentry->d_inode; 435 435 + struct inode *host = d_inode(dentry); 436 436 struct ubifs_info *c = host->i_sb->s_fs_info; 437 437 struct ubifs_inode *host_ui = ubifs_inode(host); 438 438 struct ubifs_dent_node *xent, *pxent = NULL; ··· 535 535 536 536 int ubifs_removexattr(struct dentry *dentry, const char *name) 537 537 { 538 538 - struct inode *inode, *host = dentry->d_inode; 538 538 + struct inode *inode, *host = d_inode(dentry); 539 539 struct ubifs_info *c = host->i_sb->s_fs_info; 540 540 struct qstr nm = QSTR_INIT(name, strlen(name)); 541 541 struct ubifs_dent_node *xent;

+1 -1

fs/udf/file.c

reviewed

··· 249 249 250 250 static int udf_setattr(struct dentry *dentry, struct iattr *attr) 251 251 { 252 252 - struct inode *inode = dentry->d_inode; 252 252 + struct inode *inode = d_inode(dentry); 253 253 int error; 254 254 255 255 error = inode_change_ok(inode, attr);

+8 -8

fs/udf/namei.c

reviewed

··· 551 551 static int udf_add_nondir(struct dentry *dentry, struct inode *inode) 552 552 { 553 553 struct udf_inode_info *iinfo = UDF_I(inode); 554 554 - struct inode *dir = dentry->d_parent->d_inode; 554 554 + struct inode *dir = d_inode(dentry->d_parent); 555 555 struct udf_fileident_bh fibh; 556 556 struct fileIdentDesc cfi, *fi; 557 557 int err; ··· 767 767 static int udf_rmdir(struct inode *dir, struct dentry *dentry) 768 768 { 769 769 int retval; 770 770 - struct inode *inode = dentry->d_inode; 770 770 + struct inode *inode = d_inode(dentry); 771 771 struct udf_fileident_bh fibh; 772 772 struct fileIdentDesc *fi, cfi; 773 773 struct kernel_lb_addr tloc; ··· 809 809 static int udf_unlink(struct inode *dir, struct dentry *dentry) 810 810 { 811 811 int retval; 812 812 - struct inode *inode = dentry->d_inode; 812 812 + struct inode *inode = d_inode(dentry); 813 813 struct udf_fileident_bh fibh; 814 814 struct fileIdentDesc *fi; 815 815 struct fileIdentDesc cfi; ··· 999 999 static int udf_link(struct dentry *old_dentry, struct inode *dir, 1000 1000 struct dentry *dentry) 1001 1001 { 1002 1002 - struct inode *inode = old_dentry->d_inode; 1002 1002 + struct inode *inode = d_inode(old_dentry); 1003 1003 struct udf_fileident_bh fibh; 1004 1004 struct fileIdentDesc cfi, *fi; 1005 1005 int err; ··· 1038 1038 static int udf_rename(struct inode *old_dir, struct dentry *old_dentry, 1039 1039 struct inode *new_dir, struct dentry *new_dentry) 1040 1040 { 1041 1041 - struct inode *old_inode = old_dentry->d_inode; 1042 1042 - struct inode *new_inode = new_dentry->d_inode; 1041 1041 + struct inode *old_inode = d_inode(old_dentry); 1042 1042 + struct inode *new_inode = d_inode(new_dentry); 1043 1043 struct udf_fileident_bh ofibh, nfibh; 1044 1044 struct fileIdentDesc *ofi = NULL, *nfi = NULL, *dir_fi = NULL; 1045 1045 struct fileIdentDesc ocfi, ncfi; ··· 1179 1179 struct fileIdentDesc cfi; 1180 1180 struct udf_fileident_bh fibh; 1181 1181 1182 1182 - if (!udf_find_entry(child->d_inode, &dotdot, &fibh, &cfi)) 1182 1182 + if (!udf_find_entry(d_inode(child), &dotdot, &fibh, &cfi)) 1183 1183 return ERR_PTR(-EACCES); 1184 1184 1185 1185 if (fibh.sbh != fibh.ebh) ··· 1187 1187 brelse(fibh.sbh); 1188 1188 1189 1189 tloc = lelb_to_cpu(cfi.icb.extLocation); 1190 1190 - inode = udf_iget(child->d_inode->i_sb, &tloc); 1190 1190 + inode = udf_iget(d_inode(child)->i_sb, &tloc); 1191 1191 if (IS_ERR(inode)) 1192 1192 return ERR_CAST(inode); 1193 1193

+1 -1

fs/ufs/dir.c

reviewed

··· 311 311 */ 312 312 int ufs_add_link(struct dentry *dentry, struct inode *inode) 313 313 { 314 314 - struct inode *dir = dentry->d_parent->d_inode; 314 314 + struct inode *dir = d_inode(dentry->d_parent); 315 315 const unsigned char *name = dentry->d_name.name; 316 316 int namelen = dentry->d_name.len; 317 317 struct super_block *sb = dir->i_sb;

+5 -5

fs/ufs/namei.c

reviewed

··· 165 165 static int ufs_link (struct dentry * old_dentry, struct inode * dir, 166 166 struct dentry *dentry) 167 167 { 168 168 - struct inode *inode = old_dentry->d_inode; 168 168 + struct inode *inode = d_inode(old_dentry); 169 169 int error; 170 170 171 171 lock_ufs(dir->i_sb); ··· 222 222 223 223 static int ufs_unlink(struct inode *dir, struct dentry *dentry) 224 224 { 225 225 - struct inode * inode = dentry->d_inode; 225 225 + struct inode * inode = d_inode(dentry); 226 226 struct ufs_dir_entry *de; 227 227 struct page *page; 228 228 int err = -ENOENT; ··· 244 244 245 245 static int ufs_rmdir (struct inode * dir, struct dentry *dentry) 246 246 { 247 247 - struct inode * inode = dentry->d_inode; 247 247 + struct inode * inode = d_inode(dentry); 248 248 int err= -ENOTEMPTY; 249 249 250 250 lock_ufs(dir->i_sb); ··· 263 263 static int ufs_rename(struct inode *old_dir, struct dentry *old_dentry, 264 264 struct inode *new_dir, struct dentry *new_dentry) 265 265 { 266 266 - struct inode *old_inode = old_dentry->d_inode; 267 267 - struct inode *new_inode = new_dentry->d_inode; 266 266 + struct inode *old_inode = d_inode(old_dentry); 267 267 + struct inode *new_inode = d_inode(new_dentry); 268 268 struct page *dir_page = NULL; 269 269 struct ufs_dir_entry * dir_de = NULL; 270 270 struct page *old_page;

+2 -2

fs/ufs/super.c

reviewed

··· 144 144 struct qstr dot_dot = QSTR_INIT("..", 2); 145 145 ino_t ino; 146 146 147 147 - ino = ufs_inode_by_name(child->d_inode, &dot_dot); 147 147 + ino = ufs_inode_by_name(d_inode(child), &dot_dot); 148 148 if (!ino) 149 149 return ERR_PTR(-ENOENT); 150 150 - return d_obtain_alias(ufs_iget(child->d_inode->i_sb, ino)); 150 150 + return d_obtain_alias(ufs_iget(d_inode(child)->i_sb, ino)); 151 151 } 152 152 153 153 static const struct export_operations ufs_export_ops = {

+1 -1

fs/ufs/symlink.c

reviewed

··· 34 34 35 35 static void *ufs_follow_link(struct dentry *dentry, struct nameidata *nd) 36 36 { 37 37 - struct ufs_inode_info *p = UFS_I(dentry->d_inode); 37 37 + struct ufs_inode_info *p = UFS_I(d_inode(dentry)); 38 38 nd_set_link(nd, (char*)p->i_u1.i_symlink); 39 39 return NULL; 40 40 }

+1 -1

fs/ufs/truncate.c

reviewed

··· 492 492 493 493 int ufs_setattr(struct dentry *dentry, struct iattr *attr) 494 494 { 495 495 - struct inode *inode = dentry->d_inode; 495 495 + struct inode *inode = d_inode(dentry); 496 496 unsigned int ia_valid = attr->ia_valid; 497 497 int error; 498 498

+1 -1

fs/xfs/xfs_export.c

reviewed

··· 215 215 int error; 216 216 struct xfs_inode *cip; 217 217 218 218 - error = xfs_lookup(XFS_I(child->d_inode), &xfs_name_dotdot, &cip, NULL); 218 218 + error = xfs_lookup(XFS_I(d_inode(child)), &xfs_name_dotdot, &cip, NULL); 219 219 if (unlikely(error)) 220 220 return ERR_PTR(error); 221 221

+1 -1

fs/xfs/xfs_filestream.c

reviewed

··· 294 294 if (!parent) 295 295 goto out_dput; 296 296 297 297 - dir = igrab(parent->d_inode); 297 297 + dir = igrab(d_inode(parent)); 298 298 dput(parent); 299 299 300 300 out_dput:

+9 -9

fs/xfs/xfs_ioctl.c

reviewed

··· 82 82 error = user_lpath((const char __user *)hreq->path, &path); 83 83 if (error) 84 84 return error; 85 85 - inode = path.dentry->d_inode; 85 85 + inode = d_inode(path.dentry); 86 86 } 87 87 ip = XFS_I(inode); 88 88 ··· 210 210 dentry = xfs_handlereq_to_dentry(parfilp, hreq); 211 211 if (IS_ERR(dentry)) 212 212 return PTR_ERR(dentry); 213 213 - inode = dentry->d_inode; 213 213 + inode = d_inode(dentry); 214 214 215 215 /* Restrict xfs_open_by_handle to directories & regular files. */ 216 216 if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode))) { ··· 303 303 goto out_dput; 304 304 } 305 305 306 306 - error = xfs_readlink(XFS_I(dentry->d_inode), link); 306 306 + error = xfs_readlink(XFS_I(d_inode(dentry)), link); 307 307 if (error) 308 308 goto out_kfree; 309 309 error = readlink_copy(hreq->ohandle, olen, link); ··· 376 376 return PTR_ERR(dentry); 377 377 } 378 378 379 379 - if (IS_IMMUTABLE(dentry->d_inode) || IS_APPEND(dentry->d_inode)) { 379 379 + if (IS_IMMUTABLE(d_inode(dentry)) || IS_APPEND(d_inode(dentry))) { 380 380 error = -EPERM; 381 381 goto out; 382 382 } ··· 386 386 goto out; 387 387 } 388 388 389 389 - error = xfs_set_dmattrs(XFS_I(dentry->d_inode), fsd.fsd_dmevmask, 389 389 + error = xfs_set_dmattrs(XFS_I(d_inode(dentry)), fsd.fsd_dmevmask, 390 390 fsd.fsd_dmstate); 391 391 392 392 out: ··· 429 429 goto out_dput; 430 430 431 431 cursor = (attrlist_cursor_kern_t *)&al_hreq.pos; 432 432 - error = xfs_attr_list(XFS_I(dentry->d_inode), kbuf, al_hreq.buflen, 432 432 + error = xfs_attr_list(XFS_I(d_inode(dentry)), kbuf, al_hreq.buflen, 433 433 al_hreq.flags, cursor); 434 434 if (error) 435 435 goto out_kfree; ··· 559 559 switch (ops[i].am_opcode) { 560 560 case ATTR_OP_GET: 561 561 ops[i].am_error = xfs_attrmulti_attr_get( 562 562 - dentry->d_inode, attr_name, 562 562 + d_inode(dentry), attr_name, 563 563 ops[i].am_attrvalue, &ops[i].am_length, 564 564 ops[i].am_flags); 565 565 break; ··· 568 568 if (ops[i].am_error) 569 569 break; 570 570 ops[i].am_error = xfs_attrmulti_attr_set( 571 571 - dentry->d_inode, attr_name, 571 571 + d_inode(dentry), attr_name, 572 572 ops[i].am_attrvalue, ops[i].am_length, 573 573 ops[i].am_flags); 574 574 mnt_drop_write_file(parfilp); ··· 578 578 if (ops[i].am_error) 579 579 break; 580 580 ops[i].am_error = xfs_attrmulti_attr_remove( 581 581 - dentry->d_inode, attr_name, 581 581 + d_inode(dentry), attr_name, 582 582 ops[i].am_flags); 583 583 mnt_drop_write_file(parfilp); 584 584 break;

+6 -6

fs/xfs/xfs_ioctl32.c

reviewed

··· 375 375 goto out_dput; 376 376 377 377 cursor = (attrlist_cursor_kern_t *)&al_hreq.pos; 378 378 - error = xfs_attr_list(XFS_I(dentry->d_inode), kbuf, al_hreq.buflen, 378 378 + error = xfs_attr_list(XFS_I(d_inode(dentry)), kbuf, al_hreq.buflen, 379 379 al_hreq.flags, cursor); 380 380 if (error) 381 381 goto out_kfree; ··· 445 445 switch (ops[i].am_opcode) { 446 446 case ATTR_OP_GET: 447 447 ops[i].am_error = xfs_attrmulti_attr_get( 448 448 - dentry->d_inode, attr_name, 448 448 + d_inode(dentry), attr_name, 449 449 compat_ptr(ops[i].am_attrvalue), 450 450 &ops[i].am_length, ops[i].am_flags); 451 451 break; ··· 454 454 if (ops[i].am_error) 455 455 break; 456 456 ops[i].am_error = xfs_attrmulti_attr_set( 457 457 - dentry->d_inode, attr_name, 457 457 + d_inode(dentry), attr_name, 458 458 compat_ptr(ops[i].am_attrvalue), 459 459 ops[i].am_length, ops[i].am_flags); 460 460 mnt_drop_write_file(parfilp); ··· 464 464 if (ops[i].am_error) 465 465 break; 466 466 ops[i].am_error = xfs_attrmulti_attr_remove( 467 467 - dentry->d_inode, attr_name, 467 467 + d_inode(dentry), attr_name, 468 468 ops[i].am_flags); 469 469 mnt_drop_write_file(parfilp); 470 470 break; ··· 504 504 if (IS_ERR(dentry)) 505 505 return PTR_ERR(dentry); 506 506 507 507 - if (IS_IMMUTABLE(dentry->d_inode) || IS_APPEND(dentry->d_inode)) { 507 507 + if (IS_IMMUTABLE(d_inode(dentry)) || IS_APPEND(d_inode(dentry))) { 508 508 error = -EPERM; 509 509 goto out; 510 510 } ··· 514 514 goto out; 515 515 } 516 516 517 517 - error = xfs_set_dmattrs(XFS_I(dentry->d_inode), fsd.fsd_dmevmask, 517 517 + error = xfs_set_dmattrs(XFS_I(d_inode(dentry)), fsd.fsd_dmevmask, 518 518 fsd.fsd_dmstate); 519 519 520 520 out:

+10 -10

fs/xfs/xfs_iops.c

reviewed

··· 304 304 struct inode *dir, 305 305 struct dentry *dentry) 306 306 { 307 307 - struct inode *inode = old_dentry->d_inode; 307 307 + struct inode *inode = d_inode(old_dentry); 308 308 struct xfs_name name; 309 309 int error; 310 310 ··· 329 329 330 330 xfs_dentry_to_name(&name, dentry, 0); 331 331 332 332 - error = xfs_remove(XFS_I(dir), &name, XFS_I(dentry->d_inode)); 332 332 + error = xfs_remove(XFS_I(dir), &name, XFS_I(d_inode(dentry))); 333 333 if (error) 334 334 return error; 335 335 ··· 389 389 struct dentry *ndentry, 390 390 unsigned int flags) 391 391 { 392 392 - struct inode *new_inode = ndentry->d_inode; 392 392 + struct inode *new_inode = d_inode(ndentry); 393 393 int omode = 0; 394 394 struct xfs_name oname; 395 395 struct xfs_name nname; ··· 399 399 400 400 /* if we are exchanging files, we need to set i_mode of both files */ 401 401 if (flags & RENAME_EXCHANGE) 402 402 - omode = ndentry->d_inode->i_mode; 402 402 + omode = d_inode(ndentry)->i_mode; 403 403 404 404 xfs_dentry_to_name(&oname, odentry, omode); 405 405 - xfs_dentry_to_name(&nname, ndentry, odentry->d_inode->i_mode); 405 405 + xfs_dentry_to_name(&nname, ndentry, d_inode(odentry)->i_mode); 406 406 407 407 - return xfs_rename(XFS_I(odir), &oname, XFS_I(odentry->d_inode), 407 407 + return xfs_rename(XFS_I(odir), &oname, XFS_I(d_inode(odentry)), 408 408 XFS_I(ndir), &nname, 409 409 new_inode ? XFS_I(new_inode) : NULL, flags); 410 410 } ··· 426 426 if (!link) 427 427 goto out_err; 428 428 429 429 - error = xfs_readlink(XFS_I(dentry->d_inode), link); 429 429 + error = xfs_readlink(XFS_I(d_inode(dentry)), link); 430 430 if (unlikely(error)) 431 431 goto out_kfree; 432 432 ··· 446 446 struct dentry *dentry, 447 447 struct kstat *stat) 448 448 { 449 449 - struct inode *inode = dentry->d_inode; 449 449 + struct inode *inode = d_inode(dentry); 450 450 struct xfs_inode *ip = XFS_I(inode); 451 451 struct xfs_mount *mp = ip->i_mount; 452 452 ··· 946 946 struct dentry *dentry, 947 947 struct iattr *iattr) 948 948 { 949 949 - struct xfs_inode *ip = XFS_I(dentry->d_inode); 949 949 + struct xfs_inode *ip = XFS_I(d_inode(dentry)); 950 950 int error; 951 951 952 952 if (iattr->ia_valid & ATTR_SIZE) { 953 953 uint iolock = XFS_IOLOCK_EXCL; 954 954 955 955 xfs_ilock(ip, iolock); 956 956 - error = xfs_break_layouts(dentry->d_inode, &iolock, true); 956 956 + error = xfs_break_layouts(d_inode(dentry), &iolock, true); 957 957 if (!error) { 958 958 xfs_ilock(ip, XFS_MMAPLOCK_EXCL); 959 959 iolock |= XFS_MMAPLOCK_EXCL;

+1 -1

fs/xfs/xfs_super.c

reviewed

··· 1048 1048 { 1049 1049 struct xfs_mount *mp = XFS_M(dentry->d_sb); 1050 1050 xfs_sb_t *sbp = &mp->m_sb; 1051 1051 - struct xfs_inode *ip = XFS_I(dentry->d_inode); 1051 1051 + struct xfs_inode *ip = XFS_I(d_inode(dentry)); 1052 1052 __uint64_t fakeinos, id; 1053 1053 __uint64_t icount; 1054 1054 __uint64_t ifree;

+3 -3

fs/xfs/xfs_xattr.c

reviewed

··· 35 35 xfs_xattr_get(struct dentry *dentry, const char *name, 36 36 void *value, size_t size, int xflags) 37 37 { 38 38 - struct xfs_inode *ip = XFS_I(dentry->d_inode); 38 38 + struct xfs_inode *ip = XFS_I(d_inode(dentry)); 39 39 int error, asize = size; 40 40 41 41 if (strcmp(name, "") == 0) ··· 57 57 xfs_xattr_set(struct dentry *dentry, const char *name, const void *value, 58 58 size_t size, int flags, int xflags) 59 59 { 60 60 - struct xfs_inode *ip = XFS_I(dentry->d_inode); 60 60 + struct xfs_inode *ip = XFS_I(d_inode(dentry)); 61 61 62 62 if (strcmp(name, "") == 0) 63 63 return -EINVAL; ··· 197 197 { 198 198 struct xfs_attr_list_context context; 199 199 struct attrlist_cursor_kern cursor = { 0 }; 200 200 - struct inode *inode = dentry->d_inode; 200 200 + struct inode *inode = d_inode(dentry); 201 201 int error; 202 202 203 203 /*

+29 -2

include/linux/fs.h

reviewed

··· 1820 1820 #define I_SYNC (1 << __I_SYNC) 1821 1821 #define I_REFERENCED (1 << 8) 1822 1822 #define __I_DIO_WAKEUP 9 1823 1823 - #define I_DIO_WAKEUP (1 << I_DIO_WAKEUP) 1823 1823 + #define I_DIO_WAKEUP (1 << __I_DIO_WAKEUP) 1824 1824 #define I_LINKABLE (1 << 10) 1825 1825 #define I_DIRTY_TIME (1 << 11) 1826 1826 #define __I_DIRTY_TIME_EXPIRED 12 ··· 2644 2644 2645 2645 /* filesystem can handle aio writes beyond i_size */ 2646 2646 DIO_ASYNC_EXTEND = 0x04, 2647 2647 + 2648 2648 + /* inode/fs/bdev does not need truncate protection */ 2649 2649 + DIO_SKIP_DIO_COUNT = 0x08, 2647 2650 }; 2648 2651 2649 2652 void dio_end_io(struct bio *bio, int error); ··· 2669 2666 #endif 2670 2667 2671 2668 void inode_dio_wait(struct inode *inode); 2672 2672 - void inode_dio_done(struct inode *inode); 2669 2669 + 2670 2670 + /* 2671 2671 + * inode_dio_begin - signal start of a direct I/O requests 2672 2672 + * @inode: inode the direct I/O happens on 2673 2673 + * 2674 2674 + * This is called once we've finished processing a direct I/O request, 2675 2675 + * and is used to wake up callers waiting for direct I/O to be quiesced. 2676 2676 + */ 2677 2677 + static inline void inode_dio_begin(struct inode *inode) 2678 2678 + { 2679 2679 + atomic_inc(&inode->i_dio_count); 2680 2680 + } 2681 2681 + 2682 2682 + /* 2683 2683 + * inode_dio_end - signal finish of a direct I/O requests 2684 2684 + * @inode: inode the direct I/O happens on 2685 2685 + * 2686 2686 + * This is called once we've finished processing a direct I/O request, 2687 2687 + * and is used to wake up callers waiting for direct I/O to be quiesced. 2688 2688 + */ 2689 2689 + static inline void inode_dio_end(struct inode *inode) 2690 2690 + { 2691 2691 + if (atomic_dec_and_test(&inode->i_dio_count)) 2692 2692 + wake_up_bit(&inode->i_state, __I_DIO_WAKEUP); 2693 2693 + } 2673 2694 2674 2695 extern void inode_set_flags(struct inode *inode, unsigned int flags, 2675 2696 unsigned int mask);

+2 -2

include/trace/events/btrfs.h

reviewed

··· 407 407 408 408 TP_fast_assign( 409 409 struct dentry *dentry = file->f_path.dentry; 410 410 - struct inode *inode = dentry->d_inode; 410 410 + struct inode *inode = d_inode(dentry); 411 411 412 412 __entry->ino = inode->i_ino; 413 413 - __entry->parent = dentry->d_parent->d_inode->i_ino; 413 413 + __entry->parent = d_inode(dentry->d_parent)->i_ino; 414 414 __entry->datasync = datasync; 415 415 __entry->root_objectid = 416 416 BTRFS_I(inode)->root->root_key.objectid;

+8 -8

include/trace/events/ext3.h

reviewed

··· 439 439 TP_fast_assign( 440 440 struct dentry *dentry = file->f_path.dentry; 441 441 442 442 - __entry->dev = dentry->d_inode->i_sb->s_dev; 443 443 - __entry->ino = dentry->d_inode->i_ino; 442 442 + __entry->dev = d_inode(dentry)->i_sb->s_dev; 443 443 + __entry->ino = d_inode(dentry)->i_ino; 444 444 __entry->datasync = datasync; 445 445 - __entry->parent = dentry->d_parent->d_inode->i_ino; 445 445 + __entry->parent = d_inode(dentry->d_parent)->i_ino; 446 446 ), 447 447 448 448 TP_printk("dev %d,%d ino %lu parent %ld datasync %d ", ··· 710 710 711 711 TP_fast_assign( 712 712 __entry->parent = parent->i_ino; 713 713 - __entry->ino = dentry->d_inode->i_ino; 714 714 - __entry->size = dentry->d_inode->i_size; 715 715 - __entry->dev = dentry->d_inode->i_sb->s_dev; 713 713 + __entry->ino = d_inode(dentry)->i_ino; 714 714 + __entry->size = d_inode(dentry)->i_size; 715 715 + __entry->dev = d_inode(dentry)->i_sb->s_dev; 716 716 ), 717 717 718 718 TP_printk("dev %d,%d ino %lu size %lld parent %ld", ··· 734 734 ), 735 735 736 736 TP_fast_assign( 737 737 - __entry->ino = dentry->d_inode->i_ino; 738 738 - __entry->dev = dentry->d_inode->i_sb->s_dev; 737 737 + __entry->ino = d_inode(dentry)->i_ino; 738 738 + __entry->dev = d_inode(dentry)->i_sb->s_dev; 739 739 __entry->ret = ret; 740 740 ), 741 741

+8 -8

include/trace/events/ext4.h

reviewed

··· 872 872 TP_fast_assign( 873 873 struct dentry *dentry = file->f_path.dentry; 874 874 875 875 - __entry->dev = dentry->d_inode->i_sb->s_dev; 876 876 - __entry->ino = dentry->d_inode->i_ino; 875 875 + __entry->dev = d_inode(dentry)->i_sb->s_dev; 876 876 + __entry->ino = d_inode(dentry)->i_ino; 877 877 __entry->datasync = datasync; 878 878 - __entry->parent = dentry->d_parent->d_inode->i_ino; 878 878 + __entry->parent = d_inode(dentry->d_parent)->i_ino; 879 879 ), 880 880 881 881 TP_printk("dev %d,%d ino %lu parent %lu datasync %d ", ··· 1453 1453 ), 1454 1454 1455 1455 TP_fast_assign( 1456 1456 - __entry->dev = dentry->d_inode->i_sb->s_dev; 1457 1457 - __entry->ino = dentry->d_inode->i_ino; 1456 1456 + __entry->dev = d_inode(dentry)->i_sb->s_dev; 1457 1457 + __entry->ino = d_inode(dentry)->i_ino; 1458 1458 __entry->parent = parent->i_ino; 1459 1459 - __entry->size = dentry->d_inode->i_size; 1459 1459 + __entry->size = d_inode(dentry)->i_size; 1460 1460 ), 1461 1461 1462 1462 TP_printk("dev %d,%d ino %lu size %lld parent %lu", ··· 1477 1477 ), 1478 1478 1479 1479 TP_fast_assign( 1480 1480 - __entry->dev = dentry->d_inode->i_sb->s_dev; 1481 1481 - __entry->ino = dentry->d_inode->i_ino; 1480 1480 + __entry->dev = d_inode(dentry)->i_sb->s_dev; 1481 1481 + __entry->ino = d_inode(dentry)->i_ino; 1482 1482 __entry->ret = ret; 1483 1483 ), 1484 1484

+11 -11

ipc/mqueue.c

reviewed

··· 466 466 467 467 static int mqueue_unlink(struct inode *dir, struct dentry *dentry) 468 468 { 469 469 - struct inode *inode = dentry->d_inode; 469 469 + struct inode *inode = d_inode(dentry); 470 470 471 471 dir->i_ctime = dir->i_mtime = dir->i_atime = CURRENT_TIME; 472 472 dir->i_size -= DIRENT_SIZE; ··· 770 770 if ((oflag & O_ACCMODE) == (O_RDWR | O_WRONLY)) 771 771 return ERR_PTR(-EINVAL); 772 772 acc = oflag2acc[oflag & O_ACCMODE]; 773 773 - if (inode_permission(path->dentry->d_inode, acc)) 773 773 + if (inode_permission(d_inode(path->dentry), acc)) 774 774 return ERR_PTR(-EACCES); 775 775 return dentry_open(path, oflag, current_cred()); 776 776 } ··· 802 802 803 803 ro = mnt_want_write(mnt); /* we'll drop it in any case */ 804 804 error = 0; 805 805 - mutex_lock(&root->d_inode->i_mutex); 805 805 + mutex_lock(&d_inode(root)->i_mutex); 806 806 path.dentry = lookup_one_len(name->name, root, strlen(name->name)); 807 807 if (IS_ERR(path.dentry)) { 808 808 error = PTR_ERR(path.dentry); ··· 811 811 path.mnt = mntget(mnt); 812 812 813 813 if (oflag & O_CREAT) { 814 814 - if (path.dentry->d_inode) { /* entry already exists */ 814 814 + if (d_really_is_positive(path.dentry)) { /* entry already exists */ 815 815 audit_inode(name, path.dentry, 0); 816 816 if (oflag & O_EXCL) { 817 817 error = -EEXIST; ··· 824 824 goto out; 825 825 } 826 826 audit_inode_parent_hidden(name, root); 827 827 - filp = do_create(ipc_ns, root->d_inode, 827 827 + filp = do_create(ipc_ns, d_inode(root), 828 828 &path, oflag, mode, 829 829 u_attr ? &attr : NULL); 830 830 } 831 831 } else { 832 832 - if (!path.dentry->d_inode) { 832 832 + if (d_really_is_negative(path.dentry)) { 833 833 error = -ENOENT; 834 834 goto out; 835 835 } ··· 848 848 put_unused_fd(fd); 849 849 fd = error; 850 850 } 851 851 - mutex_unlock(&root->d_inode->i_mutex); 851 851 + mutex_unlock(&d_inode(root)->i_mutex); 852 852 if (!ro) 853 853 mnt_drop_write(mnt); 854 854 out_putname: ··· 873 873 err = mnt_want_write(mnt); 874 874 if (err) 875 875 goto out_name; 876 876 - mutex_lock_nested(&mnt->mnt_root->d_inode->i_mutex, I_MUTEX_PARENT); 876 876 + mutex_lock_nested(&d_inode(mnt->mnt_root)->i_mutex, I_MUTEX_PARENT); 877 877 dentry = lookup_one_len(name->name, mnt->mnt_root, 878 878 strlen(name->name)); 879 879 if (IS_ERR(dentry)) { ··· 881 881 goto out_unlock; 882 882 } 883 883 884 884 - inode = dentry->d_inode; 884 884 + inode = d_inode(dentry); 885 885 if (!inode) { 886 886 err = -ENOENT; 887 887 } else { 888 888 ihold(inode); 889 889 - err = vfs_unlink(dentry->d_parent->d_inode, dentry, NULL); 889 889 + err = vfs_unlink(d_inode(dentry->d_parent), dentry, NULL); 890 890 } 891 891 dput(dentry); 892 892 893 893 out_unlock: 894 894 - mutex_unlock(&mnt->mnt_root->d_inode->i_mutex); 894 894 + mutex_unlock(&d_inode(mnt->mnt_root)->i_mutex); 895 895 if (inode) 896 896 iput(inode); 897 897 mnt_drop_write(mnt);

+1 -1

ipc/shm.c

reviewed

··· 1132 1132 path = shp->shm_file->f_path; 1133 1133 path_get(&path); 1134 1134 shp->shm_nattch++; 1135 1135 - size = i_size_read(path.dentry->d_inode); 1135 1135 + size = i_size_read(d_inode(path.dentry)); 1136 1136 ipc_unlock_object(&shp->shm_perm); 1137 1137 rcu_read_unlock(); 1138 1138

+1 -1

kernel/audit.c

reviewed

··· 1928 1928 1929 1929 /* Generate AUDIT_PATH record with object. */ 1930 1930 name->type = AUDIT_TYPE_NORMAL; 1931 1931 - audit_copy_inode(name, link->dentry, link->dentry->d_inode); 1931 1931 + audit_copy_inode(name, link->dentry, d_backing_inode(link->dentry)); 1932 1932 audit_log_name(current->audit_context, name, link, 0, NULL); 1933 1933 out: 1934 1934 kfree(name);

+2 -2

kernel/audit_tree.c

reviewed

··· 577 577 578 578 static int compare_root(struct vfsmount *mnt, void *arg) 579 579 { 580 580 - return mnt->mnt_root->d_inode == arg; 580 580 + return d_backing_inode(mnt->mnt_root) == arg; 581 581 } 582 582 583 583 void audit_trim_trees(void) ··· 649 649 650 650 static int tag_mount(struct vfsmount *mnt, void *arg) 651 651 { 652 652 - return tag_chunk(mnt->mnt_root->d_inode, arg); 652 652 + return tag_chunk(d_backing_inode(mnt->mnt_root), arg); 653 653 } 654 654 655 655 /*

+7 -7

kernel/audit_watch.c

reviewed

··· 146 146 /* Initialize a parent watch entry. */ 147 147 static struct audit_parent *audit_init_parent(struct path *path) 148 148 { 149 149 - struct inode *inode = path->dentry->d_inode; 149 149 + struct inode *inode = d_backing_inode(path->dentry); 150 150 struct audit_parent *parent; 151 151 int ret; 152 152 ··· 361 361 struct dentry *d = kern_path_locked(watch->path, parent); 362 362 if (IS_ERR(d)) 363 363 return PTR_ERR(d); 364 364 - mutex_unlock(&parent->dentry->d_inode->i_mutex); 365 365 - if (d->d_inode) { 364 364 + mutex_unlock(&d_backing_inode(parent->dentry)->i_mutex); 365 365 + if (d_is_positive(d)) { 366 366 /* update watch filter fields */ 367 367 - watch->dev = d->d_inode->i_sb->s_dev; 368 368 - watch->ino = d->d_inode->i_ino; 367 367 + watch->dev = d_backing_inode(d)->i_sb->s_dev; 368 368 + watch->ino = d_backing_inode(d)->i_ino; 369 369 } 370 370 dput(d); 371 371 return 0; ··· 426 426 return ret; 427 427 428 428 /* either find an old parent or attach a new one */ 429 429 - parent = audit_find_parent(parent_path.dentry->d_inode); 429 429 + parent = audit_find_parent(d_backing_inode(parent_path.dentry)); 430 430 if (!parent) { 431 431 parent = audit_init_parent(&parent_path); 432 432 if (IS_ERR(parent)) { ··· 482 482 483 483 switch (data_type) { 484 484 case (FSNOTIFY_EVENT_PATH): 485 485 - inode = ((struct path *)data)->dentry->d_inode; 485 485 + inode = d_backing_inode(((struct path *)data)->dentry); 486 486 break; 487 487 case (FSNOTIFY_EVENT_INODE): 488 488 inode = (struct inode *)data;

+3 -3

kernel/auditsc.c

reviewed

··· 1629 1629 rcu_read_lock(); 1630 1630 seq = read_seqbegin(&rename_lock); 1631 1631 for(;;) { 1632 1632 - struct inode *inode = d->d_inode; 1632 1632 + struct inode *inode = d_backing_inode(d); 1633 1633 if (inode && unlikely(!hlist_empty(&inode->i_fsnotify_marks))) { 1634 1634 struct audit_chunk *chunk; 1635 1635 chunk = audit_tree_lookup(inode); ··· 1754 1754 unsigned int flags) 1755 1755 { 1756 1756 struct audit_context *context = current->audit_context; 1757 1757 - const struct inode *inode = dentry->d_inode; 1757 1757 + const struct inode *inode = d_backing_inode(dentry); 1758 1758 struct audit_names *n; 1759 1759 bool parent = flags & AUDIT_INODE_PARENT; 1760 1760 ··· 1853 1853 const unsigned char type) 1854 1854 { 1855 1855 struct audit_context *context = current->audit_context; 1856 1856 - const struct inode *inode = dentry->d_inode; 1856 1856 + const struct inode *inode = d_backing_inode(dentry); 1857 1857 const char *dname = dentry->d_name.name; 1858 1858 struct audit_names *n, *found_parent = NULL, *found_child = NULL; 1859 1859

+2 -2

kernel/relay.c

reviewed

··· 407 407 struct dentry *dentry) 408 408 { 409 409 buf->dentry = dentry; 410 410 - buf->dentry->d_inode->i_size = buf->early_bytes; 410 410 + d_inode(buf->dentry)->i_size = buf->early_bytes; 411 411 } 412 412 413 413 static struct dentry *relay_create_buf_file(struct rchan *chan, ··· 733 733 buf->padding[old_subbuf] = buf->prev_padding; 734 734 buf->subbufs_produced++; 735 735 if (buf->dentry) 736 736 - buf->dentry->d_inode->i_size += 736 736 + d_inode(buf->dentry)->i_size += 737 737 buf->chan->subbuf_size - 738 738 buf->padding[old_subbuf]; 739 739 else

+1 -1

kernel/trace/trace.c

reviewed

··· 6079 6079 struct dentry *ret = trace_create_file(name, mode, parent, data, fops); 6080 6080 6081 6081 if (ret) /* See tracing_get_cpu() */ 6082 6082 - ret->d_inode->i_cdev = (void *)(cpu + 1); 6082 6082 + d_inode(ret)->i_cdev = (void *)(cpu + 1); 6083 6083 return ret; 6084 6084 } 6085 6085

+2 -2

kernel/trace/trace_events.c

reviewed

··· 494 494 if (dir) { 495 495 spin_lock(&dir->d_lock); /* probably unneeded */ 496 496 list_for_each_entry(child, &dir->d_subdirs, d_child) { 497 497 - if (child->d_inode) /* probably unneeded */ 498 498 - child->d_inode->i_private = NULL; 497 497 + if (d_really_is_positive(child)) /* probably unneeded */ 498 498 + d_inode(child)->i_private = NULL; 499 499 } 500 500 spin_unlock(&dir->d_lock); 501 501

+1 -1

kernel/trace/trace_uprobe.c

reviewed

··· 443 443 if (ret) 444 444 goto fail_address_parse; 445 445 446 446 - inode = igrab(path.dentry->d_inode); 446 446 + inode = igrab(d_inode(path.dentry)); 447 447 path_put(&path); 448 448 449 449 if (!inode || !S_ISREG(inode->i_mode)) {

+15 -15

mm/shmem.c

reviewed

··· 544 544 545 545 static int shmem_setattr(struct dentry *dentry, struct iattr *attr) 546 546 { 547 547 - struct inode *inode = dentry->d_inode; 547 547 + struct inode *inode = d_inode(dentry); 548 548 struct shmem_inode_info *info = SHMEM_I(inode); 549 549 int error; 550 550 ··· 2274 2274 */ 2275 2275 static int shmem_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry) 2276 2276 { 2277 2277 - struct inode *inode = old_dentry->d_inode; 2277 2277 + struct inode *inode = d_inode(old_dentry); 2278 2278 int ret; 2279 2279 2280 2280 /* ··· 2298 2298 2299 2299 static int shmem_unlink(struct inode *dir, struct dentry *dentry) 2300 2300 { 2301 2301 - struct inode *inode = dentry->d_inode; 2301 2301 + struct inode *inode = d_inode(dentry); 2302 2302 2303 2303 if (inode->i_nlink > 1 && !S_ISDIR(inode->i_mode)) 2304 2304 shmem_free_inode(inode->i_sb); ··· 2315 2315 if (!simple_empty(dentry)) 2316 2316 return -ENOTEMPTY; 2317 2317 2318 2318 - drop_nlink(dentry->d_inode); 2318 2318 + drop_nlink(d_inode(dentry)); 2319 2319 drop_nlink(dir); 2320 2320 return shmem_unlink(dir, dentry); 2321 2321 } ··· 2336 2336 } 2337 2337 old_dir->i_ctime = old_dir->i_mtime = 2338 2338 new_dir->i_ctime = new_dir->i_mtime = 2339 2339 - old_dentry->d_inode->i_ctime = 2340 2340 - new_dentry->d_inode->i_ctime = CURRENT_TIME; 2339 2339 + d_inode(old_dentry)->i_ctime = 2340 2340 + d_inode(new_dentry)->i_ctime = CURRENT_TIME; 2341 2341 2342 2342 return 0; 2343 2343 } ··· 2376 2376 */ 2377 2377 static int shmem_rename2(struct inode *old_dir, struct dentry *old_dentry, struct inode *new_dir, struct dentry *new_dentry, unsigned int flags) 2378 2378 { 2379 2379 - struct inode *inode = old_dentry->d_inode; 2379 2379 + struct inode *inode = d_inode(old_dentry); 2380 2380 int they_are_dirs = S_ISDIR(inode->i_mode); 2381 2381 2382 2382 if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE | RENAME_WHITEOUT)) ··· 2396 2396 return error; 2397 2397 } 2398 2398 2399 2399 - if (new_dentry->d_inode) { 2399 2399 + if (d_really_is_positive(new_dentry)) { 2400 2400 (void) shmem_unlink(new_dir, new_dentry); 2401 2401 if (they_are_dirs) { 2402 2402 - drop_nlink(new_dentry->d_inode); 2402 2402 + drop_nlink(d_inode(new_dentry)); 2403 2403 drop_nlink(old_dir); 2404 2404 } 2405 2405 } else if (they_are_dirs) { ··· 2476 2476 2477 2477 static void *shmem_follow_short_symlink(struct dentry *dentry, struct nameidata *nd) 2478 2478 { 2479 2479 - nd_set_link(nd, SHMEM_I(dentry->d_inode)->symlink); 2479 2479 + nd_set_link(nd, SHMEM_I(d_inode(dentry))->symlink); 2480 2480 return NULL; 2481 2481 } 2482 2482 2483 2483 static void *shmem_follow_link(struct dentry *dentry, struct nameidata *nd) 2484 2484 { 2485 2485 struct page *page = NULL; 2486 2486 - int error = shmem_getpage(dentry->d_inode, 0, &page, SGP_READ, NULL); 2486 2486 + int error = shmem_getpage(d_inode(dentry), 0, &page, SGP_READ, NULL); 2487 2487 nd_set_link(nd, error ? ERR_PTR(error) : kmap(page)); 2488 2488 if (page) 2489 2489 unlock_page(page); ··· 2574 2574 static ssize_t shmem_getxattr(struct dentry *dentry, const char *name, 2575 2575 void *buffer, size_t size) 2576 2576 { 2577 2577 - struct shmem_inode_info *info = SHMEM_I(dentry->d_inode); 2577 2577 + struct shmem_inode_info *info = SHMEM_I(d_inode(dentry)); 2578 2578 int err; 2579 2579 2580 2580 /* ··· 2595 2595 static int shmem_setxattr(struct dentry *dentry, const char *name, 2596 2596 const void *value, size_t size, int flags) 2597 2597 { 2598 2598 - struct shmem_inode_info *info = SHMEM_I(dentry->d_inode); 2598 2598 + struct shmem_inode_info *info = SHMEM_I(d_inode(dentry)); 2599 2599 int err; 2600 2600 2601 2601 /* ··· 2615 2615 2616 2616 static int shmem_removexattr(struct dentry *dentry, const char *name) 2617 2617 { 2618 2618 - struct shmem_inode_info *info = SHMEM_I(dentry->d_inode); 2618 2618 + struct shmem_inode_info *info = SHMEM_I(d_inode(dentry)); 2619 2619 int err; 2620 2620 2621 2621 /* ··· 2635 2635 2636 2636 static ssize_t shmem_listxattr(struct dentry *dentry, char *buffer, size_t size) 2637 2637 { 2638 2638 - struct shmem_inode_info *info = SHMEM_I(dentry->d_inode); 2638 2638 + struct shmem_inode_info *info = SHMEM_I(d_inode(dentry)); 2639 2639 return simple_xattr_list(&info->xattrs, buffer, size); 2640 2640 } 2641 2641 #endif /* CONFIG_TMPFS_XATTR */

+3 -3

net/socket.c

reviewed

··· 312 312 static char *sockfs_dname(struct dentry *dentry, char *buffer, int buflen) 313 313 { 314 314 return dynamic_dname(dentry, buffer, buflen, "socket:[%lu]", 315 315 - dentry->d_inode->i_ino); 315 315 + d_inode(dentry)->i_ino); 316 316 } 317 317 318 318 static const struct dentry_operations sockfs_dentry_operations = { ··· 375 375 &socket_file_ops); 376 376 if (unlikely(IS_ERR(file))) { 377 377 /* drop dentry, keep inode */ 378 378 - ihold(path.dentry->d_inode); 378 378 + ihold(d_inode(path.dentry)); 379 379 path_put(&path); 380 380 return file; 381 381 } ··· 497 497 ssize_t len; 498 498 ssize_t used = 0; 499 499 500 500 - len = security_inode_listsecurity(dentry->d_inode, buffer, size); 500 500 + len = security_inode_listsecurity(d_inode(dentry), buffer, size); 501 501 if (len < 0) 502 502 return len; 503 503 used += len;

+16 -16

net/sunrpc/rpc_pipe.c

reviewed

··· 94 94 } 95 95 dentry = dget(pipe->dentry); 96 96 spin_unlock(&pipe->lock); 97 97 - rpc_purge_list(dentry ? &RPC_I(dentry->d_inode)->waitq : NULL, 97 97 + rpc_purge_list(dentry ? &RPC_I(d_inode(dentry))->waitq : NULL, 98 98 &free_list, destroy_msg, -ETIMEDOUT); 99 99 dput(dentry); 100 100 } ··· 152 152 dentry = dget(pipe->dentry); 153 153 spin_unlock(&pipe->lock); 154 154 if (dentry) { 155 155 - wake_up(&RPC_I(dentry->d_inode)->waitq); 155 155 + wake_up(&RPC_I(d_inode(dentry))->waitq); 156 156 dput(dentry); 157 157 } 158 158 return res; ··· 591 591 err = __rpc_create_common(dir, dentry, S_IFIFO | mode, i_fop, private); 592 592 if (err) 593 593 return err; 594 594 - rpci = RPC_I(dentry->d_inode); 594 594 + rpci = RPC_I(d_inode(dentry)); 595 595 rpci->private = private; 596 596 rpci->pipe = pipe; 597 597 fsnotify_create(dir, dentry); ··· 616 616 int error; 617 617 618 618 parent = dget_parent(dentry); 619 619 - dir = parent->d_inode; 619 619 + dir = d_inode(parent); 620 620 mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT); 621 621 error = __rpc_rmdir(dir, dentry); 622 622 mutex_unlock(&dir->i_mutex); ··· 638 638 639 639 static int __rpc_rmpipe(struct inode *dir, struct dentry *dentry) 640 640 { 641 641 - struct inode *inode = dentry->d_inode; 641 641 + struct inode *inode = d_inode(dentry); 642 642 643 643 rpc_close_pipes(inode); 644 644 return __rpc_unlink(dir, dentry); ··· 654 654 if (!dentry) 655 655 return ERR_PTR(-ENOMEM); 656 656 } 657 657 - if (dentry->d_inode == NULL) 657 657 + if (d_really_is_negative(dentry)) 658 658 return dentry; 659 659 dput(dentry); 660 660 return ERR_PTR(-EEXIST); ··· 667 667 const struct rpc_filelist *files, 668 668 int start, int eof) 669 669 { 670 670 - struct inode *dir = parent->d_inode; 670 670 + struct inode *dir = d_inode(parent); 671 671 struct dentry *dentry; 672 672 struct qstr name; 673 673 int i; ··· 679 679 680 680 if (dentry == NULL) 681 681 continue; 682 682 - if (dentry->d_inode == NULL) 682 682 + if (d_really_is_negative(dentry)) 683 683 goto next; 684 684 - switch (dentry->d_inode->i_mode & S_IFMT) { 684 684 + switch (d_inode(dentry)->i_mode & S_IFMT) { 685 685 default: 686 686 BUG(); 687 687 case S_IFREG: ··· 699 699 const struct rpc_filelist *files, 700 700 int start, int eof) 701 701 { 702 702 - struct inode *dir = parent->d_inode; 702 702 + struct inode *dir = d_inode(parent); 703 703 704 704 mutex_lock_nested(&dir->i_mutex, I_MUTEX_CHILD); 705 705 __rpc_depopulate(parent, files, start, eof); ··· 711 711 int start, int eof, 712 712 void *private) 713 713 { 714 714 - struct inode *dir = parent->d_inode; 714 714 + struct inode *dir = d_inode(parent); 715 715 struct dentry *dentry; 716 716 int i, err; 717 717 ··· 754 754 int (*populate)(struct dentry *, void *), void *args_populate) 755 755 { 756 756 struct dentry *dentry; 757 757 - struct inode *dir = parent->d_inode; 757 757 + struct inode *dir = d_inode(parent); 758 758 int error; 759 759 760 760 mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT); ··· 787 787 int error; 788 788 789 789 parent = dget_parent(dentry); 790 790 - dir = parent->d_inode; 790 790 + dir = d_inode(parent); 791 791 mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT); 792 792 if (depopulate != NULL) 793 793 depopulate(dentry); ··· 819 819 void *private, struct rpc_pipe *pipe) 820 820 { 821 821 struct dentry *dentry; 822 822 - struct inode *dir = parent->d_inode; 822 822 + struct inode *dir = d_inode(parent); 823 823 umode_t umode = S_IFIFO | S_IRUSR | S_IWUSR; 824 824 int err; 825 825 ··· 864 864 int error = 0; 865 865 866 866 parent = dget_parent(dentry); 867 867 - dir = parent->d_inode; 867 867 + dir = d_inode(parent); 868 868 mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT); 869 869 error = __rpc_rmpipe(dir, dentry); 870 870 mutex_unlock(&dir->i_mutex); ··· 1375 1375 struct dentry *clnt_dir = pipe_dentry->d_parent; 1376 1376 struct dentry *gssd_dir = clnt_dir->d_parent; 1377 1377 1378 1378 - __rpc_rmpipe(clnt_dir->d_inode, pipe_dentry); 1378 1378 + __rpc_rmpipe(d_inode(clnt_dir), pipe_dentry); 1379 1379 __rpc_depopulate(clnt_dir, gssd_dummy_info_file, 0, 1); 1380 1380 __rpc_depopulate(gssd_dir, gssd_dummy_clnt_dir, 0, 1); 1381 1381 dput(pipe_dentry);

+4 -4

net/unix/af_unix.c

reviewed

··· 305 305 &unix_socket_table[i->i_ino & (UNIX_HASH_SIZE - 1)]) { 306 306 struct dentry *dentry = unix_sk(s)->path.dentry; 307 307 308 308 - if (dentry && dentry->d_inode == i) { 308 308 + if (dentry && d_backing_inode(dentry) == i) { 309 309 sock_hold(s); 310 310 goto found; 311 311 } ··· 778 778 err = kern_path(sunname->sun_path, LOOKUP_FOLLOW, &path); 779 779 if (err) 780 780 goto fail; 781 781 - inode = path.dentry->d_inode; 781 781 + inode = d_backing_inode(path.dentry); 782 782 err = inode_permission(inode, MAY_WRITE); 783 783 if (err) 784 784 goto put_fail; ··· 839 839 */ 840 840 err = security_path_mknod(&path, dentry, mode, 0); 841 841 if (!err) { 842 842 - err = vfs_mknod(path.dentry->d_inode, dentry, mode, 0); 842 842 + err = vfs_mknod(d_inode(path.dentry), dentry, mode, 0); 843 843 if (!err) { 844 844 res->mnt = mntget(path.mnt); 845 845 res->dentry = dget(dentry); ··· 905 905 goto out_up; 906 906 } 907 907 addr->hash = UNIX_HASH_SIZE; 908 908 - hash = path.dentry->d_inode->i_ino & (UNIX_HASH_SIZE-1); 908 908 + hash = d_backing_inode(path.dentry)->i_ino & (UNIX_HASH_SIZE-1); 909 909 spin_lock(&unix_table_lock); 910 910 u->path = path; 911 911 list = &unix_socket_table[hash];

+1 -1

net/unix/diag.c

reviewed

··· 25 25 26 26 if (dentry) { 27 27 struct unix_diag_vfs uv = { 28 28 - .udiag_vfs_ino = dentry->d_inode->i_ino, 28 28 + .udiag_vfs_ino = d_backing_inode(dentry)->i_ino, 29 29 .udiag_vfs_dev = dentry->d_sb->s_dev, 30 30 }; 31 31

+1 -1

security/apparmor/apparmorfs.c

reviewed

··· 365 365 if (!profile->dents[i]) 366 366 continue; 367 367 368 368 - r = profile->dents[i]->d_inode->i_private; 368 368 + r = d_inode(profile->dents[i])->i_private; 369 369 securityfs_remove(profile->dents[i]); 370 370 aa_put_replacedby(r); 371 371 profile->dents[i] = NULL;

+3 -3

security/apparmor/file.c

reviewed

··· 259 259 */ 260 260 static inline bool is_deleted(struct dentry *dentry) 261 261 { 262 262 - if (d_unlinked(dentry) && dentry->d_inode->i_nlink == 0) 262 262 + if (d_unlinked(dentry) && d_backing_inode(dentry)->i_nlink == 0) 263 263 return 1; 264 264 return 0; 265 265 } ··· 351 351 struct path link = { new_dir->mnt, new_dentry }; 352 352 struct path target = { new_dir->mnt, old_dentry }; 353 353 struct path_cond cond = { 354 354 - old_dentry->d_inode->i_uid, 355 355 - old_dentry->d_inode->i_mode 354 354 + d_backing_inode(old_dentry)->i_uid, 355 355 + d_backing_inode(old_dentry)->i_mode 356 356 }; 357 357 char *buffer = NULL, *buffer2 = NULL; 358 358 const char *lname, *tname = NULL, *info = NULL;

+9 -9

security/apparmor/lsm.c

reviewed

··· 204 204 struct dentry *dentry, u32 mask) 205 205 { 206 206 struct path path = { mnt, dentry }; 207 207 - struct path_cond cond = { dentry->d_inode->i_uid, 208 208 - dentry->d_inode->i_mode 207 207 + struct path_cond cond = { d_backing_inode(dentry)->i_uid, 208 208 + d_backing_inode(dentry)->i_mode 209 209 }; 210 210 211 211 return common_perm(op, &path, mask, &cond); ··· 223 223 static int common_perm_rm(int op, struct path *dir, 224 224 struct dentry *dentry, u32 mask) 225 225 { 226 226 - struct inode *inode = dentry->d_inode; 226 226 + struct inode *inode = d_backing_inode(dentry); 227 227 struct path_cond cond = { }; 228 228 229 229 if (!inode || !dir->mnt || !mediated_filesystem(dentry)) ··· 281 281 282 282 static int apparmor_path_truncate(struct path *path) 283 283 { 284 284 - struct path_cond cond = { path->dentry->d_inode->i_uid, 285 285 - path->dentry->d_inode->i_mode 284 284 + struct path_cond cond = { d_backing_inode(path->dentry)->i_uid, 285 285 + d_backing_inode(path->dentry)->i_mode 286 286 }; 287 287 288 288 if (!path->mnt || !mediated_filesystem(path->dentry)) ··· 327 327 if (!unconfined(profile)) { 328 328 struct path old_path = { old_dir->mnt, old_dentry }; 329 329 struct path new_path = { new_dir->mnt, new_dentry }; 330 330 - struct path_cond cond = { old_dentry->d_inode->i_uid, 331 331 - old_dentry->d_inode->i_mode 330 330 + struct path_cond cond = { d_backing_inode(old_dentry)->i_uid, 331 331 + d_backing_inode(old_dentry)->i_mode 332 332 }; 333 333 334 334 error = aa_path_perm(OP_RENAME_SRC, profile, &old_path, 0, ··· 354 354 355 355 static int apparmor_path_chown(struct path *path, kuid_t uid, kgid_t gid) 356 356 { 357 357 - struct path_cond cond = { path->dentry->d_inode->i_uid, 358 358 - path->dentry->d_inode->i_mode 357 357 + struct path_cond cond = { d_backing_inode(path->dentry)->i_uid, 358 358 + d_backing_inode(path->dentry)->i_mode 359 359 }; 360 360 361 361 if (!mediated_filesystem(path->dentry))

+3 -3

security/commoncap.c

reviewed

··· 297 297 */ 298 298 int cap_inode_need_killpriv(struct dentry *dentry) 299 299 { 300 300 - struct inode *inode = dentry->d_inode; 300 300 + struct inode *inode = d_backing_inode(dentry); 301 301 int error; 302 302 303 303 if (!inode->i_op->getxattr) ··· 319 319 */ 320 320 int cap_inode_killpriv(struct dentry *dentry) 321 321 { 322 322 - struct inode *inode = dentry->d_inode; 322 322 + struct inode *inode = d_backing_inode(dentry); 323 323 324 324 if (!inode->i_op->removexattr) 325 325 return 0; ··· 375 375 */ 376 376 int get_vfs_caps_from_disk(const struct dentry *dentry, struct cpu_vfs_cap_data *cpu_caps) 377 377 { 378 378 - struct inode *inode = dentry->d_inode; 378 378 + struct inode *inode = d_backing_inode(dentry); 379 379 __u32 magic_etc; 380 380 unsigned tocopy, i; 381 381 int size;

+9 -9

security/inode.c

reviewed

··· 27 27 28 28 static inline int positive(struct dentry *dentry) 29 29 { 30 30 - return dentry->d_inode && !d_unhashed(dentry); 30 30 + return d_really_is_positive(dentry) && !d_unhashed(dentry); 31 31 } 32 32 33 33 static int fill_super(struct super_block *sb, void *data, int silent) ··· 102 102 if (!parent) 103 103 parent = mount->mnt_root; 104 104 105 105 - dir = parent->d_inode; 105 105 + dir = d_inode(parent); 106 106 107 107 mutex_lock(&dir->i_mutex); 108 108 dentry = lookup_one_len(name, parent, strlen(name)); 109 109 if (IS_ERR(dentry)) 110 110 goto out; 111 111 112 112 - if (dentry->d_inode) { 112 112 + if (d_really_is_positive(dentry)) { 113 113 error = -EEXIST; 114 114 goto out1; 115 115 } ··· 197 197 return; 198 198 199 199 parent = dentry->d_parent; 200 200 - if (!parent || !parent->d_inode) 200 200 + if (!parent || d_really_is_negative(parent)) 201 201 return; 202 202 203 203 - mutex_lock(&parent->d_inode->i_mutex); 203 203 + mutex_lock(&d_inode(parent)->i_mutex); 204 204 if (positive(dentry)) { 205 205 - if (dentry->d_inode) { 205 205 + if (d_really_is_positive(dentry)) { 206 206 if (d_is_dir(dentry)) 207 207 - simple_rmdir(parent->d_inode, dentry); 207 207 + simple_rmdir(d_inode(parent), dentry); 208 208 else 209 209 - simple_unlink(parent->d_inode, dentry); 209 209 + simple_unlink(d_inode(parent), dentry); 210 210 dput(dentry); 211 211 } 212 212 } 213 213 - mutex_unlock(&parent->d_inode->i_mutex); 213 213 + mutex_unlock(&d_inode(parent)->i_mutex); 214 214 simple_release_fs(&mount, &mount_count); 215 215 } 216 216 EXPORT_SYMBOL_GPL(securityfs_remove);

+2 -2

security/integrity/evm/evm_crypto.c

reviewed

··· 131 131 size_t req_xattr_value_len, 132 132 char type, char *digest) 133 133 { 134 134 - struct inode *inode = dentry->d_inode; 134 134 + struct inode *inode = d_backing_inode(dentry); 135 135 struct shash_desc *desc; 136 136 char **xattrname; 137 137 size_t xattr_size = 0; ··· 199 199 int evm_update_evmxattr(struct dentry *dentry, const char *xattr_name, 200 200 const char *xattr_value, size_t xattr_value_len) 201 201 { 202 202 - struct inode *inode = dentry->d_inode; 202 202 + struct inode *inode = d_backing_inode(dentry); 203 203 struct evm_ima_xattr_data xattr_data; 204 204 int rc = 0; 205 205

+9 -9

security/integrity/evm/evm_main.c

reviewed

··· 72 72 73 73 static int evm_find_protected_xattrs(struct dentry *dentry) 74 74 { 75 75 - struct inode *inode = dentry->d_inode; 75 75 + struct inode *inode = d_backing_inode(dentry); 76 76 char **xattr; 77 77 int error; 78 78 int count = 0; ··· 165 165 /* Replace RSA with HMAC if not mounted readonly and 166 166 * not immutable 167 167 */ 168 168 - if (!IS_RDONLY(dentry->d_inode) && 169 169 - !IS_IMMUTABLE(dentry->d_inode)) 168 168 + if (!IS_RDONLY(d_backing_inode(dentry)) && 169 169 + !IS_IMMUTABLE(d_backing_inode(dentry))) 170 170 evm_update_evmxattr(dentry, xattr_name, 171 171 xattr_value, 172 172 xattr_value_len); ··· 235 235 return INTEGRITY_UNKNOWN; 236 236 237 237 if (!iint) { 238 238 - iint = integrity_iint_find(dentry->d_inode); 238 238 + iint = integrity_iint_find(d_backing_inode(dentry)); 239 239 if (!iint) 240 240 return INTEGRITY_UNKNOWN; 241 241 } ··· 253 253 */ 254 254 static enum integrity_status evm_verify_current_integrity(struct dentry *dentry) 255 255 { 256 256 - struct inode *inode = dentry->d_inode; 256 256 + struct inode *inode = d_backing_inode(dentry); 257 257 258 258 if (!evm_initialized || !S_ISREG(inode->i_mode) || evm_fixmode) 259 259 return 0; ··· 293 293 if (evm_status == INTEGRITY_NOXATTRS) { 294 294 struct integrity_iint_cache *iint; 295 295 296 296 - iint = integrity_iint_find(dentry->d_inode); 296 296 + iint = integrity_iint_find(d_backing_inode(dentry)); 297 297 if (iint && (iint->flags & IMA_NEW_FILE)) 298 298 return 0; 299 299 } 300 300 out: 301 301 if (evm_status != INTEGRITY_PASS) 302 302 - integrity_audit_msg(AUDIT_INTEGRITY_METADATA, dentry->d_inode, 302 302 + integrity_audit_msg(AUDIT_INTEGRITY_METADATA, d_backing_inode(dentry), 303 303 dentry->d_name.name, "appraise_metadata", 304 304 integrity_status_msg[evm_status], 305 305 -EPERM, 0); ··· 379 379 */ 380 380 void evm_inode_post_removexattr(struct dentry *dentry, const char *xattr_name) 381 381 { 382 382 - struct inode *inode = dentry->d_inode; 382 382 + struct inode *inode = d_backing_inode(dentry); 383 383 384 384 if (!evm_initialized || !evm_protected_xattr(xattr_name)) 385 385 return; ··· 404 404 if ((evm_status == INTEGRITY_PASS) || 405 405 (evm_status == INTEGRITY_NOXATTRS)) 406 406 return 0; 407 407 - integrity_audit_msg(AUDIT_INTEGRITY_METADATA, dentry->d_inode, 407 407 + integrity_audit_msg(AUDIT_INTEGRITY_METADATA, d_backing_inode(dentry), 408 408 dentry->d_name.name, "appraise_metadata", 409 409 integrity_status_msg[evm_status], -EPERM, 0); 410 410 return -EPERM;

+5 -5

security/integrity/ima/ima_appraise.c

reviewed

··· 165 165 int ima_read_xattr(struct dentry *dentry, 166 166 struct evm_ima_xattr_data **xattr_value) 167 167 { 168 168 - struct inode *inode = dentry->d_inode; 168 168 + struct inode *inode = d_backing_inode(dentry); 169 169 170 170 if (!inode->i_op->getxattr) 171 171 return 0; ··· 190 190 static const char op[] = "appraise_data"; 191 191 char *cause = "unknown"; 192 192 struct dentry *dentry = file->f_path.dentry; 193 193 - struct inode *inode = dentry->d_inode; 193 193 + struct inode *inode = d_backing_inode(dentry); 194 194 enum integrity_status status = INTEGRITY_UNKNOWN; 195 195 int rc = xattr_len, hash_start = 0; 196 196 ··· 314 314 */ 315 315 void ima_inode_post_setattr(struct dentry *dentry) 316 316 { 317 317 - struct inode *inode = dentry->d_inode; 317 317 + struct inode *inode = d_backing_inode(dentry); 318 318 struct integrity_iint_cache *iint; 319 319 int must_appraise, rc; 320 320 ··· 380 380 if (result == 1) { 381 381 if (!xattr_value_len || (xvalue->type >= IMA_XATTR_LAST)) 382 382 return -EINVAL; 383 383 - ima_reset_appraise_flags(dentry->d_inode, 383 383 + ima_reset_appraise_flags(d_backing_inode(dentry), 384 384 (xvalue->type == EVM_IMA_XATTR_DIGSIG) ? 1 : 0); 385 385 result = 0; 386 386 } ··· 393 393 394 394 result = ima_protect_xattr(dentry, xattr_name, NULL, 0); 395 395 if (result == 1) { 396 396 - ima_reset_appraise_flags(dentry->d_inode, 0); 396 396 + ima_reset_appraise_flags(d_backing_inode(dentry), 0); 397 397 result = 0; 398 398 } 399 399 return result;

+2 -2

security/lsm_audit.c

reviewed

··· 237 237 238 238 audit_log_d_path(ab, " path=", &a->u.path); 239 239 240 240 - inode = a->u.path.dentry->d_inode; 240 240 + inode = d_backing_inode(a->u.path.dentry); 241 241 if (inode) { 242 242 audit_log_format(ab, " dev="); 243 243 audit_log_untrustedstring(ab, inode->i_sb->s_id); ··· 251 251 audit_log_format(ab, " name="); 252 252 audit_log_untrustedstring(ab, a->u.dentry->d_name.name); 253 253 254 254 - inode = a->u.dentry->d_inode; 254 254 + inode = d_backing_inode(a->u.dentry); 255 255 if (inode) { 256 256 audit_log_format(ab, " dev="); 257 257 audit_log_untrustedstring(ab, inode->i_sb->s_id);

+25 -25

security/security.c

reviewed

··· 410 410 int security_path_mknod(struct path *dir, struct dentry *dentry, umode_t mode, 411 411 unsigned int dev) 412 412 { 413 413 - if (unlikely(IS_PRIVATE(dir->dentry->d_inode))) 413 413 + if (unlikely(IS_PRIVATE(d_backing_inode(dir->dentry)))) 414 414 return 0; 415 415 return security_ops->path_mknod(dir, dentry, mode, dev); 416 416 } ··· 418 418 419 419 int security_path_mkdir(struct path *dir, struct dentry *dentry, umode_t mode) 420 420 { 421 421 - if (unlikely(IS_PRIVATE(dir->dentry->d_inode))) 421 421 + if (unlikely(IS_PRIVATE(d_backing_inode(dir->dentry)))) 422 422 return 0; 423 423 return security_ops->path_mkdir(dir, dentry, mode); 424 424 } ··· 426 426 427 427 int security_path_rmdir(struct path *dir, struct dentry *dentry) 428 428 { 429 429 - if (unlikely(IS_PRIVATE(dir->dentry->d_inode))) 429 429 + if (unlikely(IS_PRIVATE(d_backing_inode(dir->dentry)))) 430 430 return 0; 431 431 return security_ops->path_rmdir(dir, dentry); 432 432 } 433 433 434 434 int security_path_unlink(struct path *dir, struct dentry *dentry) 435 435 { 436 436 - if (unlikely(IS_PRIVATE(dir->dentry->d_inode))) 436 436 + if (unlikely(IS_PRIVATE(d_backing_inode(dir->dentry)))) 437 437 return 0; 438 438 return security_ops->path_unlink(dir, dentry); 439 439 } ··· 442 442 int security_path_symlink(struct path *dir, struct dentry *dentry, 443 443 const char *old_name) 444 444 { 445 445 - if (unlikely(IS_PRIVATE(dir->dentry->d_inode))) 445 445 + if (unlikely(IS_PRIVATE(d_backing_inode(dir->dentry)))) 446 446 return 0; 447 447 return security_ops->path_symlink(dir, dentry, old_name); 448 448 } ··· 450 450 int security_path_link(struct dentry *old_dentry, struct path *new_dir, 451 451 struct dentry *new_dentry) 452 452 { 453 453 - if (unlikely(IS_PRIVATE(old_dentry->d_inode))) 453 453 + if (unlikely(IS_PRIVATE(d_backing_inode(old_dentry)))) 454 454 return 0; 455 455 return security_ops->path_link(old_dentry, new_dir, new_dentry); 456 456 } ··· 459 459 struct path *new_dir, struct dentry *new_dentry, 460 460 unsigned int flags) 461 461 { 462 462 - if (unlikely(IS_PRIVATE(old_dentry->d_inode) || 463 463 - (new_dentry->d_inode && IS_PRIVATE(new_dentry->d_inode)))) 462 462 + if (unlikely(IS_PRIVATE(d_backing_inode(old_dentry)) || 463 463 + (d_is_positive(new_dentry) && IS_PRIVATE(d_backing_inode(new_dentry))))) 464 464 return 0; 465 465 466 466 if (flags & RENAME_EXCHANGE) { ··· 477 477 478 478 int security_path_truncate(struct path *path) 479 479 { 480 480 - if (unlikely(IS_PRIVATE(path->dentry->d_inode))) 480 480 + if (unlikely(IS_PRIVATE(d_backing_inode(path->dentry)))) 481 481 return 0; 482 482 return security_ops->path_truncate(path); 483 483 } 484 484 485 485 int security_path_chmod(struct path *path, umode_t mode) 486 486 { 487 487 - if (unlikely(IS_PRIVATE(path->dentry->d_inode))) 487 487 + if (unlikely(IS_PRIVATE(d_backing_inode(path->dentry)))) 488 488 return 0; 489 489 return security_ops->path_chmod(path, mode); 490 490 } 491 491 492 492 int security_path_chown(struct path *path, kuid_t uid, kgid_t gid) 493 493 { 494 494 - if (unlikely(IS_PRIVATE(path->dentry->d_inode))) 494 494 + if (unlikely(IS_PRIVATE(d_backing_inode(path->dentry)))) 495 495 return 0; 496 496 return security_ops->path_chown(path, uid, gid); 497 497 } ··· 513 513 int security_inode_link(struct dentry *old_dentry, struct inode *dir, 514 514 struct dentry *new_dentry) 515 515 { 516 516 - if (unlikely(IS_PRIVATE(old_dentry->d_inode))) 516 516 + if (unlikely(IS_PRIVATE(d_backing_inode(old_dentry)))) 517 517 return 0; 518 518 return security_ops->inode_link(old_dentry, dir, new_dentry); 519 519 } 520 520 521 521 int security_inode_unlink(struct inode *dir, struct dentry *dentry) 522 522 { 523 523 - if (unlikely(IS_PRIVATE(dentry->d_inode))) 523 523 + if (unlikely(IS_PRIVATE(d_backing_inode(dentry)))) 524 524 return 0; 525 525 return security_ops->inode_unlink(dir, dentry); 526 526 } ··· 543 543 544 544 int security_inode_rmdir(struct inode *dir, struct dentry *dentry) 545 545 { 546 546 - if (unlikely(IS_PRIVATE(dentry->d_inode))) 546 546 + if (unlikely(IS_PRIVATE(d_backing_inode(dentry)))) 547 547 return 0; 548 548 return security_ops->inode_rmdir(dir, dentry); 549 549 } ··· 559 559 struct inode *new_dir, struct dentry *new_dentry, 560 560 unsigned int flags) 561 561 { 562 562 - if (unlikely(IS_PRIVATE(old_dentry->d_inode) || 563 563 - (new_dentry->d_inode && IS_PRIVATE(new_dentry->d_inode)))) 562 562 + if (unlikely(IS_PRIVATE(d_backing_inode(old_dentry)) || 563 563 + (d_is_positive(new_dentry) && IS_PRIVATE(d_backing_inode(new_dentry))))) 564 564 return 0; 565 565 566 566 if (flags & RENAME_EXCHANGE) { ··· 576 576 577 577 int security_inode_readlink(struct dentry *dentry) 578 578 { 579 579 - if (unlikely(IS_PRIVATE(dentry->d_inode))) 579 579 + if (unlikely(IS_PRIVATE(d_backing_inode(dentry)))) 580 580 return 0; 581 581 return security_ops->inode_readlink(dentry); 582 582 } 583 583 584 584 int security_inode_follow_link(struct dentry *dentry, struct nameidata *nd) 585 585 { 586 586 - if (unlikely(IS_PRIVATE(dentry->d_inode))) 586 586 + if (unlikely(IS_PRIVATE(d_backing_inode(dentry)))) 587 587 return 0; 588 588 return security_ops->inode_follow_link(dentry, nd); 589 589 } ··· 599 599 { 600 600 int ret; 601 601 602 602 - if (unlikely(IS_PRIVATE(dentry->d_inode))) 602 602 + if (unlikely(IS_PRIVATE(d_backing_inode(dentry)))) 603 603 return 0; 604 604 ret = security_ops->inode_setattr(dentry, attr); 605 605 if (ret) ··· 610 610 611 611 int security_inode_getattr(const struct path *path) 612 612 { 613 613 - if (unlikely(IS_PRIVATE(path->dentry->d_inode))) 613 613 + if (unlikely(IS_PRIVATE(d_backing_inode(path->dentry)))) 614 614 return 0; 615 615 return security_ops->inode_getattr(path); 616 616 } ··· 620 620 { 621 621 int ret; 622 622 623 623 - if (unlikely(IS_PRIVATE(dentry->d_inode))) 623 623 + if (unlikely(IS_PRIVATE(d_backing_inode(dentry)))) 624 624 return 0; 625 625 ret = security_ops->inode_setxattr(dentry, name, value, size, flags); 626 626 if (ret) ··· 634 634 void security_inode_post_setxattr(struct dentry *dentry, const char *name, 635 635 const void *value, size_t size, int flags) 636 636 { 637 637 - if (unlikely(IS_PRIVATE(dentry->d_inode))) 637 637 + if (unlikely(IS_PRIVATE(d_backing_inode(dentry)))) 638 638 return; 639 639 security_ops->inode_post_setxattr(dentry, name, value, size, flags); 640 640 evm_inode_post_setxattr(dentry, name, value, size); ··· 642 642 643 643 int security_inode_getxattr(struct dentry *dentry, const char *name) 644 644 { 645 645 - if (unlikely(IS_PRIVATE(dentry->d_inode))) 645 645 + if (unlikely(IS_PRIVATE(d_backing_inode(dentry)))) 646 646 return 0; 647 647 return security_ops->inode_getxattr(dentry, name); 648 648 } 649 649 650 650 int security_inode_listxattr(struct dentry *dentry) 651 651 { 652 652 - if (unlikely(IS_PRIVATE(dentry->d_inode))) 652 652 + if (unlikely(IS_PRIVATE(d_backing_inode(dentry)))) 653 653 return 0; 654 654 return security_ops->inode_listxattr(dentry); 655 655 } ··· 658 658 { 659 659 int ret; 660 660 661 661 - if (unlikely(IS_PRIVATE(dentry->d_inode))) 661 661 + if (unlikely(IS_PRIVATE(d_backing_inode(dentry)))) 662 662 return 0; 663 663 ret = security_ops->inode_removexattr(dentry, name); 664 664 if (ret)

+18 -18

security/selinux/hooks.c

reviewed

··· 414 414 { 415 415 struct superblock_security_struct *sbsec = sb->s_security; 416 416 struct dentry *root = sb->s_root; 417 417 - struct inode *root_inode = root->d_inode; 417 417 + struct inode *root_inode = d_backing_inode(root); 418 418 int rc = 0; 419 419 420 420 if (sbsec->behavior == SECURITY_FS_USE_XATTR) { ··· 552 552 opts->mnt_opts_flags[i++] = DEFCONTEXT_MNT; 553 553 } 554 554 if (sbsec->flags & ROOTCONTEXT_MNT) { 555 555 - struct inode *root = sbsec->sb->s_root->d_inode; 555 555 + struct inode *root = d_backing_inode(sbsec->sb->s_root); 556 556 struct inode_security_struct *isec = root->i_security; 557 557 558 558 rc = security_sid_to_context(isec->sid, &context, &len); ··· 608 608 int rc = 0, i; 609 609 struct superblock_security_struct *sbsec = sb->s_security; 610 610 const char *name = sb->s_type->name; 611 611 - struct inode *inode = sbsec->sb->s_root->d_inode; 611 611 + struct inode *inode = d_backing_inode(sbsec->sb->s_root); 612 612 struct inode_security_struct *root_isec = inode->i_security; 613 613 u32 fscontext_sid = 0, context_sid = 0, rootcontext_sid = 0; 614 614 u32 defcontext_sid = 0; ··· 835 835 if ((oldflags & DEFCONTEXT_MNT) && old->def_sid != new->def_sid) 836 836 goto mismatch; 837 837 if (oldflags & ROOTCONTEXT_MNT) { 838 838 - struct inode_security_struct *oldroot = oldsb->s_root->d_inode->i_security; 839 839 - struct inode_security_struct *newroot = newsb->s_root->d_inode->i_security; 838 838 + struct inode_security_struct *oldroot = d_backing_inode(oldsb->s_root)->i_security; 839 839 + struct inode_security_struct *newroot = d_backing_inode(newsb->s_root)->i_security; 840 840 if (oldroot->sid != newroot->sid) 841 841 goto mismatch; 842 842 } ··· 886 886 if (!set_fscontext) 887 887 newsbsec->sid = sid; 888 888 if (!set_rootcontext) { 889 889 - struct inode *newinode = newsb->s_root->d_inode; 889 889 + struct inode *newinode = d_backing_inode(newsb->s_root); 890 890 struct inode_security_struct *newisec = newinode->i_security; 891 891 newisec->sid = sid; 892 892 } 893 893 newsbsec->mntpoint_sid = sid; 894 894 } 895 895 if (set_rootcontext) { 896 896 - const struct inode *oldinode = oldsb->s_root->d_inode; 896 896 + const struct inode *oldinode = d_backing_inode(oldsb->s_root); 897 897 const struct inode_security_struct *oldisec = oldinode->i_security; 898 898 - struct inode *newinode = newsb->s_root->d_inode; 898 898 + struct inode *newinode = d_backing_inode(newsb->s_root); 899 899 struct inode_security_struct *newisec = newinode->i_security; 900 900 901 901 newisec->sid = oldisec->sid; ··· 1610 1610 struct dentry *dentry, 1611 1611 u32 av) 1612 1612 { 1613 1613 - struct inode *inode = dentry->d_inode; 1613 1613 + struct inode *inode = d_backing_inode(dentry); 1614 1614 struct common_audit_data ad; 1615 1615 1616 1616 ad.type = LSM_AUDIT_DATA_DENTRY; ··· 1625 1625 const struct path *path, 1626 1626 u32 av) 1627 1627 { 1628 1628 - struct inode *inode = path->dentry->d_inode; 1628 1628 + struct inode *inode = d_backing_inode(path->dentry); 1629 1629 struct common_audit_data ad; 1630 1630 1631 1631 ad.type = LSM_AUDIT_DATA_PATH; ··· 1753 1753 int rc; 1754 1754 1755 1755 dsec = dir->i_security; 1756 1756 - isec = dentry->d_inode->i_security; 1756 1756 + isec = d_backing_inode(dentry)->i_security; 1757 1757 1758 1758 ad.type = LSM_AUDIT_DATA_DENTRY; 1759 1759 ad.u.dentry = dentry; ··· 1797 1797 int rc; 1798 1798 1799 1799 old_dsec = old_dir->i_security; 1800 1800 - old_isec = old_dentry->d_inode->i_security; 1800 1800 + old_isec = d_backing_inode(old_dentry)->i_security; 1801 1801 old_is_dir = d_is_dir(old_dentry); 1802 1802 new_dsec = new_dir->i_security; 1803 1803 ··· 1827 1827 if (rc) 1828 1828 return rc; 1829 1829 if (d_is_positive(new_dentry)) { 1830 1830 - new_isec = new_dentry->d_inode->i_security; 1830 1830 + new_isec = d_backing_inode(new_dentry)->i_security; 1831 1831 new_is_dir = d_is_dir(new_dentry); 1832 1832 rc = avc_has_perm(sid, new_isec->sid, 1833 1833 new_isec->sclass, ··· 1963 1963 { 1964 1964 u32 sid = task_sid(to); 1965 1965 struct file_security_struct *fsec = file->f_security; 1966 1966 - struct inode *inode = file->f_path.dentry->d_inode; 1966 1966 + struct inode *inode = d_backing_inode(file->f_path.dentry); 1967 1967 struct inode_security_struct *isec = inode->i_security; 1968 1968 struct common_audit_data ad; 1969 1969 int rc; ··· 2627 2627 break; 2628 2628 case ROOTCONTEXT_MNT: { 2629 2629 struct inode_security_struct *root_isec; 2630 2630 - root_isec = sb->s_root->d_inode->i_security; 2630 2630 + root_isec = d_backing_inode(sb->s_root)->i_security; 2631 2631 2632 2632 if (bad_option(sbsec, ROOTCONTEXT_MNT, root_isec->sid, sid)) 2633 2633 goto out_bad_option; ··· 2727 2727 struct task_security_struct *tsec; 2728 2728 struct inode_security_struct *dsec; 2729 2729 struct superblock_security_struct *sbsec; 2730 2730 - struct inode *dir = dentry->d_parent->d_inode; 2730 2730 + struct inode *dir = d_backing_inode(dentry->d_parent); 2731 2731 u32 newsid; 2732 2732 int rc; 2733 2733 ··· 2982 2982 static int selinux_inode_setxattr(struct dentry *dentry, const char *name, 2983 2983 const void *value, size_t size, int flags) 2984 2984 { 2985 2985 - struct inode *inode = dentry->d_inode; 2985 2985 + struct inode *inode = d_backing_inode(dentry); 2986 2986 struct inode_security_struct *isec = inode->i_security; 2987 2987 struct superblock_security_struct *sbsec; 2988 2988 struct common_audit_data ad; ··· 3059 3059 const void *value, size_t size, 3060 3060 int flags) 3061 3061 { 3062 3062 - struct inode *inode = dentry->d_inode; 3062 3062 + struct inode *inode = d_backing_inode(dentry); 3063 3063 struct inode_security_struct *isec = inode->i_security; 3064 3064 u32 newsid; 3065 3065 int rc;

+1 -1

security/selinux/selinuxfs.c

reviewed

··· 1737 1737 inc_nlink(inode); 1738 1738 d_add(dentry, inode); 1739 1739 /* bump link count on parent directory, too */ 1740 1740 - inc_nlink(dir->d_inode); 1740 1740 + inc_nlink(d_inode(dir)); 1741 1741 1742 1742 return dentry; 1743 1743 }

+23 -23

security/smack/smack_lsm.c

reviewed

··· 593 593 static int smack_sb_kern_mount(struct super_block *sb, int flags, void *data) 594 594 { 595 595 struct dentry *root = sb->s_root; 596 596 - struct inode *inode = root->d_inode; 596 596 + struct inode *inode = d_backing_inode(root); 597 597 struct superblock_smack *sp = sb->s_security; 598 598 struct inode_smack *isp; 599 599 struct smack_known *skp; ··· 889 889 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY); 890 890 smk_ad_setfield_u_fs_path_dentry(&ad, old_dentry); 891 891 892 892 - isp = smk_of_inode(old_dentry->d_inode); 892 892 + isp = smk_of_inode(d_backing_inode(old_dentry)); 893 893 rc = smk_curacc(isp, MAY_WRITE, &ad); 894 894 - rc = smk_bu_inode(old_dentry->d_inode, MAY_WRITE, rc); 894 894 + rc = smk_bu_inode(d_backing_inode(old_dentry), MAY_WRITE, rc); 895 895 896 896 if (rc == 0 && d_is_positive(new_dentry)) { 897 897 - isp = smk_of_inode(new_dentry->d_inode); 897 897 + isp = smk_of_inode(d_backing_inode(new_dentry)); 898 898 smk_ad_setfield_u_fs_path_dentry(&ad, new_dentry); 899 899 rc = smk_curacc(isp, MAY_WRITE, &ad); 900 900 - rc = smk_bu_inode(new_dentry->d_inode, MAY_WRITE, rc); 900 900 + rc = smk_bu_inode(d_backing_inode(new_dentry), MAY_WRITE, rc); 901 901 } 902 902 903 903 return rc; ··· 913 913 */ 914 914 static int smack_inode_unlink(struct inode *dir, struct dentry *dentry) 915 915 { 916 916 - struct inode *ip = dentry->d_inode; 916 916 + struct inode *ip = d_backing_inode(dentry); 917 917 struct smk_audit_info ad; 918 918 int rc; 919 919 ··· 956 956 /* 957 957 * You need write access to the thing you're removing 958 958 */ 959 959 - rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE, &ad); 960 960 - rc = smk_bu_inode(dentry->d_inode, MAY_WRITE, rc); 959 959 + rc = smk_curacc(smk_of_inode(d_backing_inode(dentry)), MAY_WRITE, &ad); 960 960 + rc = smk_bu_inode(d_backing_inode(dentry), MAY_WRITE, rc); 961 961 if (rc == 0) { 962 962 /* 963 963 * You also need write access to the containing directory ··· 995 995 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY); 996 996 smk_ad_setfield_u_fs_path_dentry(&ad, old_dentry); 997 997 998 998 - isp = smk_of_inode(old_dentry->d_inode); 998 998 + isp = smk_of_inode(d_backing_inode(old_dentry)); 999 999 rc = smk_curacc(isp, MAY_READWRITE, &ad); 1000 1000 - rc = smk_bu_inode(old_dentry->d_inode, MAY_READWRITE, rc); 1000 1000 + rc = smk_bu_inode(d_backing_inode(old_dentry), MAY_READWRITE, rc); 1001 1001 1002 1002 if (rc == 0 && d_is_positive(new_dentry)) { 1003 1003 - isp = smk_of_inode(new_dentry->d_inode); 1003 1003 + isp = smk_of_inode(d_backing_inode(new_dentry)); 1004 1004 smk_ad_setfield_u_fs_path_dentry(&ad, new_dentry); 1005 1005 rc = smk_curacc(isp, MAY_READWRITE, &ad); 1006 1006 - rc = smk_bu_inode(new_dentry->d_inode, MAY_READWRITE, rc); 1006 1006 + rc = smk_bu_inode(d_backing_inode(new_dentry), MAY_READWRITE, rc); 1007 1007 } 1008 1008 return rc; 1009 1009 } ··· 1060 1060 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY); 1061 1061 smk_ad_setfield_u_fs_path_dentry(&ad, dentry); 1062 1062 1063 1063 - rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE, &ad); 1064 1064 - rc = smk_bu_inode(dentry->d_inode, MAY_WRITE, rc); 1063 1063 + rc = smk_curacc(smk_of_inode(d_backing_inode(dentry)), MAY_WRITE, &ad); 1064 1064 + rc = smk_bu_inode(d_backing_inode(dentry), MAY_WRITE, rc); 1065 1065 return rc; 1066 1066 } 1067 1067 ··· 1075 1075 static int smack_inode_getattr(const struct path *path) 1076 1076 { 1077 1077 struct smk_audit_info ad; 1078 1078 - struct inode *inode = path->dentry->d_inode; 1078 1078 + struct inode *inode = d_backing_inode(path->dentry); 1079 1079 int rc; 1080 1080 1081 1081 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_PATH); ··· 1142 1142 smk_ad_setfield_u_fs_path_dentry(&ad, dentry); 1143 1143 1144 1144 if (rc == 0) { 1145 1145 - rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE, &ad); 1146 1146 - rc = smk_bu_inode(dentry->d_inode, MAY_WRITE, rc); 1145 1145 + rc = smk_curacc(smk_of_inode(d_backing_inode(dentry)), MAY_WRITE, &ad); 1146 1146 + rc = smk_bu_inode(d_backing_inode(dentry), MAY_WRITE, rc); 1147 1147 } 1148 1148 1149 1149 return rc; ··· 1164 1164 const void *value, size_t size, int flags) 1165 1165 { 1166 1166 struct smack_known *skp; 1167 1167 - struct inode_smack *isp = dentry->d_inode->i_security; 1167 1167 + struct inode_smack *isp = d_backing_inode(dentry)->i_security; 1168 1168 1169 1169 if (strcmp(name, XATTR_NAME_SMACKTRANSMUTE) == 0) { 1170 1170 isp->smk_flags |= SMK_INODE_TRANSMUTE; ··· 1209 1209 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY); 1210 1210 smk_ad_setfield_u_fs_path_dentry(&ad, dentry); 1211 1211 1212 1212 - rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_READ, &ad); 1213 1213 - rc = smk_bu_inode(dentry->d_inode, MAY_READ, rc); 1212 1212 + rc = smk_curacc(smk_of_inode(d_backing_inode(dentry)), MAY_READ, &ad); 1213 1213 + rc = smk_bu_inode(d_backing_inode(dentry), MAY_READ, rc); 1214 1214 return rc; 1215 1215 } 1216 1216 ··· 1246 1246 smk_ad_init(&ad, __func__, LSM_AUDIT_DATA_DENTRY); 1247 1247 smk_ad_setfield_u_fs_path_dentry(&ad, dentry); 1248 1248 1249 1249 - rc = smk_curacc(smk_of_inode(dentry->d_inode), MAY_WRITE, &ad); 1250 1250 - rc = smk_bu_inode(dentry->d_inode, MAY_WRITE, rc); 1249 1249 + rc = smk_curacc(smk_of_inode(d_backing_inode(dentry)), MAY_WRITE, &ad); 1250 1250 + rc = smk_bu_inode(d_backing_inode(dentry), MAY_WRITE, rc); 1251 1251 if (rc != 0) 1252 1252 return rc; 1253 1253 1254 1254 - isp = dentry->d_inode->i_security; 1254 1254 + isp = d_backing_inode(dentry)->i_security; 1255 1255 /* 1256 1256 * Don't do anything special for these. 1257 1257 * XATTR_NAME_SMACKIPIN

+1 -1

security/smack/smackfs.c

reviewed

··· 2490 2490 return rc; 2491 2491 } 2492 2492 2493 2493 - root_inode = sb->s_root->d_inode; 2493 2493 + root_inode = d_inode(sb->s_root); 2494 2494 2495 2495 return 0; 2496 2496 }

+1 -1

security/tomoyo/condition.c

reviewed

··· 714 714 dentry = dget_parent(dentry); 715 715 break; 716 716 } 717 717 - inode = dentry->d_inode; 717 717 + inode = d_backing_inode(dentry); 718 718 if (inode) { 719 719 struct tomoyo_mini_stat *stat = &obj->stat[i]; 720 720 stat->uid = inode->i_uid;

+5 -5

security/tomoyo/realpath.c

reviewed

··· 97 97 /* go to whatever namespace root we are under */ 98 98 pos = d_absolute_path(path, buffer, buflen - 1); 99 99 if (!IS_ERR(pos) && *pos == '/' && pos[1]) { 100 100 - struct inode *inode = path->dentry->d_inode; 100 100 + struct inode *inode = d_backing_inode(path->dentry); 101 101 if (inode && S_ISDIR(inode->i_mode)) { 102 102 buffer[buflen - 2] = '/'; 103 103 buffer[buflen - 1] = '\0'; ··· 125 125 if (buflen >= 256) { 126 126 pos = dentry_path_raw(dentry, buffer, buflen - 1); 127 127 if (!IS_ERR(pos) && *pos == '/' && pos[1]) { 128 128 - struct inode *inode = dentry->d_inode; 128 128 + struct inode *inode = d_backing_inode(dentry); 129 129 if (inode && S_ISDIR(inode->i_mode)) { 130 130 buffer[buflen - 2] = '/'; 131 131 buffer[buflen - 1] = '\0'; ··· 168 168 if (!MAJOR(sb->s_dev)) 169 169 goto prepend_filesystem_name; 170 170 { 171 171 - struct inode *inode = sb->s_root->d_inode; 171 171 + struct inode *inode = d_backing_inode(sb->s_root); 172 172 /* 173 173 * Use filesystem name if filesystem does not support rename() 174 174 * operation. ··· 219 219 static char *tomoyo_get_socket_name(const struct path *path, char * const buffer, 220 220 const int buflen) 221 221 { 222 222 - struct inode *inode = path->dentry->d_inode; 222 222 + struct inode *inode = d_backing_inode(path->dentry); 223 223 struct socket *sock = inode ? SOCKET_I(inode) : NULL; 224 224 struct sock *sk = sock ? sock->sk : NULL; 225 225 if (sk) { ··· 277 277 pos = dentry->d_op->d_dname(dentry, buf, buf_len - 1); 278 278 goto encode; 279 279 } 280 280 - inode = sb->s_root->d_inode; 280 280 + inode = d_backing_inode(sb->s_root); 281 281 /* 282 282 * Get local name for filesystems without rename() operation 283 283 * or dentry without vfsmount.