lustre/llite/namei.o: file format elf64-x86-64 Disassembly of section .text: 0000000000000000 : static int ll_test_inode(struct inode *inode, unsigned long ino, void *opaque) #else static int ll_test_inode(struct inode *inode, void *opaque) #endif { 0: 55 push %rbp 1: 48 89 fd mov %rdi,%rbp 4: 53 push %rbx 5: 48 89 f3 mov %rsi,%rbx 8: 48 83 ec 48 sub $0x48,%rsp static int last_ino, last_gen, last_count; struct lustre_md *md = opaque; if (!(md->body->valid & (OBD_MD_FLGENER | OBD_MD_FLID))) { c: 48 8b 16 mov (%rsi),%rdx f: 48 f7 42 28 01 40 00 testq $0x4001,0x28(%rdx) 16: 00 17: 75 4d jne 66 CERROR("MDS body missing inum or generation\n"); 19: ba 00 00 02 00 mov $0x20000,%edx 1e: 41 b9 33 00 00 00 mov $0x33,%r9d 24: 49 c7 c0 00 00 00 00 mov $0x0,%r8 2b: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 32: be 80 00 00 00 mov $0x80,%esi 37: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 3e: 31 c0 xor %eax,%eax 40: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 47: 00 00 49: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 50: 00 00 52: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 59: 00 5a: e8 00 00 00 00 callq 5f return 0; 5f: 31 d2 xor %edx,%edx 61: e9 91 01 00 00 jmpq 1f7 } if (last_ino == md->body->ino && last_gen == md->body->generation && 66: 8b 0d 00 00 00 00 mov 0(%rip),%ecx # 6c 6c: 48 63 c1 movslq %ecx,%rax 6f: 48 3b 42 60 cmp 0x60(%rdx),%rax 73: 75 2b jne a0 75: 8b 82 8c 00 00 00 mov 0x8c(%rdx),%eax 7b: 39 05 00 00 00 00 cmp %eax,0(%rip) # 81 81: 75 1d jne a0 83: 8b 05 00 00 00 00 mov 0(%rip),%eax # 89 89: 3d f3 01 00 00 cmp $0x1f3,%eax 8e: 7f 16 jg a6 last_count < 500) { last_count++; 90: ff c0 inc %eax 92: 89 05 00 00 00 00 mov %eax,0(%rip) # 98 98: e9 24 01 00 00 jmpq 1c1 9d: 66 data16 9e: 66 data16 9f: 90 nop a0: 8b 05 00 00 00 00 mov 0(%rip),%eax # a6 } else { if (last_count > 1) a6: 83 f8 01 cmp $0x1,%eax a9: 7e 6a jle 115 CDEBUG(D_VFSTRACE, "compared %u/%u %u times\n", ab: 8b 15 00 00 00 00 mov 0(%rip),%edx # b1 b1: f7 c2 00 00 20 00 test $0x200000,%edx b7: 74 62 je 11b b9: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # c0 c0: 79 59 jns 11b c2: 89 44 24 28 mov %eax,0x28(%rsp) c6: 8b 05 00 00 00 00 mov 0(%rip),%eax # cc cc: 41 b9 3d 00 00 00 mov $0x3d,%r9d d2: 89 4c 24 18 mov %ecx,0x18(%rsp) d6: 49 c7 c0 00 00 00 00 mov $0x0,%r8 dd: 48 c7 c1 00 00 00 00 mov $0x0,%rcx e4: ba 00 00 20 00 mov $0x200000,%edx e9: be 80 00 00 00 mov $0x80,%esi ee: 31 ff xor %edi,%edi f0: 89 44 24 20 mov %eax,0x20(%rsp) f4: 31 c0 xor %eax,%eax f6: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) fd: 00 00 ff: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 106: 00 00 108: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 10f: 00 110: e8 00 00 00 00 callq 115 115: 8b 15 00 00 00 00 mov 0(%rip),%edx # 11b last_ino, last_gen, last_count); last_count = 0; 11b: c7 05 00 00 00 00 00 movl $0x0,0(%rip) # 125 122: 00 00 00 last_ino = md->body->ino; 125: 48 8b 03 mov (%rbx),%rax last_gen = md->body->generation; CDEBUG(D_VFSTRACE, 128: 81 e2 00 00 20 00 and $0x200000,%edx 12e: 48 8b 40 60 mov 0x60(%rax),%rax 132: 89 05 00 00 00 00 mov %eax,0(%rip) # 138 138: 48 8b 03 mov (%rbx),%rax 13b: 8b 80 8c 00 00 00 mov 0x8c(%rax),%eax 141: 89 05 00 00 00 00 mov %eax,0(%rip) # 147 147: 74 78 je 1c1 149: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 150 150: 79 6f jns 1c1 152: 48 8b 13 mov (%rbx),%rdx 155: 41 b9 44 00 00 00 mov $0x44,%r9d 15b: 49 c7 c0 00 00 00 00 mov $0x0,%r8 162: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 169: be 80 00 00 00 mov $0x80,%esi 16e: 31 ff xor %edi,%edi 170: 8b 82 8c 00 00 00 mov 0x8c(%rdx),%eax 176: 89 44 24 38 mov %eax,0x38(%rsp) 17a: 48 8b 42 60 mov 0x60(%rdx),%rax 17e: ba 00 00 20 00 mov $0x200000,%edx 183: 48 89 44 24 30 mov %rax,0x30(%rsp) 188: 8b 85 fc 01 00 00 mov 0x1fc(%rbp),%eax 18e: 89 44 24 28 mov %eax,0x28(%rsp) 192: 48 8b 45 30 mov 0x30(%rbp),%rax 196: 48 89 6c 24 18 mov %rbp,0x18(%rsp) 19b: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 1a2: 00 00 1a4: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 1ab: 00 00 1ad: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 1b4: 00 1b5: 48 89 44 24 20 mov %rax,0x20(%rsp) 1ba: 31 c0 xor %eax,%eax 1bc: e8 00 00 00 00 callq 1c1 "comparing inode %p ino %lu/%u to body "LPU64"/%u\n", inode, inode->i_ino, inode->i_generation, md->body->ino, md->body->generation); } #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) if (inode->i_ino != md->body->ino) 1c1: 48 8b 03 mov (%rbx),%rax return 0; 1c4: 31 d2 xor %edx,%edx 1c6: 48 8b 48 60 mov 0x60(%rax),%rcx 1ca: 48 39 4d 30 cmp %rcx,0x30(%rbp) 1ce: 75 27 jne 1f7 #endif if (inode->i_generation != md->body->generation) { 1d0: 8b 80 8c 00 00 00 mov 0x8c(%rax),%eax 1d6: 39 85 fc 01 00 00 cmp %eax,0x1fc(%rbp) 1dc: 75 19 jne 1f7 #ifdef HAVE_EXPORT___IGET if (inode->i_state & (I_FREEING | I_CLEAR)) return 0; if (inode->i_nlink == 0) return 0; /* add "duplicate" inode into deathrow for destroy */ spin_lock(&ll_i2sbi(inode)->ll_deathrow_lock); if (list_empty(&ll_i2info(inode)->lli_dead_list)) { __iget(inode); list_add(&ll_i2info(inode)->lli_dead_list, &ll_i2sbi(inode)->ll_deathrow); } spin_unlock(&ll_i2sbi(inode)->ll_deathrow_lock); #endif return 0; } /* Apply the attributes in 'opaque' to this inode */ if (!(inode->i_state & (I_FREEING | I_CLEAR))) 1de: f6 85 10 02 00 00 30 testb $0x30,0x210(%rbp) 1e5: 75 0b jne 1f2 ll_update_inode(inode, md); 1e7: 48 89 de mov %rbx,%rsi 1ea: 48 89 ef mov %rbp,%rdi 1ed: e8 00 00 00 00 callq 1f2 return 1; 1f2: ba 01 00 00 00 mov $0x1,%edx } 1f7: 48 83 c4 48 add $0x48,%rsp 1fb: 89 d0 mov %edx,%eax 1fd: 5b pop %rbx 1fe: 5d pop %rbp 1ff: c3 retq 0000000000000200 : extern struct dentry_operations ll_d_ops; int ll_unlock(__u32 mode, struct lustre_handle *lockh) { 200: 48 83 ec 48 sub $0x48,%rsp ENTRY; 204: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 20b 20b: 48 89 5c 24 38 mov %rbx,0x38(%rsp) 210: 48 89 6c 24 40 mov %rbp,0x40(%rsp) 215: 89 fb mov %edi,%ebx 217: 48 89 f5 mov %rsi,%rbp 21a: 74 4a je 266 21c: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 223 223: 79 41 jns 266 225: 41 b9 69 00 00 00 mov $0x69,%r9d 22b: 49 c7 c0 00 00 00 00 mov $0x0,%r8 232: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 239: ba 01 00 00 00 mov $0x1,%edx 23e: be 80 00 00 00 mov $0x80,%esi 243: 31 ff xor %edi,%edi 245: 31 c0 xor %eax,%eax 247: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 24e: 00 00 250: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 257: 00 00 259: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 260: 00 261: e8 00 00 00 00 callq 266 ldlm_lock_decref(lockh, mode); 266: 89 de mov %ebx,%esi 268: 48 89 ef mov %rbp,%rdi 26b: e8 00 00 00 00 callq 270 RETURN(0); 270: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 277 277: 74 67 je 2e0 279: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 280 280: 79 5e jns 2e0 282: 41 b9 6d 00 00 00 mov $0x6d,%r9d 288: 49 c7 c0 00 00 00 00 mov $0x0,%r8 28f: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 296: ba 01 00 00 00 mov $0x1,%edx 29b: be 80 00 00 00 mov $0x80,%esi 2a0: 31 ff xor %edi,%edi 2a2: 31 c0 xor %eax,%eax 2a4: 48 c7 44 24 28 00 00 movq $0x0,0x28(%rsp) 2ab: 00 00 2ad: 48 c7 44 24 20 00 00 movq $0x0,0x20(%rsp) 2b4: 00 00 2b6: 48 c7 44 24 18 00 00 movq $0x0,0x18(%rsp) 2bd: 00 00 2bf: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 2c6: 00 00 2c8: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 2cf: 00 00 2d1: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 2d8: 00 2d9: e8 00 00 00 00 callq 2de 2de: 66 data16 2df: 90 nop } 2e0: 48 8b 5c 24 38 mov 0x38(%rsp),%rbx 2e5: 48 8b 6c 24 40 mov 0x40(%rsp),%rbp 2ea: 31 c0 xor %eax,%eax 2ec: 48 83 c4 48 add $0x48,%rsp 2f0: c3 retq 2f1: 66 data16 2f2: 66 data16 2f3: 66 data16 2f4: 90 nop 2f5: 66 data16 2f6: 66 data16 2f7: 66 data16 2f8: 90 nop 2f9: 66 data16 2fa: 66 data16 2fb: 66 data16 2fc: 90 nop 2fd: 66 data16 2fe: 66 data16 2ff: 90 nop 0000000000000300 : /* Get an inode by inode number (already instantiated by the intent lookup). * Returns inode or NULL */ #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)) int ll_set_inode(struct inode *inode, void *opaque) { 300: 48 83 ec 08 sub $0x8,%rsp ll_read_inode2(inode, opaque); 304: e8 00 00 00 00 callq 309 return 0; } 309: 31 c0 xor %eax,%eax 30b: 48 83 c4 08 add $0x8,%rsp 30f: c3 retq 0000000000000310 : struct inode *ll_iget(struct super_block *sb, ino_t hash, struct lustre_md *md) { 310: 48 83 ec 48 sub $0x48,%rsp struct inode *inode; LASSERT(hash != 0); 314: 48 85 f6 test %rsi,%rsi 317: 48 89 5c 24 30 mov %rbx,0x30(%rsp) 31c: 48 89 6c 24 38 mov %rbp,0x38(%rsp) 321: 48 89 f3 mov %rsi,%rbx 324: 4c 89 64 24 40 mov %r12,0x40(%rsp) 329: 48 89 d5 mov %rdx,%rbp 32c: 49 89 fc mov %rdi,%r12 32f: 75 1f jne 350 331: b9 7f 00 00 00 mov $0x7f,%ecx 336: 48 c7 c2 00 00 00 00 mov $0x0,%rdx 33d: 48 c7 c6 00 00 00 00 mov $0x0,%rsi 344: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 34b: e8 00 00 00 00 callq 350 inode = iget5_locked(sb, hash, ll_test_inode, ll_set_inode, md); 350: 48 89 de mov %rbx,%rsi 353: 49 89 e8 mov %rbp,%r8 356: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 35d: 48 c7 c2 00 00 00 00 mov $0x0,%rdx 364: 4c 89 e7 mov %r12,%rdi 367: e8 00 00 00 00 callq 36c if (inode) { 36c: 48 85 c0 test %rax,%rax 36f: 48 89 c3 mov %rax,%rbx 372: 74 7c je 3f0 if (inode->i_state & I_NEW) 374: f6 80 10 02 00 00 40 testb $0x40,0x210(%rax) 37b: 74 08 je 385 unlock_new_inode(inode); 37d: 48 89 c7 mov %rax,%rdi 380: e8 00 00 00 00 callq 385 CDEBUG(D_VFSTRACE, "inode: %lu/%u(%p)\n", inode->i_ino, 385: f6 05 00 00 00 00 20 testb $0x20,0(%rip) # 38c 38c: 74 62 je 3f0 38e: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 395 395: 79 59 jns 3f0 397: 48 89 5c 24 28 mov %rbx,0x28(%rsp) 39c: 8b 83 fc 01 00 00 mov 0x1fc(%rbx),%eax 3a2: 41 b9 86 00 00 00 mov $0x86,%r9d 3a8: 49 c7 c0 00 00 00 00 mov $0x0,%r8 3af: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 3b6: ba 00 00 20 00 mov $0x200000,%edx 3bb: be 80 00 00 00 mov $0x80,%esi 3c0: 31 ff xor %edi,%edi 3c2: 89 44 24 20 mov %eax,0x20(%rsp) 3c6: 48 8b 43 30 mov 0x30(%rbx),%rax 3ca: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 3d1: 00 00 3d3: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 3da: 00 00 3dc: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 3e3: 00 3e4: 48 89 44 24 18 mov %rax,0x18(%rsp) 3e9: 31 c0 xor %eax,%eax 3eb: e8 00 00 00 00 callq 3f0 inode->i_generation, inode); } return inode; } 3f0: 48 89 d8 mov %rbx,%rax 3f3: 48 8b 6c 24 38 mov 0x38(%rsp),%rbp 3f8: 48 8b 5c 24 30 mov 0x30(%rsp),%rbx 3fd: 4c 8b 64 24 40 mov 0x40(%rsp),%r12 402: 48 83 c4 48 add $0x48,%rsp 406: c3 retq 407: 66 data16 408: 66 data16 409: 90 nop 40a: 66 data16 40b: 66 data16 40c: 90 nop 40d: 66 data16 40e: 66 data16 40f: 90 nop 0000000000000410 : #else struct inode *ll_iget(struct super_block *sb, ino_t hash, struct lustre_md *md) { struct inode *inode; LASSERT(hash != 0); inode = iget4(sb, hash, ll_test_inode, md); if (inode) CDEBUG(D_VFSTRACE, "inode: %lu/%u(%p)\n", inode->i_ino, inode->i_generation, inode); return inode; } #endif static void ll_drop_negative_dentry(struct inode *dir) { struct dentry *dentry, *tmp_alias, *tmp_subdir; spin_lock(&dcache_lock); restart: list_for_each_entry_safe(dentry, tmp_alias, &dir->i_dentry,d_alias) { if (!list_empty(&dentry->d_subdirs)) { struct dentry *child; list_for_each_entry_safe(child, tmp_subdir, &dentry->d_subdirs, d_child) { /* XXX Print some debug here? */ if (!child->d_inode) /* Negative dentry. If we were dropping dcache lock, go throught the list again */ if (ll_drop_dentry(child)) goto restart; } } } spin_unlock(&dcache_lock); } int ll_mdc_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc, void *data, int flag) { 410: 48 83 ec 68 sub $0x68,%rsp int rc; struct lustre_handle lockh; ENTRY; 414: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 41b 41b: 48 89 5c 24 38 mov %rbx,0x38(%rsp) 420: 48 89 6c 24 40 mov %rbp,0x40(%rsp) 425: 48 89 fb mov %rdi,%rbx 428: 4c 89 64 24 48 mov %r12,0x48(%rsp) 42d: 4c 89 6c 24 50 mov %r13,0x50(%rsp) 432: 89 cd mov %ecx,%ebp 434: 4c 89 74 24 58 mov %r14,0x58(%rsp) 439: 4c 89 7c 24 60 mov %r15,0x60(%rsp) 43e: 74 50 je 490 440: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 447 447: 79 47 jns 490 449: 41 b9 b8 00 00 00 mov $0xb8,%r9d 44f: 49 c7 c0 00 00 00 00 mov $0x0,%r8 456: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 45d: ba 01 00 00 00 mov $0x1,%edx 462: be 80 00 00 00 mov $0x80,%esi 467: 31 ff xor %edi,%edi 469: 31 c0 xor %eax,%eax 46b: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 472: 00 00 474: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 47b: 00 00 47d: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 484: 00 485: e8 00 00 00 00 callq 48a 48a: 66 data16 48b: 66 data16 48c: 90 nop 48d: 66 data16 48e: 66 data16 48f: 90 nop switch (flag) { 490: 83 fd 01 cmp $0x1,%ebp 493: 74 10 je 4a5 495: 83 fd 02 cmp $0x2,%ebp 498: 0f 84 f2 00 00 00 je 590 49e: 66 data16 49f: 90 nop 4a0: e9 da 03 00 00 jmpq 87f case LDLM_CB_BLOCKING: ldlm_lock2handle(lock, &lockh); 4a5: 48 8d 74 24 30 lea 0x30(%rsp),%rsi 4aa: 48 89 df mov %rbx,%rdi 4ad: e8 00 00 00 00 callq 4b2 rc = ldlm_cli_cancel(&lockh); 4b2: 48 8d 7c 24 30 lea 0x30(%rsp),%rdi 4b7: e8 00 00 00 00 callq 4bc if (rc < 0) { 4bc: 85 c0 test %eax,%eax 4be: 89 c3 mov %eax,%ebx 4c0: 0f 89 d1 03 00 00 jns 897 CDEBUG(D_INODE, "ldlm_cli_cancel: %d\n", rc); 4c6: 8b 05 00 00 00 00 mov 0(%rip),%eax # 4cc 4cc: a8 02 test $0x2,%al 4ce: 74 54 je 524 4d0: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 4d7 4d7: 79 4b jns 524 4d9: 41 b9 bf 00 00 00 mov $0xbf,%r9d 4df: 49 c7 c0 00 00 00 00 mov $0x0,%r8 4e6: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 4ed: ba 02 00 00 00 mov $0x2,%edx 4f2: be 80 00 00 00 mov $0x80,%esi 4f7: 31 ff xor %edi,%edi 4f9: 31 c0 xor %eax,%eax 4fb: 89 5c 24 18 mov %ebx,0x18(%rsp) 4ff: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 506: 00 00 508: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 50f: 00 00 511: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 518: 00 519: e8 00 00 00 00 callq 51e 51e: 8b 05 00 00 00 00 mov 0(%rip),%eax # 524 RETURN(rc); 524: a8 01 test $0x1,%al 526: 74 5c je 584 528: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 52f 52f: 79 53 jns 584 531: 48 63 c3 movslq %ebx,%rax 534: 41 b9 c0 00 00 00 mov $0xc0,%r9d 53a: 49 c7 c0 00 00 00 00 mov $0x0,%r8 541: 48 89 44 24 28 mov %rax,0x28(%rsp) 546: 48 89 44 24 20 mov %rax,0x20(%rsp) 54b: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 552: 48 89 44 24 18 mov %rax,0x18(%rsp) 557: ba 01 00 00 00 mov $0x1,%edx 55c: be 80 00 00 00 mov $0x80,%esi 561: 31 ff xor %edi,%edi 563: 31 c0 xor %eax,%eax 565: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 56c: 00 00 56e: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 575: 00 00 577: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 57e: 00 57f: e8 00 00 00 00 callq 584 584: 89 d8 mov %ebx,%eax 586: e9 7c 03 00 00 jmpq 907 58b: 66 data16 58c: 66 data16 58d: 90 nop 58e: 66 data16 58f: 90 nop } break; case LDLM_CB_CANCELING: { struct inode *inode = ll_inode_from_lock(lock); 590: 48 89 df mov %rbx,%rdi 593: e8 00 00 00 00 callq 598 __u64 bits = lock->l_policy_data.l_inodebits.bits; /* Invalidate all dentries associated with this inode */ if (inode == NULL) 598: 48 85 c0 test %rax,%rax 59b: 48 89 c5 mov %rax,%rbp 59e: 4c 8b a3 f0 00 00 00 mov 0xf0(%rbx),%r12 5a5: 0f 84 ec 02 00 00 je 897 break; LASSERT(lock->l_flags & LDLM_FL_CANCELING); 5ab: f6 83 11 01 00 00 20 testb $0x20,0x111(%rbx) 5b2: 75 1f jne 5d3 5b4: b9 cb 00 00 00 mov $0xcb,%ecx 5b9: 48 c7 c2 00 00 00 00 mov $0x0,%rdx 5c0: 48 c7 c6 00 00 00 00 mov $0x0,%rsi 5c7: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 5ce: e8 00 00 00 00 callq 5d3 if ((bits & MDS_INODELOCK_LOOKUP) && 5d3: 41 f6 c4 01 test $0x1,%r12b 5d7: 74 1a je 5f3 5d9: be 01 00 00 00 mov $0x1,%esi 5de: 48 89 ef mov %rbp,%rdi 5e1: e8 00 00 00 00 callq 5e6 ll_have_md_lock(inode, MDS_INODELOCK_LOOKUP)) bits &= ~MDS_INODELOCK_LOOKUP; 5e6: 4c 89 e2 mov %r12,%rdx 5e9: 48 83 e2 fe and $0xfffffffffffffffe,%rdx 5ed: 85 c0 test %eax,%eax 5ef: 4c 0f 45 e2 cmovne %rdx,%r12 if ((bits & MDS_INODELOCK_UPDATE) && 5f3: 41 f6 c4 02 test $0x2,%r12b 5f7: 74 1a je 613 5f9: be 02 00 00 00 mov $0x2,%esi 5fe: 48 89 ef mov %rbp,%rdi 601: e8 00 00 00 00 callq 606 ll_have_md_lock(inode, MDS_INODELOCK_UPDATE)) bits &= ~MDS_INODELOCK_UPDATE; 606: 4c 89 e2 mov %r12,%rdx 609: 48 83 e2 fd and $0xfffffffffffffffd,%rdx 60d: 85 c0 test %eax,%eax 60f: 4c 0f 45 e2 cmovne %rdx,%r12 if ((bits & MDS_INODELOCK_OPEN) && 613: 41 f6 c4 04 test $0x4,%r12b 617: 74 1a je 633 619: be 04 00 00 00 mov $0x4,%esi 61e: 48 89 ef mov %rbp,%rdi 621: e8 00 00 00 00 callq 626 ll_have_md_lock(inode, MDS_INODELOCK_OPEN)) bits &= ~MDS_INODELOCK_OPEN; 626: 4c 89 e2 mov %r12,%rdx 629: 48 83 e2 fb and $0xfffffffffffffffb,%rdx 62d: 85 c0 test %eax,%eax 62f: 4c 0f 45 e2 cmovne %rdx,%r12 if (lock->l_resource->lr_name.name[0] != inode->i_ino || 633: 48 8b 4b 60 mov 0x60(%rbx),%rcx 637: 4c 8b 45 30 mov 0x30(%rbp),%r8 63b: 4c 39 81 80 00 00 00 cmp %r8,0x80(%rcx) 642: 75 13 jne 657 644: 8b 95 fc 01 00 00 mov 0x1fc(%rbp),%edx 64a: 89 d0 mov %edx,%eax 64c: 48 39 81 88 00 00 00 cmp %rax,0x88(%rcx) 653: 74 2c je 681 655: eb 06 jmp 65d 657: 8b 95 fc 01 00 00 mov 0x1fc(%rbp),%edx lock->l_resource->lr_name.name[1] != inode->i_generation) { LDLM_ERROR(lock, "data mismatch with ino %lu/%u (%p)", 65d: 41 89 d1 mov %edx,%r9d 660: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 667: 48 c7 c2 00 00 00 00 mov $0x0,%rdx 66e: be 00 00 02 00 mov $0x20000,%esi 673: 48 89 df mov %rbx,%rdi 676: 31 c0 xor %eax,%eax 678: 48 89 2c 24 mov %rbp,(%rsp) 67c: e8 00 00 00 00 callq 681 inode->i_ino, inode->i_generation, inode); } if (bits & MDS_INODELOCK_OPEN) { 681: 41 f6 c4 04 test $0x4,%r12b 685: 0f 84 a3 00 00 00 je 72e int flags = 0; switch (lock->l_req_mode) { 68b: 8b 93 b8 00 00 00 mov 0xb8(%rbx),%edx 691: 45 31 ed xor %r13d,%r13d 694: 83 fa 08 cmp $0x8,%edx 697: 74 19 je 6b2 699: 77 07 ja 6a2 69b: 83 fa 04 cmp $0x4,%edx 69e: 74 1a je 6ba 6a0: eb 2e jmp 6d0 6a2: 83 fa 10 cmp $0x10,%edx 6a5: 74 1b je 6c2 6a7: 66 data16 6a8: 66 data16 6a9: 90 nop 6aa: 66 data16 6ab: 66 data16 6ac: 90 nop 6ad: 66 data16 6ae: 66 data16 6af: 90 nop 6b0: eb 1e jmp 6d0 case LCK_CW: flags = FMODE_WRITE; 6b2: 41 bd 02 00 00 00 mov $0x2,%r13d break; 6b8: eb 69 jmp 723 case LCK_PR: flags = FMODE_EXEC; 6ba: 41 bd 10 00 00 00 mov $0x10,%r13d if (!FMODE_EXEC) CERROR("open PR lock without FMODE_EXEC\n"); break; 6c0: eb 61 jmp 723 case LCK_CR: flags = FMODE_READ; 6c2: 41 bd 01 00 00 00 mov $0x1,%r13d break; 6c8: eb 59 jmp 723 6ca: 66 data16 6cb: 66 data16 6cc: 90 nop 6cd: 66 data16 6ce: 66 data16 6cf: 90 nop default: CERROR("Unexpected lock mode for OPEN lock " 6d0: 48 8b 45 30 mov 0x30(%rbp),%rax 6d4: 41 b9 ed 00 00 00 mov $0xed,%r9d 6da: 89 54 24 18 mov %edx,0x18(%rsp) 6de: 49 c7 c0 00 00 00 00 mov $0x0,%r8 6e5: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 6ec: ba 00 00 02 00 mov $0x20000,%edx 6f1: be 80 00 00 00 mov $0x80,%esi 6f6: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 6fd: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 704: 00 00 706: 48 89 44 24 20 mov %rax,0x20(%rsp) 70b: 31 c0 xor %eax,%eax 70d: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 714: 00 00 716: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 71d: 00 71e: e8 00 00 00 00 callq 723 "%d, inode %ld\n", lock->l_req_mode, inode->i_ino); } ll_mdc_real_close(inode, flags); 723: 44 89 ee mov %r13d,%esi 726: 48 89 ef mov %rbp,%rdi 729: e8 00 00 00 00 callq 72e } if (bits & MDS_INODELOCK_UPDATE) 72e: 4c 89 e2 mov %r12,%rdx 731: 83 e2 02 and $0x2,%edx 734: 74 09 je 73f 736: f0 0f ba b5 78 ff ff lock btrl $0x1,0xffffffffffffff78(%rbp) 73d: ff 01 clear_bit(LLI_F_HAVE_MDS_SIZE_LOCK, &(ll_i2info(inode)->lli_flags)); if (S_ISDIR(inode->i_mode) && 73f: 0f b7 45 3c movzwl 0x3c(%rbp),%eax 743: 25 00 f0 00 00 and $0xf000,%eax 748: 3d 00 40 00 00 cmp $0x4000,%eax 74d: 0f 85 fd 00 00 00 jne 850 753: 48 85 d2 test %rdx,%rdx 756: 0f 84 f4 00 00 00 je 850 (bits & MDS_INODELOCK_UPDATE)) { CDEBUG(D_INODE, "invalidating inode %lu\n", 75c: f6 05 00 00 00 00 02 testb $0x2,0(%rip) # 763 763: 74 53 je 7b8 765: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 76c 76c: 79 4a jns 7b8 76e: 48 8b 45 30 mov 0x30(%rbp),%rax 772: 41 b9 f9 00 00 00 mov $0xf9,%r9d 778: 49 c7 c0 00 00 00 00 mov $0x0,%r8 77f: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 786: ba 02 00 00 00 mov $0x2,%edx 78b: be 80 00 00 00 mov $0x80,%esi 790: 31 ff xor %edi,%edi 792: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 799: 00 00 79b: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 7a2: 00 00 7a4: 48 89 44 24 18 mov %rax,0x18(%rsp) 7a9: 31 c0 xor %eax,%eax 7ab: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 7b2: 00 7b3: e8 00 00 00 00 callq 7b8 inode->i_ino); truncate_inode_pages(inode->i_mapping, 0); 7b8: 48 8b bd 18 01 00 00 mov 0x118(%rbp),%rdi 7bf: 31 f6 xor %esi,%esi 7c1: 4c 8d 7d 20 lea 0x20(%rbp),%r15 7c5: e8 00 00 00 00 callq 7ca 7ca: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 7d1: e8 00 00 00 00 callq 7d6 7d6: 48 8b 45 20 mov 0x20(%rbp),%rax 7da: 48 8d 50 98 lea 0xffffffffffffff98(%rax),%rdx 7de: 4c 8b 72 68 mov 0x68(%rdx),%r14 7e2: 49 83 ee 68 sub $0x68,%r14 7e6: 4c 39 f8 cmp %r15,%rax 7e9: 74 57 je 842 7eb: 48 8b 42 58 mov 0x58(%rdx),%rax 7ef: 48 8d 5a 58 lea 0x58(%rdx),%rbx 7f3: 48 39 d8 cmp %rbx,%rax 7f6: 74 39 je 831 7f8: 48 8d 78 b8 lea 0xffffffffffffffb8(%rax),%rdi 7fc: 4c 8b 6f 48 mov 0x48(%rdi),%r13 800: 49 83 ed 48 sub $0x48,%r13 804: 48 39 d8 cmp %rbx,%rax 807: 74 28 je 831 809: 48 83 7f 10 00 cmpq $0x0,0x10(%rdi) 80e: 75 10 jne 820 810: e8 00 00 00 00 callq 815 815: 85 c0 test %eax,%eax 817: 75 bd jne 7d6 819: 66 data16 81a: 66 data16 81b: 66 data16 81c: 90 nop 81d: 66 data16 81e: 66 data16 81f: 90 nop 820: 4c 89 ef mov %r13,%rdi 823: 4d 8b 6d 48 mov 0x48(%r13),%r13 827: 48 8d 47 48 lea 0x48(%rdi),%rax 82b: 49 83 ed 48 sub $0x48,%r13 82f: eb d3 jmp 804 831: 4c 89 f2 mov %r14,%rdx 834: 4d 8b 76 68 mov 0x68(%r14),%r14 838: 48 8d 42 68 lea 0x68(%rdx),%rax 83c: 49 83 ee 68 sub $0x68,%r14 840: eb a4 jmp 7e6 842: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 849: e8 00 00 00 00 callq 84e 84e: 66 data16 84f: 90 nop ll_drop_negative_dentry(inode); } if (inode->i_sb->s_root && 850: 48 8b 85 08 01 00 00 mov 0x108(%rbp),%rax 857: 48 8b 40 70 mov 0x70(%rax),%rax 85b: 48 85 c0 test %rax,%rax 85e: 74 15 je 875 860: 48 39 68 10 cmp %rbp,0x10(%rax) 864: 74 0f je 875 866: 41 83 e4 01 and $0x1,%r12d 86a: 74 09 je 875 inode != inode->i_sb->s_root->d_inode && (bits & MDS_INODELOCK_LOOKUP)) ll_unhash_aliases(inode); 86c: 48 89 ef mov %rbp,%rdi 86f: 90 nop 870: e8 00 00 00 00 callq 875 iput(inode); 875: 48 89 ef mov %rbp,%rdi 878: e8 00 00 00 00 callq 87d break; 87d: eb 18 jmp 897 } default: LBUG(); 87f: ba 06 01 00 00 mov $0x106,%edx 884: 48 c7 c6 00 00 00 00 mov $0x0,%rsi 88b: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 892: e8 00 00 00 00 callq 897 } RETURN(0); 897: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 89e 89e: 74 65 je 905 8a0: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 8a7 8a7: 79 5c jns 905 8a9: 41 b9 09 01 00 00 mov $0x109,%r9d 8af: 49 c7 c0 00 00 00 00 mov $0x0,%r8 8b6: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 8bd: ba 01 00 00 00 mov $0x1,%edx 8c2: be 80 00 00 00 mov $0x80,%esi 8c7: 31 ff xor %edi,%edi 8c9: 31 c0 xor %eax,%eax 8cb: 48 c7 44 24 28 00 00 movq $0x0,0x28(%rsp) 8d2: 00 00 8d4: 48 c7 44 24 20 00 00 movq $0x0,0x20(%rsp) 8db: 00 00 8dd: 48 c7 44 24 18 00 00 movq $0x0,0x18(%rsp) 8e4: 00 00 8e6: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 8ed: 00 00 8ef: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 8f6: 00 00 8f8: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 8ff: 00 900: e8 00 00 00 00 callq 905 905: 31 c0 xor %eax,%eax } 907: 48 8b 5c 24 38 mov 0x38(%rsp),%rbx 90c: 48 8b 6c 24 40 mov 0x40(%rsp),%rbp 911: 4c 8b 64 24 48 mov 0x48(%rsp),%r12 916: 4c 8b 6c 24 50 mov 0x50(%rsp),%r13 91b: 4c 8b 74 24 58 mov 0x58(%rsp),%r14 920: 4c 8b 7c 24 60 mov 0x60(%rsp),%r15 925: 48 83 c4 68 add $0x68,%rsp 929: c3 retq 92a: 66 data16 92b: 66 data16 92c: 90 nop 92d: 66 data16 92e: 66 data16 92f: 90 nop 0000000000000930 : int ll_mdc_cancel_unused(struct lustre_handle *conn, struct inode *inode, int flags, void *opaque) { 930: 41 54 push %r12 932: 41 89 d4 mov %edx,%r12d 935: 49 89 f8 mov %rdi,%r8 struct ldlm_res_id res_id = 938: fc cld 939: 55 push %rbp 93a: 31 c0 xor %eax,%eax 93c: 48 89 cd mov %rcx,%rbp 93f: b9 04 00 00 00 mov $0x4,%ecx 944: 53 push %rbx 945: 48 83 ec 70 sub $0x70,%rsp 949: 48 8d 54 24 30 lea 0x30(%rsp),%rdx 94e: 48 89 d7 mov %rdx,%rdi 951: f3 48 ab repz stos %rax,%es:(%rdi) { .name = {inode->i_ino, inode->i_generation} }; struct obd_device *obddev = class_conn2obd(conn); 954: 4c 89 c7 mov %r8,%rdi 957: 48 8b 56 30 mov 0x30(%rsi),%rdx 95b: 48 89 54 24 30 mov %rdx,0x30(%rsp) 960: 8b 86 fc 01 00 00 mov 0x1fc(%rsi),%eax 966: 48 89 54 24 50 mov %rdx,0x50(%rsp) 96b: 48 89 44 24 38 mov %rax,0x38(%rsp) 970: 48 89 44 24 58 mov %rax,0x58(%rsp) 975: 48 8b 44 24 40 mov 0x40(%rsp),%rax 97a: 48 89 44 24 60 mov %rax,0x60(%rsp) 97f: 48 8b 44 24 48 mov 0x48(%rsp),%rax 984: 48 89 44 24 68 mov %rax,0x68(%rsp) 989: e8 00 00 00 00 callq 98e ENTRY; 98e: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 995 995: 48 89 c3 mov %rax,%rbx 998: 74 4a je 9e4 99a: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 9a1 9a1: 79 41 jns 9e4 9a3: 41 b9 12 01 00 00 mov $0x112,%r9d 9a9: 49 c7 c0 00 00 00 00 mov $0x0,%r8 9b0: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 9b7: ba 01 00 00 00 mov $0x1,%edx 9bc: be 80 00 00 00 mov $0x80,%esi 9c1: 31 ff xor %edi,%edi 9c3: 31 c0 xor %eax,%eax 9c5: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 9cc: 00 00 9ce: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 9d5: 00 00 9d7: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 9de: 00 9df: e8 00 00 00 00 callq 9e4 RETURN(ldlm_cli_cancel_unused(obddev->obd_namespace, &res_id, flags, 9e4: 48 8b bb 20 01 00 00 mov 0x120(%rbx),%rdi 9eb: 48 8d 74 24 50 lea 0x50(%rsp),%rsi 9f0: 48 89 e9 mov %rbp,%rcx 9f3: 44 89 e2 mov %r12d,%edx 9f6: e8 00 00 00 00 callq 9fb 9fb: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # a02 a02: 89 c3 mov %eax,%ebx a04: 74 5b je a61 a06: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # a0d a0d: 79 52 jns a61 a0f: 48 98 cltq a11: 41 b9 15 01 00 00 mov $0x115,%r9d a17: 49 c7 c0 00 00 00 00 mov $0x0,%r8 a1e: 48 89 44 24 28 mov %rax,0x28(%rsp) a23: 48 89 44 24 20 mov %rax,0x20(%rsp) a28: 48 c7 c1 00 00 00 00 mov $0x0,%rcx a2f: 48 89 44 24 18 mov %rax,0x18(%rsp) a34: ba 01 00 00 00 mov $0x1,%edx a39: be 80 00 00 00 mov $0x80,%esi a3e: 31 ff xor %edi,%edi a40: 31 c0 xor %eax,%eax a42: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) a49: 00 00 a4b: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) a52: 00 00 a54: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) a5b: 00 a5c: e8 00 00 00 00 callq a61 opaque)); } a61: 48 83 c4 70 add $0x70,%rsp a65: 89 d8 mov %ebx,%eax a67: 5b pop %rbx a68: 5d pop %rbp a69: 41 5c pop %r12 a6b: c3 retq a6c: 66 data16 a6d: 66 data16 a6e: 66 data16 a6f: 90 nop 0000000000000a70 : /* Pack the required supplementary groups into the supplied groups array. * If we don't need to use the groups from the target inode(s) then we * instead pack one or more groups from the user's supplementary group * array in case it might be useful. Not needed if doing an MDS-side upcall. */ void ll_i2gids(__u32 *suppgids, struct inode *i1, struct inode *i2) { a70: 41 54 push %r12 int i; LASSERT(i1 != NULL); a72: 48 85 f6 test %rsi,%rsi a75: 49 89 d4 mov %rdx,%r12 a78: 55 push %rbp a79: 48 89 f5 mov %rsi,%rbp a7c: 53 push %rbx a7d: 48 89 fb mov %rdi,%rbx a80: 75 1f jne aa1 a82: b9 20 01 00 00 mov $0x120,%ecx a87: 48 c7 c2 00 00 00 00 mov $0x0,%rdx a8e: 48 c7 c6 00 00 00 00 mov $0x0,%rsi a95: 48 c7 c7 00 00 00 00 mov $0x0,%rdi a9c: e8 00 00 00 00 callq aa1 LASSERT(suppgids != NULL); aa1: 48 85 db test %rbx,%rbx aa4: 75 1f jne ac5 aa6: b9 21 01 00 00 mov $0x121,%ecx aab: 48 c7 c2 00 00 00 00 mov $0x0,%rdx ab2: 48 c7 c6 00 00 00 00 mov $0x0,%rsi ab9: 48 c7 c7 00 00 00 00 mov $0x0,%rdi ac0: e8 00 00 00 00 callq ac5 if (in_group_p(i1->i_gid)) ac5: 8b 7d 48 mov 0x48(%rbp),%edi ac8: e8 00 00 00 00 callq acd acd: 85 c0 test %eax,%eax acf: 74 07 je ad8 suppgids[0] = i1->i_gid; ad1: 8b 45 48 mov 0x48(%rbp),%eax ad4: 89 03 mov %eax,(%rbx) ad6: eb 06 jmp ade else suppgids[0] = -1; ad8: c7 03 ff ff ff ff movl $0xffffffff,(%rbx) if (i2) { ade: 4d 85 e4 test %r12,%r12 ae1: 74 1d je b00 if (in_group_p(i2->i_gid)) ae3: 41 8b 7c 24 48 mov 0x48(%r12),%edi ae8: e8 00 00 00 00 callq aed aed: 85 c0 test %eax,%eax aef: 74 0f je b00 suppgids[1] = i2->i_gid; af1: 41 8b 44 24 48 mov 0x48(%r12),%eax af6: 89 43 04 mov %eax,0x4(%rbx) af9: eb 0c jmp b07 afb: 66 data16 afc: 66 data16 afd: 90 nop afe: 66 data16 aff: 90 nop else suppgids[1] = -1; } else { suppgids[1] = -1; b00: c7 43 04 ff ff ff ff movl $0xffffffff,0x4(%rbx) } for (i = 0; i < current_ngroups; i++) { b07: 31 f6 xor %esi,%esi b09: 65 48 8b 04 25 00 00 mov %gs:0x0,%rax b10: 00 00 b12: 48 8b 80 e8 02 00 00 mov 0x2e8(%rax),%rax b19: 8b 00 mov (%rax),%eax b1b: 85 c0 test %eax,%eax b1d: 0f 8e 8f 00 00 00 jle bb2 if (suppgids[0] == -1) { b23: 83 3b ff cmpl $0xffffffffffffffff,(%rbx) b26: 75 38 jne b60 b28: 65 48 8b 04 25 00 00 mov %gs:0x0,%rax b2f: 00 00 b31: 48 8b 90 e8 02 00 00 mov 0x2e8(%rax),%rdx b38: 48 63 ce movslq %esi,%rcx b3b: 8b 43 04 mov 0x4(%rbx),%eax b3e: 39 44 8a 08 cmp %eax,0x8(%rdx,%rcx,4) b42: 74 54 je b98 b44: 65 48 8b 04 25 00 00 mov %gs:0x0,%rax b4b: 00 00 b4d: 48 8b 80 e8 02 00 00 mov 0x2e8(%rax),%rax b54: 8b 44 88 08 mov 0x8(%rax,%rcx,4),%eax b58: 89 03 mov %eax,(%rbx) if (current_groups[i] != suppgids[1]) suppgids[0] = current_groups[i]; continue; b5a: eb 3c jmp b98 b5c: 66 data16 b5d: 66 data16 b5e: 66 data16 b5f: 90 nop } if (suppgids[1] == -1) { b60: 83 7b 04 ff cmpl $0xffffffffffffffff,0x4(%rbx) b64: 75 4c jne bb2 b66: 65 48 8b 04 25 00 00 mov %gs:0x0,%rax b6d: 00 00 b6f: 48 8b 90 e8 02 00 00 mov 0x2e8(%rax),%rdx b76: 48 63 ce movslq %esi,%rcx b79: 8b 03 mov (%rbx),%eax b7b: 39 44 8a 08 cmp %eax,0x8(%rdx,%rcx,4) b7f: 74 17 je b98 b81: 65 48 8b 04 25 00 00 mov %gs:0x0,%rax b88: 00 00 b8a: 48 8b 80 e8 02 00 00 mov 0x2e8(%rax),%rax b91: 8b 44 88 08 mov 0x8(%rax,%rcx,4),%eax b95: 89 43 04 mov %eax,0x4(%rbx) b98: ff c6 inc %esi b9a: 65 48 8b 04 25 00 00 mov %gs:0x0,%rax ba1: 00 00 ba3: 48 8b 80 e8 02 00 00 mov 0x2e8(%rax),%rax baa: 39 30 cmp %esi,(%rax) bac: 0f 8f 71 ff ff ff jg b23 bb2: 5b pop %rbx bb3: 5d pop %rbp bb4: 41 5c pop %r12 bb6: c3 retq bb7: 66 data16 bb8: 66 data16 bb9: 90 nop bba: 66 data16 bbb: 66 data16 bbc: 90 nop bbd: 66 data16 bbe: 66 data16 bbf: 90 nop 0000000000000bc0 : if (current_groups[i] != suppgids[0]) suppgids[1] = current_groups[i]; continue; } break; } } int ll_prepare_mdc_op_data(struct mdc_op_data *op_data, struct inode *i1, struct inode *i2, const char *name, int namelen, int mode, void *data) { bc0: 48 83 ec 38 sub $0x38,%rsp LASSERT(i1); bc4: 48 85 f6 test %rsi,%rsi bc7: 48 89 5c 24 08 mov %rbx,0x8(%rsp) bcc: 48 89 6c 24 10 mov %rbp,0x10(%rsp) bd1: 48 89 fb mov %rdi,%rbx bd4: 4c 89 64 24 18 mov %r12,0x18(%rsp) bd9: 4c 89 6c 24 20 mov %r13,0x20(%rsp) bde: 48 89 f5 mov %rsi,%rbp be1: 4c 89 74 24 28 mov %r14,0x28(%rsp) be6: 4c 89 7c 24 30 mov %r15,0x30(%rsp) beb: 49 89 d4 mov %rdx,%r12 bee: 49 89 ce mov %rcx,%r14 bf1: 45 89 c5 mov %r8d,%r13d bf4: 45 89 cf mov %r9d,%r15d bf7: 75 1f jne c18 bf9: b9 44 01 00 00 mov $0x144,%ecx bfe: 48 c7 c2 00 00 00 00 mov $0x0,%rdx c05: 48 c7 c6 00 00 00 00 mov $0x0,%rsi c0c: 48 c7 c7 00 00 00 00 mov $0x0,%rdi c13: e8 00 00 00 00 callq c18 // FIXME: replace the name of this with LL_SB to conform to kernel stuff static inline struct ll_sb_info *ll_i2sbi(struct inode *inode) { return ll_s2sbi(inode->i_sb); c18: 48 8b 85 08 01 00 00 mov 0x108(%rbp),%rax if (namelen > ll_i2sbi(i1)->ll_namelen) return -ENAMETOOLONG; c1f: ba dc ff ff ff mov $0xffffffdc,%edx // FIXME: replace the name of this with LL_SB to conform to kernel stuff static inline struct ll_sb_info *ll_i2sbi(struct inode *inode) { return ll_s2sbi(inode->i_sb); c24: 48 8b 80 60 02 00 00 mov 0x260(%rax),%rax c2b: 48 8b 40 20 mov 0x20(%rax),%rax c2f: 44 3b a8 60 01 00 00 cmp 0x160(%rax),%r13d c36: 0f 87 8a 00 00 00 ja cc6 ll_i2gids(op_data->suppgids, i1, i2); c3c: 48 8d 7b 58 lea 0x58(%rbx),%rdi c40: 4c 89 e2 mov %r12,%rdx c43: 48 89 ee mov %rbp,%rsi c46: e8 00 00 00 00 callq c4b int mdc_done_writing(struct obd_export *exp, struct obdo *); static inline void mdc_pack_fid(struct ll_fid *fid, obd_id ino, __u32 gen, int type) { c4b: 0f b7 45 3c movzwl 0x3c(%rbp),%eax c4f: 48 8b 55 30 mov 0x30(%rbp),%rdx c53: 8b 8d fc 01 00 00 mov 0x1fc(%rbp),%ecx fid->id = ino; c59: 48 89 13 mov %rdx,(%rbx) c5c: 25 00 f0 00 00 and $0xf000,%eax ll_inode2fid(&op_data->fid1, i1); if (i2) c61: 4d 85 e4 test %r12,%r12 static inline void mdc_pack_fid(struct ll_fid *fid, obd_id ino, __u32 gen, int type) { fid->id = ino; fid->generation = gen; c64: 89 4b 08 mov %ecx,0x8(%rbx) fid->f_type = type; c67: 89 43 0c mov %eax,0xc(%rbx) c6a: 74 28 je c94 int mdc_done_writing(struct obd_export *exp, struct obdo *); static inline void mdc_pack_fid(struct ll_fid *fid, obd_id ino, __u32 gen, int type) { c6c: 41 0f b7 44 24 3c movzwl 0x3c(%r12),%eax c72: 49 8b 54 24 30 mov 0x30(%r12),%rdx return ll_s2mdcexp(inode->i_sb); } static inline void ll_inode2fid(struct ll_fid *fid, struct inode *inode) { c77: 48 8d 73 10 lea 0x10(%rbx),%rsi int mdc_done_writing(struct obd_export *exp, struct obdo *); static inline void mdc_pack_fid(struct ll_fid *fid, obd_id ino, __u32 gen, int type) { c7b: 41 8b 8c 24 fc 01 00 mov 0x1fc(%r12),%ecx c82: 00 fid->id = ino; c83: 48 89 53 10 mov %rdx,0x10(%rbx) c87: 25 00 f0 00 00 and $0xf000,%eax fid->generation = gen; c8c: 89 4e 08 mov %ecx,0x8(%rsi) fid->f_type = type; c8f: 89 46 0c mov %eax,0xc(%rsi) c92: eb 10 jmp ca4 ll_inode2fid(&op_data->fid2, i2); else memset(&op_data->fid2, 0, sizeof(op_data->fid2)); c94: 48 c7 43 10 00 00 00 movq $0x0,0x10(%rbx) c9b: 00 c9c: 48 c7 43 18 00 00 00 movq $0x0,0x18(%rbx) ca3: 00 op_data->name = name; ca4: 4c 89 73 48 mov %r14,0x48(%rbx) op_data->namelen = namelen; ca8: 44 89 6b 50 mov %r13d,0x50(%rbx) op_data->create_mode = mode; op_data->mod_time = CURRENT_SECONDS; op_data->data = data; return 0; cac: 31 d2 xor %edx,%edx cae: 44 89 7b 54 mov %r15d,0x54(%rbx) cb2: 48 8b 05 00 00 00 00 mov 0(%rip),%rax # cb9 cb9: 48 89 43 40 mov %rax,0x40(%rbx) cbd: 48 8b 44 24 40 mov 0x40(%rsp),%rax cc2: 48 89 43 60 mov %rax,0x60(%rbx) } cc6: 48 8b 5c 24 08 mov 0x8(%rsp),%rbx ccb: 48 8b 6c 24 10 mov 0x10(%rsp),%rbp cd0: 89 d0 mov %edx,%eax cd2: 4c 8b 64 24 18 mov 0x18(%rsp),%r12 cd7: 4c 8b 6c 24 20 mov 0x20(%rsp),%r13 cdc: 4c 8b 74 24 28 mov 0x28(%rsp),%r14 ce1: 4c 8b 7c 24 30 mov 0x30(%rsp),%r15 ce6: 48 83 c4 38 add $0x38,%rsp cea: c3 retq ceb: 66 data16 cec: 66 data16 ced: 90 nop cee: 66 data16 cef: 90 nop 0000000000000cf0 : static void ll_d_add(struct dentry *de, struct inode *inode) { cf0: 55 push %rbp cf1: 48 89 f5 mov %rsi,%rbp cf4: 53 push %rbx cf5: 48 89 fb mov %rdi,%rbx cf8: 48 83 ec 48 sub $0x48,%rsp CDEBUG(D_DENTRY, "adding inode %p to dentry %p\n", inode, de); cfc: f6 05 00 00 00 00 20 testb $0x20,0(%rip) # d03 d03: 74 5b je d60 d05: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # d0c d0c: 79 52 jns d60 d0e: 48 89 7c 24 20 mov %rdi,0x20(%rsp) d13: 48 89 74 24 18 mov %rsi,0x18(%rsp) d18: 41 b9 5b 01 00 00 mov $0x15b,%r9d d1e: 49 c7 c0 00 00 00 00 mov $0x0,%r8 d25: 48 c7 c1 00 00 00 00 mov $0x0,%rcx d2c: ba 00 20 00 00 mov $0x2000,%edx d31: be 80 00 00 00 mov $0x80,%esi d36: 31 ff xor %edi,%edi d38: 31 c0 xor %eax,%eax d3a: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) d41: 00 00 d43: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) d4a: 00 00 d4c: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) d53: 00 d54: e8 00 00 00 00 callq d59 d59: 66 data16 d5a: 66 data16 d5b: 66 data16 d5c: 90 nop d5d: 66 data16 d5e: 66 data16 d5f: 90 nop d60: 48 8d 4b 68 lea 0x68(%rbx),%rcx d64: 48 39 4b 68 cmp %rcx,0x68(%rbx) d68: 0f 84 83 00 00 00 je df1 /* d_instantiate */ if (!list_empty(&de->d_alias)) { spin_unlock(&dcache_lock); d6e: 48 c7 c7 00 00 00 00 mov $0x0,%rdi d75: e8 00 00 00 00 callq d7a CERROR("dentry %.*s %p alias next %p, prev %p\n", d7a: 48 8b 43 70 mov 0x70(%rbx),%rax d7e: ba 00 00 02 00 mov $0x20000,%edx d83: 41 b9 61 01 00 00 mov $0x161,%r9d d89: 49 c7 c0 00 00 00 00 mov $0x0,%r8 d90: 48 c7 c1 00 00 00 00 mov $0x0,%rcx d97: be 80 00 00 00 mov $0x80,%esi d9c: 48 c7 c7 00 00 00 00 mov $0x0,%rdi da3: 48 89 44 24 38 mov %rax,0x38(%rsp) da8: 48 8b 43 68 mov 0x68(%rbx),%rax dac: 48 89 5c 24 28 mov %rbx,0x28(%rsp) db1: 48 89 44 24 30 mov %rax,0x30(%rsp) db6: 48 8b 43 30 mov 0x30(%rbx),%rax dba: 48 89 44 24 20 mov %rax,0x20(%rsp) dbf: 8b 43 2c mov 0x2c(%rbx),%eax dc2: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) dc9: 00 00 dcb: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) dd2: 00 00 dd4: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) ddb: 00 ddc: 89 44 24 18 mov %eax,0x18(%rsp) de0: 31 c0 xor %eax,%eax de2: e8 00 00 00 00 callq de7 de->d_name.len, de->d_name.name, de, de->d_alias.next, de->d_alias.prev); LBUG(); de7: ba 62 01 00 00 mov $0x162,%edx dec: e9 a3 00 00 00 jmpq e94 } if (inode) df1: 48 85 ed test %rbp,%rbp df4: 74 18 je e0e df6: 48 8b 45 20 mov 0x20(%rbp),%rax dfa: 48 8d 55 20 lea 0x20(%rbp),%rdx dfe: 48 89 48 08 mov %rcx,0x8(%rax) e02: 48 89 43 68 mov %rax,0x68(%rbx) e06: 48 89 51 08 mov %rdx,0x8(%rcx) e0a: 48 89 4d 20 mov %rcx,0x20(%rbp) e0e: f6 43 04 10 testb $0x10,0x4(%rbx) list_add(&de->d_alias, &inode->i_dentry); de->d_inode = inode; e12: 48 89 6b 10 mov %rbp,0x10(%rbx) e16: 0f 85 8b 00 00 00 jne ea7 /* d_rehash */ if (!d_unhashed(de)) { spin_unlock(&dcache_lock); e1c: 48 c7 c7 00 00 00 00 mov $0x0,%rdi e23: e8 00 00 00 00 callq e28 CERROR("dentry %.*s %p hash next %p\n", e28: 48 8b 83 b8 00 00 00 mov 0xb8(%rbx),%rax e2f: 48 89 5c 24 28 mov %rbx,0x28(%rsp) e34: ba 00 00 02 00 mov $0x20000,%edx e39: 41 b9 6c 01 00 00 mov $0x16c,%r9d e3f: 49 c7 c0 00 00 00 00 mov $0x0,%r8 e46: 48 c7 c1 00 00 00 00 mov $0x0,%rcx e4d: be 80 00 00 00 mov $0x80,%esi e52: 48 c7 c7 00 00 00 00 mov $0x0,%rdi e59: 48 89 44 24 30 mov %rax,0x30(%rsp) e5e: 48 8b 43 30 mov 0x30(%rbx),%rax e62: 48 89 44 24 20 mov %rax,0x20(%rsp) e67: 8b 43 2c mov 0x2c(%rbx),%eax e6a: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) e71: 00 00 e73: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) e7a: 00 00 e7c: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) e83: 00 e84: 89 44 24 18 mov %eax,0x18(%rsp) e88: 31 c0 xor %eax,%eax e8a: e8 00 00 00 00 callq e8f de->d_name.len, de->d_name.name, de, de->d_hash.next); LBUG(); e8f: ba 6d 01 00 00 mov $0x16d,%edx e94: 48 c7 c6 00 00 00 00 mov $0x0,%rsi e9b: 48 c7 c7 00 00 00 00 mov $0x0,%rdi ea2: e8 00 00 00 00 callq ea7 /* megahack */ static inline void d_rehash_cond(struct dentry * entry, int lock) { if (!lock) spin_unlock(&dcache_lock); ea7: 48 c7 c7 00 00 00 00 mov $0x0,%rdi eae: e8 00 00 00 00 callq eb3 d_rehash(entry); eb3: 48 89 df mov %rbx,%rdi eb6: e8 00 00 00 00 callq ebb } __d_rehash(de, 0); } ebb: 48 83 c4 48 add $0x48,%rsp d_rehash(entry); if (!lock) spin_lock(&dcache_lock); ebf: 48 c7 c7 00 00 00 00 mov $0x0,%rdi ec6: 5b pop %rbx ec7: 5d pop %rbp d_rehash(entry); if (!lock) spin_lock(&dcache_lock); ec8: e9 00 00 00 00 jmpq ecd ecd: 66 data16 ece: 66 data16 ecf: 90 nop 0000000000000ed0 : /* Search "inode"'s alias list for a dentry that has the same name and parent * as de. If found, return it. If not found, return de. * Lustre can't use d_add_unique because don't unhash aliases for directory * in ll_revalidate_it. After revaliadate inode will be have hashed aliases * and it triggers BUG_ON in d_instantiate_unique (bug #10954). */ static struct dentry *ll_find_alias(struct inode *inode, struct dentry *de) { struct list_head *tmp; struct dentry *dentry; struct dentry *last_discon = NULL; spin_lock(&dcache_lock); list_for_each(tmp, &inode->i_dentry) { dentry = list_entry(tmp, struct dentry, d_alias); /* We are called here with 'de' already on the aliases list. */ if (unlikely(dentry == de)) { CERROR("whoops\n"); continue; } if (dentry->d_flags & DCACHE_DISCONNECTED) { LASSERT(last_discon == NULL); last_discon = dentry; continue; } if (dentry->d_parent != de->d_parent) continue; if (dentry->d_name.hash != de->d_name.hash) continue; if (dentry->d_name.len != de->d_name.len) continue; if (memcmp(dentry->d_name.name, de->d_name.name, de->d_name.len) != 0) continue; dget_locked(dentry); lock_dentry(dentry); __d_drop(dentry); #ifdef DCACHE_LUSTRE_INVALID dentry->d_flags &= ~DCACHE_LUSTRE_INVALID; #endif unlock_dentry(dentry); __d_rehash(dentry, 0); /* avoid taking dcache_lock inside */ spin_unlock(&dcache_lock); iput(inode); CDEBUG(D_DENTRY, "alias dentry %.*s (%p) parent %p inode %p " "refc %d\n", de->d_name.len, de->d_name.name, de, de->d_parent, de->d_inode, atomic_read(&de->d_count)); return dentry; } if (last_discon) { CDEBUG(D_DENTRY, "Reuse disconnected dentry %p inode %p " "refc %d\n", last_discon, last_discon->d_inode, atomic_read(&last_discon->d_count)); dget_locked(last_discon); spin_unlock(&dcache_lock); d_rehash(de); d_move(last_discon, de); iput(inode); return last_discon; } ll_d_add(de, inode); spin_unlock(&dcache_lock); return de; } int lookup_it_finish(struct ptlrpc_request *request, int offset, struct lookup_intent *it, void *data) { ed0: 48 81 ec 88 00 00 00 sub $0x88,%rsp ed7: 4c 89 64 24 68 mov %r12,0x68(%rsp) edc: 4c 89 6c 24 70 mov %r13,0x70(%rsp) ee1: 41 89 f4 mov %esi,%r12d ee4: 4c 89 74 24 78 mov %r14,0x78(%rsp) ee9: 48 89 5c 24 58 mov %rbx,0x58(%rsp) eee: 49 89 fd mov %rdi,%r13 ef1: 48 89 6c 24 60 mov %rbp,0x60(%rsp) ef6: 4c 89 bc 24 80 00 00 mov %r15,0x80(%rsp) efd: 00 struct it_cb_data *icbd = data; struct dentry **de = icbd->icbd_childp; struct inode *parent = icbd->icbd_parent; struct ll_sb_info *sbi = ll_i2sbi(parent); struct inode *inode = NULL; int rc; /* NB 1 request reference will be taken away by ll_intent_lock() * when I return */ if (!it_disposition(it, DISP_LOOKUP_NEG)) { efe: be 04 00 00 00 mov $0x4,%esi f03: 48 8b 19 mov (%rcx),%rbx f06: 48 89 d7 mov %rdx,%rdi f09: 4c 8b 79 08 mov 0x8(%rcx),%r15 f0d: 49 89 d6 mov %rdx,%r14 // FIXME: replace the name of this with LL_SB to conform to kernel stuff static inline struct ll_sb_info *ll_i2sbi(struct inode *inode) { return ll_s2sbi(inode->i_sb); f10: 48 8b 83 08 01 00 00 mov 0x108(%rbx),%rax f17: 48 8b 80 60 02 00 00 mov 0x260(%rax),%rax f1e: 48 8b 68 20 mov 0x20(%rax),%rbp f22: 48 c7 44 24 50 00 00 movq $0x0,0x50(%rsp) f29: 00 00 f2b: e8 00 00 00 00 callq f30 f30: 85 c0 test %eax,%eax f32: 0f 85 68 04 00 00 jne 13a0 ENTRY; f38: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # f3f f3f: 74 4f je f90 f41: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # f48 f48: 79 46 jns f90 f4a: 41 b9 ca 01 00 00 mov $0x1ca,%r9d f50: 49 c7 c0 00 00 00 00 mov $0x0,%r8 f57: 48 c7 c1 00 00 00 00 mov $0x0,%rcx f5e: ba 01 00 00 00 mov $0x1,%edx f63: be 80 00 00 00 mov $0x80,%esi f68: 31 ff xor %edi,%edi f6a: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) f71: 00 00 f73: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) f7a: 00 00 f7c: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) f83: 00 f84: e8 00 00 00 00 callq f89 f89: 66 data16 f8a: 66 data16 f8b: 66 data16 f8c: 90 nop f8d: 66 data16 f8e: 66 data16 f8f: 90 nop rc = ll_prep_inode(sbi->ll_osc_exp, &inode, request, offset, f90: 49 8b 07 mov (%r15),%rax f93: 48 8b 7d 58 mov 0x58(%rbp),%rdi f97: 48 8d 74 24 50 lea 0x50(%rsp),%rsi f9c: 44 89 e1 mov %r12d,%ecx f9f: 4c 89 ea mov %r13,%rdx fa2: 4c 8b 80 88 00 00 00 mov 0x88(%rax),%r8 fa9: e8 00 00 00 00 callq fae (*de)->d_sb); if (rc) fae: 85 c0 test %eax,%eax fb0: 89 c3 mov %eax,%ebx fb2: 74 6c je 1020 RETURN(rc); fb4: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # fbb fbb: 74 5b je 1018 fbd: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # fc4 fc4: 79 52 jns 1018 fc6: 48 98 cltq fc8: 41 b9 cf 01 00 00 mov $0x1cf,%r9d fce: 49 c7 c0 00 00 00 00 mov $0x0,%r8 fd5: 48 89 44 24 28 mov %rax,0x28(%rsp) fda: 48 89 44 24 20 mov %rax,0x20(%rsp) fdf: 48 c7 c1 00 00 00 00 mov $0x0,%rcx fe6: 48 89 44 24 18 mov %rax,0x18(%rsp) feb: ba 01 00 00 00 mov $0x1,%edx ff0: be 80 00 00 00 mov $0x80,%esi ff5: 31 ff xor %edi,%edi ff7: 31 c0 xor %eax,%eax ff9: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 1000: 00 00 1002: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 1009: 00 00 100b: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 1012: 00 1013: e8 00 00 00 00 callq 1018 1018: 89 d8 mov %ebx,%eax 101a: e9 e3 04 00 00 jmpq 1502 101f: 90 nop CDEBUG(D_DLMTRACE, "setting l_data to inode %p (%lu/%u)\n", 1020: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 1027 1027: 74 67 je 1090 1029: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 1030 1030: 79 5e jns 1090 1032: 48 8b 44 24 50 mov 0x50(%rsp),%rax 1037: 41 b9 d2 01 00 00 mov $0x1d2,%r9d 103d: 49 c7 c0 00 00 00 00 mov $0x0,%r8 1044: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 104b: be 80 00 00 00 mov $0x80,%esi 1050: 31 ff xor %edi,%edi 1052: 8b 90 fc 01 00 00 mov 0x1fc(%rax),%edx 1058: 89 54 24 28 mov %edx,0x28(%rsp) 105c: 48 8b 50 30 mov 0x30(%rax),%rdx 1060: 48 89 44 24 18 mov %rax,0x18(%rsp) 1065: 31 c0 xor %eax,%eax 1067: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 106e: 00 00 1070: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 1077: 00 00 1079: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 1080: 00 1081: 48 89 54 24 20 mov %rdx,0x20(%rsp) 1086: ba 00 00 01 00 mov $0x10000,%edx 108b: e8 00 00 00 00 callq 1090 inode, inode->i_ino, inode->i_generation); mdc_set_lock_data(&it->d.lustre.it_lock_handle, inode); 1090: 48 8b 74 24 50 mov 0x50(%rsp),%rsi 1095: 49 8d 7e 18 lea 0x18(%r14),%rdi 1099: 45 31 ed xor %r13d,%r13d 109c: e8 00 00 00 00 callq 10a1 10a1: 48 8b 44 24 50 mov 0x50(%rsp),%rax 10a6: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 10ad: 48 89 44 24 48 mov %rax,0x48(%rsp) 10b2: 4d 8b 27 mov (%r15),%r12 10b5: e8 00 00 00 00 callq 10ba 10ba: 48 8b 44 24 48 mov 0x48(%rsp),%rax 10bf: 48 8b 58 20 mov 0x20(%rax),%rbx 10c3: 4c 8b 03 mov (%rbx),%r8 10c6: 41 0f 18 08 prefetcht0 (%r8) 10ca: 49 89 c6 mov %rax,%r14 10cd: 49 83 c6 20 add $0x20,%r14 10d1: 49 39 de cmp %rbx,%r14 10d4: 0f 84 a1 02 00 00 je 137b 10da: 66 data16 10db: 66 data16 10dc: 90 nop 10dd: 66 data16 10de: 66 data16 10df: 90 nop 10e0: 48 8d 6b 98 lea 0xffffffffffffff98(%rbx),%rbp 10e4: 4c 39 e5 cmp %r12,%rbp 10e7: 75 4e jne 1137 10e9: 49 c7 c0 00 00 00 00 mov $0x0,%r8 10f0: 41 b9 84 01 00 00 mov $0x184,%r9d 10f6: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 10fd: ba 00 00 02 00 mov $0x20000,%edx 1102: be 80 00 00 00 mov $0x80,%esi 1107: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 110e: 31 c0 xor %eax,%eax 1110: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 1117: 00 00 1119: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 1120: 00 00 1122: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 1129: 00 112a: e8 00 00 00 00 callq 112f 112f: 4c 8b 03 mov (%rbx),%r8 1132: e9 89 01 00 00 jmpq 12c0 1137: f6 43 9c 04 testb $0x4,0xffffffffffffff9c(%rbx) 113b: 74 33 je 1170 113d: 4d 85 ed test %r13,%r13 1140: 74 22 je 1164 1142: b9 89 01 00 00 mov $0x189,%ecx 1147: 48 c7 c2 00 00 00 00 mov $0x0,%rdx 114e: 48 c7 c6 00 00 00 00 mov $0x0,%rsi 1155: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 115c: e8 00 00 00 00 callq 1161 1161: 4c 8b 03 mov (%rbx),%r8 1164: 49 89 ed mov %rbp,%r13 1167: e9 54 01 00 00 jmpq 12c0 116c: 66 data16 116d: 66 data16 116e: 66 data16 116f: 90 nop 1170: 49 8b 44 24 18 mov 0x18(%r12),%rax 1175: 48 39 43 b0 cmp %rax,0xffffffffffffffb0(%rbx) 1179: 0f 85 41 01 00 00 jne 12c0 117f: 41 8b 44 24 28 mov 0x28(%r12),%eax 1184: 39 43 c0 cmp %eax,0xffffffffffffffc0(%rbx) 1187: 0f 85 33 01 00 00 jne 12c0 118d: 8b 43 c4 mov 0xffffffffffffffc4(%rbx),%eax 1190: 41 3b 44 24 2c cmp 0x2c(%r12),%eax 1195: 0f 85 25 01 00 00 jne 12c0 119b: 48 8b 73 c8 mov 0xffffffffffffffc8(%rbx),%rsi 119f: 49 8b 7c 24 30 mov 0x30(%r12),%rdi 11a4: 89 c1 mov %eax,%ecx 11a6: fc cld 11a7: 48 39 c9 cmp %rcx,%rcx 11aa: f3 a6 repz cmpsb %es:(%rdi),%ds:(%rsi) 11ac: 0f 85 0e 01 00 00 jne 12c0 11b2: 4c 8d 6d 08 lea 0x8(%rbp),%r13 11b6: 48 89 ef mov %rbp,%rdi 11b9: e8 00 00 00 00 callq 11be 11be: 4c 89 ef mov %r13,%rdi 11c1: e8 00 00 00 00 callq 11c6 11c6: 8b 43 9c mov 0xffffffffffffff9c(%rbx),%eax 11c9: a8 10 test $0x10,%al 11cb: 75 26 jne 11f3 11cd: 83 c8 10 or $0x10,%eax 11d0: 48 8d 4b 50 lea 0x50(%rbx),%rcx 11d4: 89 43 9c mov %eax,0xffffffffffffff9c(%rbx) 11d7: 48 8b 43 50 mov 0x50(%rbx),%rax 11db: 48 8b 51 08 mov 0x8(%rcx),%rdx 11df: 48 85 c0 test %rax,%rax 11e2: 48 89 02 mov %rax,(%rdx) 11e5: 74 04 je 11eb 11e7: 48 89 50 08 mov %rdx,0x8(%rax) 11eb: 48 c7 41 08 00 02 20 movq $0x200200,0x8(%rcx) 11f2: 00 11f3: 4c 89 ef mov %r13,%rdi 11f6: e8 00 00 00 00 callq 11fb /* megahack */ static inline void d_rehash_cond(struct dentry * entry, int lock) { if (!lock) spin_unlock(&dcache_lock); 11fb: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 1202: e8 00 00 00 00 callq 1207 d_rehash(entry); 1207: 48 89 ef mov %rbp,%rdi 120a: e8 00 00 00 00 callq 120f if (!lock) spin_lock(&dcache_lock); 120f: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 1216: e8 00 00 00 00 callq 121b 121b: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 1222: e8 00 00 00 00 callq 1227 1227: 48 8b 7c 24 48 mov 0x48(%rsp),%rdi 122c: e8 00 00 00 00 callq 1231 1231: f6 05 00 00 00 00 20 testb $0x20,0(%rip) # 1238 1238: 74 7e je 12b8 123a: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 1241 1241: 79 75 jns 12b8 1243: 41 8b 04 24 mov (%r12),%eax 1247: 41 b9 a7 01 00 00 mov $0x1a7,%r9d 124d: 49 c7 c0 00 00 00 00 mov $0x0,%r8 1254: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 125b: ba 00 20 00 00 mov $0x2000,%edx 1260: be 80 00 00 00 mov $0x80,%esi 1265: 31 ff xor %edi,%edi 1267: 89 44 24 40 mov %eax,0x40(%rsp) 126b: 49 8b 44 24 10 mov 0x10(%r12),%rax 1270: 48 89 44 24 38 mov %rax,0x38(%rsp) 1275: 49 8b 44 24 18 mov 0x18(%r12),%rax 127a: 4c 89 64 24 28 mov %r12,0x28(%rsp) 127f: 48 89 44 24 30 mov %rax,0x30(%rsp) 1284: 49 8b 44 24 30 mov 0x30(%r12),%rax 1289: 48 89 44 24 20 mov %rax,0x20(%rsp) 128e: 41 8b 44 24 2c mov 0x2c(%r12),%eax 1293: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 129a: 00 00 129c: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 12a3: 00 00 12a5: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 12ac: 00 12ad: 89 44 24 18 mov %eax,0x18(%rsp) 12b1: 31 c0 xor %eax,%eax 12b3: e8 00 00 00 00 callq 12b8 12b8: 48 89 ee mov %rbp,%rsi 12bb: e9 d7 00 00 00 jmpq 1397 12c0: 4c 89 c3 mov %r8,%rbx 12c3: 4d 8b 00 mov (%r8),%r8 12c6: 41 0f 18 08 prefetcht0 (%r8) 12ca: 49 39 de cmp %rbx,%r14 12cd: 0f 85 0d fe ff ff jne 10e0 12d3: 4d 85 ed test %r13,%r13 12d6: 0f 84 9f 00 00 00 je 137b 12dc: f6 05 00 00 00 00 20 testb $0x20,0(%rip) # 12e3 12e3: 74 60 je 1345 12e5: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 12ec 12ec: 79 57 jns 1345 12ee: 41 8b 45 00 mov 0x0(%r13),%eax 12f2: 41 b9 ad 01 00 00 mov $0x1ad,%r9d 12f8: 49 c7 c0 00 00 00 00 mov $0x0,%r8 12ff: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 1306: ba 00 20 00 00 mov $0x2000,%edx 130b: be 80 00 00 00 mov $0x80,%esi 1310: 31 ff xor %edi,%edi 1312: 89 44 24 28 mov %eax,0x28(%rsp) 1316: 49 8b 45 10 mov 0x10(%r13),%rax 131a: 4c 89 6c 24 18 mov %r13,0x18(%rsp) 131f: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 1326: 00 00 1328: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 132f: 00 00 1331: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 1338: 00 1339: 48 89 44 24 20 mov %rax,0x20(%rsp) 133e: 31 c0 xor %eax,%eax 1340: e8 00 00 00 00 callq 1345 1345: 4c 89 ef mov %r13,%rdi 1348: e8 00 00 00 00 callq 134d 134d: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 1354: e8 00 00 00 00 callq 1359 1359: 4c 89 e7 mov %r12,%rdi 135c: e8 00 00 00 00 callq 1361 1361: 4c 89 e6 mov %r12,%rsi 1364: 4c 89 ef mov %r13,%rdi 1367: e8 00 00 00 00 callq 136c 136c: 48 8b 7c 24 48 mov 0x48(%rsp),%rdi 1371: e8 00 00 00 00 callq 1376 1376: 4c 89 ee mov %r13,%rsi 1379: eb 1c jmp 1397 137b: 48 8b 74 24 48 mov 0x48(%rsp),%rsi 1380: 4c 89 e7 mov %r12,%rdi 1383: e8 68 f9 ff ff callq cf0 1388: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 138f: e8 00 00 00 00 callq 1394 1394: 4c 89 e6 mov %r12,%rsi 1397: 49 89 37 mov %rsi,(%r15) 139a: e9 dd 00 00 00 jmpq 147c 139f: 90 nop /* We used to query real size from OSTs here, but actually this is not needed. For stat() calls size would be updated from subsequent do_revalidate()->ll_inode_revalidate_it() in 2.4 and vfs_getattr_it->ll_getattr()->ll_inode_revalidate_it() in 2.6 Everybody else who needs correct file size would call ll_glimpse_size or some equivalent themselves anyway. Also see bug 7198. */ *de = ll_find_alias(inode, *de); } else { ENTRY; 13a0: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 13a7 13a7: 74 4a je 13f3 13a9: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 13b0 13b0: 79 41 jns 13f3 13b2: 41 b9 df 01 00 00 mov $0x1df,%r9d 13b8: 49 c7 c0 00 00 00 00 mov $0x0,%r8 13bf: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 13c6: ba 01 00 00 00 mov $0x1,%edx 13cb: be 80 00 00 00 mov $0x80,%esi 13d0: 31 ff xor %edi,%edi 13d2: 31 c0 xor %eax,%eax 13d4: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 13db: 00 00 13dd: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 13e4: 00 00 13e6: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 13ed: 00 13ee: e8 00 00 00 00 callq 13f3 /* Check that parent has UPDATE lock. If there is none, we cannot afford to hash this dentry (done by ll_d_add) as it might get picked up later when UPDATE lock will appear */ if (ll_have_md_lock(parent, MDS_INODELOCK_UPDATE)) { 13f3: be 02 00 00 00 mov $0x2,%esi 13f8: 48 89 df mov %rbx,%rdi 13fb: e8 00 00 00 00 callq 1400 1400: 85 c0 test %eax,%eax 1402: 74 1c je 1420 spin_lock(&dcache_lock); 1404: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 140b: e8 00 00 00 00 callq 1410 ll_d_add(*de, inode); 1410: 48 8b 74 24 50 mov 0x50(%rsp),%rsi 1415: 49 8b 3f mov (%r15),%rdi 1418: e8 d3 f8 ff ff callq cf0 141d: eb 51 jmp 1470 141f: 90 nop spin_unlock(&dcache_lock); } else { /* We do not want to hash the dentry if don`t have a * lock, but if this dentry is later used in d_move, * we'd hit uninitialised list head d_hash, so we just * do this to init d_hash field but leave dentry * unhashed. (bug 10796). */ d_rehash(*de); 1420: 49 8b 3f mov (%r15),%rdi 1423: e8 00 00 00 00 callq 1428 1428: 49 8b 1f mov (%r15),%rbx 142b: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 1432: e8 00 00 00 00 callq 1437 1437: 8b 43 04 mov 0x4(%rbx),%eax 143a: a8 10 test $0x10,%al 143c: 75 32 jne 1470 143e: 83 c8 10 or $0x10,%eax 1441: 48 8d 8b b8 00 00 00 lea 0xb8(%rbx),%rcx 1448: 89 43 04 mov %eax,0x4(%rbx) 144b: 48 8b 83 b8 00 00 00 mov 0xb8(%rbx),%rax 1452: 48 8b 51 08 mov 0x8(%rcx),%rdx 1456: 48 85 c0 test %rax,%rax 1459: 48 89 02 mov %rax,(%rdx) 145c: 74 04 je 1462 145e: 48 89 50 08 mov %rdx,0x8(%rax) 1462: 48 c7 41 08 00 02 20 movq $0x200200,0x8(%rcx) 1469: 00 146a: 66 data16 146b: 66 data16 146c: 90 nop 146d: 66 data16 146e: 66 data16 146f: 90 nop 1470: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 1477: e8 00 00 00 00 callq 147c d_drop(*de); } } ll_set_dd(*de); 147c: 49 8b 3f mov (%r15),%rdi 147f: e8 00 00 00 00 callq 1484 (*de)->d_op = &ll_d_ops; 1484: 49 8b 07 mov (%r15),%rax 1487: 48 c7 80 80 00 00 00 movq $0x0,0x80(%rax) 148e: 00 00 00 00 RETURN(0); 1492: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 1499 1499: 74 65 je 1500 149b: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 14a2 14a2: 79 5c jns 1500 14a4: 41 b9 f5 01 00 00 mov $0x1f5,%r9d 14aa: 49 c7 c0 00 00 00 00 mov $0x0,%r8 14b1: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 14b8: ba 01 00 00 00 mov $0x1,%edx 14bd: be 80 00 00 00 mov $0x80,%esi 14c2: 31 ff xor %edi,%edi 14c4: 31 c0 xor %eax,%eax 14c6: 48 c7 44 24 28 00 00 movq $0x0,0x28(%rsp) 14cd: 00 00 14cf: 48 c7 44 24 20 00 00 movq $0x0,0x20(%rsp) 14d6: 00 00 14d8: 48 c7 44 24 18 00 00 movq $0x0,0x18(%rsp) 14df: 00 00 14e1: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 14e8: 00 00 14ea: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 14f1: 00 00 14f3: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 14fa: 00 14fb: e8 00 00 00 00 callq 1500 1500: 31 c0 xor %eax,%eax } 1502: 48 8b 5c 24 58 mov 0x58(%rsp),%rbx 1507: 48 8b 6c 24 60 mov 0x60(%rsp),%rbp 150c: 4c 8b 64 24 68 mov 0x68(%rsp),%r12 1511: 4c 8b 6c 24 70 mov 0x70(%rsp),%r13 1516: 4c 8b 74 24 78 mov 0x78(%rsp),%r14 151b: 4c 8b bc 24 80 00 00 mov 0x80(%rsp),%r15 1522: 00 1523: 48 81 c4 88 00 00 00 add $0x88,%rsp 152a: c3 retq 152b: 66 data16 152c: 66 data16 152d: 90 nop 152e: 66 data16 152f: 90 nop 0000000000001530 : static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry, struct lookup_intent *it, int lookup_flags) { 1530: 41 56 push %r14 struct dentry *save = dentry, *retval; struct mdc_op_data op_data; struct it_cb_data icbd; struct ptlrpc_request *req = NULL; struct lookup_intent lookup_it = { .it_op = IT_LOOKUP }; 1532: 31 c0 xor %eax,%eax 1534: 49 89 f6 mov %rsi,%r14 1537: fc cld 1538: 41 55 push %r13 153a: 41 89 cd mov %ecx,%r13d 153d: b9 06 00 00 00 mov $0x6,%ecx 1542: 41 54 push %r12 1544: 55 push %rbp 1545: 48 89 fd mov %rdi,%rbp 1548: 53 push %rbx 1549: 48 81 ec 30 01 00 00 sub $0x130,%rsp 1550: 48 8d 5c 24 70 lea 0x70(%rsp),%rbx 1555: 48 89 74 24 60 mov %rsi,0x60(%rsp) 155a: 48 89 54 24 68 mov %rdx,0x68(%rsp) 155f: 48 c7 44 24 58 00 00 movq $0x0,0x58(%rsp) 1566: 00 00 1568: 48 89 df mov %rbx,%rdi 156b: f3 48 ab repz stos %rax,%es:(%rdi) int rc; ENTRY; 156e: 8b 05 00 00 00 00 mov 0(%rip),%eax # 1574 1574: c7 44 24 70 10 00 00 movl $0x10,0x70(%rsp) 157b: 00 157c: a8 01 test $0x1,%al 157e: 74 50 je 15d0 1580: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 1587 1587: 79 47 jns 15d0 1589: 41 b9 01 02 00 00 mov $0x201,%r9d 158f: 49 c7 c0 00 00 00 00 mov $0x0,%r8 1596: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 159d: ba 01 00 00 00 mov $0x1,%edx 15a2: be 80 00 00 00 mov $0x80,%esi 15a7: 31 ff xor %edi,%edi 15a9: 31 c0 xor %eax,%eax 15ab: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 15b2: 00 00 15b4: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 15bb: 00 00 15bd: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 15c4: 00 15c5: e8 00 00 00 00 callq 15ca 15ca: 8b 05 00 00 00 00 mov 0(%rip),%eax # 15d0 CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),intent=%s\n", 15d0: a9 00 00 20 00 test $0x200000,%eax 15d5: 0f 84 98 00 00 00 je 1673 15db: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 15e2 15e2: 0f 89 8b 00 00 00 jns 1673 15e8: 48 8b 54 24 68 mov 0x68(%rsp),%rdx 15ed: 48 c7 c0 00 00 00 00 mov $0x0,%rax 15f4: 48 85 d2 test %rdx,%rdx 15f7: 74 07 je 1600 15f9: 8b 3a mov (%rdx),%edi 15fb: e8 00 00 00 00 callq 1600 1600: 48 89 44 24 40 mov %rax,0x40(%rsp) 1605: 48 89 6c 24 38 mov %rbp,0x38(%rsp) 160a: 41 b9 05 02 00 00 mov $0x205,%r9d 1610: 8b 85 fc 01 00 00 mov 0x1fc(%rbp),%eax 1616: 48 8b 54 24 60 mov 0x60(%rsp),%rdx 161b: 49 c7 c0 00 00 00 00 mov $0x0,%r8 1622: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 1629: be 80 00 00 00 mov $0x80,%esi 162e: 31 ff xor %edi,%edi 1630: 89 44 24 30 mov %eax,0x30(%rsp) 1634: 48 8b 45 30 mov 0x30(%rbp),%rax 1638: 48 89 44 24 28 mov %rax,0x28(%rsp) 163d: 48 8b 42 30 mov 0x30(%rdx),%rax 1641: 48 89 44 24 20 mov %rax,0x20(%rsp) 1646: 8b 42 2c mov 0x2c(%rdx),%eax 1649: ba 00 00 20 00 mov $0x200000,%edx 164e: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 1655: 00 00 1657: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 165e: 00 00 1660: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 1667: 00 1668: 89 44 24 18 mov %eax,0x18(%rsp) 166c: 31 c0 xor %eax,%eax 166e: e8 00 00 00 00 callq 1673 1673: 48 8b 44 24 60 mov 0x60(%rsp),%rax 1678: 8b 90 c8 00 00 00 mov 0xc8(%rax),%edx 167e: 85 d2 test %edx,%edx 1680: 74 69 je 16eb dentry->d_name.len, dentry->d_name.name, parent->i_ino, parent->i_generation, parent, LL_IT2STR(it)); if (d_mountpoint(dentry)) CERROR("Tell Peter, lookup on mtpt, it %s\n", LL_IT2STR(it)); 1682: 48 8b 54 24 68 mov 0x68(%rsp),%rdx 1687: 48 c7 c0 00 00 00 00 mov $0x0,%rax 168e: 48 85 d2 test %rdx,%rdx 1691: 74 0d je 16a0 1693: 8b 3a mov (%rdx),%edi 1695: e8 00 00 00 00 callq 169a 169a: 66 data16 169b: 66 data16 169c: 90 nop 169d: 66 data16 169e: 66 data16 169f: 90 nop 16a0: 48 89 44 24 18 mov %rax,0x18(%rsp) 16a5: 41 b9 08 02 00 00 mov $0x208,%r9d 16ab: 49 c7 c0 00 00 00 00 mov $0x0,%r8 16b2: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 16b9: ba 00 00 02 00 mov $0x20000,%edx 16be: be 80 00 00 00 mov $0x80,%esi 16c3: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 16ca: 31 c0 xor %eax,%eax 16cc: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 16d3: 00 00 16d5: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 16dc: 00 00 16de: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 16e5: 00 16e6: e8 00 00 00 00 callq 16eb ll_frob_intent(&it, &lookup_it); 16eb: 48 8d 7c 24 68 lea 0x68(%rsp),%rdi 16f0: 48 89 de mov %rbx,%rsi 16f3: e8 00 00 00 00 callq 16f8 /* As do_lookup is called before follow_mount, root dentry may be left * not valid, revalidate it here. */ if (parent->i_sb->s_root && (parent->i_sb->s_root->d_inode == parent) && 16f8: 48 8b 85 08 01 00 00 mov 0x108(%rbp),%rax 16ff: 48 8b 78 70 mov 0x70(%rax),%rdi 1703: 48 85 ff test %rdi,%rdi 1706: 74 6d je 1775 1708: 48 39 6f 10 cmp %rbp,0x10(%rdi) 170c: 75 67 jne 1775 170e: 48 8b 54 24 68 mov 0x68(%rsp),%rdx 1713: f6 02 03 testb $0x3,(%rdx) 1716: 74 62 je 177a (it->it_op & (IT_OPEN | IT_CREAT))) { rc = ll_inode_revalidate_it(parent->i_sb->s_root, it); 1718: 48 89 d6 mov %rdx,%rsi 171b: e8 00 00 00 00 callq 1720 if (rc) 1720: 85 c0 test %eax,%eax 1722: 74 51 je 1775 RETURN(ERR_PTR(rc)); 1724: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 172b 172b: 48 63 d8 movslq %eax,%rbx 172e: 0f 84 1c 04 00 00 je 1b50 1734: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 173b 173b: 0f 89 0f 04 00 00 jns 1b50 1741: 41 b9 12 02 00 00 mov $0x212,%r9d 1747: 48 89 5c 24 28 mov %rbx,0x28(%rsp) 174c: 48 89 5c 24 20 mov %rbx,0x20(%rsp) 1751: 48 89 5c 24 18 mov %rbx,0x18(%rsp) 1756: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 175d: 00 00 175f: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 1766: 00 00 1768: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 176f: 00 1770: e9 8b 00 00 00 jmpq 1800 1775: 48 8b 54 24 68 mov 0x68(%rsp),%rdx } if (it->it_op == IT_GETATTR) { 177a: 83 3a 08 cmpl $0x8,(%rdx) 177d: 0f 85 a3 00 00 00 jne 1826 rc = ll_statahead_enter(parent, &dentry, 1); 1783: 48 8d 74 24 60 lea 0x60(%rsp),%rsi 1788: ba 01 00 00 00 mov $0x1,%edx 178d: 48 89 ef mov %rbp,%rdi 1790: e8 00 00 00 00 callq 1795 if (rc >= 0) { 1795: 85 c0 test %eax,%eax 1797: 89 c3 mov %eax,%ebx 1799: 0f 88 87 00 00 00 js 1826 ll_statahead_exit(dentry, rc); 179f: 48 8b 7c 24 60 mov 0x60(%rsp),%rdi 17a4: 89 c6 mov %eax,%esi 17a6: e8 00 00 00 00 callq 17ab if (rc == 1) 17ab: ff cb dec %ebx 17ad: 75 77 jne 1826 RETURN(retval = dentry); 17af: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 17b6 17b6: 48 8b 5c 24 60 mov 0x60(%rsp),%rbx 17bb: 0f 84 8f 03 00 00 je 1b50 17c1: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 17c8 17c8: 0f 89 82 03 00 00 jns 1b50 17ce: 48 89 5c 24 28 mov %rbx,0x28(%rsp) 17d3: 48 89 5c 24 20 mov %rbx,0x20(%rsp) 17d8: 41 b9 1a 02 00 00 mov $0x21a,%r9d 17de: 48 89 5c 24 18 mov %rbx,0x18(%rsp) 17e3: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 17ea: 00 00 17ec: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 17f3: 00 00 17f5: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 17fc: 00 17fd: 66 data16 17fe: 66 data16 17ff: 90 nop 1800: 49 c7 c0 00 00 00 00 mov $0x0,%r8 1807: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 180e: ba 01 00 00 00 mov $0x1,%edx 1813: be 80 00 00 00 mov $0x80,%esi 1818: 31 ff xor %edi,%edi 181a: 31 c0 xor %eax,%eax 181c: e8 00 00 00 00 callq 1821 1821: e9 2a 03 00 00 jmpq 1b50 } } icbd.icbd_parent = parent; icbd.icbd_childp = &dentry; 1826: 48 8d 44 24 60 lea 0x60(%rsp),%rax 182b: 48 89 ac 24 a0 00 00 mov %rbp,0xa0(%rsp) 1832: 00 rc = ll_prepare_mdc_op_data(&op_data, parent, NULL, dentry->d_name.name, 1833: 4c 8d a4 24 c0 00 00 lea 0xc0(%rsp),%r12 183a: 00 183b: 31 d2 xor %edx,%edx 183d: 45 89 e9 mov %r13d,%r9d 1840: 48 89 ee mov %rbp,%rsi 1843: 48 89 84 24 a8 00 00 mov %rax,0xa8(%rsp) 184a: 00 184b: 48 8b 44 24 60 mov 0x60(%rsp),%rax 1850: 4c 89 e7 mov %r12,%rdi 1853: 44 8b 40 2c mov 0x2c(%rax),%r8d 1857: 48 8b 48 30 mov 0x30(%rax),%rcx 185b: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 1862: 00 1863: e8 00 00 00 00 callq 1868 dentry->d_name.len, lookup_flags, NULL); if (rc) 1868: 85 c0 test %eax,%eax 186a: 74 54 je 18c0 RETURN(ERR_PTR(rc)); 186c: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 1873 1873: 48 63 d8 movslq %eax,%rbx 1876: 0f 84 d4 02 00 00 je 1b50 187c: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 1883 1883: 0f 89 c7 02 00 00 jns 1b50 1889: 41 b9 24 02 00 00 mov $0x224,%r9d 188f: 48 89 5c 24 28 mov %rbx,0x28(%rsp) 1894: 48 89 5c 24 20 mov %rbx,0x20(%rsp) 1899: 48 89 5c 24 18 mov %rbx,0x18(%rsp) 189e: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 18a5: 00 00 18a7: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 18ae: 00 00 18b0: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 18b7: 00 18b8: e9 43 ff ff ff jmpq 1800 18bd: 66 data16 18be: 66 data16 18bf: 90 nop it->it_create_mode &= ~current->fs->umask; 18c0: 48 8b 54 24 68 mov 0x68(%rsp),%rdx 18c5: 65 48 8b 04 25 00 00 mov %gs:0x0,%rax 18cc: 00 00 18ce: 48 8b 80 b0 06 00 00 mov 0x6b0(%rax),%rax return ll_s2obdexp(inode->i_sb); } static inline struct obd_export *ll_i2mdcexp(struct inode *inode) { 18d5: 31 c9 xor %ecx,%ecx 18d7: 45 89 e9 mov %r13d,%r9d 18da: 4c 89 e6 mov %r12,%rsi 18dd: 8b 40 0c mov 0xc(%rax),%eax 18e0: f7 d0 not %eax 18e2: 21 42 08 and %eax,0x8(%rdx) 18e5: 31 d2 xor %edx,%edx 18e7: 48 8b 85 08 01 00 00 mov 0x108(%rbp),%rax 18ee: 4c 8b 44 24 68 mov 0x68(%rsp),%r8 18f3: 48 8b 80 60 02 00 00 mov 0x260(%rax),%rax 18fa: 48 8b 40 20 mov 0x20(%rax),%rax 18fe: 48 8b 78 50 mov 0x50(%rax),%rdi 1902: 48 8d 44 24 58 lea 0x58(%rsp),%rax 1907: c7 44 24 10 00 00 00 movl $0x0,0x10(%rsp) 190e: 00 190f: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 1916: 00 00 1918: 48 89 04 24 mov %rax,(%rsp) 191c: e8 00 00 00 00 callq 1921 rc = mdc_intent_lock(ll_i2mdcexp(parent), &op_data, NULL, 0, it, lookup_flags, &req, ll_mdc_blocking_ast, 0); if (rc < 0) 1921: 85 c0 test %eax,%eax 1923: 79 5b jns 1980 GOTO(out, retval = ERR_PTR(rc)); 1925: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 192c 192c: 48 63 d8 movslq %eax,%rbx 192f: 0f 84 0b 02 00 00 je 1b40 1935: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 193c 193c: 0f 89 fe 01 00 00 jns 1b40 1942: 41 b9 2c 02 00 00 mov $0x22c,%r9d 1948: 48 89 5c 24 30 mov %rbx,0x30(%rsp) 194d: 48 89 5c 24 28 mov %rbx,0x28(%rsp) 1952: 48 89 5c 24 20 mov %rbx,0x20(%rsp) 1957: 48 c7 44 24 18 00 00 movq $0x0,0x18(%rsp) 195e: 00 00 1960: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 1967: 00 00 1969: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 1970: 00 00 1972: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 1979: 00 197a: e9 9e 01 00 00 jmpq 1b1d 197f: 90 nop rc = lookup_it_finish(req, DLM_REPLY_REC_OFF, it, &icbd); 1980: 48 8b 54 24 68 mov 0x68(%rsp),%rdx 1985: 48 8b 7c 24 58 mov 0x58(%rsp),%rdi 198a: 48 8d 8c 24 a0 00 00 lea 0xa0(%rsp),%rcx 1991: 00 1992: be 02 00 00 00 mov $0x2,%esi 1997: e8 00 00 00 00 callq 199c if (rc != 0) { 199c: 85 c0 test %eax,%eax 199e: 89 c3 mov %eax,%ebx 19a0: 74 64 je 1a06 ll_intent_release(it); 19a2: 48 8b 7c 24 68 mov 0x68(%rsp),%rdi 19a7: 48 63 db movslq %ebx,%rbx 19aa: e8 00 00 00 00 callq 19af GOTO(out, retval = ERR_PTR(rc)); 19af: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 19b6 19b6: 0f 84 84 01 00 00 je 1b40 19bc: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 19c3 19c3: 0f 89 77 01 00 00 jns 1b40 19c9: 41 b9 31 02 00 00 mov $0x231,%r9d 19cf: 48 89 5c 24 30 mov %rbx,0x30(%rsp) 19d4: 48 89 5c 24 28 mov %rbx,0x28(%rsp) 19d9: 48 89 5c 24 20 mov %rbx,0x20(%rsp) 19de: 48 c7 44 24 18 00 00 movq $0x0,0x18(%rsp) 19e5: 00 00 19e7: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 19ee: 00 00 19f0: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 19f7: 00 00 19f9: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 1a00: 00 1a01: e9 17 01 00 00 jmpq 1b1d } if ((it->it_op & IT_OPEN) && dentry->d_inode && 1a06: 48 8b 54 24 68 mov 0x68(%rsp),%rdx 1a0b: f6 02 01 testb $0x1,(%rdx) 1a0e: 74 3f je 1a4f 1a10: 48 8b 44 24 60 mov 0x60(%rsp),%rax 1a15: 48 8b 48 10 mov 0x10(%rax),%rcx 1a19: 48 85 c9 test %rcx,%rcx 1a1c: 74 36 je 1a54 1a1e: 0f b7 49 3c movzwl 0x3c(%rcx),%ecx 1a22: 81 e1 00 f0 00 00 and $0xf000,%ecx 1a28: 81 f9 00 80 00 00 cmp $0x8000,%ecx 1a2e: 74 24 je 1a54 1a30: 81 f9 00 40 00 00 cmp $0x4000,%ecx 1a36: 74 1c je 1a54 !S_ISREG(dentry->d_inode->i_mode) && !S_ISDIR(dentry->d_inode->i_mode)) { ll_release_openhandle(dentry, it); 1a38: 48 89 d6 mov %rdx,%rsi 1a3b: 48 89 c7 mov %rax,%rdi 1a3e: e8 00 00 00 00 callq 1a43 1a43: 48 8b 44 24 60 mov 0x60(%rsp),%rax 1a48: 48 8b 54 24 68 mov 0x68(%rsp),%rdx 1a4d: eb 05 jmp 1a54 1a4f: 48 8b 44 24 60 mov 0x60(%rsp),%rax } ll_lookup_finish_locks(it, dentry); 1a54: 48 89 c6 mov %rax,%rsi 1a57: 48 89 d7 mov %rdx,%rdi 1a5a: e8 00 00 00 00 callq 1a5f if (dentry == save) 1a5f: 48 8b 44 24 60 mov 0x60(%rsp),%rax 1a64: 4c 39 f0 cmp %r14,%rax 1a67: 75 67 jne 1ad0 GOTO(out, retval = NULL); 1a69: 31 db xor %ebx,%ebx 1a6b: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 1a72 1a72: 0f 84 c8 00 00 00 je 1b40 1a78: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 1a7f 1a7f: 0f 89 bb 00 00 00 jns 1b40 1a85: 41 b9 3c 02 00 00 mov $0x23c,%r9d 1a8b: 48 c7 44 24 30 00 00 movq $0x0,0x30(%rsp) 1a92: 00 00 1a94: 48 c7 44 24 28 00 00 movq $0x0,0x28(%rsp) 1a9b: 00 00 1a9d: 48 c7 44 24 20 00 00 movq $0x0,0x20(%rsp) 1aa4: 00 00 1aa6: 48 c7 44 24 18 00 00 movq $0x0,0x18(%rsp) 1aad: 00 00 1aaf: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 1ab6: 00 00 1ab8: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 1abf: 00 00 1ac1: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 1ac8: 00 1ac9: eb 52 jmp 1b1d 1acb: 66 data16 1acc: 66 data16 1acd: 90 nop 1ace: 66 data16 1acf: 90 nop else GOTO(out, retval = dentry); 1ad0: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 1ad7 1ad7: 48 89 c3 mov %rax,%rbx 1ada: 74 64 je 1b40 1adc: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 1ae3 1ae3: 79 5b jns 1b40 1ae5: 48 89 44 24 30 mov %rax,0x30(%rsp) 1aea: 48 89 44 24 28 mov %rax,0x28(%rsp) 1aef: 41 b9 3e 02 00 00 mov $0x23e,%r9d 1af5: 48 89 44 24 20 mov %rax,0x20(%rsp) 1afa: 48 c7 44 24 18 00 00 movq $0x0,0x18(%rsp) 1b01: 00 00 1b03: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 1b0a: 00 00 1b0c: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 1b13: 00 00 1b15: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 1b1c: 00 1b1d: 49 c7 c0 00 00 00 00 mov $0x0,%r8 1b24: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 1b2b: ba 01 00 00 00 mov $0x1,%edx 1b30: be 80 00 00 00 mov $0x80,%esi 1b35: 31 ff xor %edi,%edi 1b37: 31 c0 xor %eax,%eax 1b39: e8 00 00 00 00 callq 1b3e 1b3e: 66 data16 1b3f: 90 nop out: if (req) 1b40: 48 8b 7c 24 58 mov 0x58(%rsp),%rdi 1b45: 48 85 ff test %rdi,%rdi 1b48: 74 06 je 1b50 ptlrpc_req_finished(req); 1b4a: e8 00 00 00 00 callq 1b4f 1b4f: 90 nop return retval; } 1b50: 48 81 c4 30 01 00 00 add $0x130,%rsp 1b57: 48 89 d8 mov %rbx,%rax 1b5a: 5b pop %rbx 1b5b: 5d pop %rbp 1b5c: 41 5c pop %r12 1b5e: 41 5d pop %r13 1b60: 41 5e pop %r14 1b62: c3 retq 1b63: 66 data16 1b64: 66 data16 1b65: 66 data16 1b66: 90 nop 1b67: 66 data16 1b68: 66 data16 1b69: 90 nop 1b6a: 66 data16 1b6b: 66 data16 1b6c: 90 nop 1b6d: 66 data16 1b6e: 66 data16 1b6f: 90 nop 0000000000001b70 : #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) #ifdef HAVE_VFS_INTENT_PATCHES static struct dentry *ll_lookup_nd(struct inode *parent, struct dentry *dentry, struct nameidata *nd) { struct dentry *de; ENTRY; if (nd && nd->flags & LOOKUP_LAST && !(nd->flags & LOOKUP_LINK_NOTLAST)) de = ll_lookup_it(parent, dentry, &nd->intent, nd->flags); else de = ll_lookup_it(parent, dentry, NULL, 0); RETURN(de); } #else struct lookup_intent *ll_convert_intent(struct open_intent *oit, int lookup_flags) { 1b70: 48 83 ec 48 sub $0x48,%rsp 1b74: 48 89 6c 24 38 mov %rbp,0x38(%rsp) 1b79: 4c 89 64 24 40 mov %r12,0x40(%rsp) 1b7e: 89 f5 mov %esi,%ebp 1b80: 49 89 fc mov %rdi,%r12 struct lookup_intent *it; OBD_ALLOC(it, sizeof(*it)); 1b83: be 10 00 00 00 mov $0x10,%esi 1b88: bf 30 00 00 00 mov $0x30,%edi 1b8d: 48 89 5c 24 30 mov %rbx,0x30(%rsp) 1b92: e8 00 00 00 00 callq 1b97 1b97: 48 85 c0 test %rax,%rax 1b9a: 48 89 c3 mov %rax,%rbx 1b9d: 0f 84 c2 01 00 00 je 1d65 1ba3: 8b 15 00 00 00 00 mov 0(%rip),%edx # 1ba9 1ba9: 85 d2 test %edx,%edx 1bab: 0f 84 0f 01 00 00 je 1cc0 static inline int obd_fail_check(__u32 id) { static int count = 0; if (likely((obd_fail_loc & OBD_FAIL_MASK_LOC) != 1bb1: 66 81 fa 00 0c cmp $0xc00,%dx 1bb6: 0f 85 04 01 00 00 jne 1cc0 (id & OBD_FAIL_MASK_LOC))) return 0; if ((obd_fail_loc & (OBD_FAILED | OBD_FAIL_ONCE)) == 1bbc: 89 d0 mov %edx,%eax 1bbe: 25 00 00 00 c0 and $0xc0000000,%eax 1bc3: 3d 00 00 00 c0 cmp $0xc0000000,%eax 1bc8: 75 16 jne 1be0 (OBD_FAILED | OBD_FAIL_ONCE)) { count = 0; /* paranoia */ 1bca: c7 05 00 00 00 00 00 movl $0x0,0(%rip) # 1bd4 1bd1: 00 00 00 1bd4: e9 e7 00 00 00 jmpq 1cc0 1bd9: 66 data16 1bda: 66 data16 1bdb: 66 data16 1bdc: 90 nop 1bdd: 66 data16 1bde: 66 data16 1bdf: 90 nop return 0; } if (obd_fail_loc & OBD_FAIL_RAND) { 1be0: f7 c2 00 00 00 08 test $0x8000000,%edx 1be6: 74 28 je 1c10 unsigned int ll_rand(void); if (obd_fail_val < 2) 1be8: 83 3d 00 00 00 00 01 cmpl $0x1,0(%rip) # 1bef 1bef: 0f 86 cb 00 00 00 jbe 1cc0 return 0; if (ll_rand() % obd_fail_val > 0) 1bf5: e8 00 00 00 00 callq 1bfa 1bfa: 31 d2 xor %edx,%edx 1bfc: f7 35 00 00 00 00 divl 0(%rip) # 1c02 1c02: 85 d2 test %edx,%edx 1c04: 0f 85 b6 00 00 00 jne 1cc0 1c0a: 8b 15 00 00 00 00 mov 0(%rip),%edx # 1c10 return 0; } if (obd_fail_loc & OBD_FAIL_SKIP) { 1c10: f7 c2 00 00 00 20 test $0x20000000,%edx 1c16: 74 25 je 1c3d count++; 1c18: 8b 05 00 00 00 00 mov 0(%rip),%eax # 1c1e 1c1e: ff c0 inc %eax if (count < obd_fail_val) 1c20: 3b 05 00 00 00 00 cmp 0(%rip),%eax # 1c26 1c26: 73 0b jae 1c33 1c28: 89 05 00 00 00 00 mov %eax,0(%rip) # 1c2e 1c2e: e9 8d 00 00 00 jmpq 1cc0 return 0; count = 0; 1c33: c7 05 00 00 00 00 00 movl $0x0,0(%rip) # 1c3d 1c3a: 00 00 00 } /* Overridden by FAIL_ONCE */ if (obd_fail_loc & OBD_FAIL_SOME) { 1c3d: f7 c2 00 00 00 10 test $0x10000000,%edx 1c43: 74 28 je 1c6d count++; 1c45: 8b 05 00 00 00 00 mov 0(%rip),%eax # 1c4b 1c4b: ff c0 inc %eax if (count >= obd_fail_val) { 1c4d: 3b 05 00 00 00 00 cmp 0(%rip),%eax # 1c53 1c53: 72 12 jb 1c67 count = 0; /* Don't fail anymore */ obd_fail_loc |= OBD_FAIL_ONCE; 1c55: 81 ca 00 00 00 80 or $0x80000000,%edx 1c5b: c7 05 00 00 00 00 00 movl $0x0,0(%rip) # 1c65 1c62: 00 00 00 1c65: eb 06 jmp 1c6d 1c67: 89 05 00 00 00 00 mov %eax,0(%rip) # 1c6d 1c6d: 8b 0d 00 00 00 00 mov 0(%rip),%ecx # 1c73 } } obd_fail_loc |= OBD_FAILED; 1c73: 81 ca 00 00 00 40 or $0x40000000,%edx 1c79: 89 15 00 00 00 00 mov %edx,0(%rip) # 1c7f 1c7f: 85 c9 test %ecx,%ecx 1c81: 74 3d je 1cc0 1c83: 41 b9 5a 02 00 00 mov $0x25a,%r9d 1c89: 49 c7 c0 00 00 00 00 mov $0x0,%r8 1c90: b9 30 00 00 00 mov $0x30,%ecx 1c95: 48 c7 c2 00 00 00 00 mov $0x0,%rdx 1c9c: 48 c7 c6 00 00 00 00 mov $0x0,%rsi 1ca3: 48 89 df mov %rbx,%rdi 1ca6: e8 00 00 00 00 callq 1cab 1cab: 85 c0 test %eax,%eax 1cad: 74 11 je 1cc0 1caf: 48 89 df mov %rbx,%rdi 1cb2: e8 00 00 00 00 callq 1cb7 1cb7: e9 a9 00 00 00 jmpq 1d65 1cbc: 66 data16 1cbd: 66 data16 1cbe: 66 data16 1cbf: 90 nop 1cc0: fc cld 1cc1: 31 c0 xor %eax,%eax 1cc3: 48 89 df mov %rbx,%rdi 1cc6: b9 06 00 00 00 mov $0x6,%ecx 1ccb: f3 48 ab repz stos %rax,%es:(%rdi) 1cce: f0 83 05 00 00 00 00 lock addl $0x30,0(%rip) # 1cd6 1cd5: 30 1cd6: 8b 05 00 00 00 00 mov 0(%rip),%eax # 1cdc 1cdc: 3b 05 00 00 00 00 cmp 0(%rip),%eax # 1ce2 1ce2: 7e 0c jle 1cf0 1ce4: 8b 05 00 00 00 00 mov 0(%rip),%eax # 1cea 1cea: 89 05 00 00 00 00 mov %eax,0(%rip) # 1cf0 1cf0: f6 05 00 00 00 00 10 testb $0x10,0(%rip) # 1cf7 1cf7: 74 67 je 1d60 1cf9: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 1d00 1d00: 79 5e jns 1d60 1d02: 8b 05 00 00 00 00 mov 0(%rip),%eax # 1d08 1d08: 41 b9 5a 02 00 00 mov $0x25a,%r9d 1d0e: 49 c7 c0 00 00 00 00 mov $0x0,%r8 1d15: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 1d1c: ba 10 00 00 00 mov $0x10,%edx 1d21: be 80 00 00 00 mov $0x80,%esi 1d26: 31 ff xor %edi,%edi 1d28: 48 89 5c 24 20 mov %rbx,0x20(%rsp) 1d2d: c7 44 24 18 30 00 00 movl $0x30,0x18(%rsp) 1d34: 00 1d35: 89 44 24 28 mov %eax,0x28(%rsp) 1d39: 31 c0 xor %eax,%eax 1d3b: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 1d42: 00 00 1d44: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 1d4b: 00 00 1d4d: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 1d54: 00 1d55: e8 00 00 00 00 callq 1d5a 1d5a: 66 data16 1d5b: 66 data16 1d5c: 90 nop 1d5d: 66 data16 1d5e: 66 data16 1d5f: 90 nop if (!it) 1d60: 48 85 db test %rbx,%rbx 1d63: 75 0b jne 1d70 1d65: 48 c7 c0 f4 ff ff ff mov $0xfffffffffffffff4,%rax 1d6c: eb 46 jmp 1db4 1d6e: 66 data16 1d6f: 90 nop return ERR_PTR(-ENOMEM); if (lookup_flags & LOOKUP_OPEN) { 1d70: f7 c5 00 01 00 00 test $0x100,%ebp 1d76: 74 28 je 1da0 it->it_op = IT_OPEN; if (lookup_flags & LOOKUP_CREATE) 1d78: 81 e5 00 02 00 00 and $0x200,%ebp it->it_op |= IT_CREAT; 1d7e: 83 fd 01 cmp $0x1,%ebp 1d81: 19 c0 sbb %eax,%eax 1d83: 83 e0 fe and $0xfffffffffffffffe,%eax 1d86: 83 c0 03 add $0x3,%eax 1d89: 89 03 mov %eax,(%rbx) it->it_create_mode = oit->create_mode; 1d8b: 41 8b 44 24 04 mov 0x4(%r12),%eax 1d90: 89 43 08 mov %eax,0x8(%rbx) it->it_flags = oit->flags; 1d93: 41 8b 04 24 mov (%r12),%eax 1d97: 89 43 04 mov %eax,0x4(%rbx) 1d9a: eb 0a jmp 1da6 1d9c: 66 data16 1d9d: 66 data16 1d9e: 66 data16 1d9f: 90 nop } else { it->it_op = IT_GETATTR; 1da0: c7 03 08 00 00 00 movl $0x8,(%rbx) } #ifndef HAVE_FILE_IN_STRUCT_INTENT /* Since there is no way to pass our intent to ll_file_open, * just check the file is there. Actual open will be done * in ll_file_open */ if (it->it_op & IT_OPEN) 1da6: f6 03 01 testb $0x1,(%rbx) 1da9: 74 06 je 1db1 it->it_op = IT_LOOKUP; 1dab: c7 03 10 00 00 00 movl $0x10,(%rbx) #endif return it; 1db1: 48 89 d8 mov %rbx,%rax } 1db4: 48 8b 5c 24 30 mov 0x30(%rsp),%rbx 1db9: 48 8b 6c 24 38 mov 0x38(%rsp),%rbp 1dbe: 4c 8b 64 24 40 mov 0x40(%rsp),%r12 1dc3: 48 83 c4 48 add $0x48,%rsp 1dc7: c3 retq 1dc8: 66 data16 1dc9: 66 data16 1dca: 66 data16 1dcb: 90 nop 1dcc: 66 data16 1dcd: 66 data16 1dce: 66 data16 1dcf: 90 nop 0000000000001dd0 : static struct dentry *ll_lookup_nd(struct inode *parent, struct dentry *dentry, struct nameidata *nd) { 1dd0: 48 83 ec 58 sub $0x58,%rsp struct dentry *de; ENTRY; 1dd4: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 1ddb 1ddb: 48 89 5c 24 38 mov %rbx,0x38(%rsp) 1de0: 4c 89 64 24 48 mov %r12,0x48(%rsp) 1de5: 48 89 d3 mov %rdx,%rbx 1de8: 4c 89 6c 24 50 mov %r13,0x50(%rsp) 1ded: 48 89 6c 24 40 mov %rbp,0x40(%rsp) 1df2: 49 89 fd mov %rdi,%r13 1df5: 49 89 f4 mov %rsi,%r12 1df8: 74 4a je 1e44 1dfa: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 1e01 1e01: 79 41 jns 1e44 1e03: 41 b9 77 02 00 00 mov $0x277,%r9d 1e09: 49 c7 c0 00 00 00 00 mov $0x0,%r8 1e10: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 1e17: ba 01 00 00 00 mov $0x1,%edx 1e1c: be 80 00 00 00 mov $0x80,%esi 1e21: 31 ff xor %edi,%edi 1e23: 31 c0 xor %eax,%eax 1e25: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 1e2c: 00 00 1e2e: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 1e35: 00 00 1e37: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 1e3e: 00 1e3f: e8 00 00 00 00 callq 1e44 if (nd && !(nd->flags & (LOOKUP_CONTINUE|LOOKUP_PARENT))) { 1e44: 48 85 db test %rbx,%rbx 1e47: 0f 84 08 02 00 00 je 2055 1e4d: 8b 73 20 mov 0x20(%rbx),%esi 1e50: 40 f6 c6 14 test $0x14,%sil 1e54: 0f 85 fb 01 00 00 jne 2055 struct lookup_intent *it; #if defined(HAVE_FILE_IN_STRUCT_INTENT) && (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,17)) /* Did we came here from failed revalidate just to propagate * its error? */ if (nd->flags & LOOKUP_OPEN) if (IS_ERR(nd->intent.open.file)) RETURN((struct dentry *)nd->intent.open.file); #endif if (ll_d2d(dentry) && ll_d2d(dentry)->lld_it) { 1e5a: 49 8b 94 24 90 00 00 mov 0x90(%r12),%rdx 1e61: 00 1e62: 48 85 d2 test %rdx,%rdx 1e65: 74 19 je 1e80 1e67: 48 8b 42 78 mov 0x78(%rdx),%rax 1e6b: 48 85 c0 test %rax,%rax 1e6e: 74 10 je 1e80 it = ll_d2d(dentry)->lld_it; 1e70: 48 89 c5 mov %rax,%rbp ll_d2d(dentry)->lld_it = NULL; 1e73: 48 c7 42 78 00 00 00 movq $0x0,0x78(%rdx) 1e7a: 00 1e7b: e9 80 00 00 00 jmpq 1f00 } else { it = ll_convert_intent(&nd->intent.open, nd->flags); 1e80: 48 8d 7b 78 lea 0x78(%rbx),%rdi 1e84: e8 00 00 00 00 callq 1e89 1e89: 48 3d 18 fc ff ff cmp $0xfffffffffffffc18,%rax 1e8f: 48 89 c5 mov %rax,%rbp 1e92: 76 6c jbe 1f00 if (IS_ERR(it)) RETURN((struct dentry *)it); 1e94: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 1e9b 1e9b: 74 59 je 1ef6 1e9d: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 1ea4 1ea4: 79 50 jns 1ef6 1ea6: 48 89 44 24 28 mov %rax,0x28(%rsp) 1eab: 48 89 44 24 20 mov %rax,0x20(%rsp) 1eb0: 41 b9 8a 02 00 00 mov $0x28a,%r9d 1eb6: 48 89 44 24 18 mov %rax,0x18(%rsp) 1ebb: 49 c7 c0 00 00 00 00 mov $0x0,%r8 1ec2: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 1ec9: ba 01 00 00 00 mov $0x1,%edx 1ece: be 80 00 00 00 mov $0x80,%esi 1ed3: 31 ff xor %edi,%edi 1ed5: 31 c0 xor %eax,%eax 1ed7: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 1ede: 00 00 1ee0: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 1ee7: 00 00 1ee9: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 1ef0: 00 1ef1: e8 00 00 00 00 callq 1ef6 1ef6: 48 89 e8 mov %rbp,%rax 1ef9: e9 d5 01 00 00 jmpq 20d3 1efe: 66 data16 1eff: 90 nop } de = ll_lookup_it(parent, dentry, it, nd->flags); 1f00: 8b 4b 20 mov 0x20(%rbx),%ecx 1f03: 4c 89 e6 mov %r12,%rsi 1f06: 4c 89 ef mov %r13,%rdi 1f09: 48 89 ea mov %rbp,%rdx 1f0c: e8 1f f6 ff ff callq 1530 if (de) dentry = de; 1f11: 48 85 c0 test %rax,%rax 1f14: 49 89 c5 mov %rax,%r13 1f17: 4c 0f 45 e0 cmovne %rax,%r12 if ((nd->flags & LOOKUP_OPEN) && !IS_ERR(dentry)) { /* Open */ 1f1b: f6 43 21 01 testb $0x1,0x21(%rbx) 1f1f: 74 53 je 1f74 1f21: 49 81 fc 18 fc ff ff cmp $0xfffffffffffffc18,%r12 1f28: 77 4a ja 1f74 if (dentry->d_inode && 1f2a: 49 83 7c 24 10 00 cmpq $0x0,0x10(%r12) 1f30: 74 20 je 1f52 1f32: be 20 00 00 00 mov $0x20,%esi 1f37: 48 89 ef mov %rbp,%rdi 1f3a: e8 00 00 00 00 callq 1f3f 1f3f: 85 c0 test %eax,%eax 1f41: 74 0f je 1f52 it_disposition(it, DISP_OPEN_OPEN)) { /* nocreate */ #ifdef HAVE_FILE_IN_STRUCT_INTENT if (S_ISFIFO(dentry->d_inode->i_mode)) { // We cannot call open here as it would // deadlock. ptlrpc_req_finished( (struct ptlrpc_request *) it->d.lustre.it_data); } else { struct file *filp; nd->intent.open.file->private_data = it; filp =lookup_instantiate_filp(nd,dentry, NULL); #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,17)) /* 2.6.1[456] have a bug in open_namei() that forgets to check * nd->intent.open.file for error, so we need to return it as lookup's result * instead */ if (IS_ERR(filp)) { if (de) dput(de); de = (struct dentry *) filp; } #endif } #else /* HAVE_FILE_IN_STRUCT_INTENT */ /* Release open handle as we have no way to * pass it to ll_file_open */ ll_release_openhandle(dentry, it); 1f43: 48 89 ee mov %rbp,%rsi 1f46: 4c 89 e7 mov %r12,%rdi 1f49: e8 00 00 00 00 callq 1f4e 1f4e: 66 data16 1f4f: 90 nop 1f50: eb 22 jmp 1f74 #endif /* HAVE_FILE_IN_STRUCT_INTENT */ } else if (it_disposition(it, DISP_OPEN_CREATE)) { 1f52: be 10 00 00 00 mov $0x10,%esi 1f57: 48 89 ef mov %rbp,%rdi 1f5a: e8 00 00 00 00 callq 1f5f 1f5f: 85 c0 test %eax,%eax 1f61: 74 11 je 1f74 // XXX This can only reliably work on assumption // that there are NO hashed negative dentries. ll_d2d(dentry)->lld_it = it; 1f63: 49 8b 84 24 90 00 00 mov 0x90(%r12),%rax 1f6a: 00 1f6b: 48 89 68 78 mov %rbp,0x78(%rax) 1f6f: e9 f3 00 00 00 jmpq 2067 it = NULL; /* Will be freed in ll_create_nd */ /* We absolutely depend on ll_create_nd to be * called to not leak this intent and possible * data attached to it */ } } if (it) { 1f74: 48 85 ed test %rbp,%rbp 1f77: 0f 84 ea 00 00 00 je 2067 ll_intent_release(it); 1f7d: 48 89 ef mov %rbp,%rdi 1f80: e8 00 00 00 00 callq 1f85 1f85: f0 83 2d 00 00 00 00 lock subl $0x30,0(%rip) # 1f8d 1f8c: 30 OBD_FREE(it, sizeof(*it)); 1f8d: f6 05 00 00 00 00 10 testb $0x10,0(%rip) # 1f94 1f94: 74 61 je 1ff7 1f96: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 1f9d 1f9d: 79 58 jns 1ff7 1f9f: 8b 05 00 00 00 00 mov 0(%rip),%eax # 1fa5 1fa5: 41 b9 bd 02 00 00 mov $0x2bd,%r9d 1fab: 49 c7 c0 00 00 00 00 mov $0x0,%r8 1fb2: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 1fb9: ba 10 00 00 00 mov $0x10,%edx 1fbe: be 80 00 00 00 mov $0x80,%esi 1fc3: 31 ff xor %edi,%edi 1fc5: 48 89 6c 24 20 mov %rbp,0x20(%rsp) 1fca: c7 44 24 18 30 00 00 movl $0x30,0x18(%rsp) 1fd1: 00 1fd2: 89 44 24 28 mov %eax,0x28(%rsp) 1fd6: 31 c0 xor %eax,%eax 1fd8: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 1fdf: 00 00 1fe1: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 1fe8: 00 00 1fea: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 1ff1: 00 1ff2: e8 00 00 00 00 callq 1ff7 1ff7: 49 bb 5a 5a 5a 5a 5a mov $0x5a5a5a5a5a5a5a5a,%r11 1ffe: 5a 5a 5a 2001: 49 ba 5a 5a 5a 5a 5a mov $0x5a5a5a5a5a5a5a5a,%r10 2008: 5a 5a 5a 200b: 49 b9 5a 5a 5a 5a 5a mov $0x5a5a5a5a5a5a5a5a,%r9 2012: 5a 5a 5a 2015: 49 b8 5a 5a 5a 5a 5a mov $0x5a5a5a5a5a5a5a5a,%r8 201c: 5a 5a 5a 201f: 48 bf 5a 5a 5a 5a 5a mov $0x5a5a5a5a5a5a5a5a,%rdi 2026: 5a 5a 5a 2029: 48 be 5a 5a 5a 5a 5a mov $0x5a5a5a5a5a5a5a5a,%rsi 2030: 5a 5a 5a 2033: 48 89 7d 20 mov %rdi,0x20(%rbp) 2037: 4c 89 5d 00 mov %r11,0x0(%rbp) 203b: 48 89 ef mov %rbp,%rdi 203e: 4c 89 55 08 mov %r10,0x8(%rbp) 2042: 4c 89 4d 10 mov %r9,0x10(%rbp) 2046: 4c 89 45 18 mov %r8,0x18(%rbp) 204a: 48 89 75 28 mov %rsi,0x28(%rbp) 204e: e8 00 00 00 00 callq 2053 2053: eb 12 jmp 2067 } } else { de = ll_lookup_it(parent, dentry, NULL, 0); 2055: 4c 89 ef mov %r13,%rdi 2058: 31 c9 xor %ecx,%ecx 205a: 31 d2 xor %edx,%edx 205c: 4c 89 e6 mov %r12,%rsi 205f: e8 cc f4 ff ff callq 1530 2064: 49 89 c5 mov %rax,%r13 } RETURN(de); 2067: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 206e 206e: 74 60 je 20d0 2070: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 2077 2077: 79 57 jns 20d0 2079: 41 b9 c3 02 00 00 mov $0x2c3,%r9d 207f: 49 c7 c0 00 00 00 00 mov $0x0,%r8 2086: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 208d: ba 01 00 00 00 mov $0x1,%edx 2092: be 80 00 00 00 mov $0x80,%esi 2097: 31 ff xor %edi,%edi 2099: 31 c0 xor %eax,%eax 209b: 4c 89 6c 24 28 mov %r13,0x28(%rsp) 20a0: 4c 89 6c 24 20 mov %r13,0x20(%rsp) 20a5: 4c 89 6c 24 18 mov %r13,0x18(%rsp) 20aa: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 20b1: 00 00 20b3: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 20ba: 00 00 20bc: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 20c3: 00 20c4: e8 00 00 00 00 callq 20c9 20c9: 66 data16 20ca: 66 data16 20cb: 66 data16 20cc: 90 nop 20cd: 66 data16 20ce: 66 data16 20cf: 90 nop 20d0: 4c 89 e8 mov %r13,%rax } 20d3: 48 8b 5c 24 38 mov 0x38(%rsp),%rbx 20d8: 48 8b 6c 24 40 mov 0x40(%rsp),%rbp 20dd: 4c 8b 64 24 48 mov 0x48(%rsp),%r12 20e2: 4c 8b 6c 24 50 mov 0x50(%rsp),%r13 20e7: 48 83 c4 58 add $0x58,%rsp 20eb: c3 retq 20ec: 66 data16 20ed: 66 data16 20ee: 66 data16 20ef: 90 nop 00000000000020f0 : #endif #endif /* We depend on "mode" being set with the proper file type/umask by now */ static struct inode *ll_create_node(struct inode *dir, const char *name, int namelen, const void *data, int datalen, int mode, __u64 extra, struct lookup_intent *it) { struct inode *inode = NULL; struct ptlrpc_request *request = NULL; struct ll_sb_info *sbi = ll_i2sbi(dir); int rc; ENTRY; LASSERT(it && it->d.lustre.it_disposition); LASSERT(it_disposition(it, DISP_ENQ_CREATE_REF)); request = it->d.lustre.it_data; it_clear_disposition(it, DISP_ENQ_CREATE_REF); rc = ll_prep_inode(sbi->ll_osc_exp, &inode, request, DLM_REPLY_REC_OFF, dir->i_sb); if (rc) GOTO(out, inode = ERR_PTR(rc)); LASSERT(list_empty(&inode->i_dentry)); /* We asked for a lock on the directory, but were granted a * lock on the inode. Since we finally have an inode pointer, * stuff it in the lock. */ CDEBUG(D_DLMTRACE, "setting l_ast_data to inode %p (%lu/%u)\n", inode, inode->i_ino, inode->i_generation); mdc_set_lock_data(&it->d.lustre.it_lock_handle, inode); EXIT; out: ptlrpc_req_finished(request); return inode; } /* * By the time this is called, we already have created the directory cache * entry for the new file, but it is so far negative - it has no inode. * * We defer creating the OBD object(s) until open, to keep the intent and * non-intent code paths similar, and also because we do not have the MDS * inode number before calling ll_create_node() (which is needed for LOV), * so we would need to do yet another RPC to the MDS to store the LOV EA * data on the MDS. If needed, we would pass the PACKED lmm as data and * lmm_size in datalen (the MDS still has code which will handle that). * * If the create succeeds, we fill in the inode information * with d_instantiate(). */ static int ll_create_it(struct inode *dir, struct dentry *dentry, int mode, struct lookup_intent *it) { struct inode *inode; struct ptlrpc_request *request = it->d.lustre.it_data; int rc = 0; ENTRY; CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),intent=%s\n", dentry->d_name.len, dentry->d_name.name, dir->i_ino, dir->i_generation, dir, LL_IT2STR(it)); rc = it_open_error(DISP_OPEN_CREATE, it); if (rc) RETURN(rc); mdc_store_inode_generation(request, DLM_INTENT_REC_OFF, DLM_REPLY_REC_OFF); inode = ll_create_node(dir, dentry->d_name.name, dentry->d_name.len, NULL, 0, mode, 0, it); if (IS_ERR(inode)) { RETURN(PTR_ERR(inode)); } d_instantiate(dentry, inode); /* Negative dentry may be unhashed if parent does not have UPDATE lock, * but some callers, e.g. do_coredump, expect dentry to be hashed after * successful create. Hash it here. */ spin_lock(&dcache_lock); if (d_unhashed(dentry)) __d_rehash(dentry, 0); spin_unlock(&dcache_lock); RETURN(0); } static void ll_update_times(struct ptlrpc_request *request, int offset, struct inode *inode) { 20f0: 48 83 ec 48 sub $0x48,%rsp 20f4: 48 89 5c 24 38 mov %rbx,0x38(%rsp) 20f9: 48 89 6c 24 40 mov %rbp,0x40(%rsp) 20fe: 48 89 d5 mov %rdx,%rbp struct mds_body *body = lustre_msg_buf(request->rq_repmsg, offset, 2101: 48 8b 7f 70 mov 0x70(%rdi),%rdi 2105: ba a8 00 00 00 mov $0xa8,%edx 210a: e8 00 00 00 00 callq 210f sizeof(*body)); LASSERT(body); 210f: 48 85 c0 test %rax,%rax 2112: 48 89 c3 mov %rax,%rbx 2115: 75 1f jne 2136 2117: b9 22 03 00 00 mov $0x322,%ecx 211c: 48 c7 c2 00 00 00 00 mov $0x0,%rdx 2123: 48 c7 c6 00 00 00 00 mov $0x0,%rsi 212a: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 2131: e8 00 00 00 00 callq 2136 /* mtime is always updated with ctime, but can be set in past. As write and utime(2) may happen within 1 second, and utime's mtime has a priority over write's one, so take mtime from mds for the same ctimes. */ if (body->valid & OBD_MD_FLCTIME && 2136: f6 43 28 08 testb $0x8,0x28(%rbx) 213a: 0f 84 90 00 00 00 je 21d0 2140: 48 8b 43 48 mov 0x48(%rbx),%rax 2144: 48 3b 45 78 cmp 0x78(%rbp),%rax 2148: 0f 82 82 00 00 00 jb 21d0 body->ctime >= LTIME_S(inode->i_ctime)) { LTIME_S(inode->i_ctime) = body->ctime; 214e: 48 89 45 78 mov %rax,0x78(%rbp) if (body->valid & OBD_MD_FLMTIME) { 2152: f6 43 28 04 testb $0x4,0x28(%rbx) 2156: 74 78 je 21d0 CDEBUG(D_INODE, "setting ino %lu mtime from %lu " 2158: f6 05 00 00 00 00 02 testb $0x2,0(%rip) # 215f 215f: 74 65 je 21c6 2161: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 2168 2168: 79 5c jns 21c6 216a: 48 8b 43 38 mov 0x38(%rbx),%rax 216e: 41 b9 2f 03 00 00 mov $0x32f,%r9d 2174: 49 c7 c0 00 00 00 00 mov $0x0,%r8 217b: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 2182: ba 02 00 00 00 mov $0x2,%edx 2187: be 80 00 00 00 mov $0x80,%esi 218c: 31 ff xor %edi,%edi 218e: 48 89 44 24 28 mov %rax,0x28(%rsp) 2193: 48 8b 45 68 mov 0x68(%rbp),%rax 2197: 48 89 44 24 20 mov %rax,0x20(%rsp) 219c: 48 8b 45 30 mov 0x30(%rbp),%rax 21a0: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 21a7: 00 00 21a9: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 21b0: 00 00 21b2: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 21b9: 00 21ba: 48 89 44 24 18 mov %rax,0x18(%rsp) 21bf: 31 c0 xor %eax,%eax 21c1: e8 00 00 00 00 callq 21c6 "to "LPU64"\n", inode->i_ino, LTIME_S(inode->i_mtime), body->mtime); LTIME_S(inode->i_mtime) = body->mtime; 21c6: 48 8b 43 38 mov 0x38(%rbx),%rax 21ca: 48 89 45 68 mov %rax,0x68(%rbp) 21ce: 66 data16 21cf: 90 nop } } } 21d0: 48 8b 5c 24 38 mov 0x38(%rsp),%rbx 21d5: 48 8b 6c 24 40 mov 0x40(%rsp),%rbp 21da: 48 83 c4 48 add $0x48,%rsp 21de: c3 retq 21df: 90 nop 00000000000021e0 : static int ll_new_node(struct inode *dir, struct qstr *name, const char *tgt, int mode, int rdev, struct dentry *dchild) { 21e0: 48 81 ec 18 01 00 00 sub $0x118,%rsp struct ptlrpc_request *request = NULL; struct inode *inode = NULL; struct ll_sb_info *sbi = ll_i2sbi(dir); struct mdc_op_data op_data; int tgt_len = 0; int err; ENTRY; 21e7: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 21ee 21ee: 48 89 9c 24 e8 00 00 mov %rbx,0xe8(%rsp) 21f5: 00 21f6: 48 89 ac 24 f0 00 00 mov %rbp,0xf0(%rsp) 21fd: 00 21fe: 48 89 f3 mov %rsi,%rbx 2201: 4c 89 a4 24 f8 00 00 mov %r12,0xf8(%rsp) 2208: 00 2209: 4c 89 ac 24 00 01 00 mov %r13,0x100(%rsp) 2210: 00 2211: 48 89 fd mov %rdi,%rbp 2214: 4c 89 bc 24 10 01 00 mov %r15,0x110(%rsp) 221b: 00 221c: 4c 89 b4 24 08 01 00 mov %r14,0x108(%rsp) 2223: 00 2224: 49 89 d4 mov %rdx,%r12 2227: 89 4c 24 5c mov %ecx,0x5c(%rsp) 222b: 48 c7 44 24 68 00 00 movq $0x0,0x68(%rsp) 2232: 00 00 2234: 45 89 c7 mov %r8d,%r15d 2237: 48 c7 44 24 60 00 00 movq $0x0,0x60(%rsp) 223e: 00 00 // FIXME: replace the name of this with LL_SB to conform to kernel stuff static inline struct ll_sb_info *ll_i2sbi(struct inode *inode) { return ll_s2sbi(inode->i_sb); 2240: 48 8b 87 08 01 00 00 mov 0x108(%rdi),%rax 2247: 4d 89 cd mov %r9,%r13 // FIXME: replace the name of this with LL_SB to conform to kernel stuff static inline struct ll_sb_info *ll_i2sbi(struct inode *inode) { return ll_s2sbi(inode->i_sb); 224a: 48 8b 80 60 02 00 00 mov 0x260(%rax),%rax 2251: 48 8b 40 20 mov 0x20(%rax),%rax 2255: c7 44 24 4c 00 00 00 movl $0x0,0x4c(%rsp) 225c: 00 // FIXME: replace the name of this with LL_SB to conform to kernel stuff static inline struct ll_sb_info *ll_i2sbi(struct inode *inode) { return ll_s2sbi(inode->i_sb); 225d: 48 89 44 24 50 mov %rax,0x50(%rsp) 2262: 74 4c je 22b0 2264: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 226b 226b: 79 43 jns 22b0 226d: 41 b9 40 03 00 00 mov $0x340,%r9d 2273: 49 c7 c0 00 00 00 00 mov $0x0,%r8 227a: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 2281: ba 01 00 00 00 mov $0x1,%edx 2286: be 80 00 00 00 mov $0x80,%esi 228b: 31 ff xor %edi,%edi 228d: 31 c0 xor %eax,%eax 228f: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 2296: 00 00 2298: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 229f: 00 00 22a1: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 22a8: 00 22a9: e8 00 00 00 00 callq 22ae 22ae: 66 data16 22af: 90 nop if (unlikely(tgt != NULL)) 22b0: 4d 85 e4 test %r12,%r12 22b3: 74 0e je 22c3 tgt_len = strlen(tgt)+1; 22b5: 4c 89 e7 mov %r12,%rdi 22b8: e8 00 00 00 00 callq 22bd 22bd: ff c0 inc %eax 22bf: 89 44 24 4c mov %eax,0x4c(%rsp) err = ll_prepare_mdc_op_data(&op_data, dir, NULL, name->name, 22c3: 44 8b 43 04 mov 0x4(%rbx),%r8d 22c7: 48 8b 4b 08 mov 0x8(%rbx),%rcx 22cb: 4c 8d 74 24 70 lea 0x70(%rsp),%r14 22d0: 45 31 c9 xor %r9d,%r9d 22d3: 31 d2 xor %edx,%edx 22d5: 48 89 ee mov %rbp,%rsi 22d8: 4c 89 f7 mov %r14,%rdi 22db: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 22e2: 00 22e3: e8 00 00 00 00 callq 22e8 name->len, 0, NULL); if (err) 22e8: 85 c0 test %eax,%eax 22ea: 89 c3 mov %eax,%ebx 22ec: 74 59 je 2347 GOTO(err_exit, err); 22ee: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 22f5 22f5: 48 98 cltq 22f7: 0f 84 86 02 00 00 je 2583 22fd: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 2304 2304: 0f 89 79 02 00 00 jns 2583 230a: 41 b9 47 03 00 00 mov $0x347,%r9d 2310: 48 89 44 24 30 mov %rax,0x30(%rsp) 2315: 48 89 44 24 28 mov %rax,0x28(%rsp) 231a: 48 89 44 24 20 mov %rax,0x20(%rsp) 231f: 48 c7 44 24 18 00 00 movq $0x0,0x18(%rsp) 2326: 00 00 2328: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 232f: 00 00 2331: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 2338: 00 00 233a: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 2341: 00 2342: e9 69 01 00 00 jmpq 24b0 2347: 65 48 8b 14 25 00 00 mov %gs:0x0,%rdx 234e: 00 00 2350: 65 48 8b 0c 25 00 00 mov %gs:0x0,%rcx 2357: 00 00 2359: 65 48 8b 04 25 00 00 mov %gs:0x0,%rax 2360: 00 00 2362: 44 8b 88 d4 02 00 00 mov 0x2d4(%rax),%r9d 2369: 48 8b 44 24 50 mov 0x50(%rsp),%rax 236e: 4c 89 f6 mov %r14,%rsi 2371: 44 8b 44 24 5c mov 0x5c(%rsp),%r8d 2376: 48 8b 78 50 mov 0x50(%rax),%rdi 237a: 48 8d 44 24 68 lea 0x68(%rsp),%rax 237f: 48 89 44 24 18 mov %rax,0x18(%rsp) 2384: 49 63 c7 movslq %r15d,%rax 2387: 48 89 44 24 10 mov %rax,0x10(%rsp) 238c: 8b 82 f0 02 00 00 mov 0x2f0(%rdx),%eax 2392: 4c 89 e2 mov %r12,%rdx 2395: 89 44 24 08 mov %eax,0x8(%rsp) 2399: 8b 81 e4 02 00 00 mov 0x2e4(%rcx),%eax 239f: 8b 4c 24 4c mov 0x4c(%rsp),%ecx 23a3: 89 04 24 mov %eax,(%rsp) 23a6: e8 00 00 00 00 callq 23ab err = mdc_create(sbi->ll_mdc_exp, &op_data, tgt, tgt_len, mode, current->fsuid, current->fsgid, current->cap_effective, rdev, &request); if (err) 23ab: 85 c0 test %eax,%eax 23ad: 89 c3 mov %eax,%ebx 23af: 74 5f je 2410 GOTO(err_exit, err); 23b1: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 23b8 23b8: 48 98 cltq 23ba: 0f 84 c3 01 00 00 je 2583 23c0: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 23c7 23c7: 0f 89 b6 01 00 00 jns 2583 23cd: 41 b9 4d 03 00 00 mov $0x34d,%r9d 23d3: 48 89 44 24 30 mov %rax,0x30(%rsp) 23d8: 48 89 44 24 28 mov %rax,0x28(%rsp) 23dd: 48 89 44 24 20 mov %rax,0x20(%rsp) 23e2: 48 c7 44 24 18 00 00 movq $0x0,0x18(%rsp) 23e9: 00 00 23eb: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 23f2: 00 00 23f4: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 23fb: 00 00 23fd: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 2404: 00 2405: e9 a6 00 00 00 jmpq 24b0 240a: 66 data16 240b: 66 data16 240c: 90 nop 240d: 66 data16 240e: 66 data16 240f: 90 nop ll_update_times(request, REPLY_REC_OFF, dir); 2410: 48 8b 7c 24 68 mov 0x68(%rsp),%rdi 2415: 48 89 ea mov %rbp,%rdx 2418: be 01 00 00 00 mov $0x1,%esi 241d: e8 ce fc ff ff callq 20f0 if (dchild) { 2422: 4d 85 ed test %r13,%r13 2425: 0f 84 58 01 00 00 je 2583 err = ll_prep_inode(sbi->ll_osc_exp, &inode, request, 242b: 48 8b 44 24 50 mov 0x50(%rsp),%rax 2430: 48 8b 54 24 68 mov 0x68(%rsp),%rdx 2435: 48 8d 74 24 60 lea 0x60(%rsp),%rsi 243a: 4d 8b 85 88 00 00 00 mov 0x88(%r13),%r8 2441: b9 01 00 00 00 mov $0x1,%ecx 2446: 48 8b 78 58 mov 0x58(%rax),%rdi 244a: e8 00 00 00 00 callq 244f REPLY_REC_OFF, dchild->d_sb); if (err) 244f: 85 c0 test %eax,%eax 2451: 89 c3 mov %eax,%ebx 2453: 0f 84 7d 00 00 00 je 24d6 GOTO(err_exit, err); 2459: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 2460 2460: 48 98 cltq 2462: 0f 84 1b 01 00 00 je 2583 2468: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 246f 246f: 0f 89 0e 01 00 00 jns 2583 2475: 48 89 44 24 30 mov %rax,0x30(%rsp) 247a: 48 89 44 24 28 mov %rax,0x28(%rsp) 247f: 41 b9 55 03 00 00 mov $0x355,%r9d 2485: 48 89 44 24 20 mov %rax,0x20(%rsp) 248a: 48 c7 44 24 18 00 00 movq $0x0,0x18(%rsp) 2491: 00 00 2493: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 249a: 00 00 249c: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 24a3: 00 00 24a5: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 24ac: 00 24ad: 66 data16 24ae: 66 data16 24af: 90 nop 24b0: 49 c7 c0 00 00 00 00 mov $0x0,%r8 24b7: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 24be: ba 01 00 00 00 mov $0x1,%edx 24c3: be 80 00 00 00 mov $0x80,%esi 24c8: 31 ff xor %edi,%edi 24ca: 31 c0 xor %eax,%eax 24cc: e8 00 00 00 00 callq 24d1 24d1: e9 ad 00 00 00 jmpq 2583 24d6: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 24dd: e8 00 00 00 00 callq 24e2 24e2: 41 8b 45 04 mov 0x4(%r13),%eax 24e6: a8 10 test $0x10,%al 24e8: 75 2d jne 2517 24ea: 83 c8 10 or $0x10,%eax 24ed: 49 8d 8d b8 00 00 00 lea 0xb8(%r13),%rcx 24f4: 41 89 45 04 mov %eax,0x4(%r13) 24f8: 49 8b 85 b8 00 00 00 mov 0xb8(%r13),%rax 24ff: 48 8b 51 08 mov 0x8(%rcx),%rdx 2503: 48 85 c0 test %rax,%rax 2506: 48 89 02 mov %rax,(%rdx) 2509: 74 04 je 250f 250b: 48 89 50 08 mov %rdx,0x8(%rax) 250f: 48 c7 41 08 00 02 20 movq $0x200200,0x8(%rcx) 2516: 00 2517: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 251e: e8 00 00 00 00 callq 2523 d_drop(dchild); d_instantiate(dchild, inode); 2523: 48 8b 74 24 60 mov 0x60(%rsp),%rsi 2528: 4c 89 ef mov %r13,%rdi 252b: e8 00 00 00 00 callq 2530 EXIT; 2530: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 2537 2537: 74 4a je 2583 2539: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 2540 2540: 79 41 jns 2583 2542: 41 b9 59 03 00 00 mov $0x359,%r9d 2548: 49 c7 c0 00 00 00 00 mov $0x0,%r8 254f: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 2556: ba 01 00 00 00 mov $0x1,%edx 255b: be 80 00 00 00 mov $0x80,%esi 2560: 31 ff xor %edi,%edi 2562: 31 c0 xor %eax,%eax 2564: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 256b: 00 00 256d: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 2574: 00 00 2576: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 257d: 00 257e: e8 00 00 00 00 callq 2583 } err_exit: ptlrpc_req_finished(request); 2583: 48 8b 7c 24 68 mov 0x68(%rsp),%rdi 2588: e8 00 00 00 00 callq 258d return err; } 258d: 89 d8 mov %ebx,%eax 258f: 48 8b ac 24 f0 00 00 mov 0xf0(%rsp),%rbp 2596: 00 2597: 48 8b 9c 24 e8 00 00 mov 0xe8(%rsp),%rbx 259e: 00 259f: 4c 8b a4 24 f8 00 00 mov 0xf8(%rsp),%r12 25a6: 00 25a7: 4c 8b ac 24 00 01 00 mov 0x100(%rsp),%r13 25ae: 00 25af: 4c 8b b4 24 08 01 00 mov 0x108(%rsp),%r14 25b6: 00 25b7: 4c 8b bc 24 10 01 00 mov 0x110(%rsp),%r15 25be: 00 25bf: 48 81 c4 18 01 00 00 add $0x118,%rsp 25c6: c3 retq 25c7: 66 data16 25c8: 66 data16 25c9: 90 nop 25ca: 66 data16 25cb: 66 data16 25cc: 90 nop 25cd: 66 data16 25ce: 66 data16 25cf: 90 nop 00000000000025d0 : static int ll_mknod_generic(struct inode *dir, struct qstr *name, int mode, unsigned rdev, struct dentry *dchild) { 25d0: 48 81 ec 88 00 00 00 sub $0x88,%rsp int err; ENTRY; 25d7: 8b 05 00 00 00 00 mov 0(%rip),%eax # 25dd 25dd: 48 89 5c 24 58 mov %rbx,0x58(%rsp) 25e2: 4c 89 64 24 68 mov %r12,0x68(%rsp) 25e7: 89 d3 mov %edx,%ebx 25e9: 4c 89 6c 24 70 mov %r13,0x70(%rsp) 25ee: 4c 89 74 24 78 mov %r14,0x78(%rsp) 25f3: 49 89 fc mov %rdi,%r12 25f6: a8 01 test $0x1,%al 25f8: 4c 89 bc 24 80 00 00 mov %r15,0x80(%rsp) 25ff: 00 2600: 48 89 6c 24 60 mov %rbp,0x60(%rsp) 2605: 49 89 f5 mov %rsi,%r13 2608: 41 89 ce mov %ecx,%r14d 260b: 4d 89 c7 mov %r8,%r15 260e: 74 50 je 2660 2610: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 2617 2617: 79 47 jns 2660 2619: 41 b9 66 03 00 00 mov $0x366,%r9d 261f: 49 c7 c0 00 00 00 00 mov $0x0,%r8 2626: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 262d: ba 01 00 00 00 mov $0x1,%edx 2632: be 80 00 00 00 mov $0x80,%esi 2637: 31 ff xor %edi,%edi 2639: 31 c0 xor %eax,%eax 263b: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 2642: 00 00 2644: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 264b: 00 00 264d: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 2654: 00 2655: e8 00 00 00 00 callq 265a 265a: 8b 05 00 00 00 00 mov 0(%rip),%eax # 2660 CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p) mode %o dev %x\n", 2660: a9 00 00 20 00 test $0x200000,%eax 2665: 74 7f je 26e6 2667: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 266e 266e: 79 76 jns 26e6 2670: 41 8b 84 24 fc 01 00 mov 0x1fc(%r12),%eax 2677: 00 2678: 41 b9 6a 03 00 00 mov $0x36a,%r9d 267e: 49 c7 c0 00 00 00 00 mov $0x0,%r8 2685: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 268c: ba 00 00 20 00 mov $0x200000,%edx 2691: be 80 00 00 00 mov $0x80,%esi 2696: 31 ff xor %edi,%edi 2698: 44 89 74 24 48 mov %r14d,0x48(%rsp) 269d: 89 5c 24 40 mov %ebx,0x40(%rsp) 26a1: 89 44 24 30 mov %eax,0x30(%rsp) 26a5: 49 8b 44 24 30 mov 0x30(%r12),%rax 26aa: 4c 89 64 24 38 mov %r12,0x38(%rsp) 26af: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 26b6: 00 00 26b8: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 26bf: 00 00 26c1: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 26c8: 00 26c9: 48 89 44 24 28 mov %rax,0x28(%rsp) 26ce: 49 8b 45 08 mov 0x8(%r13),%rax 26d2: 48 89 44 24 20 mov %rax,0x20(%rsp) 26d7: 41 8b 45 04 mov 0x4(%r13),%eax 26db: 89 44 24 18 mov %eax,0x18(%rsp) 26df: 31 c0 xor %eax,%eax 26e1: e8 00 00 00 00 callq 26e6 26e6: 65 48 8b 04 25 00 00 mov %gs:0x0,%rax 26ed: 00 00 26ef: 48 8b 80 b0 06 00 00 mov 0x6b0(%rax),%rax name->len, name->name, dir->i_ino, dir->i_generation, dir, mode, rdev); mode &= ~current->fs->umask; switch (mode & S_IFMT) { case 0: mode |= S_IFREG; /* for mode = 0 case, fallthrough */ case S_IFREG: case S_IFCHR: case S_IFBLK: case S_IFIFO: case S_IFSOCK: err = ll_new_node(dir, name, NULL, mode, rdev, dchild); break; case S_IFDIR: err = -EPERM; 26f6: bd ff ff ff ff mov $0xffffffff,%ebp 26fb: 8b 40 0c mov 0xc(%rax),%eax 26fe: f7 d0 not %eax 2700: 21 c3 and %eax,%ebx 2702: 89 d8 mov %ebx,%eax 2704: 25 00 f0 00 00 and $0xf000,%eax 2709: 3d 00 40 00 00 cmp $0x4000,%eax 270e: 74 75 je 2785 2710: 7f 20 jg 2732 2712: 3d 00 10 00 00 cmp $0x1000,%eax 2717: 74 47 je 2760 2719: 66 data16 271a: 66 data16 271b: 66 data16 271c: 90 nop 271d: 66 data16 271e: 66 data16 271f: 90 nop 2720: 7f 06 jg 2728 2722: 85 c0 test %eax,%eax 2724: 74 33 je 2759 2726: eb 58 jmp 2780 2728: 3d 00 20 00 00 cmp $0x2000,%eax 272d: 66 data16 272e: 66 data16 272f: 90 nop 2730: eb 23 jmp 2755 2732: 3d 00 80 00 00 cmp $0x8000,%eax 2737: 74 27 je 2760 2739: 66 data16 273a: 66 data16 273b: 66 data16 273c: 90 nop 273d: 66 data16 273e: 66 data16 273f: 90 nop 2740: 7f 0e jg 2750 2742: 3d 00 60 00 00 cmp $0x6000,%eax 2747: eb 0c jmp 2755 2749: 66 data16 274a: 66 data16 274b: 66 data16 274c: 90 nop 274d: 66 data16 274e: 66 data16 274f: 90 nop 2750: 3d 00 c0 00 00 cmp $0xc000,%eax 2755: 74 09 je 2760 2757: eb 27 jmp 2780 2759: 80 cf 80 or $0x80,%bh 275c: 66 data16 275d: 66 data16 275e: 66 data16 275f: 90 nop 2760: 4d 89 f9 mov %r15,%r9 2763: 45 89 f0 mov %r14d,%r8d 2766: 89 d9 mov %ebx,%ecx 2768: 31 d2 xor %edx,%edx 276a: 4c 89 ee mov %r13,%rsi 276d: 4c 89 e7 mov %r12,%rdi 2770: e8 6b fa ff ff callq 21e0 2775: 89 c5 mov %eax,%ebp 2777: eb 0c jmp 2785 2779: 66 data16 277a: 66 data16 277b: 66 data16 277c: 90 nop 277d: 66 data16 277e: 66 data16 277f: 90 nop break; default: err = -EINVAL; 2780: bd ea ff ff ff mov $0xffffffea,%ebp } RETURN(err); 2785: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 278c 278c: 74 62 je 27f0 278e: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 2795 2795: 79 59 jns 27f0 2797: 48 63 c5 movslq %ebp,%rax 279a: 41 b9 7e 03 00 00 mov $0x37e,%r9d 27a0: 49 c7 c0 00 00 00 00 mov $0x0,%r8 27a7: 48 89 44 24 28 mov %rax,0x28(%rsp) 27ac: 48 89 44 24 20 mov %rax,0x20(%rsp) 27b1: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 27b8: 48 89 44 24 18 mov %rax,0x18(%rsp) 27bd: ba 01 00 00 00 mov $0x1,%edx 27c2: be 80 00 00 00 mov $0x80,%esi 27c7: 31 ff xor %edi,%edi 27c9: 31 c0 xor %eax,%eax 27cb: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 27d2: 00 00 27d4: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 27db: 00 00 27dd: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 27e4: 00 27e5: e8 00 00 00 00 callq 27ea 27ea: 66 data16 27eb: 66 data16 27ec: 90 nop 27ed: 66 data16 27ee: 66 data16 27ef: 90 nop } 27f0: 89 e8 mov %ebp,%eax 27f2: 48 8b 5c 24 58 mov 0x58(%rsp),%rbx 27f7: 48 8b 6c 24 60 mov 0x60(%rsp),%rbp 27fc: 4c 8b 64 24 68 mov 0x68(%rsp),%r12 2801: 4c 8b 6c 24 70 mov 0x70(%rsp),%r13 2806: 4c 8b 74 24 78 mov 0x78(%rsp),%r14 280b: 4c 8b bc 24 80 00 00 mov 0x80(%rsp),%r15 2812: 00 2813: 48 81 c4 88 00 00 00 add $0x88,%rsp 281a: c3 retq 281b: 66 data16 281c: 66 data16 281d: 90 nop 281e: 66 data16 281f: 90 nop 0000000000002820 : #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) #ifndef HAVE_VFS_INTENT_PATCHES static int ll_create_nd(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd) { 2820: 48 83 ec 78 sub $0x78,%rsp 2824: 4c 89 64 24 60 mov %r12,0x60(%rsp) 2829: 4c 89 6c 24 68 mov %r13,0x68(%rsp) 282e: 49 89 f4 mov %rsi,%r12 2831: 48 89 5c 24 50 mov %rbx,0x50(%rsp) 2836: 48 89 6c 24 58 mov %rbp,0x58(%rsp) 283b: 49 89 fd mov %rdi,%r13 283e: 4c 89 74 24 70 mov %r14,0x70(%rsp) struct lookup_intent *it = ll_d2d(dentry)->lld_it; 2843: 48 8b 86 90 00 00 00 mov 0x90(%rsi),%rax 284a: 48 8b 58 78 mov 0x78(%rax),%rbx int rc; if (!it) 284e: 48 85 db test %rbx,%rbx 2851: 75 13 jne 2866 return ll_mknod_generic(dir, &dentry->d_name, mode, 0, dentry); 2853: 48 8d 76 28 lea 0x28(%rsi),%rsi 2857: 4d 89 e0 mov %r12,%r8 285a: 31 c9 xor %ecx,%ecx 285c: e8 6f fd ff ff callq 25d0 2861: e9 59 06 00 00 jmpq 2ebf ll_d2d(dentry)->lld_it = NULL; 2866: 48 c7 40 78 00 00 00 movq $0x0,0x78(%rax) 286d: 00 /* Was there an error? Propagate it! */ if (it->d.lustre.it_status) { 286e: 8b 43 14 mov 0x14(%rbx),%eax 2871: 85 c0 test %eax,%eax rc = it->d.lustre.it_status; 2873: 89 c5 mov %eax,%ebp 2875: 0f 85 44 05 00 00 jne 2dbf 287b: 8b 05 00 00 00 00 mov 0(%rip),%eax # 2881 2881: 4c 8b 73 20 mov 0x20(%rbx),%r14 2885: a8 01 test $0x1,%al 2887: 74 57 je 28e0 2889: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 2890 2890: 79 4e jns 28e0 2892: 41 b9 00 03 00 00 mov $0x300,%r9d 2898: 49 c7 c0 00 00 00 00 mov $0x0,%r8 289f: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 28a6: ba 01 00 00 00 mov $0x1,%edx 28ab: be 80 00 00 00 mov $0x80,%esi 28b0: 31 ff xor %edi,%edi 28b2: 31 c0 xor %eax,%eax 28b4: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 28bb: 00 00 28bd: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 28c4: 00 00 28c6: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 28cd: 00 28ce: e8 00 00 00 00 callq 28d3 28d3: 8b 05 00 00 00 00 mov 0(%rip),%eax # 28d9 28d9: 66 data16 28da: 66 data16 28db: 66 data16 28dc: 90 nop 28dd: 66 data16 28de: 66 data16 28df: 90 nop 28e0: a9 00 00 20 00 test $0x200000,%eax 28e5: 0f 84 95 00 00 00 je 2980 28eb: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 28f2 28f2: 0f 89 88 00 00 00 jns 2980 28f8: 48 85 db test %rbx,%rbx 28fb: 48 c7 c0 00 00 00 00 mov $0x0,%rax 2902: 74 07 je 290b 2904: 8b 3b mov (%rbx),%edi 2906: e8 00 00 00 00 callq 290b 290b: 48 89 44 24 40 mov %rax,0x40(%rsp) 2910: 4c 89 6c 24 38 mov %r13,0x38(%rsp) 2915: 41 b9 04 03 00 00 mov $0x304,%r9d 291b: 41 8b 85 fc 01 00 00 mov 0x1fc(%r13),%eax 2922: 49 c7 c0 00 00 00 00 mov $0x0,%r8 2929: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 2930: ba 00 00 20 00 mov $0x200000,%edx 2935: be 80 00 00 00 mov $0x80,%esi 293a: 31 ff xor %edi,%edi 293c: 89 44 24 30 mov %eax,0x30(%rsp) 2940: 49 8b 45 30 mov 0x30(%r13),%rax 2944: 48 89 44 24 28 mov %rax,0x28(%rsp) 2949: 49 8b 44 24 30 mov 0x30(%r12),%rax 294e: 48 89 44 24 20 mov %rax,0x20(%rsp) 2953: 41 8b 44 24 2c mov 0x2c(%r12),%eax 2958: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 295f: 00 00 2961: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 2968: 00 00 296a: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 2971: 00 2972: 89 44 24 18 mov %eax,0x18(%rsp) 2976: 31 c0 xor %eax,%eax 2978: e8 00 00 00 00 callq 297d 297d: 66 data16 297e: 66 data16 297f: 90 nop 2980: 48 89 de mov %rbx,%rsi 2983: bf 10 00 00 00 mov $0x10,%edi 2988: e8 00 00 00 00 callq 298d 298d: 85 c0 test %eax,%eax 298f: 89 c5 mov %eax,%ebp 2991: 74 50 je 29e3 2993: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 299a 299a: 0f 84 48 03 00 00 je 2ce8 29a0: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 29a7 29a7: 0f 89 3b 03 00 00 jns 2ce8 29ad: 48 98 cltq 29af: 41 b9 08 03 00 00 mov $0x308,%r9d 29b5: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 29bc: 00 00 29be: 48 89 44 24 28 mov %rax,0x28(%rsp) 29c3: 48 89 44 24 20 mov %rax,0x20(%rsp) 29c8: 48 89 44 24 18 mov %rax,0x18(%rsp) 29cd: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 29d4: 00 00 29d6: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 29dd: 00 29de: e9 e4 02 00 00 jmpq 2cc7 29e3: ba 02 00 00 00 mov $0x2,%edx 29e8: be 03 00 00 00 mov $0x3,%esi 29ed: 4c 89 f7 mov %r14,%rdi 29f0: e8 00 00 00 00 callq 29f5 29f5: 48 c7 44 24 48 00 00 movq $0x0,0x48(%rsp) 29fc: 00 00 // FIXME: replace the name of this with LL_SB to conform to kernel stuff static inline struct ll_sb_info *ll_i2sbi(struct inode *inode) { return ll_s2sbi(inode->i_sb); 29fe: 49 8b 85 08 01 00 00 mov 0x108(%r13),%rax 2a05: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 2a0c // FIXME: replace the name of this with LL_SB to conform to kernel stuff static inline struct ll_sb_info *ll_i2sbi(struct inode *inode) { return ll_s2sbi(inode->i_sb); 2a0c: 48 8b 80 60 02 00 00 mov 0x260(%rax),%rax 2a13: 48 8b 68 20 mov 0x20(%rax),%rbp 2a17: 74 4a je 2a63 2a19: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 2a20 2a20: 79 41 jns 2a63 2a22: 41 b9 d2 02 00 00 mov $0x2d2,%r9d 2a28: 49 c7 c0 00 00 00 00 mov $0x0,%r8 2a2f: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 2a36: ba 01 00 00 00 mov $0x1,%edx 2a3b: be 80 00 00 00 mov $0x80,%esi 2a40: 31 ff xor %edi,%edi 2a42: 31 c0 xor %eax,%eax 2a44: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 2a4b: 00 00 2a4d: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 2a54: 00 00 2a56: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 2a5d: 00 2a5e: e8 00 00 00 00 callq 2a63 2a63: 48 85 db test %rbx,%rbx 2a66: 74 07 je 2a6f 2a68: 8b 43 10 mov 0x10(%rbx),%eax 2a6b: 85 c0 test %eax,%eax 2a6d: 75 21 jne 2a90 2a6f: b9 d4 02 00 00 mov $0x2d4,%ecx 2a74: 48 c7 c2 00 00 00 00 mov $0x0,%rdx 2a7b: 48 c7 c6 00 00 00 00 mov $0x0,%rsi 2a82: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 2a89: e8 00 00 00 00 callq 2a8e 2a8e: 66 data16 2a8f: 90 nop 2a90: be 00 00 00 01 mov $0x1000000,%esi 2a95: 48 89 df mov %rbx,%rdi 2a98: e8 00 00 00 00 callq 2a9d 2a9d: 85 c0 test %eax,%eax 2a9f: 75 1f jne 2ac0 2aa1: b9 d6 02 00 00 mov $0x2d6,%ecx 2aa6: 48 c7 c2 00 00 00 00 mov $0x0,%rdx 2aad: 48 c7 c6 00 00 00 00 mov $0x0,%rsi 2ab4: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 2abb: e8 00 00 00 00 callq 2ac0 2ac0: 4c 8b 73 20 mov 0x20(%rbx),%r14 2ac4: be 00 00 00 01 mov $0x1000000,%esi 2ac9: 48 89 df mov %rbx,%rdi 2acc: e8 00 00 00 00 callq 2ad1 2ad1: 48 8b 7d 58 mov 0x58(%rbp),%rdi 2ad5: 4d 8b 85 08 01 00 00 mov 0x108(%r13),%r8 2adc: 48 8d 74 24 48 lea 0x48(%rsp),%rsi 2ae1: b9 02 00 00 00 mov $0x2,%ecx 2ae6: 4c 89 f2 mov %r14,%rdx 2ae9: e8 00 00 00 00 callq 2aee 2aee: 85 c0 test %eax,%eax 2af0: 74 7f je 2b71 2af2: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 2af9 2af9: 48 98 cltq 2afb: 48 89 44 24 48 mov %rax,0x48(%rsp) 2b00: 0f 84 6a 01 00 00 je 2c70 2b06: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 2b0d 2b0d: 0f 89 5d 01 00 00 jns 2c70 2b13: 48 89 44 24 30 mov %rax,0x30(%rsp) 2b18: 48 89 44 24 28 mov %rax,0x28(%rsp) 2b1d: 41 b9 dc 02 00 00 mov $0x2dc,%r9d 2b23: 48 89 44 24 20 mov %rax,0x20(%rsp) 2b28: 49 c7 c0 00 00 00 00 mov $0x0,%r8 2b2f: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 2b36: ba 01 00 00 00 mov $0x1,%edx 2b3b: be 80 00 00 00 mov $0x80,%esi 2b40: 31 ff xor %edi,%edi 2b42: 31 c0 xor %eax,%eax 2b44: 48 c7 44 24 18 00 00 movq $0x0,0x18(%rsp) 2b4b: 00 00 2b4d: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 2b54: 00 00 2b56: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 2b5d: 00 00 2b5f: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 2b66: 00 2b67: e8 00 00 00 00 callq 2b6c 2b6c: e9 ff 00 00 00 jmpq 2c70 2b71: 48 8b 74 24 48 mov 0x48(%rsp),%rsi 2b76: 48 8d 46 20 lea 0x20(%rsi),%rax 2b7a: 48 39 46 20 cmp %rax,0x20(%rsi) 2b7e: 74 24 je 2ba4 2b80: 48 c7 c6 00 00 00 00 mov $0x0,%rsi 2b87: b9 de 02 00 00 mov $0x2de,%ecx 2b8c: 48 c7 c2 00 00 00 00 mov $0x0,%rdx 2b93: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 2b9a: e8 00 00 00 00 callq 2b9f 2b9f: 48 8b 74 24 48 mov 0x48(%rsp),%rsi 2ba4: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 2bab 2bab: 74 67 je 2c14 2bad: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 2bb4 2bb4: 79 5e jns 2c14 2bb6: 8b 86 fc 01 00 00 mov 0x1fc(%rsi),%eax 2bbc: 41 b9 e4 02 00 00 mov $0x2e4,%r9d 2bc2: 49 c7 c0 00 00 00 00 mov $0x0,%r8 2bc9: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 2bd0: ba 00 00 01 00 mov $0x10000,%edx 2bd5: 31 ff xor %edi,%edi 2bd7: 89 44 24 28 mov %eax,0x28(%rsp) 2bdb: 48 8b 46 30 mov 0x30(%rsi),%rax 2bdf: 48 89 74 24 18 mov %rsi,0x18(%rsp) 2be4: be 80 00 00 00 mov $0x80,%esi 2be9: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 2bf0: 00 00 2bf2: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 2bf9: 00 00 2bfb: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 2c02: 00 2c03: 48 89 44 24 20 mov %rax,0x20(%rsp) 2c08: 31 c0 xor %eax,%eax 2c0a: e8 00 00 00 00 callq 2c0f 2c0f: 48 8b 74 24 48 mov 0x48(%rsp),%rsi 2c14: 48 8d 7b 18 lea 0x18(%rbx),%rdi 2c18: e8 00 00 00 00 callq 2c1d 2c1d: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 2c24 2c24: 74 4a je 2c70 2c26: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 2c2d 2c2d: 79 41 jns 2c70 2c2f: 41 b9 e6 02 00 00 mov $0x2e6,%r9d 2c35: 49 c7 c0 00 00 00 00 mov $0x0,%r8 2c3c: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 2c43: ba 01 00 00 00 mov $0x1,%edx 2c48: be 80 00 00 00 mov $0x80,%esi 2c4d: 31 ff xor %edi,%edi 2c4f: 31 c0 xor %eax,%eax 2c51: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 2c58: 00 00 2c5a: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 2c61: 00 00 2c63: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 2c6a: 00 2c6b: e8 00 00 00 00 callq 2c70 2c70: 4c 89 f7 mov %r14,%rdi 2c73: e8 00 00 00 00 callq 2c78 2c78: 48 8b 6c 24 48 mov 0x48(%rsp),%rbp 2c7d: 48 81 fd 18 fc ff ff cmp $0xfffffffffffffc18,%rbp 2c84: 76 6a jbe 2cf0 2c86: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 2c8d 2c8d: 74 59 je 2ce8 2c8f: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 2c96 2c96: 79 50 jns 2ce8 2c98: 48 89 6c 24 28 mov %rbp,0x28(%rsp) 2c9d: 48 89 6c 24 20 mov %rbp,0x20(%rsp) 2ca2: 41 b9 0f 03 00 00 mov $0x30f,%r9d 2ca8: 48 89 6c 24 18 mov %rbp,0x18(%rsp) 2cad: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 2cb4: 00 00 2cb6: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 2cbd: 00 00 2cbf: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 2cc6: 00 2cc7: 49 c7 c0 00 00 00 00 mov $0x0,%r8 2cce: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 2cd5: ba 01 00 00 00 mov $0x1,%edx 2cda: be 80 00 00 00 mov $0x80,%esi 2cdf: 31 ff xor %edi,%edi 2ce1: 31 c0 xor %eax,%eax 2ce3: e8 00 00 00 00 callq 2ce8 2ce8: 89 e8 mov %ebp,%eax 2cea: e9 c3 00 00 00 jmpq 2db2 2cef: 90 nop 2cf0: 48 89 ee mov %rbp,%rsi 2cf3: 4c 89 e7 mov %r12,%rdi 2cf6: e8 00 00 00 00 callq 2cfb 2cfb: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 2d02: e8 00 00 00 00 callq 2d07 2d07: 41 f6 44 24 04 10 testb $0x10,0x4(%r12) 2d0d: 74 21 je 2d30 /* megahack */ static inline void d_rehash_cond(struct dentry * entry, int lock) { if (!lock) spin_unlock(&dcache_lock); 2d0f: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 2d16: e8 00 00 00 00 callq 2d1b d_rehash(entry); 2d1b: 4c 89 e7 mov %r12,%rdi 2d1e: e8 00 00 00 00 callq 2d23 if (!lock) spin_lock(&dcache_lock); 2d23: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 2d2a: e8 00 00 00 00 callq 2d2f 2d2f: 90 nop 2d30: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 2d37: e8 00 00 00 00 callq 2d3c 2d3c: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 2d43 2d43: 74 6b je 2db0 2d45: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 2d4c 2d4c: 79 62 jns 2db0 2d4e: 41 b9 1a 03 00 00 mov $0x31a,%r9d 2d54: 49 c7 c0 00 00 00 00 mov $0x0,%r8 2d5b: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 2d62: ba 01 00 00 00 mov $0x1,%edx 2d67: be 80 00 00 00 mov $0x80,%esi 2d6c: 31 ff xor %edi,%edi 2d6e: 31 c0 xor %eax,%eax 2d70: 48 c7 44 24 28 00 00 movq $0x0,0x28(%rsp) 2d77: 00 00 2d79: 48 c7 44 24 20 00 00 movq $0x0,0x20(%rsp) 2d80: 00 00 2d82: 48 c7 44 24 18 00 00 movq $0x0,0x18(%rsp) 2d89: 00 00 2d8b: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 2d92: 00 00 2d94: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 2d9b: 00 00 2d9d: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 2da4: 00 2da5: e8 00 00 00 00 callq 2daa 2daa: 66 data16 2dab: 66 data16 2dac: 90 nop 2dad: 66 data16 2dae: 66 data16 2daf: 90 nop 2db0: 31 c0 xor %eax,%eax goto out; } rc = ll_create_it(dir, dentry, mode, it); #ifdef HAVE_FILE_IN_STRUCT_INTENT if (nd && (nd->flags & LOOKUP_OPEN) && dentry->d_inode) { /* Open */ nd->intent.open.file->private_data = it; lookup_instantiate_filp(nd, dentry, NULL); } #else ll_release_openhandle(dentry,it); 2db2: 48 89 de mov %rbx,%rsi 2db5: 4c 89 e7 mov %r12,%rdi 2db8: 89 c5 mov %eax,%ebp 2dba: e8 00 00 00 00 callq 2dbf #endif out: ll_intent_release(it); 2dbf: 48 89 df mov %rbx,%rdi 2dc2: e8 00 00 00 00 callq 2dc7 OBD_FREE(it, sizeof(*it)); 2dc7: 48 85 db test %rbx,%rbx 2dca: 75 24 jne 2df0 2dcc: b9 9f 03 00 00 mov $0x39f,%ecx 2dd1: 48 c7 c2 00 00 00 00 mov $0x0,%rdx 2dd8: 48 c7 c6 00 00 00 00 mov $0x0,%rsi 2ddf: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 2de6: e8 00 00 00 00 callq 2deb 2deb: 66 data16 2dec: 66 data16 2ded: 90 nop 2dee: 66 data16 2def: 90 nop 2df0: f0 83 2d 00 00 00 00 lock subl $0x30,0(%rip) # 2df8 2df7: 30 2df8: f6 05 00 00 00 00 10 testb $0x10,0(%rip) # 2dff 2dff: 74 61 je 2e62 2e01: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 2e08 2e08: 79 58 jns 2e62 2e0a: 8b 05 00 00 00 00 mov 0(%rip),%eax # 2e10 2e10: 41 b9 9f 03 00 00 mov $0x39f,%r9d 2e16: 49 c7 c0 00 00 00 00 mov $0x0,%r8 2e1d: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 2e24: ba 10 00 00 00 mov $0x10,%edx 2e29: be 80 00 00 00 mov $0x80,%esi 2e2e: 31 ff xor %edi,%edi 2e30: 48 89 5c 24 20 mov %rbx,0x20(%rsp) 2e35: c7 44 24 18 30 00 00 movl $0x30,0x18(%rsp) 2e3c: 00 2e3d: 89 44 24 28 mov %eax,0x28(%rsp) 2e41: 31 c0 xor %eax,%eax 2e43: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 2e4a: 00 00 2e4c: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 2e53: 00 00 2e55: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 2e5c: 00 2e5d: e8 00 00 00 00 callq 2e62 2e62: 48 b8 5a 5a 5a 5a 5a mov $0x5a5a5a5a5a5a5a5a,%rax 2e69: 5a 5a 5a 2e6c: 49 be 5a 5a 5a 5a 5a mov $0x5a5a5a5a5a5a5a5a,%r14 2e73: 5a 5a 5a 2e76: 49 bd 5a 5a 5a 5a 5a mov $0x5a5a5a5a5a5a5a5a,%r13 2e7d: 5a 5a 5a 2e80: 48 89 03 mov %rax,(%rbx) 2e83: 48 b8 5a 5a 5a 5a 5a mov $0x5a5a5a5a5a5a5a5a,%rax 2e8a: 5a 5a 5a 2e8d: 49 bc 5a 5a 5a 5a 5a mov $0x5a5a5a5a5a5a5a5a,%r12 2e94: 5a 5a 5a 2e97: 48 89 43 08 mov %rax,0x8(%rbx) 2e9b: 48 b8 5a 5a 5a 5a 5a mov $0x5a5a5a5a5a5a5a5a,%rax 2ea2: 5a 5a 5a 2ea5: 4c 89 73 18 mov %r14,0x18(%rbx) 2ea9: 48 89 43 10 mov %rax,0x10(%rbx) 2ead: 4c 89 6b 20 mov %r13,0x20(%rbx) 2eb1: 48 89 df mov %rbx,%rdi 2eb4: 4c 89 63 28 mov %r12,0x28(%rbx) 2eb8: e8 00 00 00 00 callq 2ebd return rc; 2ebd: 89 e8 mov %ebp,%eax } 2ebf: 48 8b 5c 24 50 mov 0x50(%rsp),%rbx 2ec4: 48 8b 6c 24 58 mov 0x58(%rsp),%rbp 2ec9: 4c 8b 64 24 60 mov 0x60(%rsp),%r12 2ece: 4c 8b 6c 24 68 mov 0x68(%rsp),%r13 2ed3: 4c 8b 74 24 70 mov 0x70(%rsp),%r14 2ed8: 48 83 c4 78 add $0x78,%rsp 2edc: c3 retq 2edd: 66 data16 2ede: 66 data16 2edf: 90 nop 0000000000002ee0 : #else static int ll_create_nd(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd) { if (!nd || !nd->intent.d.lustre.it_disposition) /* No saved request? Just mknod the file */ return ll_mknod_generic(dir, &dentry->d_name, mode, 0, dentry); return ll_create_it(dir, dentry, mode, &nd->intent); } #endif #endif static int ll_symlink_generic(struct inode *dir, struct qstr *name, const char *tgt, struct dentry *dchild) { int err; ENTRY; CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),target=%.*s\n", name->len, name->name, dir->i_ino, dir->i_generation, dir, 3000, tgt); err = ll_new_node(dir, name, (char *)tgt, S_IFLNK | S_IRWXUGO, 0, dchild); RETURN(err); } static int ll_link_generic(struct inode *src, struct inode *dir, struct qstr *name, struct dentry *dchild) { struct ptlrpc_request *request = NULL; struct mdc_op_data op_data; int err; struct ll_sb_info *sbi = ll_i2sbi(dir); ENTRY; CDEBUG(D_VFSTRACE, "VFS Op: inode=%lu/%u(%p), dir=%lu/%u(%p), target=%.*s\n", src->i_ino, src->i_generation, src, dir->i_ino, dir->i_generation, dir, name->len, name->name); err = ll_prepare_mdc_op_data(&op_data, src, dir, name->name, name->len, 0, NULL); if (err) GOTO(out, err); err = mdc_link(sbi->ll_mdc_exp, &op_data, &request); if (err) GOTO(out, err); if (dchild) { d_drop(dchild); } ll_update_times(request, REPLY_REC_OFF, dir); EXIT; out: ptlrpc_req_finished(request); RETURN(err); } static int ll_mkdir_generic(struct inode *dir, struct qstr *name, int mode, struct dentry *dchild) { int err; ENTRY; CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n", name->len, name->name, dir->i_ino, dir->i_generation, dir); mode = (mode & (S_IRWXUGO|S_ISVTX) & ~current->fs->umask) | S_IFDIR; err = ll_new_node(dir, name, NULL, mode, 0, dchild); RETURN(err); } /* Try to find the child dentry by its name. If found, put the result fid into @fid. */ static void ll_get_child_fid(struct inode * dir, struct qstr *name, struct ll_fid *fid) { 2ee0: 53 push %rbx struct dentry *parent, *child; parent = list_entry(dir->i_dentry.next, struct dentry, d_alias); 2ee1: 48 8b 7f 20 mov 0x20(%rdi),%rdi 2ee5: 48 89 d3 mov %rdx,%rbx 2ee8: 48 83 ef 68 sub $0x68,%rdi child = d_lookup(parent, name); 2eec: e8 00 00 00 00 callq 2ef1 if (child) { 2ef1: 48 85 c0 test %rax,%rax 2ef4: 48 89 c6 mov %rax,%rsi 2ef7: 74 37 je 2f30 if (child->d_inode) 2ef9: 48 8b 50 10 mov 0x10(%rax),%rdx 2efd: 48 85 d2 test %rdx,%rdx 2f00: 74 1e je 2f20 int mdc_done_writing(struct obd_export *exp, struct obdo *); static inline void mdc_pack_fid(struct ll_fid *fid, obd_id ino, __u32 gen, int type) { 2f02: 48 8b 42 30 mov 0x30(%rdx),%rax 2f06: 8b 8a fc 01 00 00 mov 0x1fc(%rdx),%ecx 2f0c: 0f b7 52 3c movzwl 0x3c(%rdx),%edx fid->id = ino; 2f10: 48 89 03 mov %rax,(%rbx) fid->generation = gen; 2f13: 89 4b 08 mov %ecx,0x8(%rbx) 2f16: 81 e2 00 f0 00 00 and $0xf000,%edx fid->f_type = type; 2f1c: 89 53 0c mov %edx,0xc(%rbx) 2f1f: 90 nop ll_inode2fid(fid, child->d_inode); dput(child); } } 2f20: 5b pop %rbx 2f21: 48 89 f7 mov %rsi,%rdi 2f24: e9 00 00 00 00 jmpq 2f29 2f29: 66 data16 2f2a: 66 data16 2f2b: 66 data16 2f2c: 90 nop 2f2d: 66 data16 2f2e: 66 data16 2f2f: 90 nop 2f30: 5b pop %rbx 2f31: c3 retq 2f32: 66 data16 2f33: 66 data16 2f34: 66 data16 2f35: 90 nop 2f36: 66 data16 2f37: 66 data16 2f38: 66 data16 2f39: 90 nop 2f3a: 66 data16 2f3b: 66 data16 2f3c: 90 nop 2f3d: 66 data16 2f3e: 66 data16 2f3f: 90 nop 0000000000002f40 : static int ll_rmdir_generic(struct inode *dir, struct dentry *dparent, struct qstr *name) { struct ptlrpc_request *request = NULL; struct mdc_op_data op_data = {{0}}; struct dentry *dentry; int rc; ENTRY; CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n", name->len, name->name, dir->i_ino, dir->i_generation, dir); /* Check if we have something mounted at the dir we are going to delete * In such a case there would always be dentry present. */ if (dparent) { dentry = d_lookup(dparent, name); if (dentry) { int mounted = d_mountpoint(dentry); dput(dentry); if (mounted) GOTO(out, rc = -EBUSY); } } rc = ll_prepare_mdc_op_data(&op_data, dir, NULL, name->name, name->len, S_IFDIR, NULL); if (rc) GOTO(out, rc); ll_get_child_fid(dir, name, &op_data.fid3); rc = mdc_unlink(ll_i2sbi(dir)->ll_mdc_exp, &op_data, &request); if (rc) GOTO(out, rc); ll_update_times(request, REPLY_REC_OFF, dir); EXIT; out: ptlrpc_req_finished(request); return(rc); } int ll_objects_destroy(struct ptlrpc_request *request, struct inode *dir) { 2f40: 48 81 ec 58 01 00 00 sub $0x158,%rsp struct mds_body *body; struct lov_mds_md *eadata; struct lov_stripe_md *lsm = NULL; struct obd_trans_info oti = { 0 }; 2f47: ba 98 00 00 00 mov $0x98,%edx 2f4c: 4c 89 ac 24 40 01 00 mov %r13,0x140(%rsp) 2f53: 00 2f54: 49 89 fd mov %rdi,%r13 2f57: 48 8d bc 24 80 00 00 lea 0x80(%rsp),%rdi 2f5e: 00 2f5f: 48 89 74 24 70 mov %rsi,0x70(%rsp) 2f64: 31 f6 xor %esi,%esi 2f66: 48 89 9c 24 28 01 00 mov %rbx,0x128(%rsp) 2f6d: 00 2f6e: 48 89 ac 24 30 01 00 mov %rbp,0x130(%rsp) 2f75: 00 2f76: 4c 89 a4 24 38 01 00 mov %r12,0x138(%rsp) 2f7d: 00 2f7e: 4c 89 b4 24 48 01 00 mov %r14,0x148(%rsp) 2f85: 00 2f86: 4c 89 bc 24 50 01 00 mov %r15,0x150(%rsp) 2f8d: 00 2f8e: 48 c7 44 24 78 00 00 movq $0x0,0x78(%rsp) 2f95: 00 00 2f97: e8 00 00 00 00 callq 2f9c struct obdo *oa; int rc; ENTRY; 2f9c: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 2fa3 2fa3: 74 4b je 2ff0 2fa5: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 2fac 2fac: 79 42 jns 2ff0 2fae: 41 b9 30 04 00 00 mov $0x430,%r9d 2fb4: 49 c7 c0 00 00 00 00 mov $0x0,%r8 2fbb: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 2fc2: ba 01 00 00 00 mov $0x1,%edx 2fc7: be 80 00 00 00 mov $0x80,%esi 2fcc: 31 ff xor %edi,%edi 2fce: 31 c0 xor %eax,%eax 2fd0: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 2fd7: 00 00 2fd9: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 2fe0: 00 00 2fe2: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 2fe9: 00 2fea: e8 00 00 00 00 callq 2fef 2fef: 90 nop /* req is swabbed so this is safe */ body = lustre_msg_buf(request->rq_repmsg, REPLY_REC_OFF, sizeof(*body)); 2ff0: 49 8b 7d 70 mov 0x70(%r13),%rdi 2ff4: ba a8 00 00 00 mov $0xa8,%edx 2ff9: be 01 00 00 00 mov $0x1,%esi 2ffe: e8 00 00 00 00 callq 3003 if (!(body->valid & OBD_MD_FLEASIZE)) 3003: f6 40 2a 02 testb $0x2,0x2a(%rax) 3007: 49 89 c4 mov %rax,%r12 300a: 75 7b jne 3087 RETURN(0); 300c: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 3013 3013: 74 6b je 3080 3015: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 301c 301c: 79 62 jns 3080 301e: 41 b9 36 04 00 00 mov $0x436,%r9d 3024: 49 c7 c0 00 00 00 00 mov $0x0,%r8 302b: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 3032: ba 01 00 00 00 mov $0x1,%edx 3037: be 80 00 00 00 mov $0x80,%esi 303c: 31 ff xor %edi,%edi 303e: 31 c0 xor %eax,%eax 3040: 48 c7 44 24 28 00 00 movq $0x0,0x28(%rsp) 3047: 00 00 3049: 48 c7 44 24 20 00 00 movq $0x0,0x20(%rsp) 3050: 00 00 3052: 48 c7 44 24 18 00 00 movq $0x0,0x18(%rsp) 3059: 00 00 305b: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 3062: 00 00 3064: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 306b: 00 00 306d: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 3074: 00 3075: e8 00 00 00 00 callq 307a 307a: 66 data16 307b: 66 data16 307c: 90 nop 307d: 66 data16 307e: 66 data16 307f: 90 nop 3080: 31 c0 xor %eax,%eax 3082: e9 ee 16 00 00 jmpq 4775 if (body->eadatasize == 0) { 3087: 8b 90 94 00 00 00 mov 0x94(%rax),%edx 308d: 85 d2 test %edx,%edx 308f: 0f 85 af 00 00 00 jne 3144 CERROR("OBD_MD_FLEASIZE set but eadatasize zero\n"); 3095: 31 c0 xor %eax,%eax 3097: 41 b9 39 04 00 00 mov $0x439,%r9d 309d: 49 c7 c0 00 00 00 00 mov $0x0,%r8 30a4: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 30ab: ba 00 00 02 00 mov $0x20000,%edx 30b0: be 80 00 00 00 mov $0x80,%esi 30b5: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 30bc: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 30c3: 00 00 30c5: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 30cc: 00 00 30ce: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 30d5: 00 GOTO(out, rc = -EPROTO); 30d6: 41 be b9 ff ff ff mov $0xffffffb9,%r14d 30dc: e8 00 00 00 00 callq 30e1 30e1: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 30e8 30e8: 0f 84 84 16 00 00 je 4772 30ee: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 30f5 30f5: 0f 89 77 16 00 00 jns 4772 30fb: 41 b9 3a 04 00 00 mov $0x43a,%r9d 3101: 48 c7 44 24 30 b9 ff movq $0xffffffffffffffb9,0x30(%rsp) 3108: ff ff 310a: 48 c7 44 24 28 b9 ff movq $0xffffffffffffffb9,0x28(%rsp) 3111: ff ff 3113: 48 c7 44 24 20 b9 ff movq $0xffffffffffffffb9,0x20(%rsp) 311a: ff ff 311c: 48 c7 44 24 18 00 00 movq $0x0,0x18(%rsp) 3123: 00 00 3125: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 312c: 00 00 312e: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 3135: 00 00 3137: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 313e: 00 313f: e9 a6 05 00 00 jmpq 36ea } /* The MDS sent back the EA because we unlinked the last reference * to this file. Use this EA to unlink the objects on the OST. * It's opaque so we don't swab here; we leave it to obd_unpackmd() to * check it is complete and sensible. */ eadata = lustre_swab_repbuf(request, REPLY_REC_OFF + 1, 3144: 31 c9 xor %ecx,%ecx 3146: be 02 00 00 00 mov $0x2,%esi 314b: 4c 89 ef mov %r13,%rdi 314e: e8 00 00 00 00 callq 3153 body->eadatasize, NULL); LASSERT(eadata != NULL); 3153: 48 85 c0 test %rax,%rax 3156: 49 89 c6 mov %rax,%r14 3159: 0f 85 d1 00 00 00 jne 3230 315f: b9 43 04 00 00 mov $0x443,%ecx 3164: 48 c7 c2 00 00 00 00 mov $0x0,%rdx 316b: 48 c7 c6 00 00 00 00 mov $0x0,%rsi 3172: 48 c7 c7 00 00 00 00 mov $0x0,%rdi if (eadata == NULL) { CERROR("Can't unpack MDS EA data\n"); GOTO(out, rc = -EPROTO); 3179: 41 be b9 ff ff ff mov $0xffffffb9,%r14d 317f: e8 00 00 00 00 callq 3184 3184: 31 c0 xor %eax,%eax 3186: 41 b9 45 04 00 00 mov $0x445,%r9d 318c: 49 c7 c0 00 00 00 00 mov $0x0,%r8 3193: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 319a: ba 00 00 02 00 mov $0x20000,%edx 319f: be 80 00 00 00 mov $0x80,%esi 31a4: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 31ab: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 31b2: 00 00 31b4: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 31bb: 00 00 31bd: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 31c4: 00 31c5: e8 00 00 00 00 callq 31ca 31ca: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 31d1 31d1: 0f 84 9b 15 00 00 je 4772 31d7: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 31de 31de: 0f 89 8e 15 00 00 jns 4772 31e4: 41 b9 46 04 00 00 mov $0x446,%r9d 31ea: 48 c7 44 24 30 b9 ff movq $0xffffffffffffffb9,0x30(%rsp) 31f1: ff ff 31f3: 48 c7 44 24 28 b9 ff movq $0xffffffffffffffb9,0x28(%rsp) 31fa: ff ff 31fc: 48 c7 44 24 20 b9 ff movq $0xffffffffffffffb9,0x20(%rsp) 3203: ff ff 3205: 48 c7 44 24 18 00 00 movq $0x0,0x18(%rsp) 320c: 00 00 320e: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 3215: 00 00 3217: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 321e: 00 00 3220: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 3227: 00 3228: e9 bd 04 00 00 jmpq 36ea 322d: 66 data16 322e: 66 data16 322f: 90 nop #endif /* don't need an addref as the sb_info should be holding one */ static inline struct obd_export *ll_s2obdexp(struct super_block *sb) { 3230: 48 8b 54 24 70 mov 0x70(%rsp),%rdx struct lov_mds_md *disk_src, int disk_len) { int rc; ENTRY; 3235: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 323c #endif /* don't need an addref as the sb_info should be holding one */ static inline struct obd_export *ll_s2obdexp(struct super_block *sb) { 323c: 48 8b 82 08 01 00 00 mov 0x108(%rdx),%rax return ll_s2sbi(sb)->ll_osc_exp; 3243: 48 8b 80 60 02 00 00 mov 0x260(%rax),%rax 324a: 48 8b 40 20 mov 0x20(%rax),%rax 324e: 48 8b 58 58 mov 0x58(%rax),%rbx static inline int obd_unpackmd(struct obd_export *exp, struct lov_stripe_md **mem_tgt, struct lov_mds_md *disk_src, int disk_len) { 3252: 41 8b 84 24 94 00 00 mov 0x94(%r12),%eax 3259: 00 325a: 89 44 24 6c mov %eax,0x6c(%rsp) int rc; ENTRY; 325e: 74 50 je 32b0 3260: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 3267 3267: 79 47 jns 32b0 3269: 41 b9 b7 01 00 00 mov $0x1b7,%r9d 326f: 49 c7 c0 00 00 00 00 mov $0x0,%r8 3276: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 327d: ba 01 00 00 00 mov $0x1,%edx 3282: be 80 00 00 00 mov $0x80,%esi 3287: 31 ff xor %edi,%edi 3289: 31 c0 xor %eax,%eax 328b: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 3292: 00 00 3294: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 329b: 00 00 329d: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 32a4: 00 32a5: e8 00 00 00 00 callq 32aa 32aa: 66 data16 32ab: 66 data16 32ac: 90 nop 32ad: 66 data16 32ae: 66 data16 32af: 90 nop EXP_CHECK_OP(exp, unpackmd); 32b0: 48 85 db test %rbx,%rbx 32b3: 0f 85 be 00 00 00 jne 3377 32b9: 31 c0 xor %eax,%eax 32bb: 41 b9 b9 01 00 00 mov $0x1b9,%r9d 32c1: 49 c7 c0 00 00 00 00 mov $0x0,%r8 32c8: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 32cf: ba 00 00 02 00 mov $0x20000,%edx 32d4: be 80 00 00 00 mov $0x80,%esi 32d9: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 32e0: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 32e7: 00 00 32e9: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 32f0: 00 00 32f2: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 32f9: 00 32fa: e8 00 00 00 00 callq 32ff 32ff: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 3306 3306: 74 65 je 336d 3308: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 330f 330f: 79 5c jns 336d 3311: 41 b9 b9 01 00 00 mov $0x1b9,%r9d 3317: 49 c7 c0 00 00 00 00 mov $0x0,%r8 331e: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 3325: ba 01 00 00 00 mov $0x1,%edx 332a: be 80 00 00 00 mov $0x80,%esi 332f: 31 ff xor %edi,%edi 3331: 31 c0 xor %eax,%eax 3333: 48 c7 44 24 28 ed ff movq $0xffffffffffffffed,0x28(%rsp) 333a: ff ff 333c: 48 c7 44 24 20 ed ff movq $0xffffffffffffffed,0x20(%rsp) 3343: ff ff 3345: 48 c7 44 24 18 ed ff movq $0xffffffffffffffed,0x18(%rsp) 334c: ff ff 334e: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 3355: 00 00 3357: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 335e: 00 00 3360: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 3367: 00 3368: e8 00 00 00 00 callq 336d 336d: b8 ed ff ff ff mov $0xffffffed,%eax 3372: e9 c9 02 00 00 jmpq 3640 3377: 48 8b 93 c0 00 00 00 mov 0xc0(%rbx),%rdx 337e: 48 85 d2 test %rdx,%rdx 3381: 74 08 je 338b 3383: 48 8b 02 mov (%rdx),%rax 3386: 48 85 c0 test %rax,%rax 3389: 75 48 jne 33d3 338b: 41 b9 b9 01 00 00 mov $0x1b9,%r9d 3391: 49 c7 c0 00 00 00 00 mov $0x0,%r8 3398: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 339f: ba 00 00 02 00 mov $0x20000,%edx 33a4: be 80 00 00 00 mov $0x80,%esi 33a9: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 33b0: 31 c0 xor %eax,%eax 33b2: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 33b9: 00 00 33bb: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 33c2: 00 00 33c4: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 33cb: 00 33cc: e8 00 00 00 00 callq 33d1 33d1: eb 62 jmp 3435 33d3: 48 8b 40 10 mov 0x10(%rax),%rax 33d7: 48 83 b8 98 00 00 00 cmpq $0x0,0x98(%rax) 33de: 00 33df: 0f 85 c8 00 00 00 jne 34ad 33e5: 8b 82 b4 00 00 00 mov 0xb4(%rdx),%eax 33eb: 41 b9 b9 01 00 00 mov $0x1b9,%r9d 33f1: 49 c7 c0 00 00 00 00 mov $0x0,%r8 33f8: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 33ff: ba 00 00 02 00 mov $0x20000,%edx 3404: be 80 00 00 00 mov $0x80,%esi 3409: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 3410: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 3417: 00 00 3419: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 3420: 00 00 3422: 89 44 24 18 mov %eax,0x18(%rsp) 3426: 31 c0 xor %eax,%eax 3428: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 342f: 00 3430: e8 00 00 00 00 callq 3435 3435: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 343c 343c: 74 65 je 34a3 343e: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 3445 3445: 79 5c jns 34a3 3447: 41 b9 b9 01 00 00 mov $0x1b9,%r9d 344d: 49 c7 c0 00 00 00 00 mov $0x0,%r8 3454: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 345b: ba 01 00 00 00 mov $0x1,%edx 3460: be 80 00 00 00 mov $0x80,%esi 3465: 31 ff xor %edi,%edi 3467: 31 c0 xor %eax,%eax 3469: 48 c7 44 24 28 a1 ff movq $0xffffffffffffffa1,0x28(%rsp) 3470: ff ff 3472: 48 c7 44 24 20 a1 ff movq $0xffffffffffffffa1,0x20(%rsp) 3479: ff ff 347b: 48 c7 44 24 18 a1 ff movq $0xffffffffffffffa1,0x18(%rsp) 3482: ff ff 3484: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 348b: 00 00 348d: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 3494: 00 00 3496: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 349d: 00 349e: e8 00 00 00 00 callq 34a3 34a3: b8 a1 ff ff ff mov $0xffffffa1,%eax 34a8: e9 93 01 00 00 jmpq 3640 EXP_COUNTER_INCREMENT(exp, unpackmd); 34ad: 48 8b 82 78 14 00 00 mov 0x1478(%rdx),%rax 34b4: 48 85 c0 test %rax,%rax 34b7: 0f 84 fd 00 00 00 je 35ba 34bd: 44 8b ba 88 14 00 00 mov 0x1488(%rdx),%r15d 34c4: 41 83 c7 12 add $0x12,%r15d 34c8: 44 39 38 cmp %r15d,(%rax) 34cb: 77 26 ja 34f3 34cd: 48 c7 c2 00 00 00 00 mov $0x0,%rdx 34d4: b9 ba 01 00 00 mov $0x1ba,%ecx 34d9: 48 c7 c6 00 00 00 00 mov $0x0,%rsi 34e0: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 34e7: e8 00 00 00 00 callq 34ec 34ec: 48 8b 93 c0 00 00 00 mov 0xc0(%rbx),%rdx lprocfs_stats_unlock(stats); } static inline void lprocfs_counter_incr(struct lprocfs_stats *stats, int idx) { 34f3: 48 8b aa 78 14 00 00 mov 0x1478(%rdx),%rbp struct lprocfs_counter *percpu_cntr; int smp_id; if (!stats) 34fa: 48 85 ed test %rbp,%rbp 34fd: 74 54 je 3553 34ff: c7 44 24 68 00 00 00 movl $0x0,0x68(%rsp) 3506: 00 3507: f6 45 08 01 testb $0x1,0x8(%rbp) 350b: 74 0b je 3518 350d: 48 8d 7d 0c lea 0xc(%rbp),%rdi 3511: e8 00 00 00 00 callq 3516 3516: eb 0c jmp 3524 3518: 65 8b 14 25 34 00 00 mov %gs:0x34,%edx 351f: 00 3520: 89 54 24 68 mov %edx,0x68(%rsp) return; smp_id = lprocfs_stats_lock(stats, LPROCFS_GET_SMP_ID); percpu_cntr = &(stats->ls_percpu[smp_id]->lp_cntr[idx]); 3524: 48 63 44 24 68 movslq 0x68(%rsp),%rax 3529: 49 63 d7 movslq %r15d,%rdx 352c: 48 8d 14 d2 lea (%rdx,%rdx,8),%rdx 3530: 48 8b 44 c5 18 mov 0x18(%rbp,%rax,8),%rax 3535: 48 8d 14 d0 lea (%rax,%rdx,8),%rdx 3539: f0 ff 02 lock incl (%rdx) atomic_inc(&percpu_cntr->lc_cntl.la_entry); percpu_cntr->lc_count++; 353c: 48 ff 42 10 incq 0x10(%rdx) 3540: f0 ff 42 04 lock incl 0x4(%rdx) 3544: f6 45 08 01 testb $0x1,0x8(%rbp) 3548: 74 09 je 3553 354a: 48 8d 7d 0c lea 0xc(%rbp),%rdi 354e: e8 00 00 00 00 callq 3553 int rc; ENTRY; EXP_CHECK_OP(exp, unpackmd); EXP_COUNTER_INCREMENT(exp, unpackmd); 3553: 48 8b ab d8 00 00 00 mov 0xd8(%rbx),%rbp 355a: 48 85 ed test %rbp,%rbp 355d: 74 54 je 35b3 #ifdef LPROCFS static inline int lprocfs_stats_lock(struct lprocfs_stats *stats, int type) { int rc = 0; 355f: c7 44 24 64 00 00 00 movl $0x0,0x64(%rsp) 3566: 00 if (stats->ls_flags & LPROCFS_STATS_FLAG_NOPERCPU) { 3567: f6 45 08 01 testb $0x1,0x8(%rbp) 356b: 74 0b je 3578 if (type & LPROCFS_GET_NUM_CPU) rc = 1; if (type & LPROCFS_GET_SMP_ID) rc = 0; spin_lock(&stats->ls_lock); 356d: 48 8d 7d 0c lea 0xc(%rbp),%rdi 3571: e8 00 00 00 00 callq 3576 3576: eb 0c jmp 3584 } else { if (type & LPROCFS_GET_NUM_CPU) rc = num_possible_cpus(); if (type & LPROCFS_GET_SMP_ID) rc = smp_processor_id(); 3578: 65 8b 04 25 34 00 00 mov %gs:0x34,%eax 357f: 00 3580: 89 44 24 64 mov %eax,0x64(%rsp) } return rc; } static inline void lprocfs_stats_unlock(struct lprocfs_stats *stats) { if (stats->ls_flags & LPROCFS_STATS_FLAG_NOPERCPU) spin_unlock(&stats->ls_lock); } /* Two optimized LPROCFS counter increment functions are provided: * lprocfs_counter_incr(cntr, value) - optimized for by-one counters * lprocfs_counter_add(cntr) - use for multi-valued counters * Counter data layout allows config flag, counter lock and the * count itself to reside within a single cache line. */ static inline void lprocfs_counter_add(struct lprocfs_stats *stats, int idx, long amount) { struct lprocfs_counter *percpu_cntr; int smp_id; if (!stats) return; /* With per-client stats, statistics are allocated only for * single CPU area, so the smp_id should be 0 always. */ smp_id = lprocfs_stats_lock(stats, LPROCFS_GET_SMP_ID); percpu_cntr = &(stats->ls_percpu[smp_id]->lp_cntr[idx]); atomic_inc(&percpu_cntr->lc_cntl.la_entry); percpu_cntr->lc_count++; if (percpu_cntr->lc_config & LPROCFS_CNTR_AVGMINMAX) { percpu_cntr->lc_sum += amount; if (percpu_cntr->lc_config & LPROCFS_CNTR_STDDEV) percpu_cntr->lc_sumsquare += (__u64)amount * amount; if (amount < percpu_cntr->lc_min) percpu_cntr->lc_min = amount; if (amount > percpu_cntr->lc_max) percpu_cntr->lc_max = amount; } atomic_inc(&percpu_cntr->lc_cntl.la_exit); lprocfs_stats_unlock(stats); } static inline void lprocfs_counter_incr(struct lprocfs_stats *stats, int idx) { struct lprocfs_counter *percpu_cntr; int smp_id; if (!stats) return; smp_id = lprocfs_stats_lock(stats, LPROCFS_GET_SMP_ID); percpu_cntr = &(stats->ls_percpu[smp_id]->lp_cntr[idx]); 3584: 48 63 44 24 64 movslq 0x64(%rsp),%rax 3589: 49 63 d7 movslq %r15d,%rdx 358c: 48 8d 14 d2 lea (%rdx,%rdx,8),%rdx 3590: 48 8b 44 c5 18 mov 0x18(%rbp,%rax,8),%rax 3595: 48 8d 14 d0 lea (%rax,%rdx,8),%rdx 3599: f0 ff 02 lock incl (%rdx) atomic_inc(&percpu_cntr->lc_cntl.la_entry); percpu_cntr->lc_count++; 359c: 48 ff 42 10 incq 0x10(%rdx) 35a0: f0 ff 42 04 lock incl 0x4(%rdx) 35a4: f6 45 08 01 testb $0x1,0x8(%rbp) 35a8: 74 09 je 35b3 35aa: 48 8d 7d 0c lea 0xc(%rbp),%rdi 35ae: e8 00 00 00 00 callq 35b3 35b3: 48 8b 93 c0 00 00 00 mov 0xc0(%rbx),%rdx EXP_CHECK_OP(exp, unpackmd); EXP_COUNTER_INCREMENT(exp, unpackmd); rc = OBP(exp->exp_obd, unpackmd)(exp, mem_tgt, disk_src, disk_len); 35ba: 48 8b 02 mov (%rdx),%rax 35bd: 48 89 df mov %rbx,%rdi 35c0: 8b 4c 24 6c mov 0x6c(%rsp),%ecx 35c4: 4c 89 f2 mov %r14,%rdx 35c7: 48 8d 74 24 78 lea 0x78(%rsp),%rsi 35cc: 48 8b 40 10 mov 0x10(%rax),%rax 35d0: ff 90 98 00 00 00 callq *0x98(%rax) RETURN(rc); 35d6: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 35dd 35dd: 89 c3 mov %eax,%ebx 35df: 74 5b je 363c 35e1: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 35e8 35e8: 79 52 jns 363c 35ea: 48 98 cltq 35ec: 41 b9 bd 01 00 00 mov $0x1bd,%r9d 35f2: 49 c7 c0 00 00 00 00 mov $0x0,%r8 35f9: 48 89 44 24 28 mov %rax,0x28(%rsp) 35fe: 48 89 44 24 20 mov %rax,0x20(%rsp) 3603: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 360a: 48 89 44 24 18 mov %rax,0x18(%rsp) 360f: ba 01 00 00 00 mov $0x1,%edx 3614: be 80 00 00 00 mov $0x80,%esi 3619: 31 ff xor %edi,%edi 361b: 31 c0 xor %eax,%eax 361d: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 3624: 00 00 3626: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 362d: 00 00 362f: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 3636: 00 3637: e8 00 00 00 00 callq 363c 363c: 89 d8 mov %ebx,%eax 363e: 66 data16 363f: 90 nop } rc = obd_unpackmd(ll_i2obdexp(dir), &lsm, eadata, body->eadatasize); if (rc < 0) { 3640: 85 c0 test %eax,%eax static inline int obd_unpackmd(struct obd_export *exp, struct lov_stripe_md **mem_tgt, struct lov_mds_md *disk_src, int disk_len) { 3642: 41 89 c6 mov %eax,%r14d 3645: 0f 89 c5 00 00 00 jns 3710 CERROR("obd_unpackmd: %d\n", rc); 364b: 89 44 24 18 mov %eax,0x18(%rsp) 364f: 41 b9 4b 04 00 00 mov $0x44b,%r9d 3655: 31 c0 xor %eax,%eax 3657: 49 c7 c0 00 00 00 00 mov $0x0,%r8 365e: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 3665: ba 00 00 02 00 mov $0x20000,%edx 366a: be 80 00 00 00 mov $0x80,%esi 366f: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 3676: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 367d: 00 00 367f: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 3686: 00 00 3688: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 368f: 00 3690: e8 00 00 00 00 callq 3695 GOTO(out, rc); 3695: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 369c 369c: 49 63 c6 movslq %r14d,%rax 369f: 0f 84 cd 10 00 00 je 4772 36a5: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 36ac 36ac: 0f 89 c0 10 00 00 jns 4772 36b2: 48 89 44 24 30 mov %rax,0x30(%rsp) 36b7: 48 89 44 24 28 mov %rax,0x28(%rsp) 36bc: 41 b9 4c 04 00 00 mov $0x44c,%r9d 36c2: 48 89 44 24 20 mov %rax,0x20(%rsp) 36c7: 48 c7 44 24 18 00 00 movq $0x0,0x18(%rsp) 36ce: 00 00 36d0: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 36d7: 00 00 36d9: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 36e0: 00 00 36e2: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 36e9: 00 36ea: 49 c7 c0 00 00 00 00 mov $0x0,%r8 36f1: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 36f8: ba 01 00 00 00 mov $0x1,%edx 36fd: be 80 00 00 00 mov $0x80,%esi 3702: 31 ff xor %edi,%edi 3704: 31 c0 xor %eax,%eax 3706: e8 00 00 00 00 callq 370b 370b: e9 62 10 00 00 jmpq 4772 } LASSERT(rc >= sizeof(*lsm)); 3710: 83 f8 3f cmp $0x3f,%eax 3713: 77 1f ja 3734 3715: b9 4e 04 00 00 mov $0x44e,%ecx 371a: 48 c7 c2 00 00 00 00 mov $0x0,%rdx 3721: 48 c7 c6 00 00 00 00 mov $0x0,%rsi 3728: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 372f: e8 00 00 00 00 callq 3734 #endif /* don't need an addref as the sb_info should be holding one */ static inline struct obd_export *ll_s2obdexp(struct super_block *sb) { 3734: 48 8b 54 24 70 mov 0x70(%rsp),%rdx struct obd_export *md_exp, struct lov_stripe_md *mem_tgt) { int rc; ENTRY; 3739: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 3740 #endif /* don't need an addref as the sb_info should be holding one */ static inline struct obd_export *ll_s2obdexp(struct super_block *sb) { 3740: 48 8b 82 08 01 00 00 mov 0x108(%rdx),%rax return ll_s2sbi(sb)->ll_osc_exp; 3747: 48 8b 80 60 02 00 00 mov 0x260(%rax),%rax 374e: 48 8b 40 20 mov 0x20(%rax),%rax 3752: 48 8b 58 58 mov 0x58(%rax),%rbx } /* don't need an addref as the sb_info should be holding one */ static inline struct obd_export *ll_s2mdcexp(struct super_block *sb) { return ll_s2sbi(sb)->ll_mdc_exp; 3756: 48 8b 40 50 mov 0x50(%rax),%rax 375a: 48 89 44 24 58 mov %rax,0x58(%rsp) static inline int obd_checkmd(struct obd_export *exp, struct obd_export *md_exp, struct lov_stripe_md *mem_tgt) { 375f: 48 8b 44 24 78 mov 0x78(%rsp),%rax 3764: 48 89 44 24 50 mov %rax,0x50(%rsp) int rc; ENTRY; 3769: 74 4a je 37b5 376b: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 3772 3772: 79 41 jns 37b5 3774: 41 b9 d6 01 00 00 mov $0x1d6,%r9d 377a: 49 c7 c0 00 00 00 00 mov $0x0,%r8 3781: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 3788: ba 01 00 00 00 mov $0x1,%edx 378d: be 80 00 00 00 mov $0x80,%esi 3792: 31 ff xor %edi,%edi 3794: 31 c0 xor %eax,%eax 3796: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 379d: 00 00 379f: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 37a6: 00 00 37a8: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 37af: 00 37b0: e8 00 00 00 00 callq 37b5 EXP_CHECK_OP(exp, checkmd); 37b5: 48 85 db test %rbx,%rbx 37b8: 0f 85 c2 00 00 00 jne 3880 37be: 31 c0 xor %eax,%eax 37c0: 41 b9 d8 01 00 00 mov $0x1d8,%r9d 37c6: 49 c7 c0 00 00 00 00 mov $0x0,%r8 37cd: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 37d4: ba 00 00 02 00 mov $0x20000,%edx 37d9: be 80 00 00 00 mov $0x80,%esi 37de: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 37e5: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 37ec: 00 00 37ee: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 37f5: 00 00 37f7: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 37fe: 00 37ff: e8 00 00 00 00 callq 3804 3804: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 380b 380b: 74 65 je 3872 380d: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 3814 3814: 79 5c jns 3872 3816: 41 b9 d8 01 00 00 mov $0x1d8,%r9d 381c: 49 c7 c0 00 00 00 00 mov $0x0,%r8 3823: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 382a: ba 01 00 00 00 mov $0x1,%edx 382f: be 80 00 00 00 mov $0x80,%esi 3834: 31 ff xor %edi,%edi 3836: 31 c0 xor %eax,%eax 3838: 48 c7 44 24 28 ed ff movq $0xffffffffffffffed,0x28(%rsp) 383f: ff ff 3841: 48 c7 44 24 20 ed ff movq $0xffffffffffffffed,0x20(%rsp) 3848: ff ff 384a: 48 c7 44 24 18 ed ff movq $0xffffffffffffffed,0x18(%rsp) 3851: ff ff 3853: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 385a: 00 00 385c: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 3863: 00 00 3865: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 386c: 00 386d: e8 00 00 00 00 callq 3872 3872: b8 ed ff ff ff mov $0xffffffed,%eax 3877: e9 bb 02 00 00 jmpq 3b37 387c: 66 data16 387d: 66 data16 387e: 66 data16 387f: 90 nop 3880: 48 8b 93 c0 00 00 00 mov 0xc0(%rbx),%rdx 3887: 48 85 d2 test %rdx,%rdx 388a: 74 08 je 3894 388c: 48 8b 02 mov (%rdx),%rax 388f: 48 85 c0 test %rax,%rax 3892: 75 4c jne 38e0 3894: 41 b9 d8 01 00 00 mov $0x1d8,%r9d 389a: 49 c7 c0 00 00 00 00 mov $0x0,%r8 38a1: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 38a8: ba 00 00 02 00 mov $0x20000,%edx 38ad: be 80 00 00 00 mov $0x80,%esi 38b2: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 38b9: 31 c0 xor %eax,%eax 38bb: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 38c2: 00 00 38c4: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 38cb: 00 00 38cd: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 38d4: 00 38d5: e8 00 00 00 00 callq 38da 38da: eb 66 jmp 3942 38dc: 66 data16 38dd: 66 data16 38de: 66 data16 38df: 90 nop 38e0: 48 8b 40 10 mov 0x10(%rax),%rax 38e4: 48 83 b8 a0 00 00 00 cmpq $0x0,0xa0(%rax) 38eb: 00 38ec: 0f 85 c8 00 00 00 jne 39ba 38f2: 8b 82 b4 00 00 00 mov 0xb4(%rdx),%eax 38f8: 41 b9 d8 01 00 00 mov $0x1d8,%r9d 38fe: 49 c7 c0 00 00 00 00 mov $0x0,%r8 3905: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 390c: ba 00 00 02 00 mov $0x20000,%edx 3911: be 80 00 00 00 mov $0x80,%esi 3916: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 391d: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 3924: 00 00 3926: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 392d: 00 00 392f: 89 44 24 18 mov %eax,0x18(%rsp) 3933: 31 c0 xor %eax,%eax 3935: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 393c: 00 393d: e8 00 00 00 00 callq 3942 3942: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 3949 3949: 74 65 je 39b0 394b: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 3952 3952: 79 5c jns 39b0 3954: 41 b9 d8 01 00 00 mov $0x1d8,%r9d 395a: 49 c7 c0 00 00 00 00 mov $0x0,%r8 3961: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 3968: ba 01 00 00 00 mov $0x1,%edx 396d: be 80 00 00 00 mov $0x80,%esi 3972: 31 ff xor %edi,%edi 3974: 31 c0 xor %eax,%eax 3976: 48 c7 44 24 28 a1 ff movq $0xffffffffffffffa1,0x28(%rsp) 397d: ff ff 397f: 48 c7 44 24 20 a1 ff movq $0xffffffffffffffa1,0x20(%rsp) 3986: ff ff 3988: 48 c7 44 24 18 a1 ff movq $0xffffffffffffffa1,0x18(%rsp) 398f: ff ff 3991: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 3998: 00 00 399a: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 39a1: 00 00 39a3: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 39aa: 00 39ab: e8 00 00 00 00 callq 39b0 39b0: b8 a1 ff ff ff mov $0xffffffa1,%eax 39b5: e9 7d 01 00 00 jmpq 3b37 EXP_COUNTER_INCREMENT(exp, checkmd); 39ba: 48 8b 82 78 14 00 00 mov 0x1478(%rdx),%rax 39c1: 48 85 c0 test %rax,%rax 39c4: 0f 84 eb 00 00 00 je 3ab5 39ca: 44 8b b2 88 14 00 00 mov 0x1488(%rdx),%r14d 39d1: 41 83 c6 13 add $0x13,%r14d 39d5: 44 39 30 cmp %r14d,(%rax) 39d8: 77 26 ja 3a00 39da: 48 c7 c2 00 00 00 00 mov $0x0,%rdx 39e1: b9 d9 01 00 00 mov $0x1d9,%ecx 39e6: 48 c7 c6 00 00 00 00 mov $0x0,%rsi 39ed: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 39f4: e8 00 00 00 00 callq 39f9 39f9: 48 8b 93 c0 00 00 00 mov 0xc0(%rbx),%rdx lprocfs_stats_unlock(stats); } static inline void lprocfs_counter_incr(struct lprocfs_stats *stats, int idx) { 3a00: 48 8b aa 78 14 00 00 mov 0x1478(%rdx),%rbp struct lprocfs_counter *percpu_cntr; int smp_id; if (!stats) 3a07: 48 85 ed test %rbp,%rbp 3a0a: 74 4c je 3a58 3a0c: 45 31 ff xor %r15d,%r15d 3a0f: f6 45 08 01 testb $0x1,0x8(%rbp) 3a13: 74 0d je 3a22 3a15: 48 8d 7d 0c lea 0xc(%rbp),%rdi 3a19: e8 00 00 00 00 callq 3a1e 3a1e: 66 data16 3a1f: 90 nop 3a20: eb 09 jmp 3a2b 3a22: 65 44 8b 3c 25 34 00 mov %gs:0x34,%r15d 3a29: 00 00 return; smp_id = lprocfs_stats_lock(stats, LPROCFS_GET_SMP_ID); percpu_cntr = &(stats->ls_percpu[smp_id]->lp_cntr[idx]); 3a2b: 49 63 c7 movslq %r15d,%rax 3a2e: 49 63 d6 movslq %r14d,%rdx 3a31: 48 8b 44 c5 18 mov 0x18(%rbp,%rax,8),%rax 3a36: 48 8d 14 d2 lea (%rdx,%rdx,8),%rdx 3a3a: 48 8d 14 d0 lea (%rax,%rdx,8),%rdx 3a3e: f0 ff 02 lock incl (%rdx) atomic_inc(&percpu_cntr->lc_cntl.la_entry); percpu_cntr->lc_count++; 3a41: 48 ff 42 10 incq 0x10(%rdx) 3a45: f0 ff 42 04 lock incl 0x4(%rdx) 3a49: f6 45 08 01 testb $0x1,0x8(%rbp) 3a4d: 74 09 je 3a58 3a4f: 48 8d 7d 0c lea 0xc(%rbp),%rdi 3a53: e8 00 00 00 00 callq 3a58 int rc; ENTRY; EXP_CHECK_OP(exp, checkmd); EXP_COUNTER_INCREMENT(exp, checkmd); 3a58: 48 8b ab d8 00 00 00 mov 0xd8(%rbx),%rbp 3a5f: 48 85 ed test %rbp,%rbp 3a62: 74 4a je 3aae #ifdef LPROCFS static inline int lprocfs_stats_lock(struct lprocfs_stats *stats, int type) { int rc = 0; 3a64: 45 31 ff xor %r15d,%r15d if (stats->ls_flags & LPROCFS_STATS_FLAG_NOPERCPU) { 3a67: f6 45 08 01 testb $0x1,0x8(%rbp) 3a6b: 74 0b je 3a78 if (type & LPROCFS_GET_NUM_CPU) rc = 1; if (type & LPROCFS_GET_SMP_ID) rc = 0; spin_lock(&stats->ls_lock); 3a6d: 48 8d 7d 0c lea 0xc(%rbp),%rdi 3a71: e8 00 00 00 00 callq 3a76 3a76: eb 09 jmp 3a81 } else { if (type & LPROCFS_GET_NUM_CPU) rc = num_possible_cpus(); if (type & LPROCFS_GET_SMP_ID) rc = smp_processor_id(); 3a78: 65 44 8b 3c 25 34 00 mov %gs:0x34,%r15d 3a7f: 00 00 } return rc; } static inline void lprocfs_stats_unlock(struct lprocfs_stats *stats) { if (stats->ls_flags & LPROCFS_STATS_FLAG_NOPERCPU) spin_unlock(&stats->ls_lock); } /* Two optimized LPROCFS counter increment functions are provided: * lprocfs_counter_incr(cntr, value) - optimized for by-one counters * lprocfs_counter_add(cntr) - use for multi-valued counters * Counter data layout allows config flag, counter lock and the * count itself to reside within a single cache line. */ static inline void lprocfs_counter_add(struct lprocfs_stats *stats, int idx, long amount) { struct lprocfs_counter *percpu_cntr; int smp_id; if (!stats) return; /* With per-client stats, statistics are allocated only for * single CPU area, so the smp_id should be 0 always. */ smp_id = lprocfs_stats_lock(stats, LPROCFS_GET_SMP_ID); percpu_cntr = &(stats->ls_percpu[smp_id]->lp_cntr[idx]); atomic_inc(&percpu_cntr->lc_cntl.la_entry); percpu_cntr->lc_count++; if (percpu_cntr->lc_config & LPROCFS_CNTR_AVGMINMAX) { percpu_cntr->lc_sum += amount; if (percpu_cntr->lc_config & LPROCFS_CNTR_STDDEV) percpu_cntr->lc_sumsquare += (__u64)amount * amount; if (amount < percpu_cntr->lc_min) percpu_cntr->lc_min = amount; if (amount > percpu_cntr->lc_max) percpu_cntr->lc_max = amount; } atomic_inc(&percpu_cntr->lc_cntl.la_exit); lprocfs_stats_unlock(stats); } static inline void lprocfs_counter_incr(struct lprocfs_stats *stats, int idx) { struct lprocfs_counter *percpu_cntr; int smp_id; if (!stats) return; smp_id = lprocfs_stats_lock(stats, LPROCFS_GET_SMP_ID); percpu_cntr = &(stats->ls_percpu[smp_id]->lp_cntr[idx]); 3a81: 49 63 c7 movslq %r15d,%rax 3a84: 49 63 d6 movslq %r14d,%rdx 3a87: 48 8b 44 c5 18 mov 0x18(%rbp,%rax,8),%rax 3a8c: 48 8d 14 d2 lea (%rdx,%rdx,8),%rdx 3a90: 48 8d 14 d0 lea (%rax,%rdx,8),%rdx 3a94: f0 ff 02 lock incl (%rdx) atomic_inc(&percpu_cntr->lc_cntl.la_entry); percpu_cntr->lc_count++; 3a97: 48 ff 42 10 incq 0x10(%rdx) 3a9b: f0 ff 42 04 lock incl 0x4(%rdx) 3a9f: f6 45 08 01 testb $0x1,0x8(%rbp) 3aa3: 74 09 je 3aae 3aa5: 48 8d 7d 0c lea 0xc(%rbp),%rdi 3aa9: e8 00 00 00 00 callq 3aae 3aae: 48 8b 93 c0 00 00 00 mov 0xc0(%rbx),%rdx EXP_CHECK_OP(exp, checkmd); EXP_COUNTER_INCREMENT(exp, checkmd); rc = OBP(exp->exp_obd, checkmd)(exp, md_exp, mem_tgt); 3ab5: 48 8b 02 mov (%rdx),%rax 3ab8: 48 89 df mov %rbx,%rdi 3abb: 48 8b 54 24 50 mov 0x50(%rsp),%rdx 3ac0: 48 8b 74 24 58 mov 0x58(%rsp),%rsi 3ac5: 48 8b 40 10 mov 0x10(%rax),%rax 3ac9: ff 90 a0 00 00 00 callq *0xa0(%rax) RETURN(rc); 3acf: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 3ad6 3ad6: 89 c3 mov %eax,%ebx 3ad8: 74 5b je 3b35 3ada: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 3ae1 3ae1: 79 52 jns 3b35 3ae3: 48 98 cltq 3ae5: 41 b9 dc 01 00 00 mov $0x1dc,%r9d 3aeb: 49 c7 c0 00 00 00 00 mov $0x0,%r8 3af2: 48 89 44 24 28 mov %rax,0x28(%rsp) 3af7: 48 89 44 24 20 mov %rax,0x20(%rsp) 3afc: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 3b03: 48 89 44 24 18 mov %rax,0x18(%rsp) 3b08: ba 01 00 00 00 mov $0x1,%edx 3b0d: be 80 00 00 00 mov $0x80,%esi 3b12: 31 ff xor %edi,%edi 3b14: 31 c0 xor %eax,%eax 3b16: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 3b1d: 00 00 3b1f: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 3b26: 00 00 3b28: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 3b2f: 00 3b30: e8 00 00 00 00 callq 3b35 3b35: 89 d8 mov %ebx,%eax rc = obd_checkmd(ll_i2obdexp(dir), ll_i2mdcexp(dir), lsm); if (rc) 3b37: 85 c0 test %eax,%eax static inline int obd_checkmd(struct obd_export *exp, struct obd_export *md_exp, struct lov_stripe_md *mem_tgt) { 3b39: 41 89 c6 mov %eax,%r14d 3b3c: 74 59 je 3b97 GOTO(out_free_memmd, rc); 3b3e: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 3b45 3b45: 48 98 cltq 3b47: 0f 84 6b 08 00 00 je 43b8 3b4d: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 3b54 3b54: 0f 89 5e 08 00 00 jns 43b8 3b5a: 41 b9 52 04 00 00 mov $0x452,%r9d 3b60: 48 89 44 24 30 mov %rax,0x30(%rsp) 3b65: 48 89 44 24 28 mov %rax,0x28(%rsp) 3b6a: 48 89 44 24 20 mov %rax,0x20(%rsp) 3b6f: 48 c7 44 24 18 00 00 movq $0x0,0x18(%rsp) 3b76: 00 00 3b78: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 3b7f: 00 00 3b81: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 3b88: 00 00 3b8a: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 3b91: 00 3b92: e9 7a 02 00 00 jmpq 3e11 3b97: 65 48 8b 04 25 18 00 mov %gs:0x18,%rax 3b9e: 00 00 3ba0: 48 63 80 44 e0 ff ff movslq 0xffffffffffffe044(%rax),%rax 3ba7: a9 00 ff ff 00 test $0xffff00,%eax 3bac: 74 22 je 3bd0 OBDO_ALLOC(oa); 3bae: b9 54 04 00 00 mov $0x454,%ecx 3bb3: 48 c7 c2 00 00 00 00 mov $0x0,%rdx 3bba: 48 c7 c6 00 00 00 00 mov $0x0,%rsi 3bc1: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 3bc8: e8 00 00 00 00 callq 3bcd 3bcd: 66 data16 3bce: 66 data16 3bcf: 90 nop 3bd0: 48 8b 3d 00 00 00 00 mov 0(%rip),%rdi # 3bd7 3bd7: be 18 00 00 00 mov $0x18,%esi 3bdc: e8 00 00 00 00 callq 3be1 3be1: 48 85 c0 test %rax,%rax 3be4: 48 89 c3 mov %rax,%rbx 3be7: 0f 84 c0 01 00 00 je 3dad 3bed: 8b 15 00 00 00 00 mov 0(%rip),%edx # 3bf3 3bf3: 85 d2 test %edx,%edx 3bf5: 0f 84 0b 01 00 00 je 3d06 static inline int obd_fail_check(__u32 id) { static int count = 0; if (likely((obd_fail_loc & OBD_FAIL_MASK_LOC) != 3bfb: 66 81 fa 00 0c cmp $0xc00,%dx 3c00: 0f 85 00 01 00 00 jne 3d06 (id & OBD_FAIL_MASK_LOC))) return 0; if ((obd_fail_loc & (OBD_FAILED | OBD_FAIL_ONCE)) == 3c06: 89 d0 mov %edx,%eax 3c08: 25 00 00 00 c0 and $0xc0000000,%eax 3c0d: 3d 00 00 00 c0 cmp $0xc0000000,%eax 3c12: 75 0f jne 3c23 (OBD_FAILED | OBD_FAIL_ONCE)) { count = 0; /* paranoia */ 3c14: c7 05 00 00 00 00 00 movl $0x0,0(%rip) # 3c1e 3c1b: 00 00 00 3c1e: e9 e3 00 00 00 jmpq 3d06 return 0; } if (obd_fail_loc & OBD_FAIL_RAND) { 3c23: f7 c2 00 00 00 08 test $0x8000000,%edx 3c29: 74 28 je 3c53 unsigned int ll_rand(void); if (obd_fail_val < 2) 3c2b: 83 3d 00 00 00 00 01 cmpl $0x1,0(%rip) # 3c32 3c32: 0f 86 ce 00 00 00 jbe 3d06 return 0; if (ll_rand() % obd_fail_val > 0) 3c38: e8 00 00 00 00 callq 3c3d 3c3d: 31 d2 xor %edx,%edx 3c3f: f7 35 00 00 00 00 divl 0(%rip) # 3c45 3c45: 85 d2 test %edx,%edx 3c47: 0f 85 b9 00 00 00 jne 3d06 3c4d: 8b 15 00 00 00 00 mov 0(%rip),%edx # 3c53 return 0; } if (obd_fail_loc & OBD_FAIL_SKIP) { 3c53: f7 c2 00 00 00 20 test $0x20000000,%edx 3c59: 74 25 je 3c80 count++; 3c5b: 8b 05 00 00 00 00 mov 0(%rip),%eax # 3c61 3c61: ff c0 inc %eax if (count < obd_fail_val) 3c63: 3b 05 00 00 00 00 cmp 0(%rip),%eax # 3c69 3c69: 73 0b jae 3c76 3c6b: 89 05 00 00 00 00 mov %eax,0(%rip) # 3c71 3c71: e9 90 00 00 00 jmpq 3d06 return 0; count = 0; 3c76: c7 05 00 00 00 00 00 movl $0x0,0(%rip) # 3c80 3c7d: 00 00 00 } /* Overridden by FAIL_ONCE */ if (obd_fail_loc & OBD_FAIL_SOME) { 3c80: f7 c2 00 00 00 10 test $0x10000000,%edx 3c86: 74 28 je 3cb0 count++; 3c88: 8b 05 00 00 00 00 mov 0(%rip),%eax # 3c8e 3c8e: ff c0 inc %eax if (count >= obd_fail_val) { 3c90: 3b 05 00 00 00 00 cmp 0(%rip),%eax # 3c96 3c96: 72 12 jb 3caa count = 0; /* Don't fail anymore */ obd_fail_loc |= OBD_FAIL_ONCE; 3c98: 81 ca 00 00 00 80 or $0x80000000,%edx 3c9e: c7 05 00 00 00 00 00 movl $0x0,0(%rip) # 3ca8 3ca5: 00 00 00 3ca8: eb 06 jmp 3cb0 3caa: 89 05 00 00 00 00 mov %eax,0(%rip) # 3cb0 3cb0: 8b 05 00 00 00 00 mov 0(%rip),%eax # 3cb6 } } obd_fail_loc |= OBD_FAILED; 3cb6: 81 ca 00 00 00 40 or $0x40000000,%edx 3cbc: 89 15 00 00 00 00 mov %edx,0(%rip) # 3cc2 3cc2: 85 c0 test %eax,%eax 3cc4: 74 40 je 3d06 3cc6: 41 b9 54 04 00 00 mov $0x454,%r9d 3ccc: 49 c7 c0 00 00 00 00 mov $0x0,%r8 3cd3: b9 d0 00 00 00 mov $0xd0,%ecx 3cd8: 48 c7 c2 00 00 00 00 mov $0x0,%rdx 3cdf: 48 c7 c6 00 00 00 00 mov $0x0,%rsi 3ce6: 48 89 df mov %rbx,%rdi 3ce9: e8 00 00 00 00 callq 3cee 3cee: 85 c0 test %eax,%eax 3cf0: 74 14 je 3d06 3cf2: 48 8b 3d 00 00 00 00 mov 0(%rip),%rdi # 3cf9 3cf9: 48 89 de mov %rbx,%rsi 3cfc: e8 00 00 00 00 callq 3d01 3d01: e9 a7 00 00 00 jmpq 3dad 3d06: ba d0 00 00 00 mov $0xd0,%edx 3d0b: 31 f6 xor %esi,%esi 3d0d: 48 89 df mov %rbx,%rdi 3d10: e8 00 00 00 00 callq 3d15 3d15: f0 81 05 00 00 00 00 lock addl $0xd0,0(%rip) # 3d20 3d1c: d0 00 00 00 3d20: 8b 05 00 00 00 00 mov 0(%rip),%eax # 3d26 3d26: 3b 05 00 00 00 00 cmp 0(%rip),%eax # 3d2c 3d2c: 7e 0c jle 3d3a 3d2e: 8b 05 00 00 00 00 mov 0(%rip),%eax # 3d34 3d34: 89 05 00 00 00 00 mov %eax,0(%rip) # 3d3a 3d3a: f6 05 00 00 00 00 10 testb $0x10,0(%rip) # 3d41 3d41: 74 61 je 3da4 3d43: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 3d4a 3d4a: 79 58 jns 3da4 3d4c: 8b 05 00 00 00 00 mov 0(%rip),%eax # 3d52 3d52: 41 b9 54 04 00 00 mov $0x454,%r9d 3d58: 49 c7 c0 00 00 00 00 mov $0x0,%r8 3d5f: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 3d66: ba 10 00 00 00 mov $0x10,%edx 3d6b: be 80 00 00 00 mov $0x80,%esi 3d70: 31 ff xor %edi,%edi 3d72: 48 89 5c 24 20 mov %rbx,0x20(%rsp) 3d77: c7 44 24 18 d0 00 00 movl $0xd0,0x18(%rsp) 3d7e: 00 3d7f: 89 44 24 28 mov %eax,0x28(%rsp) 3d83: 31 c0 xor %eax,%eax 3d85: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 3d8c: 00 00 3d8e: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 3d95: 00 00 3d97: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 3d9e: 00 3d9f: e8 00 00 00 00 callq 3da4 if (oa == NULL) 3da4: 48 85 db test %rbx,%rbx 3da7: 0f 85 8a 00 00 00 jne 3e37 GOTO(out_free_memmd, rc = -ENOMEM); 3dad: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 3db4 3db4: 41 be f4 ff ff ff mov $0xfffffff4,%r14d 3dba: 0f 84 f8 05 00 00 je 43b8 3dc0: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 3dc7 3dc7: 0f 89 eb 05 00 00 jns 43b8 3dcd: 48 c7 44 24 30 f4 ff movq $0xfffffffffffffff4,0x30(%rsp) 3dd4: ff ff 3dd6: 48 c7 44 24 28 f4 ff movq $0xfffffffffffffff4,0x28(%rsp) 3ddd: ff ff 3ddf: 41 b9 56 04 00 00 mov $0x456,%r9d 3de5: 48 c7 44 24 20 f4 ff movq $0xfffffffffffffff4,0x20(%rsp) 3dec: ff ff 3dee: 48 c7 44 24 18 00 00 movq $0x0,0x18(%rsp) 3df5: 00 00 3df7: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 3dfe: 00 00 3e00: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 3e07: 00 00 3e09: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 3e10: 00 3e11: 49 c7 c0 00 00 00 00 mov $0x0,%r8 3e18: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 3e1f: ba 01 00 00 00 mov $0x1,%edx 3e24: be 80 00 00 00 mov $0x80,%esi 3e29: 31 ff xor %edi,%edi 3e2b: 31 c0 xor %eax,%eax 3e2d: e8 00 00 00 00 callq 3e32 3e32: e9 81 05 00 00 jmpq 43b8 oa->o_id = lsm->lsm_object_id; 3e37: 48 8b 44 24 78 mov 0x78(%rsp),%rax 3e3c: 48 8b 40 10 mov 0x10(%rax),%rax 3e40: 48 89 43 08 mov %rax,0x8(%rbx) oa->o_mode = body->mode & S_IFMT; 3e44: 41 8b 44 24 74 mov 0x74(%r12),%eax oa->o_valid = OBD_MD_FLID | OBD_MD_FLTYPE; 3e49: 48 c7 03 01 01 00 00 movq $0x101,(%rbx) 3e50: 25 00 f0 00 00 and $0xf000,%eax 3e55: 89 43 54 mov %eax,0x54(%rbx) if (body->valid & OBD_MD_FLCOOKIE) { 3e58: 41 f6 44 24 2a 80 testb $0x80,0x2a(%r12) 3e5e: 74 40 je 3ea0 oa->o_valid |= OBD_MD_FLCOOKIE; 3e60: 48 c7 03 01 01 80 00 movq $0x800101,(%rbx) oti.oti_logcookies = 3e67: 48 8b 44 24 78 mov 0x78(%rsp),%rax 3e6c: be 03 00 00 00 mov $0x3,%esi 3e71: 49 8b 7d 70 mov 0x70(%r13),%rdi 3e75: 8b 50 34 mov 0x34(%rax),%edx 3e78: 48 c1 e2 05 shl $0x5,%rdx 3e7c: e8 00 00 00 00 callq 3e81 lustre_msg_buf(request->rq_repmsg, REPLY_REC_OFF + 2, sizeof(struct llog_cookie) * lsm->lsm_stripe_count); if (oti.oti_logcookies == NULL) { 3e81: 48 85 c0 test %rax,%rax 3e84: 48 89 84 24 00 01 00 mov %rax,0x100(%rsp) 3e8b: 00 3e8c: 75 12 jne 3ea0 oa->o_valid &= ~OBD_MD_FLCOOKIE; 3e8e: 48 81 23 ff ff 7f ff andq $0xffffffffff7fffff,(%rbx) body->valid &= ~OBD_MD_FLCOOKIE; 3e95: 49 81 64 24 28 ff ff andq $0xffffffffff7fffff,0x28(%r12) 3e9c: 7f ff 3e9e: 66 data16 3e9f: 90 nop #endif /* don't need an addref as the sb_info should be holding one */ static inline struct obd_export *ll_s2obdexp(struct super_block *sb) { 3ea0: 48 8b 54 24 70 mov 0x70(%rsp),%rdx struct obd_trans_info *oti, struct obd_export *md_exp) { int rc; ENTRY; 3ea5: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 3eac #endif /* don't need an addref as the sb_info should be holding one */ static inline struct obd_export *ll_s2obdexp(struct super_block *sb) { 3eac: 48 8b 82 08 01 00 00 mov 0x108(%rdx),%rax static inline int obd_destroy(struct obd_export *exp, struct obdo *obdo, struct lov_stripe_md *ea, struct obd_trans_info *oti, struct obd_export *md_exp) { 3eb3: 48 8b 54 24 78 mov 0x78(%rsp),%rdx /* don't need an addref as the sb_info should be holding one */ static inline struct obd_export *ll_s2obdexp(struct super_block *sb) { return ll_s2sbi(sb)->ll_osc_exp; 3eb8: 48 8b 80 60 02 00 00 mov 0x260(%rax),%rax 3ebf: 48 8b 40 20 mov 0x20(%rax),%rax 3ec3: 48 8b 68 58 mov 0x58(%rax),%rbp static inline int obd_destroy(struct obd_export *exp, struct obdo *obdo, struct lov_stripe_md *ea, struct obd_trans_info *oti, struct obd_export *md_exp) { 3ec7: 48 89 54 24 48 mov %rdx,0x48(%rsp) /* don't need an addref as the sb_info should be holding one */ static inline struct obd_export *ll_s2mdcexp(struct super_block *sb) { return ll_s2sbi(sb)->ll_mdc_exp; 3ecc: 4c 8b 78 50 mov 0x50(%rax),%r15 struct obd_trans_info *oti, struct obd_export *md_exp) { int rc; ENTRY; 3ed0: 74 4e je 3f20 3ed2: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 3ed9 3ed9: 79 45 jns 3f20 3edb: 41 b9 ff 01 00 00 mov $0x1ff,%r9d 3ee1: 49 c7 c0 00 00 00 00 mov $0x0,%r8 3ee8: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 3eef: ba 01 00 00 00 mov $0x1,%edx 3ef4: be 80 00 00 00 mov $0x80,%esi 3ef9: 31 ff xor %edi,%edi 3efb: 31 c0 xor %eax,%eax 3efd: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 3f04: 00 00 3f06: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 3f0d: 00 00 3f0f: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 3f16: 00 3f17: e8 00 00 00 00 callq 3f1c 3f1c: 66 data16 3f1d: 66 data16 3f1e: 66 data16 3f1f: 90 nop EXP_CHECK_OP(exp, destroy); 3f20: 48 85 ed test %rbp,%rbp 3f23: 0f 85 c7 00 00 00 jne 3ff0 3f29: 31 c0 xor %eax,%eax 3f2b: 41 b9 01 02 00 00 mov $0x201,%r9d 3f31: 49 c7 c0 00 00 00 00 mov $0x0,%r8 3f38: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 3f3f: ba 00 00 02 00 mov $0x20000,%edx 3f44: be 80 00 00 00 mov $0x80,%esi 3f49: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 3f50: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 3f57: 00 00 3f59: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 3f60: 00 00 3f62: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 3f69: 00 3f6a: e8 00 00 00 00 callq 3f6f 3f6f: 8b 05 00 00 00 00 mov 0(%rip),%eax # 3f75 3f75: a8 01 test $0x1,%al 3f77: 74 6b je 3fe4 3f79: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 3f80 3f80: 79 62 jns 3fe4 3f82: 41 b9 01 02 00 00 mov $0x201,%r9d 3f88: 49 c7 c0 00 00 00 00 mov $0x0,%r8 3f8f: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 3f96: ba 01 00 00 00 mov $0x1,%edx 3f9b: be 80 00 00 00 mov $0x80,%esi 3fa0: 31 ff xor %edi,%edi 3fa2: 31 c0 xor %eax,%eax 3fa4: 48 c7 44 24 28 ed ff movq $0xffffffffffffffed,0x28(%rsp) 3fab: ff ff 3fad: 48 c7 44 24 20 ed ff movq $0xffffffffffffffed,0x20(%rsp) 3fb4: ff ff 3fb6: 48 c7 44 24 18 ed ff movq $0xffffffffffffffed,0x18(%rsp) 3fbd: ff ff 3fbf: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 3fc6: 00 00 3fc8: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 3fcf: 00 00 3fd1: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 3fd8: 00 3fd9: e8 00 00 00 00 callq 3fde 3fde: 8b 05 00 00 00 00 mov 0(%rip),%eax # 3fe4 3fe4: bd ed ff ff ff mov $0xffffffed,%ebp 3fe9: e9 d7 02 00 00 jmpq 42c5 3fee: 66 data16 3fef: 90 nop 3ff0: 48 8b 95 c0 00 00 00 mov 0xc0(%rbp),%rdx 3ff7: 48 85 d2 test %rdx,%rdx 3ffa: 74 08 je 4004 3ffc: 48 8b 02 mov (%rdx),%rax 3fff: 48 85 c0 test %rax,%rax 4002: 75 48 jne 404c 4004: 41 b9 01 02 00 00 mov $0x201,%r9d 400a: 49 c7 c0 00 00 00 00 mov $0x0,%r8 4011: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 4018: ba 00 00 02 00 mov $0x20000,%edx 401d: be 80 00 00 00 mov $0x80,%esi 4022: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 4029: 31 c0 xor %eax,%eax 402b: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 4032: 00 00 4034: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 403b: 00 00 403d: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 4044: 00 4045: e8 00 00 00 00 callq 404a 404a: eb 64 jmp 40b0 404c: 48 8b 40 10 mov 0x10(%rax),%rax 4050: 48 83 b8 c0 00 00 00 cmpq $0x0,0xc0(%rax) 4057: 00 4058: 0f 85 d1 00 00 00 jne 412f 405e: 8b 82 b4 00 00 00 mov 0xb4(%rdx),%eax 4064: 41 b9 01 02 00 00 mov $0x201,%r9d 406a: 49 c7 c0 00 00 00 00 mov $0x0,%r8 4071: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 4078: ba 00 00 02 00 mov $0x20000,%edx 407d: be 80 00 00 00 mov $0x80,%esi 4082: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 4089: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 4090: 00 00 4092: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 4099: 00 00 409b: 89 44 24 18 mov %eax,0x18(%rsp) 409f: 31 c0 xor %eax,%eax 40a1: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 40a8: 00 40a9: e8 00 00 00 00 callq 40ae 40ae: 66 data16 40af: 90 nop 40b0: 8b 05 00 00 00 00 mov 0(%rip),%eax # 40b6 40b6: a8 01 test $0x1,%al 40b8: 74 6b je 4125 40ba: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 40c1 40c1: 79 62 jns 4125 40c3: 41 b9 01 02 00 00 mov $0x201,%r9d 40c9: 49 c7 c0 00 00 00 00 mov $0x0,%r8 40d0: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 40d7: ba 01 00 00 00 mov $0x1,%edx 40dc: be 80 00 00 00 mov $0x80,%esi 40e1: 31 ff xor %edi,%edi 40e3: 31 c0 xor %eax,%eax 40e5: 48 c7 44 24 28 a1 ff movq $0xffffffffffffffa1,0x28(%rsp) 40ec: ff ff 40ee: 48 c7 44 24 20 a1 ff movq $0xffffffffffffffa1,0x20(%rsp) 40f5: ff ff 40f7: 48 c7 44 24 18 a1 ff movq $0xffffffffffffffa1,0x18(%rsp) 40fe: ff ff 4100: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 4107: 00 00 4109: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 4110: 00 00 4112: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 4119: 00 411a: e8 00 00 00 00 callq 411f 411f: 8b 05 00 00 00 00 mov 0(%rip),%eax # 4125 4125: bd a1 ff ff ff mov $0xffffffa1,%ebp 412a: e9 96 01 00 00 jmpq 42c5 EXP_COUNTER_INCREMENT(exp, destroy); 412f: 48 8b 82 78 14 00 00 mov 0x1478(%rdx),%rax 4136: 48 85 c0 test %rax,%rax 4139: 0f 84 f5 00 00 00 je 4234 413f: 44 8b aa 88 14 00 00 mov 0x1488(%rdx),%r13d 4146: 41 83 c5 17 add $0x17,%r13d 414a: 44 39 28 cmp %r13d,(%rax) 414d: 77 26 ja 4175 414f: 48 c7 c2 00 00 00 00 mov $0x0,%rdx 4156: b9 02 02 00 00 mov $0x202,%ecx 415b: 48 c7 c6 00 00 00 00 mov $0x0,%rsi 4162: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 4169: e8 00 00 00 00 callq 416e 416e: 48 8b 95 c0 00 00 00 mov 0xc0(%rbp),%rdx lprocfs_stats_unlock(stats); } static inline void lprocfs_counter_incr(struct lprocfs_stats *stats, int idx) { 4175: 4c 8b a2 78 14 00 00 mov 0x1478(%rdx),%r12 struct lprocfs_counter *percpu_cntr; int smp_id; if (!stats) 417c: 4d 85 e4 test %r12,%r12 417f: 74 50 je 41d1 4181: 45 31 f6 xor %r14d,%r14d 4184: 41 f6 44 24 08 01 testb $0x1,0x8(%r12) 418a: 74 0c je 4198 418c: 49 8d 7c 24 0c lea 0xc(%r12),%rdi 4191: e8 00 00 00 00 callq 4196 4196: eb 09 jmp 41a1 4198: 65 44 8b 34 25 34 00 mov %gs:0x34,%r14d 419f: 00 00 return; smp_id = lprocfs_stats_lock(stats, LPROCFS_GET_SMP_ID); percpu_cntr = &(stats->ls_percpu[smp_id]->lp_cntr[idx]); 41a1: 49 63 c6 movslq %r14d,%rax 41a4: 49 63 d5 movslq %r13d,%rdx 41a7: 49 8b 44 c4 18 mov 0x18(%r12,%rax,8),%rax 41ac: 48 8d 14 d2 lea (%rdx,%rdx,8),%rdx 41b0: 48 8d 14 d0 lea (%rax,%rdx,8),%rdx 41b4: f0 ff 02 lock incl (%rdx) atomic_inc(&percpu_cntr->lc_cntl.la_entry); percpu_cntr->lc_count++; 41b7: 48 ff 42 10 incq 0x10(%rdx) 41bb: f0 ff 42 04 lock incl 0x4(%rdx) 41bf: 41 f6 44 24 08 01 testb $0x1,0x8(%r12) 41c5: 74 0a je 41d1 41c7: 49 8d 7c 24 0c lea 0xc(%r12),%rdi 41cc: e8 00 00 00 00 callq 41d1 int rc; ENTRY; EXP_CHECK_OP(exp, destroy); EXP_COUNTER_INCREMENT(exp, destroy); 41d1: 4c 8b a5 d8 00 00 00 mov 0xd8(%rbp),%r12 41d8: 4d 85 e4 test %r12,%r12 41db: 74 50 je 422d #ifdef LPROCFS static inline int lprocfs_stats_lock(struct lprocfs_stats *stats, int type) { int rc = 0; 41dd: 45 31 f6 xor %r14d,%r14d if (stats->ls_flags & LPROCFS_STATS_FLAG_NOPERCPU) { 41e0: 41 f6 44 24 08 01 testb $0x1,0x8(%r12) 41e6: 74 0c je 41f4 if (type & LPROCFS_GET_NUM_CPU) rc = 1; if (type & LPROCFS_GET_SMP_ID) rc = 0; spin_lock(&stats->ls_lock); 41e8: 49 8d 7c 24 0c lea 0xc(%r12),%rdi 41ed: e8 00 00 00 00 callq 41f2 41f2: eb 09 jmp 41fd } else { if (type & LPROCFS_GET_NUM_CPU) rc = num_possible_cpus(); if (type & LPROCFS_GET_SMP_ID) rc = smp_processor_id(); 41f4: 65 44 8b 34 25 34 00 mov %gs:0x34,%r14d 41fb: 00 00 } return rc; } static inline void lprocfs_stats_unlock(struct lprocfs_stats *stats) { if (stats->ls_flags & LPROCFS_STATS_FLAG_NOPERCPU) spin_unlock(&stats->ls_lock); } /* Two optimized LPROCFS counter increment functions are provided: * lprocfs_counter_incr(cntr, value) - optimized for by-one counters * lprocfs_counter_add(cntr) - use for multi-valued counters * Counter data layout allows config flag, counter lock and the * count itself to reside within a single cache line. */ static inline void lprocfs_counter_add(struct lprocfs_stats *stats, int idx, long amount) { struct lprocfs_counter *percpu_cntr; int smp_id; if (!stats) return; /* With per-client stats, statistics are allocated only for * single CPU area, so the smp_id should be 0 always. */ smp_id = lprocfs_stats_lock(stats, LPROCFS_GET_SMP_ID); percpu_cntr = &(stats->ls_percpu[smp_id]->lp_cntr[idx]); atomic_inc(&percpu_cntr->lc_cntl.la_entry); percpu_cntr->lc_count++; if (percpu_cntr->lc_config & LPROCFS_CNTR_AVGMINMAX) { percpu_cntr->lc_sum += amount; if (percpu_cntr->lc_config & LPROCFS_CNTR_STDDEV) percpu_cntr->lc_sumsquare += (__u64)amount * amount; if (amount < percpu_cntr->lc_min) percpu_cntr->lc_min = amount; if (amount > percpu_cntr->lc_max) percpu_cntr->lc_max = amount; } atomic_inc(&percpu_cntr->lc_cntl.la_exit); lprocfs_stats_unlock(stats); } static inline void lprocfs_counter_incr(struct lprocfs_stats *stats, int idx) { struct lprocfs_counter *percpu_cntr; int smp_id; if (!stats) return; smp_id = lprocfs_stats_lock(stats, LPROCFS_GET_SMP_ID); percpu_cntr = &(stats->ls_percpu[smp_id]->lp_cntr[idx]); 41fd: 49 63 c6 movslq %r14d,%rax 4200: 49 63 d5 movslq %r13d,%rdx 4203: 49 8b 44 c4 18 mov 0x18(%r12,%rax,8),%rax 4208: 48 8d 14 d2 lea (%rdx,%rdx,8),%rdx 420c: 48 8d 14 d0 lea (%rax,%rdx,8),%rdx 4210: f0 ff 02 lock incl (%rdx) atomic_inc(&percpu_cntr->lc_cntl.la_entry); percpu_cntr->lc_count++; 4213: 48 ff 42 10 incq 0x10(%rdx) 4217: f0 ff 42 04 lock incl 0x4(%rdx) 421b: 41 f6 44 24 08 01 testb $0x1,0x8(%r12) 4221: 74 0a je 422d 4223: 49 8d 7c 24 0c lea 0xc(%r12),%rdi 4228: e8 00 00 00 00 callq 422d 422d: 48 8b 95 c0 00 00 00 mov 0xc0(%rbp),%rdx EXP_CHECK_OP(exp, destroy); EXP_COUNTER_INCREMENT(exp, destroy); rc = OBP(exp->exp_obd, destroy)(exp, obdo, ea, oti, md_exp); 4234: 48 8b 02 mov (%rdx),%rax 4237: 48 89 ef mov %rbp,%rdi 423a: 4d 89 f8 mov %r15,%r8 423d: 48 8d 8c 24 80 00 00 lea 0x80(%rsp),%rcx 4244: 00 4245: 48 8b 54 24 48 mov 0x48(%rsp),%rdx 424a: 48 89 de mov %rbx,%rsi 424d: 48 8b 40 10 mov 0x10(%rax),%rax 4251: ff 90 c0 00 00 00 callq *0xc0(%rax) 4257: 89 c5 mov %eax,%ebp RETURN(rc); 4259: 8b 05 00 00 00 00 mov 0(%rip),%eax # 425f 425f: a8 01 test $0x1,%al 4261: 74 62 je 42c5 4263: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 426a 426a: 79 59 jns 42c5 426c: 48 63 c5 movslq %ebp,%rax 426f: 41 b9 05 02 00 00 mov $0x205,%r9d 4275: 49 c7 c0 00 00 00 00 mov $0x0,%r8 427c: 48 89 44 24 28 mov %rax,0x28(%rsp) 4281: 48 89 44 24 20 mov %rax,0x20(%rsp) 4286: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 428d: 48 89 44 24 18 mov %rax,0x18(%rsp) 4292: ba 01 00 00 00 mov $0x1,%edx 4297: be 80 00 00 00 mov $0x80,%esi 429c: 31 ff xor %edi,%edi 429e: 31 c0 xor %eax,%eax 42a0: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 42a7: 00 00 42a9: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 42b0: 00 00 42b2: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 42b9: 00 42ba: e8 00 00 00 00 callq 42bf 42bf: 8b 05 00 00 00 00 mov 0(%rip),%eax # 42c5 } } rc = obd_destroy(ll_i2obdexp(dir), oa, lsm, &oti, ll_i2mdcexp(dir)); OBDO_FREE(oa); 42c5: a8 10 test $0x10,%al CDEBUG(D_SUPER, "%s: osfs %p age "LPU64", max_age "LPU64"\n", obd->obd_name, &obd->obd_osfs, obd->obd_osfs_age, max_age); if (cfs_time_before_64(obd->obd_osfs_age, max_age)) { rc = OBP(obd, statfs_async)(obd, oinfo, max_age, rqset); 42c7: 41 89 ee mov %ebp,%r14d 42ca: 74 64 je 4330 42cc: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 42d3 42d3: 79 5b jns 4330 42d5: 8b 05 00 00 00 00 mov 0(%rip),%eax # 42db 42db: 41 b9 69 04 00 00 mov $0x469,%r9d 42e1: 49 c7 c0 00 00 00 00 mov $0x0,%r8 42e8: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 42ef: ba 10 00 00 00 mov $0x10,%edx 42f4: be 80 00 00 00 mov $0x80,%esi 42f9: 31 ff xor %edi,%edi 42fb: 48 89 5c 24 20 mov %rbx,0x20(%rsp) 4300: c7 44 24 18 d0 00 00 movl $0xd0,0x18(%rsp) 4307: 00 4308: 89 44 24 28 mov %eax,0x28(%rsp) 430c: 31 c0 xor %eax,%eax 430e: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 4315: 00 00 4317: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 431e: 00 00 4320: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 4327: 00 4328: e8 00 00 00 00 callq 432d 432d: 66 data16 432e: 66 data16 432f: 90 nop 4330: f0 81 2d 00 00 00 00 lock subl $0xd0,0(%rip) # 433b 4337: d0 00 00 00 433b: ba d0 00 00 00 mov $0xd0,%edx 4340: be 5a 00 00 00 mov $0x5a,%esi 4345: 48 89 df mov %rbx,%rdi 4348: e8 00 00 00 00 callq 434d 434d: 48 8b 3d 00 00 00 00 mov 0(%rip),%rdi # 4354 4354: 48 89 de mov %rbx,%rsi 4357: e8 00 00 00 00 callq 435c if (rc) 435c: 85 ed test %ebp,%ebp 435e: 74 58 je 43b8 CERROR("obd destroy objid "LPX64" error %d\n", 4360: 48 8b 44 24 78 mov 0x78(%rsp),%rax 4365: 89 6c 24 20 mov %ebp,0x20(%rsp) 4369: 41 b9 6c 04 00 00 mov $0x46c,%r9d 436f: 49 c7 c0 00 00 00 00 mov $0x0,%r8 4376: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 437d: ba 00 00 02 00 mov $0x20000,%edx 4382: be 80 00 00 00 mov $0x80,%esi 4387: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 438e: 48 8b 40 10 mov 0x10(%rax),%rax 4392: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 4399: 00 00 439b: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 43a2: 00 00 43a4: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 43ab: 00 43ac: 48 89 44 24 18 mov %rax,0x18(%rsp) 43b1: 31 c0 xor %eax,%eax 43b3: e8 00 00 00 00 callq 43b8 #endif /* don't need an addref as the sb_info should be holding one */ static inline struct obd_export *ll_s2obdexp(struct super_block *sb) { 43b8: 48 8b 54 24 70 mov 0x70(%rsp),%rdx static inline int obd_free_memmd(struct obd_export *exp, struct lov_stripe_md **mem_tgt) { LASSERT(mem_tgt); LASSERT(*mem_tgt); 43bd: 48 83 7c 24 78 00 cmpq $0x0,0x78(%rsp) #endif /* don't need an addref as the sb_info should be holding one */ static inline struct obd_export *ll_s2obdexp(struct super_block *sb) { 43c3: 48 8b 82 08 01 00 00 mov 0x108(%rdx),%rax return ll_s2sbi(sb)->ll_osc_exp; 43ca: 48 8b 80 60 02 00 00 mov 0x260(%rax),%rax 43d1: 48 8b 40 20 mov 0x20(%rax),%rax 43d5: 48 8b 58 58 mov 0x58(%rax),%rbx static inline int obd_free_memmd(struct obd_export *exp, struct lov_stripe_md **mem_tgt) { LASSERT(mem_tgt); LASSERT(*mem_tgt); 43d9: 75 25 jne 4400 43db: b9 cd 01 00 00 mov $0x1cd,%ecx 43e0: 48 c7 c2 00 00 00 00 mov $0x0,%rdx 43e7: 48 c7 c6 00 00 00 00 mov $0x0,%rsi 43ee: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 43f5: e8 00 00 00 00 callq 43fa 43fa: 66 data16 43fb: 66 data16 43fc: 90 nop 43fd: 66 data16 43fe: 66 data16 43ff: 90 nop 4400: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 4407 4407: 74 4a je 4453 4409: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 4410 4410: 79 41 jns 4453 4412: 41 b9 b7 01 00 00 mov $0x1b7,%r9d 4418: 49 c7 c0 00 00 00 00 mov $0x0,%r8 441f: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 4426: ba 01 00 00 00 mov $0x1,%edx 442b: be 80 00 00 00 mov $0x80,%esi 4430: 31 ff xor %edi,%edi 4432: 31 c0 xor %eax,%eax 4434: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 443b: 00 00 443d: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 4444: 00 00 4446: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 444d: 00 444e: e8 00 00 00 00 callq 4453 4453: 48 85 db test %rbx,%rbx 4456: 0f 85 84 00 00 00 jne 44e0 445c: 31 c0 xor %eax,%eax 445e: 41 b9 b9 01 00 00 mov $0x1b9,%r9d 4464: 49 c7 c0 00 00 00 00 mov $0x0,%r8 446b: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 4472: ba 00 00 02 00 mov $0x20000,%edx 4477: be 80 00 00 00 mov $0x80,%esi 447c: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 4483: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 448a: 00 00 448c: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 4493: 00 00 4495: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 449c: 00 449d: e8 00 00 00 00 callq 44a2 44a2: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 44a9 44a9: 0f 84 c3 02 00 00 je 4772 44af: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 44b6 44b6: 0f 89 b6 02 00 00 jns 4772 44bc: 48 c7 44 24 28 ed ff movq $0xffffffffffffffed,0x28(%rsp) 44c3: ff ff 44c5: 48 c7 44 24 20 ed ff movq $0xffffffffffffffed,0x20(%rsp) 44cc: ff ff 44ce: 48 c7 44 24 18 ed ff movq $0xffffffffffffffed,0x18(%rsp) 44d5: ff ff 44d7: e9 97 00 00 00 jmpq 4573 44dc: 66 data16 44dd: 66 data16 44de: 66 data16 44df: 90 nop 44e0: 48 8b 93 c0 00 00 00 mov 0xc0(%rbx),%rdx 44e7: 48 85 d2 test %rdx,%rdx 44ea: 74 0c je 44f8 44ec: 48 8b 02 mov (%rdx),%rax 44ef: 48 85 c0 test %rax,%rax 44f2: 0f 85 a0 00 00 00 jne 4598 44f8: 41 b9 b9 01 00 00 mov $0x1b9,%r9d 44fe: 49 c7 c0 00 00 00 00 mov $0x0,%r8 4505: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 450c: ba 00 00 02 00 mov $0x20000,%edx 4511: be 80 00 00 00 mov $0x80,%esi 4516: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 451d: 31 c0 xor %eax,%eax 451f: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 4526: 00 00 4528: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 452f: 00 00 4531: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 4538: 00 4539: e8 00 00 00 00 callq 453e 453e: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 4545 4545: 0f 84 27 02 00 00 je 4772 454b: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 4552 4552: 0f 89 1a 02 00 00 jns 4772 4558: 48 c7 44 24 28 a1 ff movq $0xffffffffffffffa1,0x28(%rsp) 455f: ff ff 4561: 48 c7 44 24 20 a1 ff movq $0xffffffffffffffa1,0x20(%rsp) 4568: ff ff 456a: 48 c7 44 24 18 a1 ff movq $0xffffffffffffffa1,0x18(%rsp) 4571: ff ff 4573: 41 b9 b9 01 00 00 mov $0x1b9,%r9d 4579: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 4580: 00 00 4582: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 4589: 00 00 458b: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 4592: 00 4593: e9 b9 01 00 00 jmpq 4751 4598: 48 8b 40 10 mov 0x10(%rax),%rax 459c: 48 83 b8 98 00 00 00 cmpq $0x0,0x98(%rax) 45a3: 00 45a4: 75 55 jne 45fb 45a6: 8b 82 b4 00 00 00 mov 0xb4(%rdx),%eax 45ac: 41 b9 b9 01 00 00 mov $0x1b9,%r9d 45b2: 49 c7 c0 00 00 00 00 mov $0x0,%r8 45b9: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 45c0: ba 00 00 02 00 mov $0x20000,%edx 45c5: be 80 00 00 00 mov $0x80,%esi 45ca: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 45d1: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 45d8: 00 00 45da: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 45e1: 00 00 45e3: 89 44 24 18 mov %eax,0x18(%rsp) 45e7: 31 c0 xor %eax,%eax 45e9: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 45f0: 00 45f1: e8 00 00 00 00 callq 45f6 45f6: e9 43 ff ff ff jmpq 453e 45fb: 48 8b 82 78 14 00 00 mov 0x1478(%rdx),%rax 4602: 48 85 c0 test %rax,%rax 4605: 0f 84 ea 00 00 00 je 46f5 460b: 44 8b a2 88 14 00 00 mov 0x1488(%rdx),%r12d 4612: 41 83 c4 12 add $0x12,%r12d 4616: 44 39 20 cmp %r12d,(%rax) 4619: 77 26 ja 4641 461b: 48 c7 c2 00 00 00 00 mov $0x0,%rdx 4622: b9 ba 01 00 00 mov $0x1ba,%ecx 4627: 48 c7 c6 00 00 00 00 mov $0x0,%rsi 462e: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 4635: e8 00 00 00 00 callq 463a 463a: 48 8b 93 c0 00 00 00 mov 0xc0(%rbx),%rdx lprocfs_stats_unlock(stats); } static inline void lprocfs_counter_incr(struct lprocfs_stats *stats, int idx) { 4641: 48 8b aa 78 14 00 00 mov 0x1478(%rdx),%rbp struct lprocfs_counter *percpu_cntr; int smp_id; if (!stats) 4648: 48 85 ed test %rbp,%rbp 464b: 74 4b je 4698 464d: 45 31 ed xor %r13d,%r13d 4650: f6 45 08 01 testb $0x1,0x8(%rbp) 4654: 74 0c je 4662 4656: 48 8d 7d 0c lea 0xc(%rbp),%rdi 465a: e8 00 00 00 00 callq 465f 465f: 90 nop 4660: eb 09 jmp 466b 4662: 65 44 8b 2c 25 34 00 mov %gs:0x34,%r13d 4669: 00 00 return; smp_id = lprocfs_stats_lock(stats, LPROCFS_GET_SMP_ID); percpu_cntr = &(stats->ls_percpu[smp_id]->lp_cntr[idx]); 466b: 49 63 c5 movslq %r13d,%rax 466e: 49 63 d4 movslq %r12d,%rdx 4671: 48 8b 44 c5 18 mov 0x18(%rbp,%rax,8),%rax 4676: 48 8d 14 d2 lea (%rdx,%rdx,8),%rdx 467a: 48 8d 14 d0 lea (%rax,%rdx,8),%rdx 467e: f0 ff 02 lock incl (%rdx) atomic_inc(&percpu_cntr->lc_cntl.la_entry); percpu_cntr->lc_count++; 4681: 48 ff 42 10 incq 0x10(%rdx) 4685: f0 ff 42 04 lock incl 0x4(%rdx) 4689: f6 45 08 01 testb $0x1,0x8(%rbp) 468d: 74 09 je 4698 468f: 48 8d 7d 0c lea 0xc(%rbp),%rdi 4693: e8 00 00 00 00 callq 4698 int rc; ENTRY; EXP_CHECK_OP(exp, unpackmd); EXP_COUNTER_INCREMENT(exp, unpackmd); 4698: 48 8b ab d8 00 00 00 mov 0xd8(%rbx),%rbp 469f: 48 85 ed test %rbp,%rbp 46a2: 74 4a je 46ee #ifdef LPROCFS static inline int lprocfs_stats_lock(struct lprocfs_stats *stats, int type) { int rc = 0; 46a4: 45 31 ed xor %r13d,%r13d if (stats->ls_flags & LPROCFS_STATS_FLAG_NOPERCPU) { 46a7: f6 45 08 01 testb $0x1,0x8(%rbp) 46ab: 74 0b je 46b8 if (type & LPROCFS_GET_NUM_CPU) rc = 1; if (type & LPROCFS_GET_SMP_ID) rc = 0; spin_lock(&stats->ls_lock); 46ad: 48 8d 7d 0c lea 0xc(%rbp),%rdi 46b1: e8 00 00 00 00 callq 46b6 46b6: eb 09 jmp 46c1 } else { if (type & LPROCFS_GET_NUM_CPU) rc = num_possible_cpus(); if (type & LPROCFS_GET_SMP_ID) rc = smp_processor_id(); 46b8: 65 44 8b 2c 25 34 00 mov %gs:0x34,%r13d 46bf: 00 00 } return rc; } static inline void lprocfs_stats_unlock(struct lprocfs_stats *stats) { if (stats->ls_flags & LPROCFS_STATS_FLAG_NOPERCPU) spin_unlock(&stats->ls_lock); } /* Two optimized LPROCFS counter increment functions are provided: * lprocfs_counter_incr(cntr, value) - optimized for by-one counters * lprocfs_counter_add(cntr) - use for multi-valued counters * Counter data layout allows config flag, counter lock and the * count itself to reside within a single cache line. */ static inline void lprocfs_counter_add(struct lprocfs_stats *stats, int idx, long amount) { struct lprocfs_counter *percpu_cntr; int smp_id; if (!stats) return; /* With per-client stats, statistics are allocated only for * single CPU area, so the smp_id should be 0 always. */ smp_id = lprocfs_stats_lock(stats, LPROCFS_GET_SMP_ID); percpu_cntr = &(stats->ls_percpu[smp_id]->lp_cntr[idx]); atomic_inc(&percpu_cntr->lc_cntl.la_entry); percpu_cntr->lc_count++; if (percpu_cntr->lc_config & LPROCFS_CNTR_AVGMINMAX) { percpu_cntr->lc_sum += amount; if (percpu_cntr->lc_config & LPROCFS_CNTR_STDDEV) percpu_cntr->lc_sumsquare += (__u64)amount * amount; if (amount < percpu_cntr->lc_min) percpu_cntr->lc_min = amount; if (amount > percpu_cntr->lc_max) percpu_cntr->lc_max = amount; } atomic_inc(&percpu_cntr->lc_cntl.la_exit); lprocfs_stats_unlock(stats); } static inline void lprocfs_counter_incr(struct lprocfs_stats *stats, int idx) { struct lprocfs_counter *percpu_cntr; int smp_id; if (!stats) return; smp_id = lprocfs_stats_lock(stats, LPROCFS_GET_SMP_ID); percpu_cntr = &(stats->ls_percpu[smp_id]->lp_cntr[idx]); 46c1: 49 63 c5 movslq %r13d,%rax 46c4: 49 63 d4 movslq %r12d,%rdx 46c7: 48 8b 44 c5 18 mov 0x18(%rbp,%rax,8),%rax 46cc: 48 8d 14 d2 lea (%rdx,%rdx,8),%rdx 46d0: 48 8d 14 d0 lea (%rax,%rdx,8),%rdx 46d4: f0 ff 02 lock incl (%rdx) atomic_inc(&percpu_cntr->lc_cntl.la_entry); percpu_cntr->lc_count++; 46d7: 48 ff 42 10 incq 0x10(%rdx) 46db: f0 ff 42 04 lock incl 0x4(%rdx) 46df: f6 45 08 01 testb $0x1,0x8(%rbp) 46e3: 74 09 je 46ee 46e5: 48 8d 7d 0c lea 0xc(%rbp),%rdi 46e9: e8 00 00 00 00 callq 46ee 46ee: 48 8b 93 c0 00 00 00 mov 0xc0(%rbx),%rdx EXP_CHECK_OP(exp, unpackmd); EXP_COUNTER_INCREMENT(exp, unpackmd); rc = OBP(exp->exp_obd, unpackmd)(exp, mem_tgt, disk_src, disk_len); 46f5: 48 8b 02 mov (%rdx),%rax 46f8: 31 c9 xor %ecx,%ecx 46fa: 31 d2 xor %edx,%edx 46fc: 48 8d 74 24 78 lea 0x78(%rsp),%rsi 4701: 48 89 df mov %rbx,%rdi 4704: 48 8b 40 10 mov 0x10(%rax),%rax 4708: ff 90 98 00 00 00 callq *0x98(%rax) RETURN(rc); 470e: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 4715 4715: 74 5b je 4772 4717: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 471e 471e: 79 52 jns 4772 4720: 48 98 cltq 4722: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 4729: 00 00 472b: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 4732: 00 00 4734: 48 89 44 24 28 mov %rax,0x28(%rsp) 4739: 48 89 44 24 20 mov %rax,0x20(%rsp) 473e: 41 b9 bd 01 00 00 mov $0x1bd,%r9d 4744: 48 89 44 24 18 mov %rax,0x18(%rsp) 4749: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 4750: 00 4751: 49 c7 c0 00 00 00 00 mov $0x0,%r8 4758: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 475f: ba 01 00 00 00 mov $0x1,%edx 4764: be 80 00 00 00 mov $0x80,%esi 4769: 31 ff xor %edi,%edi 476b: 31 c0 xor %eax,%eax 476d: e8 00 00 00 00 callq 4772 lsm->lsm_object_id, rc); out_free_memmd: obd_free_memmd(ll_i2obdexp(dir), &lsm); out: return rc; 4772: 44 89 f0 mov %r14d,%eax } 4775: 48 8b 9c 24 28 01 00 mov 0x128(%rsp),%rbx 477c: 00 477d: 48 8b ac 24 30 01 00 mov 0x130(%rsp),%rbp 4784: 00 4785: 4c 8b a4 24 38 01 00 mov 0x138(%rsp),%r12 478c: 00 478d: 4c 8b ac 24 40 01 00 mov 0x140(%rsp),%r13 4794: 00 4795: 4c 8b b4 24 48 01 00 mov 0x148(%rsp),%r14 479c: 00 479d: 4c 8b bc 24 50 01 00 mov 0x150(%rsp),%r15 47a4: 00 47a5: 48 81 c4 58 01 00 00 add $0x158,%rsp 47ac: c3 retq 47ad: 66 data16 47ae: 66 data16 47af: 90 nop 00000000000047b0 : static int ll_unlink_generic(struct inode * dir, struct qstr *name) { struct ptlrpc_request *request = NULL; struct mdc_op_data op_data = {{0}}; int rc; ENTRY; CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n", name->len, name->name, dir->i_ino, dir->i_generation, dir); rc = ll_prepare_mdc_op_data(&op_data, dir, NULL, name->name, name->len, 0, NULL); if (rc) GOTO(out, rc); ll_get_child_fid(dir, name, &op_data.fid3); rc = mdc_unlink(ll_i2sbi(dir)->ll_mdc_exp, &op_data, &request); if (rc) GOTO(out, rc); ll_update_times(request, REPLY_REC_OFF, dir); rc = ll_objects_destroy(request, dir); if (rc) GOTO(out, rc); EXIT; out: ptlrpc_req_finished(request); return(rc); } static int ll_rename_generic(struct inode *src, struct qstr *src_name, struct inode *tgt, struct qstr *tgt_name) { struct ptlrpc_request *request = NULL; struct ll_sb_info *sbi = ll_i2sbi(src); struct mdc_op_data op_data = {{0}}; int err; ENTRY; CDEBUG(D_VFSTRACE,"VFS Op:oldname=%.*s,src_dir=%lu/%u(%p),newname=%.*s," "tgt_dir=%lu/%u(%p)\n", src_name->len, src_name->name, src->i_ino, src->i_generation, src, tgt_name->len, tgt_name->name, tgt->i_ino, tgt->i_generation, tgt); err = ll_prepare_mdc_op_data(&op_data, src, tgt, NULL, 0, 0, NULL); if (err) GOTO(out, err); ll_get_child_fid(src, src_name, &op_data.fid3); ll_get_child_fid(tgt, tgt_name, &op_data.fid4); err = mdc_rename(sbi->ll_mdc_exp, &op_data, src_name->name, src_name->len, tgt_name->name, tgt_name->len, &request); if (err) GOTO(out, err); ll_update_times(request, REPLY_REC_OFF, src); ll_update_times(request, REPLY_REC_OFF, tgt); err = ll_objects_destroy(request, src); if (err) GOTO(out, err); EXIT; out: ptlrpc_req_finished(request); return(err); } #ifdef HAVE_VFS_INTENT_PATCHES static int ll_mknod_raw(struct nameidata *nd, int mode, dev_t rdev) { return ll_mknod_generic(nd->dentry->d_inode, &nd->last, mode,rdev,NULL); } static int ll_rename_raw(struct nameidata *srcnd, struct nameidata *tgtnd) { return ll_rename_generic(srcnd->dentry->d_inode, &srcnd->last, tgtnd->dentry->d_inode, &tgtnd->last); } static int ll_link_raw(struct nameidata *srcnd, struct nameidata *tgtnd) { return ll_link_generic(srcnd->dentry->d_inode, tgtnd->dentry->d_inode, &tgtnd->last, NULL); } static int ll_symlink_raw(struct nameidata *nd, const char *tgt) { return ll_symlink_generic(nd->dentry->d_inode, &nd->last, tgt, NULL); } static int ll_rmdir_raw(struct nameidata *nd) { return ll_rmdir_generic(nd->dentry->d_inode, nd->dentry, &nd->last); } static int ll_mkdir_raw(struct nameidata *nd, int mode) { return ll_mkdir_generic(nd->dentry->d_inode, &nd->last, mode, NULL); } static int ll_unlink_raw(struct nameidata *nd) { return ll_unlink_generic(nd->dentry->d_inode, &nd->last); } #endif static int ll_mknod(struct inode *dir, struct dentry *dchild, int mode, ll_dev_t rdev) { 47b0: 89 c8 mov %ecx,%eax 47b2: c1 e9 14 shr $0x14,%ecx 47b5: 49 89 f0 mov %rsi,%r8 47b8: c1 e1 08 shl $0x8,%ecx 47bb: 48 8d 76 28 lea 0x28(%rsi),%rsi 47bf: 09 c1 or %eax,%ecx 47c1: 0f b7 c9 movzwl %cx,%ecx 47c4: e9 07 de ff ff jmpq 25d0 47c9: 66 data16 47ca: 66 data16 47cb: 66 data16 47cc: 90 nop 47cd: 66 data16 47ce: 66 data16 47cf: 90 nop 00000000000047d0 : return ll_mknod_generic(dir, &dchild->d_name, mode, old_encode_dev(rdev), dchild); } #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) static int ll_unlink(struct inode * dir, struct dentry *dentry) { 47d0: 48 81 ec e8 00 00 00 sub $0xe8,%rsp 47d7: ba 68 00 00 00 mov $0x68,%edx 47dc: 4c 89 ac 24 e0 00 00 mov %r13,0xe0(%rsp) 47e3: 00 47e4: 4c 8d 6c 24 50 lea 0x50(%rsp),%r13 47e9: 48 89 ac 24 d0 00 00 mov %rbp,0xd0(%rsp) 47f0: 00 47f1: 4c 89 a4 24 d8 00 00 mov %r12,0xd8(%rsp) 47f8: 00 47f9: 48 89 fd mov %rdi,%rbp 47fc: 4c 8d 66 28 lea 0x28(%rsi),%r12 4800: 4c 89 ef mov %r13,%rdi 4803: 31 f6 xor %esi,%esi 4805: 48 89 9c 24 c8 00 00 mov %rbx,0xc8(%rsp) 480c: 00 480d: 48 c7 44 24 48 00 00 movq $0x0,0x48(%rsp) 4814: 00 00 4816: e8 00 00 00 00 callq 481b 481b: 8b 05 00 00 00 00 mov 0(%rip),%eax # 4821 4821: a8 01 test $0x1,%al 4823: 74 50 je 4875 4825: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 482c 482c: 79 47 jns 4875 482e: 41 b9 78 04 00 00 mov $0x478,%r9d 4834: 49 c7 c0 00 00 00 00 mov $0x0,%r8 483b: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 4842: ba 01 00 00 00 mov $0x1,%edx 4847: be 80 00 00 00 mov $0x80,%esi 484c: 31 ff xor %edi,%edi 484e: 31 c0 xor %eax,%eax 4850: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 4857: 00 00 4859: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 4860: 00 00 4862: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 4869: 00 486a: e8 00 00 00 00 callq 486f 486f: 8b 05 00 00 00 00 mov 0(%rip),%eax # 4875 4875: a9 00 00 20 00 test $0x200000,%eax 487a: 74 75 je 48f1 487c: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 4883 4883: 79 6c jns 48f1 4885: 48 89 6c 24 38 mov %rbp,0x38(%rsp) 488a: 8b 85 fc 01 00 00 mov 0x1fc(%rbp),%eax 4890: 41 b9 7b 04 00 00 mov $0x47b,%r9d 4896: 49 c7 c0 00 00 00 00 mov $0x0,%r8 489d: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 48a4: ba 00 00 20 00 mov $0x200000,%edx 48a9: be 80 00 00 00 mov $0x80,%esi 48ae: 31 ff xor %edi,%edi 48b0: 89 44 24 30 mov %eax,0x30(%rsp) 48b4: 48 8b 45 30 mov 0x30(%rbp),%rax 48b8: 48 89 44 24 28 mov %rax,0x28(%rsp) 48bd: 49 8b 44 24 08 mov 0x8(%r12),%rax 48c2: 48 89 44 24 20 mov %rax,0x20(%rsp) 48c7: 41 8b 44 24 04 mov 0x4(%r12),%eax 48cc: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 48d3: 00 00 48d5: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 48dc: 00 00 48de: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 48e5: 00 48e6: 89 44 24 18 mov %eax,0x18(%rsp) 48ea: 31 c0 xor %eax,%eax 48ec: e8 00 00 00 00 callq 48f1 48f1: 45 8b 44 24 04 mov 0x4(%r12),%r8d 48f6: 49 8b 4c 24 08 mov 0x8(%r12),%rcx 48fb: 45 31 c9 xor %r9d,%r9d 48fe: 31 d2 xor %edx,%edx 4900: 48 89 ee mov %rbp,%rsi 4903: 4c 89 ef mov %r13,%rdi 4906: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 490d: 00 490e: e8 00 00 00 00 callq 4913 4913: 85 c0 test %eax,%eax 4915: 89 c3 mov %eax,%ebx 4917: 74 59 je 4972 4919: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 4920 4920: 48 98 cltq 4922: 0f 84 ce 01 00 00 je 4af6 4928: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 492f 492f: 0f 89 c1 01 00 00 jns 4af6 4935: 41 b9 80 04 00 00 mov $0x480,%r9d 493b: 48 89 44 24 30 mov %rax,0x30(%rsp) 4940: 48 89 44 24 28 mov %rax,0x28(%rsp) 4945: 48 89 44 24 20 mov %rax,0x20(%rsp) 494a: 48 c7 44 24 18 00 00 movq $0x0,0x18(%rsp) 4951: 00 00 4953: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 495a: 00 00 495c: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 4963: 00 00 4965: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 496c: 00 496d: e9 0e 01 00 00 jmpq 4a80 4972: 49 8d 55 20 lea 0x20(%r13),%rdx 4976: 4c 89 e6 mov %r12,%rsi 4979: 48 89 ef mov %rbp,%rdi 497c: e8 5f e5 ff ff callq 2ee0 // FIXME: replace the name of this with LL_SB to conform to kernel stuff static inline struct ll_sb_info *ll_i2sbi(struct inode *inode) { return ll_s2sbi(inode->i_sb); 4981: 48 8b 85 08 01 00 00 mov 0x108(%rbp),%rax 4988: 48 8d 54 24 48 lea 0x48(%rsp),%rdx 498d: 4c 89 ee mov %r13,%rsi 4990: 48 8b 80 60 02 00 00 mov 0x260(%rax),%rax 4997: 48 8b 40 20 mov 0x20(%rax),%rax 499b: 48 8b 78 50 mov 0x50(%rax),%rdi 499f: e8 00 00 00 00 callq 49a4 49a4: 85 c0 test %eax,%eax } // FIXME: replace the name of this with LL_SB to conform to kernel stuff static inline struct ll_sb_info *ll_i2sbi(struct inode *inode) { 49a6: 89 c3 mov %eax,%ebx 49a8: 74 59 je 4a03 49aa: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 49b1 49b1: 48 98 cltq 49b3: 0f 84 3d 01 00 00 je 4af6 49b9: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 49c0 49c0: 0f 89 30 01 00 00 jns 4af6 49c6: 41 b9 85 04 00 00 mov $0x485,%r9d 49cc: 48 89 44 24 30 mov %rax,0x30(%rsp) 49d1: 48 89 44 24 28 mov %rax,0x28(%rsp) 49d6: 48 89 44 24 20 mov %rax,0x20(%rsp) 49db: 48 c7 44 24 18 00 00 movq $0x0,0x18(%rsp) 49e2: 00 00 49e4: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 49eb: 00 00 49ed: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 49f4: 00 00 49f6: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 49fd: 00 49fe: e9 7d 00 00 00 jmpq 4a80 4a03: 48 8b 7c 24 48 mov 0x48(%rsp),%rdi 4a08: 48 89 ea mov %rbp,%rdx 4a0b: be 01 00 00 00 mov $0x1,%esi 4a10: e8 db d6 ff ff callq 20f0 4a15: 48 8b 7c 24 48 mov 0x48(%rsp),%rdi 4a1a: 48 89 ee mov %rbp,%rsi 4a1d: e8 00 00 00 00 callq 4a22 4a22: 85 c0 test %eax,%eax 4a24: 89 c3 mov %eax,%ebx 4a26: 74 7b je 4aa3 4a28: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 4a2f 4a2f: 48 98 cltq 4a31: 0f 84 bf 00 00 00 je 4af6 4a37: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 4a3e 4a3e: 0f 89 b2 00 00 00 jns 4af6 4a44: 48 89 44 24 30 mov %rax,0x30(%rsp) 4a49: 48 89 44 24 28 mov %rax,0x28(%rsp) 4a4e: 41 b9 8b 04 00 00 mov $0x48b,%r9d 4a54: 48 89 44 24 20 mov %rax,0x20(%rsp) 4a59: 48 c7 44 24 18 00 00 movq $0x0,0x18(%rsp) 4a60: 00 00 4a62: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 4a69: 00 00 4a6b: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 4a72: 00 00 4a74: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 4a7b: 00 4a7c: 66 data16 4a7d: 66 data16 4a7e: 66 data16 4a7f: 90 nop 4a80: 49 c7 c0 00 00 00 00 mov $0x0,%r8 4a87: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 4a8e: ba 01 00 00 00 mov $0x1,%edx 4a93: be 80 00 00 00 mov $0x80,%esi 4a98: 31 ff xor %edi,%edi 4a9a: 31 c0 xor %eax,%eax 4a9c: e8 00 00 00 00 callq 4aa1 4aa1: eb 53 jmp 4af6 4aa3: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 4aaa 4aaa: 74 4a je 4af6 4aac: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 4ab3 4ab3: 79 41 jns 4af6 4ab5: 41 b9 8c 04 00 00 mov $0x48c,%r9d 4abb: 49 c7 c0 00 00 00 00 mov $0x0,%r8 4ac2: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 4ac9: ba 01 00 00 00 mov $0x1,%edx 4ace: be 80 00 00 00 mov $0x80,%esi 4ad3: 31 ff xor %edi,%edi 4ad5: 31 c0 xor %eax,%eax 4ad7: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 4ade: 00 00 4ae0: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 4ae7: 00 00 4ae9: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 4af0: 00 4af1: e8 00 00 00 00 callq 4af6 4af6: 48 8b 7c 24 48 mov 0x48(%rsp),%rdi 4afb: e8 00 00 00 00 callq 4b00 return ll_unlink_generic(dir, &dentry->d_name); } 4b00: 89 d8 mov %ebx,%eax 4b02: 48 8b ac 24 d0 00 00 mov 0xd0(%rsp),%rbp 4b09: 00 4b0a: 48 8b 9c 24 c8 00 00 mov 0xc8(%rsp),%rbx 4b11: 00 4b12: 4c 8b a4 24 d8 00 00 mov 0xd8(%rsp),%r12 4b19: 00 4b1a: 4c 8b ac 24 e0 00 00 mov 0xe0(%rsp),%r13 4b21: 00 4b22: 48 81 c4 e8 00 00 00 add $0xe8,%rsp 4b29: c3 retq 4b2a: 66 data16 4b2b: 66 data16 4b2c: 90 nop 4b2d: 66 data16 4b2e: 66 data16 4b2f: 90 nop 0000000000004b30 : static int ll_mkdir(struct inode *dir, struct dentry *dentry, int mode) { 4b30: 48 83 ec 68 sub $0x68,%rsp 4b34: 8b 05 00 00 00 00 mov 0(%rip),%eax # 4b3a 4b3a: 48 89 5c 24 48 mov %rbx,0x48(%rsp) 4b3f: 48 89 6c 24 50 mov %rbp,0x50(%rsp) 4b44: 48 8d 5e 28 lea 0x28(%rsi),%rbx 4b48: 4c 89 64 24 58 mov %r12,0x58(%rsp) 4b4d: 4c 89 6c 24 60 mov %r13,0x60(%rsp) 4b52: 48 89 fd mov %rdi,%rbp 4b55: a8 01 test $0x1,%al 4b57: 49 89 f4 mov %rsi,%r12 4b5a: 41 89 d5 mov %edx,%r13d 4b5d: 74 51 je 4bb0 4b5f: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 4b66 4b66: 79 48 jns 4bb0 4b68: 41 b9 e6 03 00 00 mov $0x3e6,%r9d 4b6e: 49 c7 c0 00 00 00 00 mov $0x0,%r8 4b75: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 4b7c: ba 01 00 00 00 mov $0x1,%edx 4b81: be 80 00 00 00 mov $0x80,%esi 4b86: 31 ff xor %edi,%edi 4b88: 31 c0 xor %eax,%eax 4b8a: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 4b91: 00 00 4b93: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 4b9a: 00 00 4b9c: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 4ba3: 00 4ba4: e8 00 00 00 00 callq 4ba9 4ba9: 8b 05 00 00 00 00 mov 0(%rip),%eax # 4baf 4baf: 90 nop 4bb0: a9 00 00 20 00 test $0x200000,%eax 4bb5: 74 79 je 4c30 4bb7: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 4bbe 4bbe: 79 70 jns 4c30 4bc0: 48 89 6c 24 38 mov %rbp,0x38(%rsp) 4bc5: 8b 85 fc 01 00 00 mov 0x1fc(%rbp),%eax 4bcb: 41 b9 e8 03 00 00 mov $0x3e8,%r9d 4bd1: 49 c7 c0 00 00 00 00 mov $0x0,%r8 4bd8: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 4bdf: ba 00 00 20 00 mov $0x200000,%edx 4be4: be 80 00 00 00 mov $0x80,%esi 4be9: 31 ff xor %edi,%edi 4beb: 89 44 24 30 mov %eax,0x30(%rsp) 4bef: 48 8b 45 30 mov 0x30(%rbp),%rax 4bf3: 48 89 44 24 28 mov %rax,0x28(%rsp) 4bf8: 48 8b 43 08 mov 0x8(%rbx),%rax 4bfc: 48 89 44 24 20 mov %rax,0x20(%rsp) 4c01: 8b 43 04 mov 0x4(%rbx),%eax 4c04: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 4c0b: 00 00 4c0d: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 4c14: 00 00 4c16: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 4c1d: 00 4c1e: 89 44 24 18 mov %eax,0x18(%rsp) 4c22: 31 c0 xor %eax,%eax 4c24: e8 00 00 00 00 callq 4c29 4c29: 66 data16 4c2a: 66 data16 4c2b: 66 data16 4c2c: 90 nop 4c2d: 66 data16 4c2e: 66 data16 4c2f: 90 nop 4c30: 65 48 8b 04 25 00 00 mov %gs:0x0,%rax 4c37: 00 00 4c39: 48 8b 80 b0 06 00 00 mov 0x6b0(%rax),%rax 4c40: 45 31 c0 xor %r8d,%r8d 4c43: 31 d2 xor %edx,%edx 4c45: 48 89 de mov %rbx,%rsi 4c48: 4d 89 e1 mov %r12,%r9 4c4b: 48 89 ef mov %rbp,%rdi 4c4e: 8b 48 0c mov 0xc(%rax),%ecx 4c51: f7 d1 not %ecx 4c53: 44 21 e9 and %r13d,%ecx 4c56: 81 e1 ff 03 00 00 and $0x3ff,%ecx 4c5c: 80 cd 40 or $0x40,%ch 4c5f: e8 7c d5 ff ff callq 21e0 4c64: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 4c6b 4c6b: 89 c3 mov %eax,%ebx 4c6d: 74 61 je 4cd0 4c6f: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 4c76 4c76: 79 58 jns 4cd0 4c78: 48 98 cltq 4c7a: 41 b9 ed 03 00 00 mov $0x3ed,%r9d 4c80: 49 c7 c0 00 00 00 00 mov $0x0,%r8 4c87: 48 89 44 24 28 mov %rax,0x28(%rsp) 4c8c: 48 89 44 24 20 mov %rax,0x20(%rsp) 4c91: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 4c98: 48 89 44 24 18 mov %rax,0x18(%rsp) 4c9d: ba 01 00 00 00 mov $0x1,%edx 4ca2: be 80 00 00 00 mov $0x80,%esi 4ca7: 31 ff xor %edi,%edi 4ca9: 31 c0 xor %eax,%eax 4cab: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 4cb2: 00 00 4cb4: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 4cbb: 00 00 4cbd: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 4cc4: 00 4cc5: e8 00 00 00 00 callq 4cca 4cca: 66 data16 4ccb: 66 data16 4ccc: 90 nop 4ccd: 66 data16 4cce: 66 data16 4ccf: 90 nop return ll_mkdir_generic(dir, &dentry->d_name, mode, dentry); } 4cd0: 89 d8 mov %ebx,%eax 4cd2: 48 8b 6c 24 50 mov 0x50(%rsp),%rbp 4cd7: 48 8b 5c 24 48 mov 0x48(%rsp),%rbx 4cdc: 4c 8b 64 24 58 mov 0x58(%rsp),%r12 4ce1: 4c 8b 6c 24 60 mov 0x60(%rsp),%r13 4ce6: 48 83 c4 68 add $0x68,%rsp 4cea: c3 retq 4ceb: 66 data16 4cec: 66 data16 4ced: 90 nop 4cee: 66 data16 4cef: 90 nop 0000000000004cf0 : static int ll_rmdir(struct inode *dir, struct dentry *dentry) { 4cf0: 48 81 ec e8 00 00 00 sub $0xe8,%rsp 4cf7: ba 68 00 00 00 mov $0x68,%edx 4cfc: 4c 89 ac 24 e0 00 00 mov %r13,0xe0(%rsp) 4d03: 00 4d04: 4c 8d 6c 24 50 lea 0x50(%rsp),%r13 4d09: 48 89 9c 24 c8 00 00 mov %rbx,0xc8(%rsp) 4d10: 00 4d11: 4c 89 a4 24 d8 00 00 mov %r12,0xd8(%rsp) 4d18: 00 4d19: 48 89 fb mov %rdi,%rbx 4d1c: 4c 8d 66 28 lea 0x28(%rsi),%r12 4d20: 4c 89 ef mov %r13,%rdi 4d23: 31 f6 xor %esi,%esi 4d25: 48 89 ac 24 d0 00 00 mov %rbp,0xd0(%rsp) 4d2c: 00 4d2d: 48 c7 44 24 48 00 00 movq $0x0,0x48(%rsp) 4d34: 00 00 4d36: e8 00 00 00 00 callq 4d3b 4d3b: 8b 05 00 00 00 00 mov 0(%rip),%eax # 4d41 4d41: a8 01 test $0x1,%al 4d43: 74 50 je 4d95 4d45: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 4d4c 4d4c: 79 47 jns 4d95 4d4e: 41 b9 07 04 00 00 mov $0x407,%r9d 4d54: 49 c7 c0 00 00 00 00 mov $0x0,%r8 4d5b: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 4d62: ba 01 00 00 00 mov $0x1,%edx 4d67: be 80 00 00 00 mov $0x80,%esi 4d6c: 31 ff xor %edi,%edi 4d6e: 31 c0 xor %eax,%eax 4d70: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 4d77: 00 00 4d79: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 4d80: 00 00 4d82: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 4d89: 00 4d8a: e8 00 00 00 00 callq 4d8f 4d8f: 8b 05 00 00 00 00 mov 0(%rip),%eax # 4d95 4d95: a9 00 00 20 00 test $0x200000,%eax 4d9a: 74 75 je 4e11 4d9c: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 4da3 4da3: 79 6c jns 4e11 4da5: 8b 83 fc 01 00 00 mov 0x1fc(%rbx),%eax 4dab: 48 89 5c 24 38 mov %rbx,0x38(%rsp) 4db0: 41 b9 09 04 00 00 mov $0x409,%r9d 4db6: 49 c7 c0 00 00 00 00 mov $0x0,%r8 4dbd: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 4dc4: ba 00 00 20 00 mov $0x200000,%edx 4dc9: be 80 00 00 00 mov $0x80,%esi 4dce: 31 ff xor %edi,%edi 4dd0: 89 44 24 30 mov %eax,0x30(%rsp) 4dd4: 48 8b 43 30 mov 0x30(%rbx),%rax 4dd8: 48 89 44 24 28 mov %rax,0x28(%rsp) 4ddd: 49 8b 44 24 08 mov 0x8(%r12),%rax 4de2: 48 89 44 24 20 mov %rax,0x20(%rsp) 4de7: 41 8b 44 24 04 mov 0x4(%r12),%eax 4dec: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 4df3: 00 00 4df5: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 4dfc: 00 00 4dfe: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 4e05: 00 4e06: 89 44 24 18 mov %eax,0x18(%rsp) 4e0a: 31 c0 xor %eax,%eax 4e0c: e8 00 00 00 00 callq 4e11 4e11: 45 8b 44 24 04 mov 0x4(%r12),%r8d 4e16: 49 8b 4c 24 08 mov 0x8(%r12),%rcx 4e1b: 31 d2 xor %edx,%edx 4e1d: 41 b9 00 40 00 00 mov $0x4000,%r9d 4e23: 48 89 de mov %rbx,%rsi 4e26: 4c 89 ef mov %r13,%rdi 4e29: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 4e30: 00 4e31: e8 00 00 00 00 callq 4e36 4e36: 85 c0 test %eax,%eax 4e38: 89 c5 mov %eax,%ebp 4e3a: 74 59 je 4e95 4e3c: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 4e43 4e43: 48 98 cltq 4e45: 0f 84 65 01 00 00 je 4fb0 4e4b: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 4e52 4e52: 0f 89 58 01 00 00 jns 4fb0 4e58: 41 b9 1a 04 00 00 mov $0x41a,%r9d 4e5e: 48 89 44 24 30 mov %rax,0x30(%rsp) 4e63: 48 89 44 24 28 mov %rax,0x28(%rsp) 4e68: 48 89 44 24 20 mov %rax,0x20(%rsp) 4e6d: 48 c7 44 24 18 00 00 movq $0x0,0x18(%rsp) 4e74: 00 00 4e76: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 4e7d: 00 00 4e7f: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 4e86: 00 00 4e88: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 4e8f: 00 4e90: e9 8c 00 00 00 jmpq 4f21 4e95: 49 8d 55 20 lea 0x20(%r13),%rdx 4e99: 4c 89 e6 mov %r12,%rsi 4e9c: 48 89 df mov %rbx,%rdi 4e9f: e8 3c e0 ff ff callq 2ee0 // FIXME: replace the name of this with LL_SB to conform to kernel stuff static inline struct ll_sb_info *ll_i2sbi(struct inode *inode) { return ll_s2sbi(inode->i_sb); 4ea4: 48 8b 83 08 01 00 00 mov 0x108(%rbx),%rax 4eab: 48 8d 54 24 48 lea 0x48(%rsp),%rdx 4eb0: 4c 89 ee mov %r13,%rsi 4eb3: 48 8b 80 60 02 00 00 mov 0x260(%rax),%rax 4eba: 48 8b 40 20 mov 0x20(%rax),%rax 4ebe: 48 8b 78 50 mov 0x50(%rax),%rdi 4ec2: e8 00 00 00 00 callq 4ec7 4ec7: 85 c0 test %eax,%eax } // FIXME: replace the name of this with LL_SB to conform to kernel stuff static inline struct ll_sb_info *ll_i2sbi(struct inode *inode) { 4ec9: 89 c5 mov %eax,%ebp 4ecb: 74 77 je 4f44 4ecd: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 4ed4 4ed4: 48 98 cltq 4ed6: 0f 84 d4 00 00 00 je 4fb0 4edc: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 4ee3 4ee3: 0f 89 c7 00 00 00 jns 4fb0 4ee9: 48 89 44 24 30 mov %rax,0x30(%rsp) 4eee: 48 89 44 24 28 mov %rax,0x28(%rsp) 4ef3: 41 b9 1f 04 00 00 mov $0x41f,%r9d 4ef9: 48 89 44 24 20 mov %rax,0x20(%rsp) 4efe: 48 c7 44 24 18 00 00 movq $0x0,0x18(%rsp) 4f05: 00 00 4f07: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 4f0e: 00 00 4f10: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 4f17: 00 00 4f19: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 4f20: 00 4f21: 49 c7 c0 00 00 00 00 mov $0x0,%r8 4f28: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 4f2f: ba 01 00 00 00 mov $0x1,%edx 4f34: be 80 00 00 00 mov $0x80,%esi 4f39: 31 ff xor %edi,%edi 4f3b: 31 c0 xor %eax,%eax 4f3d: e8 00 00 00 00 callq 4f42 4f42: eb 6c jmp 4fb0 4f44: 48 8b 7c 24 48 mov 0x48(%rsp),%rdi 4f49: 48 89 da mov %rbx,%rdx 4f4c: be 01 00 00 00 mov $0x1,%esi 4f51: e8 9a d1 ff ff callq 20f0 4f56: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 4f5d 4f5d: 74 51 je 4fb0 4f5f: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 4f66 4f66: 79 48 jns 4fb0 4f68: 41 b9 22 04 00 00 mov $0x422,%r9d 4f6e: 49 c7 c0 00 00 00 00 mov $0x0,%r8 4f75: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 4f7c: ba 01 00 00 00 mov $0x1,%edx 4f81: be 80 00 00 00 mov $0x80,%esi 4f86: 31 ff xor %edi,%edi 4f88: 31 c0 xor %eax,%eax 4f8a: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 4f91: 00 00 4f93: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 4f9a: 00 00 4f9c: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 4fa3: 00 4fa4: e8 00 00 00 00 callq 4fa9 4fa9: 66 data16 4faa: 66 data16 4fab: 66 data16 4fac: 90 nop 4fad: 66 data16 4fae: 66 data16 4faf: 90 nop 4fb0: 48 8b 7c 24 48 mov 0x48(%rsp),%rdi 4fb5: e8 00 00 00 00 callq 4fba return ll_rmdir_generic(dir, NULL, &dentry->d_name); } 4fba: 89 e8 mov %ebp,%eax 4fbc: 48 8b 9c 24 c8 00 00 mov 0xc8(%rsp),%rbx 4fc3: 00 4fc4: 48 8b ac 24 d0 00 00 mov 0xd0(%rsp),%rbp 4fcb: 00 4fcc: 4c 8b a4 24 d8 00 00 mov 0xd8(%rsp),%r12 4fd3: 00 4fd4: 4c 8b ac 24 e0 00 00 mov 0xe0(%rsp),%r13 4fdb: 00 4fdc: 48 81 c4 e8 00 00 00 add $0xe8,%rsp 4fe3: c3 retq 4fe4: 66 data16 4fe5: 66 data16 4fe6: 66 data16 4fe7: 90 nop 4fe8: 66 data16 4fe9: 66 data16 4fea: 66 data16 4feb: 90 nop 4fec: 66 data16 4fed: 66 data16 4fee: 66 data16 4fef: 90 nop 0000000000004ff0 : static int ll_symlink(struct inode *dir, struct dentry *dentry, const char *oldname) { 4ff0: 48 83 ec 78 sub $0x78,%rsp 4ff4: 8b 05 00 00 00 00 mov 0(%rip),%eax # 4ffa 4ffa: 48 89 5c 24 58 mov %rbx,0x58(%rsp) 4fff: 48 89 6c 24 60 mov %rbp,0x60(%rsp) 5004: 48 8d 5e 28 lea 0x28(%rsi),%rbx 5008: 4c 89 64 24 68 mov %r12,0x68(%rsp) 500d: 4c 89 6c 24 70 mov %r13,0x70(%rsp) 5012: 48 89 fd mov %rdi,%rbp 5015: a8 01 test $0x1,%al 5017: 49 89 f4 mov %rsi,%r12 501a: 49 89 d5 mov %rdx,%r13 501d: 74 51 je 5070 501f: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 5026 5026: 79 48 jns 5070 5028: 41 b9 b4 03 00 00 mov $0x3b4,%r9d 502e: 49 c7 c0 00 00 00 00 mov $0x0,%r8 5035: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 503c: ba 01 00 00 00 mov $0x1,%edx 5041: be 80 00 00 00 mov $0x80,%esi 5046: 31 ff xor %edi,%edi 5048: 31 c0 xor %eax,%eax 504a: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 5051: 00 00 5053: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 505a: 00 00 505c: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 5063: 00 5064: e8 00 00 00 00 callq 5069 5069: 8b 05 00 00 00 00 mov 0(%rip),%eax # 506f 506f: 90 nop 5070: a9 00 00 20 00 test $0x200000,%eax 5075: 74 7f je 50f6 5077: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 507e 507e: 79 76 jns 50f6 5080: 4c 89 6c 24 48 mov %r13,0x48(%rsp) 5085: c7 44 24 40 b8 0b 00 movl $0xbb8,0x40(%rsp) 508c: 00 508d: 41 b9 b8 03 00 00 mov $0x3b8,%r9d 5093: 48 89 6c 24 38 mov %rbp,0x38(%rsp) 5098: 8b 85 fc 01 00 00 mov 0x1fc(%rbp),%eax 509e: 49 c7 c0 00 00 00 00 mov $0x0,%r8 50a5: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 50ac: ba 00 00 20 00 mov $0x200000,%edx 50b1: be 80 00 00 00 mov $0x80,%esi 50b6: 31 ff xor %edi,%edi 50b8: 89 44 24 30 mov %eax,0x30(%rsp) 50bc: 48 8b 45 30 mov 0x30(%rbp),%rax 50c0: 48 89 44 24 28 mov %rax,0x28(%rsp) 50c5: 48 8b 43 08 mov 0x8(%rbx),%rax 50c9: 48 89 44 24 20 mov %rax,0x20(%rsp) 50ce: 8b 43 04 mov 0x4(%rbx),%eax 50d1: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 50d8: 00 00 50da: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 50e1: 00 00 50e3: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 50ea: 00 50eb: 89 44 24 18 mov %eax,0x18(%rsp) 50ef: 31 c0 xor %eax,%eax 50f1: e8 00 00 00 00 callq 50f6 50f6: 45 31 c0 xor %r8d,%r8d 50f9: 48 89 de mov %rbx,%rsi 50fc: 4d 89 e1 mov %r12,%r9 50ff: b9 ff a1 00 00 mov $0xa1ff,%ecx 5104: 4c 89 ea mov %r13,%rdx 5107: 48 89 ef mov %rbp,%rdi 510a: e8 d1 d0 ff ff callq 21e0 510f: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 5116 5116: 89 c3 mov %eax,%ebx 5118: 74 5b je 5175 511a: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 5121 5121: 79 52 jns 5175 5123: 48 98 cltq 5125: 41 b9 bc 03 00 00 mov $0x3bc,%r9d 512b: 49 c7 c0 00 00 00 00 mov $0x0,%r8 5132: 48 89 44 24 28 mov %rax,0x28(%rsp) 5137: 48 89 44 24 20 mov %rax,0x20(%rsp) 513c: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 5143: 48 89 44 24 18 mov %rax,0x18(%rsp) 5148: ba 01 00 00 00 mov $0x1,%edx 514d: be 80 00 00 00 mov $0x80,%esi 5152: 31 ff xor %edi,%edi 5154: 31 c0 xor %eax,%eax 5156: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 515d: 00 00 515f: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 5166: 00 00 5168: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 516f: 00 5170: e8 00 00 00 00 callq 5175 return ll_symlink_generic(dir, &dentry->d_name, oldname, dentry); } 5175: 89 d8 mov %ebx,%eax 5177: 48 8b 6c 24 60 mov 0x60(%rsp),%rbp 517c: 48 8b 5c 24 58 mov 0x58(%rsp),%rbx 5181: 4c 8b 64 24 68 mov 0x68(%rsp),%r12 5186: 4c 8b 6c 24 70 mov 0x70(%rsp),%r13 518b: 48 83 c4 78 add $0x78,%rsp 518f: c3 retq 0000000000005190 : static int ll_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_dentry) { 5190: 48 81 ec 18 01 00 00 sub $0x118,%rsp 5197: 48 89 9c 24 e8 00 00 mov %rbx,0xe8(%rsp) 519e: 00 519f: 4c 89 ac 24 00 01 00 mov %r13,0x100(%rsp) 51a6: 00 51a7: 48 8d 5a 28 lea 0x28(%rdx),%rbx 51ab: 4c 89 b4 24 08 01 00 mov %r14,0x108(%rsp) 51b2: 00 51b3: 48 89 ac 24 f0 00 00 mov %rbp,0xf0(%rsp) 51ba: 00 51bb: 49 89 f5 mov %rsi,%r13 51be: 4c 89 a4 24 f8 00 00 mov %r12,0xf8(%rsp) 51c5: 00 51c6: 4c 89 bc 24 10 01 00 mov %r15,0x110(%rsp) 51cd: 00 51ce: 49 89 d6 mov %rdx,%r14 51d1: 4c 8b 67 10 mov 0x10(%rdi),%r12 51d5: 48 c7 44 24 68 00 00 movq $0x0,0x68(%rsp) 51dc: 00 00 // FIXME: replace the name of this with LL_SB to conform to kernel stuff static inline struct ll_sb_info *ll_i2sbi(struct inode *inode) { return ll_s2sbi(inode->i_sb); 51de: 48 8b 86 08 01 00 00 mov 0x108(%rsi),%rax 51e5: 48 8b 80 60 02 00 00 mov 0x260(%rax),%rax 51ec: 4c 8b 78 20 mov 0x20(%rax),%r15 51f0: 8b 05 00 00 00 00 mov 0(%rip),%eax # 51f6 51f6: a8 01 test $0x1,%al 51f8: 74 56 je 5250 51fa: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 5201 5201: 79 4d jns 5250 5203: 41 b9 c7 03 00 00 mov $0x3c7,%r9d 5209: 49 c7 c0 00 00 00 00 mov $0x0,%r8 5210: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 5217: ba 01 00 00 00 mov $0x1,%edx 521c: be 80 00 00 00 mov $0x80,%esi 5221: 31 ff xor %edi,%edi 5223: 31 c0 xor %eax,%eax 5225: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 522c: 00 00 522e: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 5235: 00 00 5237: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 523e: 00 523f: e8 00 00 00 00 callq 5244 5244: 8b 05 00 00 00 00 mov 0(%rip),%eax # 524a 524a: 66 data16 524b: 66 data16 524c: 90 nop 524d: 66 data16 524e: 66 data16 524f: 90 nop 5250: a9 00 00 20 00 test $0x200000,%eax 5255: 0f 84 95 00 00 00 je 52f0 525b: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 5262 5262: 0f 89 88 00 00 00 jns 52f0 5268: 48 8b 43 08 mov 0x8(%rbx),%rax 526c: 41 b9 cb 03 00 00 mov $0x3cb,%r9d 5272: 49 c7 c0 00 00 00 00 mov $0x0,%r8 5279: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 5280: ba 00 00 20 00 mov $0x200000,%edx 5285: be 80 00 00 00 mov $0x80,%esi 528a: 31 ff xor %edi,%edi 528c: 48 89 44 24 50 mov %rax,0x50(%rsp) 5291: 8b 43 04 mov 0x4(%rbx),%eax 5294: 4c 89 6c 24 40 mov %r13,0x40(%rsp) 5299: 4c 89 64 24 28 mov %r12,0x28(%rsp) 529e: 89 44 24 48 mov %eax,0x48(%rsp) 52a2: 41 8b 85 fc 01 00 00 mov 0x1fc(%r13),%eax 52a9: 89 44 24 38 mov %eax,0x38(%rsp) 52ad: 49 8b 45 30 mov 0x30(%r13),%rax 52b1: 48 89 44 24 30 mov %rax,0x30(%rsp) 52b6: 41 8b 84 24 fc 01 00 mov 0x1fc(%r12),%eax 52bd: 00 52be: 89 44 24 20 mov %eax,0x20(%rsp) 52c2: 49 8b 44 24 30 mov 0x30(%r12),%rax 52c7: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 52ce: 00 00 52d0: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 52d7: 00 00 52d9: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 52e0: 00 52e1: 48 89 44 24 18 mov %rax,0x18(%rsp) 52e6: 31 c0 xor %eax,%eax 52e8: e8 00 00 00 00 callq 52ed 52ed: 66 data16 52ee: 66 data16 52ef: 90 nop 52f0: 44 8b 43 04 mov 0x4(%rbx),%r8d 52f4: 48 8b 4b 08 mov 0x8(%rbx),%rcx 52f8: 48 8d 6c 24 70 lea 0x70(%rsp),%rbp 52fd: 45 31 c9 xor %r9d,%r9d 5300: 4c 89 ea mov %r13,%rdx 5303: 4c 89 e6 mov %r12,%rsi 5306: 48 89 ef mov %rbp,%rdi 5309: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 5310: 00 5311: e8 00 00 00 00 callq 5316 5316: 85 c0 test %eax,%eax 5318: 89 c3 mov %eax,%ebx 531a: 74 56 je 5372 531c: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 5323 5323: 48 98 cltq 5325: 0f 84 95 01 00 00 je 54c0 532b: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 5332 5332: 0f 89 88 01 00 00 jns 54c0 5338: 41 b9 d0 03 00 00 mov $0x3d0,%r9d 533e: 48 89 44 24 30 mov %rax,0x30(%rsp) 5343: 48 89 44 24 28 mov %rax,0x28(%rsp) 5348: 48 89 44 24 20 mov %rax,0x20(%rsp) 534d: 48 c7 44 24 18 00 00 movq $0x0,0x18(%rsp) 5354: 00 00 5356: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 535d: 00 00 535f: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 5366: 00 00 5368: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 536f: 00 5370: eb 6b jmp 53dd 5372: 49 8b 7f 50 mov 0x50(%r15),%rdi 5376: 48 8d 54 24 68 lea 0x68(%rsp),%rdx 537b: 48 89 ee mov %rbp,%rsi 537e: e8 00 00 00 00 callq 5383 5383: 85 c0 test %eax,%eax 5385: 89 c3 mov %eax,%ebx 5387: 74 7a je 5403 5389: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 5390 5390: 48 98 cltq 5392: 0f 84 28 01 00 00 je 54c0 5398: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 539f 539f: 0f 89 1b 01 00 00 jns 54c0 53a5: 48 89 44 24 30 mov %rax,0x30(%rsp) 53aa: 48 89 44 24 28 mov %rax,0x28(%rsp) 53af: 41 b9 d3 03 00 00 mov $0x3d3,%r9d 53b5: 48 89 44 24 20 mov %rax,0x20(%rsp) 53ba: 48 c7 44 24 18 00 00 movq $0x0,0x18(%rsp) 53c1: 00 00 53c3: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 53ca: 00 00 53cc: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 53d3: 00 00 53d5: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 53dc: 00 53dd: 49 c7 c0 00 00 00 00 mov $0x0,%r8 53e4: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 53eb: ba 01 00 00 00 mov $0x1,%edx 53f0: be 80 00 00 00 mov $0x80,%esi 53f5: 31 ff xor %edi,%edi 53f7: 31 c0 xor %eax,%eax 53f9: e8 00 00 00 00 callq 53fe 53fe: e9 bd 00 00 00 jmpq 54c0 5403: 4d 85 f6 test %r14,%r14 5406: 74 4d je 5455 5408: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 540f: e8 00 00 00 00 callq 5414 5414: 41 8b 46 04 mov 0x4(%r14),%eax 5418: a8 10 test $0x10,%al 541a: 75 2d jne 5449 541c: 83 c8 10 or $0x10,%eax 541f: 49 8d 8e b8 00 00 00 lea 0xb8(%r14),%rcx 5426: 41 89 46 04 mov %eax,0x4(%r14) 542a: 49 8b 86 b8 00 00 00 mov 0xb8(%r14),%rax 5431: 48 8b 51 08 mov 0x8(%rcx),%rdx 5435: 48 85 c0 test %rax,%rax 5438: 48 89 02 mov %rax,(%rdx) 543b: 74 04 je 5441 543d: 48 89 50 08 mov %rdx,0x8(%rax) 5441: 48 c7 41 08 00 02 20 movq $0x200200,0x8(%rcx) 5448: 00 5449: 48 c7 c7 00 00 00 00 mov $0x0,%rdi 5450: e8 00 00 00 00 callq 5455 5455: 48 8b 7c 24 68 mov 0x68(%rsp),%rdi 545a: 4c 89 ea mov %r13,%rdx 545d: be 01 00 00 00 mov $0x1,%esi 5462: e8 89 cc ff ff callq 20f0 5467: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 546e 546e: 74 50 je 54c0 5470: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 5477 5477: 79 47 jns 54c0 5479: 41 b9 da 03 00 00 mov $0x3da,%r9d 547f: 49 c7 c0 00 00 00 00 mov $0x0,%r8 5486: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 548d: ba 01 00 00 00 mov $0x1,%edx 5492: be 80 00 00 00 mov $0x80,%esi 5497: 31 ff xor %edi,%edi 5499: 31 c0 xor %eax,%eax 549b: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 54a2: 00 00 54a4: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 54ab: 00 00 54ad: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 54b4: 00 54b5: e8 00 00 00 00 callq 54ba 54ba: 66 data16 54bb: 66 data16 54bc: 90 nop 54bd: 66 data16 54be: 66 data16 54bf: 90 nop 54c0: 48 8b 7c 24 68 mov 0x68(%rsp),%rdi 54c5: e8 00 00 00 00 callq 54ca 54ca: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 54d1 54d1: 74 5d je 5530 54d3: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 54da 54da: 79 54 jns 5530 54dc: 48 63 c3 movslq %ebx,%rax 54df: 41 b9 dd 03 00 00 mov $0x3dd,%r9d 54e5: 49 c7 c0 00 00 00 00 mov $0x0,%r8 54ec: 48 89 44 24 28 mov %rax,0x28(%rsp) 54f1: 48 89 44 24 20 mov %rax,0x20(%rsp) 54f6: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 54fd: 48 89 44 24 18 mov %rax,0x18(%rsp) 5502: ba 01 00 00 00 mov $0x1,%edx 5507: be 80 00 00 00 mov $0x80,%esi 550c: 31 ff xor %edi,%edi 550e: 31 c0 xor %eax,%eax 5510: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 5517: 00 00 5519: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 5520: 00 00 5522: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 5529: 00 552a: e8 00 00 00 00 callq 552f 552f: 90 nop return ll_link_generic(old_dentry->d_inode, dir, &new_dentry->d_name, new_dentry); } 5530: 89 d8 mov %ebx,%eax 5532: 48 8b ac 24 f0 00 00 mov 0xf0(%rsp),%rbp 5539: 00 553a: 48 8b 9c 24 e8 00 00 mov 0xe8(%rsp),%rbx 5541: 00 5542: 4c 8b a4 24 f8 00 00 mov 0xf8(%rsp),%r12 5549: 00 554a: 4c 8b ac 24 00 01 00 mov 0x100(%rsp),%r13 5551: 00 5552: 4c 8b b4 24 08 01 00 mov 0x108(%rsp),%r14 5559: 00 555a: 4c 8b bc 24 10 01 00 mov 0x110(%rsp),%r15 5561: 00 5562: 48 81 c4 18 01 00 00 add $0x118,%rsp 5569: c3 retq 556a: 66 data16 556b: 66 data16 556c: 90 nop 556d: 66 data16 556e: 66 data16 556f: 90 nop 0000000000005570 : static int ll_rename(struct inode *old_dir, struct dentry *old_dentry, struct inode *new_dir, struct dentry *new_dentry) { 5570: 48 81 ec 28 01 00 00 sub $0x128,%rsp 5577: 48 89 ac 24 00 01 00 mov %rbp,0x100(%rsp) 557e: 00 557f: 4c 89 a4 24 08 01 00 mov %r12,0x108(%rsp) 5586: 00 5587: 48 89 fd mov %rdi,%rbp 558a: 4c 89 ac 24 10 01 00 mov %r13,0x110(%rsp) 5591: 00 5592: 4c 89 b4 24 18 01 00 mov %r14,0x118(%rsp) 5599: 00 559a: 4c 8d 6e 28 lea 0x28(%rsi),%r13 559e: 4c 89 bc 24 20 01 00 mov %r15,0x120(%rsp) 55a5: 00 55a6: 48 89 9c 24 f8 00 00 mov %rbx,0xf8(%rsp) 55ad: 00 55ae: 4c 8d bc 24 80 00 00 lea 0x80(%rsp),%r15 55b5: 00 55b6: 48 c7 44 24 78 00 00 movq $0x0,0x78(%rsp) 55bd: 00 00 // FIXME: replace the name of this with LL_SB to conform to kernel stuff static inline struct ll_sb_info *ll_i2sbi(struct inode *inode) { return ll_s2sbi(inode->i_sb); 55bf: 48 8b 87 08 01 00 00 mov 0x108(%rdi),%rax 55c6: 31 f6 xor %esi,%esi 55c8: 49 89 d6 mov %rdx,%r14 55cb: 4c 89 ff mov %r15,%rdi 55ce: ba 68 00 00 00 mov $0x68,%edx 55d3: 4c 8d 61 28 lea 0x28(%rcx),%r12 // FIXME: replace the name of this with LL_SB to conform to kernel stuff static inline struct ll_sb_info *ll_i2sbi(struct inode *inode) { return ll_s2sbi(inode->i_sb); 55d7: 48 8b 80 60 02 00 00 mov 0x260(%rax),%rax 55de: 48 8b 40 20 mov 0x20(%rax),%rax 55e2: 48 89 44 24 70 mov %rax,0x70(%rsp) 55e7: e8 00 00 00 00 callq 55ec 55ec: 8b 05 00 00 00 00 mov 0(%rip),%eax # 55f2 55f2: a8 01 test $0x1,%al 55f4: 74 50 je 5646 55f6: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 55fd 55fd: 79 47 jns 5646 55ff: 41 b9 9a 04 00 00 mov $0x49a,%r9d 5605: 49 c7 c0 00 00 00 00 mov $0x0,%r8 560c: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 5613: ba 01 00 00 00 mov $0x1,%edx 5618: be 80 00 00 00 mov $0x80,%esi 561d: 31 ff xor %edi,%edi 561f: 31 c0 xor %eax,%eax 5621: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 5628: 00 00 562a: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 5631: 00 00 5633: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 563a: 00 563b: e8 00 00 00 00 callq 5640 5640: 8b 05 00 00 00 00 mov 0(%rip),%eax # 5646 5646: a9 00 00 20 00 test $0x200000,%eax 564b: 0f 84 a3 00 00 00 je 56f4 5651: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 5658 5658: 0f 89 96 00 00 00 jns 56f4 565e: 41 8b 86 fc 01 00 00 mov 0x1fc(%r14),%eax 5665: 4c 89 74 24 60 mov %r14,0x60(%rsp) 566a: 41 b9 9e 04 00 00 mov $0x49e,%r9d 5670: 49 c7 c0 00 00 00 00 mov $0x0,%r8 5677: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 567e: ba 00 00 20 00 mov $0x200000,%edx 5683: be 80 00 00 00 mov $0x80,%esi 5688: 31 ff xor %edi,%edi 568a: 89 44 24 58 mov %eax,0x58(%rsp) 568e: 49 8b 46 30 mov 0x30(%r14),%rax 5692: 48 89 44 24 50 mov %rax,0x50(%rsp) 5697: 49 8b 44 24 08 mov 0x8(%r12),%rax 569c: 48 89 44 24 48 mov %rax,0x48(%rsp) 56a1: 41 8b 44 24 04 mov 0x4(%r12),%eax 56a6: 48 89 6c 24 38 mov %rbp,0x38(%rsp) 56ab: 89 44 24 40 mov %eax,0x40(%rsp) 56af: 8b 85 fc 01 00 00 mov 0x1fc(%rbp),%eax 56b5: 89 44 24 30 mov %eax,0x30(%rsp) 56b9: 48 8b 45 30 mov 0x30(%rbp),%rax 56bd: 48 89 44 24 28 mov %rax,0x28(%rsp) 56c2: 49 8b 45 08 mov 0x8(%r13),%rax 56c6: 48 89 44 24 20 mov %rax,0x20(%rsp) 56cb: 41 8b 45 04 mov 0x4(%r13),%eax 56cf: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 56d6: 00 00 56d8: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 56df: 00 00 56e1: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 56e8: 00 56e9: 89 44 24 18 mov %eax,0x18(%rsp) 56ed: 31 c0 xor %eax,%eax 56ef: e8 00 00 00 00 callq 56f4 56f4: 45 31 c9 xor %r9d,%r9d 56f7: 45 31 c0 xor %r8d,%r8d 56fa: 31 c9 xor %ecx,%ecx 56fc: 4c 89 f2 mov %r14,%rdx 56ff: 48 89 ee mov %rbp,%rsi 5702: 4c 89 ff mov %r15,%rdi 5705: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 570c: 00 570d: e8 00 00 00 00 callq 5712 5712: 85 c0 test %eax,%eax 5714: 89 c3 mov %eax,%ebx 5716: 74 59 je 5771 5718: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 571f 571f: 48 98 cltq 5721: 0f 84 ff 01 00 00 je 5926 5727: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 572e 572e: 0f 89 f2 01 00 00 jns 5926 5734: 41 b9 a2 04 00 00 mov $0x4a2,%r9d 573a: 48 89 44 24 30 mov %rax,0x30(%rsp) 573f: 48 89 44 24 28 mov %rax,0x28(%rsp) 5744: 48 89 44 24 20 mov %rax,0x20(%rsp) 5749: 48 c7 44 24 18 00 00 movq $0x0,0x18(%rsp) 5750: 00 00 5752: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 5759: 00 00 575b: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 5762: 00 00 5764: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 576b: 00 576c: e9 3f 01 00 00 jmpq 58b0 5771: 49 8d 57 20 lea 0x20(%r15),%rdx 5775: 4c 89 ee mov %r13,%rsi 5778: 48 89 ef mov %rbp,%rdi 577b: e8 60 d7 ff ff callq 2ee0 5780: 49 8d 57 30 lea 0x30(%r15),%rdx 5784: 4c 89 e6 mov %r12,%rsi 5787: 4c 89 f7 mov %r14,%rdi 578a: e8 51 d7 ff ff callq 2ee0 578f: 48 8b 44 24 70 mov 0x70(%rsp),%rax 5794: 45 8b 4c 24 04 mov 0x4(%r12),%r9d 5799: 4c 89 fe mov %r15,%rsi 579c: 4d 8b 44 24 08 mov 0x8(%r12),%r8 57a1: 41 8b 4d 04 mov 0x4(%r13),%ecx 57a5: 49 8b 55 08 mov 0x8(%r13),%rdx 57a9: 48 8b 78 50 mov 0x50(%rax),%rdi 57ad: 48 8d 44 24 78 lea 0x78(%rsp),%rax 57b2: 48 89 04 24 mov %rax,(%rsp) 57b6: e8 00 00 00 00 callq 57bb 57bb: 85 c0 test %eax,%eax 57bd: 89 c3 mov %eax,%ebx 57bf: 74 5f je 5820 57c1: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 57c8 57c8: 48 98 cltq 57ca: 0f 84 56 01 00 00 je 5926 57d0: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 57d7 57d7: 0f 89 49 01 00 00 jns 5926 57dd: 41 b9 aa 04 00 00 mov $0x4aa,%r9d 57e3: 48 89 44 24 30 mov %rax,0x30(%rsp) 57e8: 48 89 44 24 28 mov %rax,0x28(%rsp) 57ed: 48 89 44 24 20 mov %rax,0x20(%rsp) 57f2: 48 c7 44 24 18 00 00 movq $0x0,0x18(%rsp) 57f9: 00 00 57fb: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 5802: 00 00 5804: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 580b: 00 00 580d: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 5814: 00 5815: e9 96 00 00 00 jmpq 58b0 581a: 66 data16 581b: 66 data16 581c: 90 nop 581d: 66 data16 581e: 66 data16 581f: 90 nop 5820: 48 8b 7c 24 78 mov 0x78(%rsp),%rdi 5825: 48 89 ea mov %rbp,%rdx 5828: be 01 00 00 00 mov $0x1,%esi 582d: e8 be c8 ff ff callq 20f0 5832: 48 8b 7c 24 78 mov 0x78(%rsp),%rdi 5837: 4c 89 f2 mov %r14,%rdx 583a: be 01 00 00 00 mov $0x1,%esi 583f: e8 ac c8 ff ff callq 20f0 5844: 48 8b 7c 24 78 mov 0x78(%rsp),%rdi 5849: 48 89 ee mov %rbp,%rsi 584c: e8 00 00 00 00 callq 5851 5851: 85 c0 test %eax,%eax 5853: 89 c3 mov %eax,%ebx 5855: 74 7c je 58d3 5857: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 585e 585e: 48 98 cltq 5860: 0f 84 c0 00 00 00 je 5926 5866: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 586d 586d: 0f 89 b3 00 00 00 jns 5926 5873: 48 89 44 24 30 mov %rax,0x30(%rsp) 5878: 48 89 44 24 28 mov %rax,0x28(%rsp) 587d: 41 b9 af 04 00 00 mov $0x4af,%r9d 5883: 48 89 44 24 20 mov %rax,0x20(%rsp) 5888: 48 c7 44 24 18 00 00 movq $0x0,0x18(%rsp) 588f: 00 00 5891: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 5898: 00 00 589a: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 58a1: 00 00 58a3: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 58aa: 00 58ab: 66 data16 58ac: 66 data16 58ad: 90 nop 58ae: 66 data16 58af: 90 nop 58b0: 49 c7 c0 00 00 00 00 mov $0x0,%r8 58b7: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 58be: ba 01 00 00 00 mov $0x1,%edx 58c3: be 80 00 00 00 mov $0x80,%esi 58c8: 31 ff xor %edi,%edi 58ca: 31 c0 xor %eax,%eax 58cc: e8 00 00 00 00 callq 58d1 58d1: eb 53 jmp 5926 58d3: f6 05 00 00 00 00 01 testb $0x1,0(%rip) # 58da 58da: 74 4a je 5926 58dc: 80 3d 00 00 00 00 00 cmpb $0x0,0(%rip) # 58e3 58e3: 79 41 jns 5926 58e5: 41 b9 b1 04 00 00 mov $0x4b1,%r9d 58eb: 49 c7 c0 00 00 00 00 mov $0x0,%r8 58f2: 48 c7 c1 00 00 00 00 mov $0x0,%rcx 58f9: ba 01 00 00 00 mov $0x1,%edx 58fe: be 80 00 00 00 mov $0x80,%esi 5903: 31 ff xor %edi,%edi 5905: 31 c0 xor %eax,%eax 5907: 48 c7 44 24 10 00 00 movq $0x0,0x10(%rsp) 590e: 00 00 5910: 48 c7 44 24 08 00 00 movq $0x0,0x8(%rsp) 5917: 00 00 5919: 48 c7 04 24 00 00 00 movq $0x0,(%rsp) 5920: 00 5921: e8 00 00 00 00 callq 5926 5926: 48 8b 7c 24 78 mov 0x78(%rsp),%rdi 592b: e8 00 00 00 00 callq 5930 return ll_rename_generic(old_dir, &old_dentry->d_name, new_dir, &new_dentry->d_name); } 5930: 89 d8 mov %ebx,%eax 5932: 48 8b ac 24 00 01 00 mov 0x100(%rsp),%rbp 5939: 00 593a: 48 8b 9c 24 f8 00 00 mov 0xf8(%rsp),%rbx 5941: 00 5942: 4c 8b a4 24 08 01 00 mov 0x108(%rsp),%r12 5949: 00 594a: 4c 8b ac 24 10 01 00 mov 0x110(%rsp),%r13 5951: 00 5952: 4c 8b b4 24 18 01 00 mov 0x118(%rsp),%r14 5959: 00 595a: 4c 8b bc 24 20 01 00 mov 0x120(%rsp),%r15 5961: 00 5962: 48 81 c4 28 01 00 00 add $0x128,%rsp 5969: c3 retq