Subject: Recurring Oops in link_path_walk()

From: Christophe Leroy <[email-masked]>
Date: Fri, 20 Nov 2015 18:07:59 +0100

Al,

We've been running Kernel 3.18 for several monthes on our embedded 
boards, and we have a recurring Oops in link_path_walk()
It doesn't happen very often (approximatly once every month on one board 
among a set of 50 boards, never the same board).

Here below is the last oops I got, with kernel 3.18.22. It crashes at 
address 0xc00b75ac. Here below is the full desassembly of 
link_path_walk() so that you can see exactly the offending line.

The address it fails at is always the same (link_path_walk+0x414) but 
the oopsing data address is each time different. I added all Oops I got 
below after the disassembly (on different sub-versions of 3.18).

Do you have any idea of what this can be ? Is there any recent change 
made since 3.18 that could fix it and could be backported into 3.18 ?

Thanks,
Christophe

[10250.855670] Unable to handle kernel paging request for data at 
address 0x00003879
[10250.867593] Faulting instruction address: 0xc00b75ac
[10250.883695] Oops: Kernel access of bad area, sig: 11 [#1]
[10250.888766] PREEMPT CMPC885
[10250.891564] CPU: 0 PID: 2416 Comm: SUO_ Not tainted 3.18.22 #53
[10250.899123] task: c628e680 ti: c66c8000 task.ti: c66c8000
[10250.904451] NIP: c00b75ac LR: c00b7574 CTR: c00fcdc8
[10250.909364] REGS: c66c9d10 TRAP: 0300   Not tainted  (3.18.22)
[10250.916825] MSR: 00009032 <EE,ME,IR,DR,RI>  CR: 22002482 XER: 00000000
[10250.923374] DAR: 00003879 DSISR: c0000000
[10250.923374] GPR00: c00b7574 c66c9dc0 c628e680 c1088330 c50883b8 
c50883f2 90f9ced3 00000031
[10250.923374] GPR08: 00000000 00003869 c5085560 31c52da7 22002482 
101ccd18 101c0000 1017da60
[10250.923374] GPR16: 1024b884 101758d4 1017d9a8 1014e64c 1051553c 
00000000 00000000 c66c8000
[10250.923374] GPR24: 00100000 c66c9ea0 00300000 00000004 fffff000 
c651b02f 00000000 c66c9e88
[10250.955351] NIP [c00b75ac] link_path_walk+0x414/0x86c
[10250.960326] LR [c00b7574] link_path_walk+0x3dc/0x86c
[10250.965191] Call Trace:
[10250.967640] [c66c9dc0] [c00b7574] link_path_walk+0x3dc/0x86c (unreliable)
[10250.974363] [c66c9e20] [c00b9e30] path_openat+0x90/0x678
[10250.979605] [c66c9e80] [c00ba448] do_filp_open+0x30/0x8c
[10250.984857] [c66c9f00] [c00abc08] do_sys_open+0x14c/0x238
[10250.990196] [c66c9f40] [c000b294] ret_from_syscall+0x0/0x38
[10250.995654] Instruction dump:
[10250.998585] 7f834800 419e000c 48014f81 80610018 8081001c 81410020 
907f0000 909f0004
[10251.006243] 915f0020 3bc00000 8061000c 81230028 <81290010> 81290014 
2f890000 419e0014

c00b7198 <link_path_walk>:
  *
  * Returns 0 and nd will have valid dentry and mnt on success.
  * Returns error and drops reference to input namei data on failure.
  */
static int link_path_walk(const char *name, struct nameidata *nd)
{
c00b7198:    7c 08 02 a6     mflr    r0
c00b719c:    94 21 ff a0     stwu    r1,-96(r1)
c00b71a0:    be a1 00 34     stmw    r21,52(r1)
c00b71a4:    90 01 00 64     stw     r0,100(r1)
c00b71a8:    7c 7d 1b 78     mr      r29,r3
     struct path next;
     int err;

     while (*name=='/')
c00b71ac:    89 23 00 00     lbz     r9,0(r3)
  *
  * Returns 0 and nd will have valid dentry and mnt on success.
  * Returns error and drops reference to input namei data on failure.
  */
static int link_path_walk(const char *name, struct nameidata *nd)
{
c00b71b0:    7c 9f 23 78     mr      r31,r4
     struct path next;
     int err;

     while (*name=='/')
c00b71b4:    2b 89 00 2f     cmplwi  cr7,r9,47
c00b71b8:    40 9e 00 10     bne     cr7,c00b71c8 <link_path_walk+0x30>
c00b71bc:    8d 3d 00 01     lbzu    r9,1(r29)
c00b71c0:    2b 89 00 2f     cmplwi  cr7,r9,47
c00b71c4:    41 9e ff f8     beq     cr7,c00b71bc <link_path_walk+0x24>
         name++;
     if (!*name)
c00b71c8:    2f 89 00 00     cmpwi   cr7,r9,0
c00b71cc:    41 9e 02 48     beq     cr7,c00b7414 <link_path_walk+0x27c>
  * so we keep a cache of "no, this doesn't need follow_link"
  * for the common case.
  */
static inline int should_follow_link(struct dentry *dentry, int follow)
{
     return unlikely(d_is_symlink(dentry)) ? follow : 0;
c00b71d0:    3f 40 00 30     lis     r26,48

     error = security_inode_follow_link(link->dentry, nd);
     if (error)
         goto out_put_nd_path;

     nd->last_type = LAST_BIND;
c00b71d4:    3b 60 00 04     li      r27,4
     *p = dentry->d_inode->i_op->follow_link(dentry, nd);
     error = PTR_ERR(*p);
     if (IS_ERR(*p))
c00b71d8:    3b 80 f0 00     li      r28,-4096
     return status;
}

static __always_inline void set_root(struct nameidata *nd)
{
     get_fs_root(current->fs, &nd->root);
c00b71dc:    3b 3f 00 18     addi    r25,r31,24
c00b71e0:    54 37 00 24     rlwinm  r23,r1,0,0,18
         if (err) {
             err = nested_symlink(&next, nd);
             if (err)
                 return err;
         }
         if (!d_can_lookup(nd->path.dentry)) {
c00b71e4:    3f 00 00 10     lis     r24,16
     return 0;
}

static inline int may_lookup(struct nameidata *nd)
{
     if (nd->flags & LOOKUP_RCU) {
c00b71e8:    81 3f 00 24     lwz     r9,36(r31)
c00b71ec:    71 24 00 40     andi.   r4,r9,64
c00b71f0:    40 82 01 a0     bne     c00b7390 <link_path_walk+0x1f8>
         if (err != -ECHILD)
             return err;
         if (unlazy_walk(nd, NULL))
             return -ECHILD;
     }
     return inode_permission(nd->inode, MAY_EXEC);
c00b71f4:    80 7f 00 20     lwz     r3,32(r31)
c00b71f8:    38 80 00 01     li      r4,1
c00b71fc:    4b ff f2 15     bl      c00b6410 <inode_permission>
c00b7200:    7c 7e 1b 78     mr      r30,r3
     for(;;) {
         u64 hash_len;
         int type;

         err = may_lookup(nd);
          if (err)
c00b7204:    2f 9e 00 00     cmpwi   cr7,r30,0
c00b7208:    40 9e 01 1c     bne     cr7,c00b7324 <link_path_walk+0x18c>
static inline u64 hash_name(const char *name)
{
     unsigned long hash = init_name_hash();
     unsigned long len = 0, c;

     c = (unsigned char)*name;
c00b720c:    88 bd 00 00     lbz     r5,0(r29)
  * one character.
  */
static inline u64 hash_name(const char *name)
{
     unsigned long hash = init_name_hash();
     unsigned long len = 0, c;
c00b7210:    39 40 00 00     li      r10,0

     c = (unsigned char)*name;
c00b7214:    7c a9 2b 78     mr      r9,r5
  * We know there's a real path component here of at least
  * one character.
  */
static inline u64 hash_name(const char *name)
{
     unsigned long hash = init_name_hash();
c00b7218:    39 00 00 00     li      r8,0
c00b721c:    48 00 00 08     b       c00b7224 <link_path_walk+0x8c>
     c = (unsigned char)*name;
     do {
         len++;
         hash = partial_name_hash(c, hash);
         c = (unsigned char)name[len];
     } while (c && c != '/');
c00b7220:    41 9a 00 2c     beq     cr6,c00b724c <link_path_walk+0xb4>
     unsigned long hash = init_name_hash();
     unsigned long len = 0, c;

     c = (unsigned char)*name;
     do {
         len++;
c00b7224:    39 4a 00 01     addi    r10,r10,1

/* partial hash update function. Assume roughly 4 bits per character */
static inline unsigned long
partial_name_hash(unsigned long c, unsigned long prevhash)
{
     return (prevhash + (c << 4) + (c >> 4)) * 11;
c00b7228:    55 26 e1 3e     rlwinm  r6,r9,28,4,31
c00b722c:    55 27 20 36     rlwinm  r7,r9,4,0,27
         hash = partial_name_hash(c, hash);
         c = (unsigned char)name[len];
c00b7230:    7d 3d 50 ae     lbzx    r9,r29,r10
c00b7234:    7c e6 3a 14     add     r7,r6,r7
     } while (c && c != '/');
c00b7238:    2f 89 00 00     cmpwi   cr7,r9,0
c00b723c:    7d 07 42 14     add     r8,r7,r8
c00b7240:    2b 09 00 2f     cmplwi  cr6,r9,47
c00b7244:    1d 08 00 0b     mulli   r8,r8,11
c00b7248:    40 9e ff d8     bne     cr7,c00b7220 <link_path_walk+0x88>
             break;

         hash_len = hash_name(name);

         type = LAST_NORM;
         if (name[0] == '.') switch (hashlen_len(hash_len)) {
c00b724c:    2b 85 00 2e     cmplwi  cr7,r5,46
     do {
         len++;
         hash = partial_name_hash(c, hash);
         c = (unsigned char)name[len];
     } while (c && c != '/');
     return hashlen_create(end_name_hash(hash), len);
c00b7250:    7d 47 53 78     mr      r7,r10
c00b7254:    7d 06 43 78     mr      r6,r8
             break;

         hash_len = hash_name(name);

         type = LAST_NORM;
         if (name[0] == '.') switch (hashlen_len(hash_len)) {
c00b7258:    41 9e 01 70     beq     cr7,c00b73c8 <link_path_walk+0x230>
             case 1:
                 type = LAST_DOT;
         }
         if (likely(type == LAST_NORM)) {
             struct dentry *parent = nd->path.dentry;
             nd->flags &= ~LOOKUP_JUMPED;
c00b725c:    80 bf 00 24     lwz     r5,36(r31)
                 break;
             case 1:
                 type = LAST_DOT;
         }
         if (likely(type == LAST_NORM)) {
             struct dentry *parent = nd->path.dentry;
c00b7260:    81 3f 00 04     lwz     r9,4(r31)
             nd->flags &= ~LOOKUP_JUMPED;
c00b7264:    54 a5 05 24     rlwinm  r5,r5,0,20,18
c00b7268:    90 bf 00 24     stw     r5,36(r31)
             if (unlikely(parent->d_flags & DCACHE_OP_HASH)) {
c00b726c:    80 a9 00 00     lwz     r5,0(r9)
c00b7270:    70 a4 00 01     andi.   r4,r5,1
c00b7274:    40 82 02 30     bne     c00b74a4 <link_path_walk+0x30c>
c00b7278:    7d 45 53 78     mr      r5,r10
c00b727c:    39 20 00 00     li      r9,0
                 hash_len = this.hash_len;
                 name = this.name;
             }
         }

         nd->last.hash_len = hash_len;
c00b7280:    90 ff 00 08     stw     r7,8(r31)
c00b7284:    90 df 00 0c     stw     r6,12(r31)
         nd->last.name = name;
c00b7288:    93 bf 00 10     stw     r29,16(r31)
         nd->last_type = type;
c00b728c:    91 3f 00 30     stw     r9,48(r31)

         name += hashlen_len(hash_len);
         if (!*name)
c00b7290:    7d 5d 28 ee     lbzux   r10,r29,r5
c00b7294:    2f 8a 00 00     cmpwi   cr7,r10,0
c00b7298:    41 9e 01 7c     beq     cr7,c00b7414 <link_path_walk+0x27c>
          * If it wasn't NUL, we know it was '/'. Skip that
          * slash, and continue until no more slashes.
          */
         do {
             name++;
         } while (unlikely(*name == '/'));
c00b729c:    8d 5d 00 01     lbzu    r10,1(r29)
c00b72a0:    2b 8a 00 2f     cmplwi  cr7,r10,47
c00b72a4:    41 be ff f8     beq     cr7,c00b729c <link_path_walk+0x104>
         if (!*name)
c00b72a8:    2f 8a 00 00     cmpwi   cr7,r10,0
c00b72ac:    41 9e 01 68     beq     cr7,c00b7414 <link_path_walk+0x27c>
     /*
      * "." and ".." are special - ".." especially so because it has
      * to be able to know about the current root directory and
      * parent relationships.
      */
     if (unlikely(nd->last_type != LAST_NORM))
c00b72b0:    2f 89 00 00     cmpwi   cr7,r9,0
c00b72b4:    40 9e 01 bc     bne     cr7,c00b7470 <link_path_walk+0x2d8>
         return handle_dots(nd, nd->last_type);
     err = lookup_fast(nd, path, &inode);
c00b72b8:    7f e3 fb 78     mr      r3,r31
c00b72bc:    38 81 00 18     addi    r4,r1,24
c00b72c0:    38 a1 00 08     addi    r5,r1,8
c00b72c4:    4b ff f9 69     bl      c00b6c2c <lookup_fast>
     if (unlikely(err)) {
c00b72c8:    7c 7e 1b 79     mr.     r30,r3
c00b72cc:    40 82 06 f8     bne     c00b79c4 <link_path_walk+0x82c>
c00b72d0:    81 41 00 08     lwz     r10,8(r1)
             goto out_err;

         inode = path->dentry->d_inode;
     }
     err = -ENOENT;
     if (!inode || d_is_negative(path->dentry))
c00b72d4:    2f 8a 00 00     cmpwi   cr7,r10,0
c00b72d8:    41 9e 00 6c     beq     cr7,c00b7344 <link_path_walk+0x1ac>
c00b72dc:    80 81 00 1c     lwz     r4,28(r1)
     spin_unlock(&dentry->d_lock);
}

static inline unsigned __d_entry_type(const struct dentry *dentry)
{
     return dentry->d_flags & DCACHE_ENTRY_TYPE;
c00b72e0:    81 24 00 00     lwz     r9,0(r4)
c00b72e4:    75 28 00 70     andis.  r8,r9,112
c00b72e8:    41 82 00 5c     beq     c00b7344 <link_path_walk+0x1ac>
  * so we keep a cache of "no, this doesn't need follow_link"
  * for the common case.
  */
static inline int should_follow_link(struct dentry *dentry, int follow)
{
     return unlikely(d_is_symlink(dentry)) ? follow : 0;
c00b72ec:    7f 88 d0 00     cmpw    cr7,r8,r26
c00b72f0:    41 9e 02 04     beq     cr7,c00b74f4 <link_path_walk+0x35c>
}

static inline void path_to_nameidata(const struct path *path,
                     struct nameidata *nd)
{
     if (!(nd->flags & LOOKUP_RCU)) {
c00b72f4:    81 3f 00 24     lwz     r9,36(r31)
c00b72f8:    71 28 00 40     andi.   r8,r9,64
c00b72fc:    41 82 01 38     beq     c00b7434 <link_path_walk+0x29c>
c00b7300:    81 21 00 18     lwz     r9,24(r1)
         dput(nd->path.dentry);
         if (nd->path.mnt != path->mnt)
             mntput(nd->path.mnt);
     }
     nd->path.mnt = path->mnt;
c00b7304:    91 3f 00 00     stw     r9,0(r31)
     nd->path.dentry = path->dentry;
c00b7308:    90 9f 00 04     stw     r4,4(r31)
         }
         BUG_ON(inode != path->dentry->d_inode);
         return 1;
     }
     path_to_nameidata(path, nd);
     nd->inode = inode;
c00b730c:    91 5f 00 20     stw     r10,32(r31)
c00b7310:    81 24 00 00     lwz     r9,0(r4)
c00b7314:    55 29 02 56     rlwinm  r9,r9,0,9,11
         if (err) {
             err = nested_symlink(&next, nd);
             if (err)
                 return err;
         }
         if (!d_can_lookup(nd->path.dentry)) {
c00b7318:    7f 89 c0 00     cmpw    cr7,r9,r24
c00b731c:    41 9e fe cc     beq     cr7,c00b71e8 <link_path_walk+0x50>
             err = -ENOTDIR;
c00b7320:    3b c0 ff ec     li      r30,-20
             break;
         }
     }
     terminate_walk(nd);
c00b7324:    7f e3 fb 78     mr      r3,r31
c00b7328:    4b ff eb b9     bl      c00b5ee0 <terminate_walk>
     return err;
c00b732c:    7f c3 f3 78     mr      r3,r30
}
c00b7330:    80 01 00 64     lwz     r0,100(r1)
c00b7334:    ba a1 00 34     lmw     r21,52(r1)
c00b7338:    7c 08 03 a6     mtlr    r0
c00b733c:    38 21 00 60     addi    r1,r1,96
c00b7340:    4e 80 00 20     blr
}

static inline void path_to_nameidata(const struct path *path,
                     struct nameidata *nd)
{
     if (!(nd->flags & LOOKUP_RCU)) {
c00b7344:    81 3f 00 24     lwz     r9,36(r31)
c00b7348:    71 28 00 40     andi.   r8,r9,64
c00b734c:    41 82 00 24     beq     c00b7370 <link_path_walk+0x1d8>
c00b7350:    80 61 00 18     lwz     r3,24(r1)
         dput(nd->path.dentry);
         if (nd->path.mnt != path->mnt)
             mntput(nd->path.mnt);
     }
     nd->path.mnt = path->mnt;
     nd->path.dentry = path->dentry;
c00b7354:    81 21 00 1c     lwz     r9,28(r1)
     if (!(nd->flags & LOOKUP_RCU)) {
         dput(nd->path.dentry);
         if (nd->path.mnt != path->mnt)
             mntput(nd->path.mnt);
     }
     nd->path.mnt = path->mnt;
c00b7358:    90 7f 00 00     stw     r3,0(r31)
     nd->path.dentry = path->dentry;
c00b735c:    91 3f 00 04     stw     r9,4(r31)
         if (!d_can_lookup(nd->path.dentry)) {
             err = -ENOTDIR;
             break;
         }
     }
     terminate_walk(nd);
c00b7360:    7f e3 fb 78     mr      r3,r31
         if (err < 0)
             goto out_err;

         inode = path->dentry->d_inode;
     }
     err = -ENOENT;
c00b7364:    3b c0 ff fe     li      r30,-2
         if (!d_can_lookup(nd->path.dentry)) {
             err = -ENOTDIR;
             break;
         }
     }
     terminate_walk(nd);
c00b7368:    4b ff eb 79     bl      c00b5ee0 <terminate_walk>
c00b736c:    4b ff ff c0     b       c00b732c <link_path_walk+0x194>

static inline void path_to_nameidata(const struct path *path,
                     struct nameidata *nd)
{
     if (!(nd->flags & LOOKUP_RCU)) {
         dput(nd->path.dentry);
c00b7370:    80 7f 00 04     lwz     r3,4(r31)
c00b7374:    48 00 b5 89     bl      c00c28fc <dput>
         if (nd->path.mnt != path->mnt)
c00b7378:    80 7f 00 00     lwz     r3,0(r31)
c00b737c:    81 21 00 18     lwz     r9,24(r1)
c00b7380:    7f 83 48 40     cmplw   cr7,r3,r9
c00b7384:    41 be ff d0     beq     cr7,c00b7354 <link_path_walk+0x1bc>
             mntput(nd->path.mnt);
c00b7388:    48 01 51 7d     bl      c00cc504 <mntput>
c00b738c:    4b ff ff c4     b       c00b7350 <link_path_walk+0x1b8>
}

static inline int may_lookup(struct nameidata *nd)
{
     if (nd->flags & LOOKUP_RCU) {
         int err = inode_permission(nd->inode, MAY_EXEC|MAY_NOT_BLOCK);
c00b7390:    80 7f 00 20     lwz     r3,32(r31)
c00b7394:    38 80 00 81     li      r4,129
c00b7398:    4b ff f0 79     bl      c00b6410 <inode_permission>
         if (err != -ECHILD)
c00b739c:    2f 83 ff f6     cmpwi   cr7,r3,-10
}

static inline int may_lookup(struct nameidata *nd)
{
     if (nd->flags & LOOKUP_RCU) {
         int err = inode_permission(nd->inode, MAY_EXEC|MAY_NOT_BLOCK);
c00b73a0:    7c 7e 1b 78     mr      r30,r3
         if (err != -ECHILD)
c00b73a4:    40 9e fe 60     bne     cr7,c00b7204 <link_path_walk+0x6c>
             return err;
         if (unlazy_walk(nd, NULL))
c00b73a8:    7f e3 fb 78     mr      r3,r31
c00b73ac:    38 80 00 00     li      r4,0
c00b73b0:    4b ff f6 c5     bl      c00b6a74 <unlazy_walk>
c00b73b4:    2f 83 00 00     cmpwi   cr7,r3,0
c00b73b8:    41 be fe 3c     beq     cr7,c00b71f4 <link_path_walk+0x5c>
         if (!d_can_lookup(nd->path.dentry)) {
             err = -ENOTDIR;
             break;
         }
     }
     terminate_walk(nd);
c00b73bc:    7f e3 fb 78     mr      r3,r31
c00b73c0:    4b ff eb 21     bl      c00b5ee0 <terminate_walk>
c00b73c4:    4b ff ff 68     b       c00b732c <link_path_walk+0x194>
             break;

         hash_len = hash_name(name);

         type = LAST_NORM;
         if (name[0] == '.') switch (hashlen_len(hash_len)) {
c00b73c8:    2f 8a 00 01     cmpwi   cr7,r10,1
c00b73cc:    7d 45 53 78     mr      r5,r10
c00b73d0:    41 9e 00 5c     beq     cr7,c00b742c <link_path_walk+0x294>
c00b73d4:    2f 8a 00 02     cmpwi   cr7,r10,2
c00b73d8:    40 be fe 84     bne     cr7,c00b725c <link_path_walk+0xc4>
             case 2:
                 if (name[1] == '.') {
c00b73dc:    89 3d 00 01     lbz     r9,1(r29)
c00b73e0:    2f 89 00 2e     cmpwi   cr7,r9,46
c00b73e4:    40 9e fe 78     bne     cr7,c00b725c <link_path_walk+0xc4>
                     type = LAST_DOTDOT;
                     nd->flags |= LOOKUP_JUMPED;
c00b73e8:    81 5f 00 24     lwz     r10,36(r31)

         type = LAST_NORM;
         if (name[0] == '.') switch (hashlen_len(hash_len)) {
             case 2:
                 if (name[1] == '.') {
                     type = LAST_DOTDOT;
c00b73ec:    39 20 00 03     li      r9,3
                     nd->flags |= LOOKUP_JUMPED;
c00b73f0:    61 4a 10 00     ori     r10,r10,4096
c00b73f4:    91 5f 00 24     stw     r10,36(r31)
                 hash_len = this.hash_len;
                 name = this.name;
             }
         }

         nd->last.hash_len = hash_len;
c00b73f8:    90 ff 00 08     stw     r7,8(r31)
c00b73fc:    90 df 00 0c     stw     r6,12(r31)
         nd->last.name = name;
c00b7400:    93 bf 00 10     stw     r29,16(r31)
         nd->last_type = type;
c00b7404:    91 3f 00 30     stw     r9,48(r31)

         name += hashlen_len(hash_len);
         if (!*name)
c00b7408:    7d 5d 28 ee     lbzux   r10,r29,r5
c00b740c:    2f 8a 00 00     cmpwi   cr7,r10,0
c00b7410:    40 9e fe 8c     bne     cr7,c00b729c <link_path_walk+0x104>
             break;
         }
     }
     terminate_walk(nd);
     return err;
}
c00b7414:    80 01 00 64     lwz     r0,100(r1)
c00b7418:    ba a1 00 34     lmw     r21,52(r1)
c00b741c:    7c 08 03 a6     mtlr    r0
     int err;

     while (*name=='/')
         name++;
     if (!*name)
         return 0;
c00b7420:    38 60 00 00     li      r3,0
             break;
         }
     }
     terminate_walk(nd);
     return err;
}
c00b7424:    38 21 00 60     addi    r1,r1,96
c00b7428:    4e 80 00 20     blr
                     type = LAST_DOTDOT;
                     nd->flags |= LOOKUP_JUMPED;
                 }
                 break;
             case 1:
                 type = LAST_DOT;
c00b742c:    39 20 00 02     li      r9,2
c00b7430:    4b ff fe 50     b       c00b7280 <link_path_walk+0xe8>

static inline void path_to_nameidata(const struct path *path,
                     struct nameidata *nd)
{
     if (!(nd->flags & LOOKUP_RCU)) {
         dput(nd->path.dentry);
c00b7434:    80 7f 00 04     lwz     r3,4(r31)
c00b7438:    48 00 b4 c5     bl      c00c28fc <dput>
         if (nd->path.mnt != path->mnt)
c00b743c:    80 7f 00 00     lwz     r3,0(r31)
c00b7440:    81 21 00 18     lwz     r9,24(r1)
c00b7444:    7f 83 48 00     cmpw    cr7,r3,r9
c00b7448:    41 9e 00 18     beq     cr7,c00b7460 <link_path_walk+0x2c8>
             mntput(nd->path.mnt);
c00b744c:    48 01 50 b9     bl      c00cc504 <mntput>
c00b7450:    81 21 00 18     lwz     r9,24(r1)
c00b7454:    80 81 00 1c     lwz     r4,28(r1)
c00b7458:    81 41 00 08     lwz     r10,8(r1)
c00b745c:    4b ff fe a8     b       c00b7304 <link_path_walk+0x16c>
c00b7460:    80 81 00 1c     lwz     r4,28(r1)
c00b7464:    81 41 00 08     lwz     r10,8(r1)
static inline void path_to_nameidata(const struct path *path,
                     struct nameidata *nd)
{
     if (!(nd->flags & LOOKUP_RCU)) {
         dput(nd->path.dentry);
         if (nd->path.mnt != path->mnt)
c00b7468:    7c 69 1b 78     mr      r9,r3
c00b746c:    4b ff fe 98     b       c00b7304 <link_path_walk+0x16c>
     return inode_permission(nd->inode, MAY_EXEC);
}

static inline int handle_dots(struct nameidata *nd, int type)
{
     if (type == LAST_DOTDOT) {
c00b7470:    2f 89 00 03     cmpwi   cr7,r9,3
c00b7474:    41 9e 00 0c     beq     cr7,c00b7480 <link_path_walk+0x2e8>
c00b7478:    80 9f 00 04     lwz     r4,4(r31)
c00b747c:    4b ff fe 94     b       c00b7310 <link_path_walk+0x178>
         if (nd->flags & LOOKUP_RCU) {
c00b7480:    81 3f 00 24     lwz     r9,36(r31)
             if (follow_dotdot_rcu(nd))
c00b7484:    7f e3 fb 78     mr      r3,r31
}

static inline int handle_dots(struct nameidata *nd, int type)
{
     if (type == LAST_DOTDOT) {
         if (nd->flags & LOOKUP_RCU) {
c00b7488:    71 24 00 40     andi.   r4,r9,64
c00b748c:    41 82 00 5c     beq     c00b74e8 <link_path_walk+0x350>
             if (follow_dotdot_rcu(nd))
c00b7490:    4b ff e3 b1     bl      c00b5840 <follow_dotdot_rcu>
c00b7494:    2f 83 00 00     cmpwi   cr7,r3,0
c00b7498:    41 be ff e0     beq     cr7,c00b7478 <link_path_walk+0x2e0>
                 return -ECHILD;
c00b749c:    38 60 ff f6     li      r3,-10
c00b74a0:    4b ff fe 90     b       c00b7330 <link_path_walk+0x198>
         }
         if (likely(type == LAST_NORM)) {
             struct dentry *parent = nd->path.dentry;
             nd->flags &= ~LOOKUP_JUMPED;
             if (unlikely(parent->d_flags & DCACHE_OP_HASH)) {
                 struct qstr this = { { .hash_len = hash_len }, .name = 
name };
c00b74a4:    91 41 00 08     stw     r10,8(r1)
c00b74a8:    91 01 00 0c     stw     r8,12(r1)
c00b74ac:    93 a1 00 10     stw     r29,16(r1)
                 err = parent->d_op->d_hash(parent, &this);
c00b74b0:    7d 23 4b 78     mr      r3,r9
c00b74b4:    81 29 00 58     lwz     r9,88(r9)
c00b74b8:    38 81 00 08     addi    r4,r1,8
c00b74bc:    81 29 00 08     lwz     r9,8(r9)
c00b74c0:    7d 29 03 a6     mtctr   r9
c00b74c4:    4e 80 04 21     bctrl
                 if (err < 0)
c00b74c8:    7c 7e 1b 79     mr.     r30,r3
c00b74cc:    41 a0 fe 58     blt     c00b7324 <link_path_walk+0x18c>
                     break;
                 hash_len = this.hash_len;
c00b74d0:    80 e1 00 08     lwz     r7,8(r1)
c00b74d4:    80 c1 00 0c     lwz     r6,12(r1)
                 name = this.name;
c00b74d8:    83 a1 00 10     lwz     r29,16(r1)
c00b74dc:    7c e5 3b 78     mr      r5,r7
c00b74e0:    39 20 00 00     li      r9,0
c00b74e4:    4b ff fd 9c     b       c00b7280 <link_path_walk+0xe8>
     if (type == LAST_DOTDOT) {
         if (nd->flags & LOOKUP_RCU) {
             if (follow_dotdot_rcu(nd))
                 return -ECHILD;
         } else
             follow_dotdot(nd);
c00b74e8:    4b ff fb 99     bl      c00b7080 <follow_dotdot>
c00b74ec:    80 9f 00 04     lwz     r4,4(r31)
c00b74f0:    4b ff fe 20     b       c00b7310 <link_path_walk+0x178>
     err = -ENOENT;
     if (!inode || d_is_negative(path->dentry))
         goto out_path_put;

     if (should_follow_link(path->dentry, follow)) {
         if (nd->flags & LOOKUP_RCU) {
c00b74f4:    81 3f 00 24     lwz     r9,36(r31)
c00b74f8:    71 28 00 40     andi.   r8,r9,64
c00b74fc:    40 82 03 10     bne     c00b780c <link_path_walk+0x674>
                      unlazy_walk(nd, path->dentry))) {
                 err = -ECHILD;
                 goto out_err;
             }
         }
         BUG_ON(inode != path->dentry->d_inode);
c00b7500:    81 24 00 28     lwz     r9,40(r4)
c00b7504:    7d 49 4a 78     xor     r9,r10,r9
c00b7508:    7d 29 00 34     cntlzw  r9,r9
c00b750c:    55 29 d9 7e     rlwinm  r9,r9,27,5,31
c00b7510:    69 29 00 01     xori    r9,r9,1
c00b7514:    0f 09 00 00     twnei   r9,0
  */
static inline int nested_symlink(struct path *path, struct nameidata *nd)
{
     int res;

     if (unlikely(current->link_count >= MAX_NESTED_LINKS)) {
c00b7518:    81 22 02 88     lwz     r9,648(r2)
c00b751c:    2f 89 00 07     cmpwi   cr7,r9,7
c00b7520:    41 9d 04 88     bgt     cr7,c00b79a8 <link_path_walk+0x810>
         path_put_conditional(path, nd);
         path_put(&nd->path);
         return -ELOOP;
     }
     BUG_ON(nd->depth >= MAX_NESTED_LINKS);
c00b7524:    81 5f 00 34     lwz     r10,52(r31)
c00b7528:    21 2a 00 07     subfic  r9,r10,7
c00b752c:    7d 29 49 10     subfe   r9,r9,r9
c00b7530:    7d 29 00 d0     neg     r9,r9
c00b7534:    0f 09 00 00     twnei   r9,0

     nd->depth++;
c00b7538:    39 4a 00 01     addi    r10,r10,1
c00b753c:    91 5f 00 34     stw     r10,52(r31)
c00b7540:    3a c0 00 00     li      r22,0
     current->link_count++;
c00b7544:    81 42 02 88     lwz     r10,648(r2)
c00b7548:    39 4a 00 01     addi    r10,r10,1
c00b754c:    91 42 02 88     stw     r10,648(r2)
c00b7550:    48 00 00 8c     b       c00b75dc <link_path_walk+0x444>
  * so we keep a cache of "no, this doesn't need follow_link"
  * for the common case.
  */
static inline int should_follow_link(struct dentry *dentry, int follow)
{
     return unlikely(d_is_symlink(dentry)) ? follow : 0;
c00b7554:    7f 88 d0 00     cmpw    cr7,r8,r26
c00b7558:    41 9e 03 d8     beq     cr7,c00b7930 <link_path_walk+0x798>
}

static inline void path_to_nameidata(const struct path *path,
                     struct nameidata *nd)
{
     if (!(nd->flags & LOOKUP_RCU)) {
c00b755c:    81 3f 00 24     lwz     r9,36(r31)
c00b7560:    80 61 00 18     lwz     r3,24(r1)
c00b7564:    71 28 00 40     andi.   r8,r9,64
c00b7568:    40 82 00 2c     bne     c00b7594 <link_path_walk+0x3fc>
         dput(nd->path.dentry);
c00b756c:    80 7f 00 04     lwz     r3,4(r31)
c00b7570:    48 00 b3 8d     bl      c00c28fc <dput>
         if (nd->path.mnt != path->mnt)
c00b7574:    80 7f 00 00     lwz     r3,0(r31)
c00b7578:    81 21 00 18     lwz     r9,24(r1)
c00b757c:    7f 83 48 00     cmpw    cr7,r3,r9
c00b7580:    41 9e 00 0c     beq     cr7,c00b758c <link_path_walk+0x3f4>
             mntput(nd->path.mnt);
c00b7584:    48 01 4f 81     bl      c00cc504 <mntput>
c00b7588:    80 61 00 18     lwz     r3,24(r1)
c00b758c:    80 81 00 1c     lwz     r4,28(r1)
c00b7590:    81 41 00 20     lwz     r10,32(r1)
     }
     nd->path.mnt = path->mnt;
c00b7594:    90 7f 00 00     stw     r3,0(r31)
     nd->path.dentry = path->dentry;
c00b7598:    90 9f 00 04     stw     r4,4(r31)
         }
         BUG_ON(inode != path->dentry->d_inode);
         return 1;
     }
     path_to_nameidata(path, nd);
     nd->inode = inode;
c00b759c:    91 5f 00 20     stw     r10,32(r31)
     return 0;
c00b75a0:    3b c0 00 00     li      r30,0
     nd->flags |= LOOKUP_JUMPED;
}

static inline void put_link(struct nameidata *nd, struct path *link, 
void *cookie)
{
     struct inode *inode = link->dentry->d_inode;
c00b75a4:    80 61 00 0c     lwz     r3,12(r1)
     if (inode->i_op->put_link)
c00b75a8:    81 23 00 28     lwz     r9,40(r3)
==> c00b75ac:    81 29 00 10     lwz     r9,16(r9)
c00b75b0:    81 29 00 14     lwz     r9,20(r9)
c00b75b4:    2f 89 00 00     cmpwi   cr7,r9,0
c00b75b8:    41 9e 00 14     beq     cr7,c00b75cc <link_path_walk+0x434>
         inode->i_op->put_link(link->dentry, nd, cookie);
c00b75bc:    7f e4 fb 78     mr      r4,r31
c00b75c0:    7e a5 ab 78     mr      r5,r21
c00b75c4:    7d 29 03 a6     mtctr   r9
c00b75c8:    4e 80 04 21     bctrl
     path_put(link);
c00b75cc:    38 61 00 08     addi    r3,r1,8
c00b75d0:    4b ff f9 3d     bl      c00b6f0c <path_put>
         res = follow_link(&link, nd, &cookie);
         if (res)
             break;
         res = walk_component(nd, path, LOOKUP_FOLLOW);
         put_link(nd, &link, cookie);
     } while (res > 0);
c00b75d4:    2f 9e 00 01     cmpwi   cr7,r30,1
c00b75d8:    40 9e 01 bc     bne     cr7,c00b7794 <link_path_walk+0x5fc>

     nd->depth++;
     current->link_count++;

     do {
         struct path link = *path;
c00b75dc:    81 21 00 1c     lwz     r9,28(r1)
{
     struct dentry *dentry = link->dentry;
     int error;
     char *s;

     BUG_ON(nd->flags & LOOKUP_RCU);
c00b75e0:    81 5f 00 24     lwz     r10,36(r31)

     nd->depth++;
     current->link_count++;

     do {
         struct path link = *path;
c00b75e4:    81 01 00 18     lwz     r8,24(r1)
c00b75e8:    7d 3e 4b 78     mr      r30,r9
c00b75ec:    91 01 00 08     stw     r8,8(r1)
c00b75f0:    91 21 00 0c     stw     r9,12(r1)
}

static __always_inline int
follow_link(struct path *link, struct nameidata *nd, void **p)
{
     struct dentry *dentry = link->dentry;
c00b75f4:    7d 35 4b 78     mr      r21,r9
     int error;
     char *s;

     BUG_ON(nd->flags & LOOKUP_RCU);
c00b75f8:    55 4a 06 72     rlwinm  r10,r10,0,25,25
c00b75fc:    0f 0a 00 00     twnei   r10,0

     if (link->mnt == nd->path.mnt)
c00b7600:    80 61 00 08     lwz     r3,8(r1)
c00b7604:    81 5f 00 00     lwz     r10,0(r31)
c00b7608:    7f 83 50 00     cmpw    cr7,r3,r10
c00b760c:    41 9e 01 80     beq     cr7,c00b778c <link_path_walk+0x5f4>
         mntget(link->mnt);

     error = -ELOOP;
     if (unlikely(current->total_link_count >= 40))
c00b7610:    81 22 02 8c     lwz     r9,652(r2)
c00b7614:    2f 89 00 27     cmpwi   cr7,r9,39
c00b7618:    41 9d 02 e0     bgt     cr7,c00b78f8 <link_path_walk+0x760>
         goto out_put_nd_path;

     cond_resched();
c00b761c:    48 2e b4 99     bl      c03a2ab4 <_cond_resched>
     current->total_link_count++;
c00b7620:    81 42 02 8c     lwz     r10,652(r2)

     touch_atime(link);
c00b7624:    38 61 00 08     addi    r3,r1,8
     error = -ELOOP;
     if (unlikely(current->total_link_count >= 40))
         goto out_put_nd_path;

     cond_resched();
     current->total_link_count++;
c00b7628:    39 4a 00 01     addi    r10,r10,1
c00b762c:    91 42 02 8c     stw     r10,652(r2)

     touch_atime(link);
c00b7630:    48 01 03 f9     bl      c00c7a28 <touch_atime>
c00b7634:    81 3f 00 34     lwz     r9,52(r31)
     error = security_inode_follow_link(link->dentry, nd);
     if (error)
         goto out_put_nd_path;

     nd->last_type = LAST_BIND;
     *p = dentry->d_inode->i_op->follow_link(dentry, nd);
c00b7638:    7e a3 ab 78     mr      r3,r21
c00b763c:    39 29 00 0c     addi    r9,r9,12
c00b7640:    55 29 10 3a     rlwinm  r9,r9,2,0,29
c00b7644:    7d 3f 4a 14     add     r9,r31,r9
c00b7648:    92 c9 00 08     stw     r22,8(r9)

     error = security_inode_follow_link(link->dentry, nd);
     if (error)
         goto out_put_nd_path;

     nd->last_type = LAST_BIND;
c00b764c:    93 7f 00 30     stw     r27,48(r31)
     *p = dentry->d_inode->i_op->follow_link(dentry, nd);
c00b7650:    7f e4 fb 78     mr      r4,r31
c00b7654:    81 3e 00 28     lwz     r9,40(r30)
c00b7658:    81 29 00 10     lwz     r9,16(r9)
c00b765c:    81 29 00 04     lwz     r9,4(r9)
c00b7660:    7d 29 03 a6     mtctr   r9
c00b7664:    4e 80 04 21     bctrl
     error = PTR_ERR(*p);
     if (IS_ERR(*p))
c00b7668:    7f 83 e0 40     cmplw   cr7,r3,r28
     error = security_inode_follow_link(link->dentry, nd);
     if (error)
         goto out_put_nd_path;

     nd->last_type = LAST_BIND;
     *p = dentry->d_inode->i_op->follow_link(dentry, nd);
c00b766c:    7c 75 1b 78     mr      r21,r3
     error = PTR_ERR(*p);
     if (IS_ERR(*p))
c00b7670:    41 9d 02 a0     bgt     cr7,c00b7910 <link_path_walk+0x778>
}

static inline char *nd_get_link(struct nameidata *nd)
{
     return nd->saved_names[nd->depth];
c00b7674:    81 3f 00 34     lwz     r9,52(r31)
c00b7678:    39 29 00 0c     addi    r9,r9,12
c00b767c:    55 29 10 3a     rlwinm  r9,r9,2,0,29
c00b7680:    7d 3f 4a 14     add     r9,r31,r9
c00b7684:    83 c9 00 08     lwz     r30,8(r9)
         goto out_put_nd_path;

     error = 0;
     s = nd_get_link(nd);
     if (s) {
c00b7688:    2f 9e 00 00     cmpwi   cr7,r30,0
c00b768c:    41 9e 00 38     beq     cr7,c00b76c4 <link_path_walk+0x52c>
         if (unlikely(IS_ERR(s))) {
c00b7690:    7f 9e e0 40     cmplw   cr7,r30,r28
c00b7694:    41 9d 01 b8     bgt     cr7,c00b784c <link_path_walk+0x6b4>
             path_put(&nd->path);
             put_link(nd, link, *p);
             return PTR_ERR(s);
         }
         if (*s == '/') {
c00b7698:    89 3e 00 00     lbz     r9,0(r30)
c00b769c:    2f 89 00 2f     cmpwi   cr7,r9,47
c00b76a0:    41 9e 00 b0     beq     cr7,c00b7750 <link_path_walk+0x5b8>
             path_put(&nd->path);
             nd->path = nd->root;
             path_get(&nd->root);
             nd->flags |= LOOKUP_JUMPED;
         }
         nd->inode = nd->path.dentry->d_inode;
c00b76a4:    81 3f 00 04     lwz     r9,4(r31)
         error = link_path_walk(s, nd);
c00b76a8:    7f c3 f3 78     mr      r3,r30
             path_put(&nd->path);
             nd->path = nd->root;
             path_get(&nd->root);
             nd->flags |= LOOKUP_JUMPED;
         }
         nd->inode = nd->path.dentry->d_inode;
c00b76ac:    81 29 00 28     lwz     r9,40(r9)
         error = link_path_walk(s, nd);
c00b76b0:    7f e4 fb 78     mr      r4,r31
             path_put(&nd->path);
             nd->path = nd->root;
             path_get(&nd->root);
             nd->flags |= LOOKUP_JUMPED;
         }
         nd->inode = nd->path.dentry->d_inode;
c00b76b4:    91 3f 00 20     stw     r9,32(r31)
         error = link_path_walk(s, nd);
c00b76b8:    4b ff fa e1     bl      c00b7198 <link_path_walk>
         if (unlikely(error))
c00b76bc:    7c 7e 1b 79     mr.     r30,r3
c00b76c0:    40 82 01 94     bne     c00b7854 <link_path_walk+0x6bc>
     /*
      * "." and ".." are special - ".." especially so because it has
      * to be able to know about the current root directory and
      * parent relationships.
      */
     if (unlikely(nd->last_type != LAST_NORM))
c00b76c4:    81 3f 00 30     lwz     r9,48(r31)
c00b76c8:    2f 89 00 00     cmpwi   cr7,r9,0
c00b76cc:    40 9e 01 d4     bne     cr7,c00b78a0 <link_path_walk+0x708>
         return handle_dots(nd, nd->last_type);
     err = lookup_fast(nd, path, &inode);
c00b76d0:    7f e3 fb 78     mr      r3,r31
c00b76d4:    38 81 00 18     addi    r4,r1,24
c00b76d8:    38 a1 00 20     addi    r5,r1,32
c00b76dc:    4b ff f5 51     bl      c00b6c2c <lookup_fast>
     if (unlikely(err)) {
c00b76e0:    7c 7e 1b 79     mr.     r30,r3
c00b76e4:    40 82 01 ec     bne     c00b78d0 <link_path_walk+0x738>
c00b76e8:    81 41 00 20     lwz     r10,32(r1)
             goto out_err;

         inode = path->dentry->d_inode;
     }
     err = -ENOENT;
     if (!inode || d_is_negative(path->dentry))
c00b76ec:    2f 8a 00 00     cmpwi   cr7,r10,0
c00b76f0:    41 9e 00 14     beq     cr7,c00b7704 <link_path_walk+0x56c>
c00b76f4:    80 81 00 1c     lwz     r4,28(r1)
c00b76f8:    81 24 00 00     lwz     r9,0(r4)
c00b76fc:    75 28 00 70     andis.  r8,r9,112
c00b7700:    40 a2 fe 54     bne     c00b7554 <link_path_walk+0x3bc>
}

static inline void path_to_nameidata(const struct path *path,
                     struct nameidata *nd)
{
     if (!(nd->flags & LOOKUP_RCU)) {
c00b7704:    81 3f 00 24     lwz     r9,36(r31)
c00b7708:    71 24 00 40     andi.   r4,r9,64
c00b770c:    41 82 00 24     beq     c00b7730 <link_path_walk+0x598>
c00b7710:    80 61 00 18     lwz     r3,24(r1)
         dput(nd->path.dentry);
         if (nd->path.mnt != path->mnt)
             mntput(nd->path.mnt);
     }
     nd->path.mnt = path->mnt;
     nd->path.dentry = path->dentry;
c00b7714:    81 21 00 1c     lwz     r9,28(r1)
     if (!(nd->flags & LOOKUP_RCU)) {
         dput(nd->path.dentry);
         if (nd->path.mnt != path->mnt)
             mntput(nd->path.mnt);
     }
     nd->path.mnt = path->mnt;
c00b7718:    90 7f 00 00     stw     r3,0(r31)
     nd->path.dentry = path->dentry;
c00b771c:    91 3f 00 04     stw     r9,4(r31)
         if (err < 0)
             goto out_err;

         inode = path->dentry->d_inode;
     }
     err = -ENOENT;
c00b7720:    3b c0 ff fe     li      r30,-2
     return 0;

out_path_put:
     path_to_nameidata(path, nd);
out_err:
     terminate_walk(nd);
c00b7724:    7f e3 fb 78     mr      r3,r31
c00b7728:    4b ff e7 b9     bl      c00b5ee0 <terminate_walk>
c00b772c:    4b ff fe 78     b       c00b75a4 <link_path_walk+0x40c>

static inline void path_to_nameidata(const struct path *path,
                     struct nameidata *nd)
{
     if (!(nd->flags & LOOKUP_RCU)) {
         dput(nd->path.dentry);
c00b7730:    80 7f 00 04     lwz     r3,4(r31)
c00b7734:    48 00 b1 c9     bl      c00c28fc <dput>
         if (nd->path.mnt != path->mnt)
c00b7738:    80 7f 00 00     lwz     r3,0(r31)
c00b773c:    81 21 00 18     lwz     r9,24(r1)
c00b7740:    7f 83 48 40     cmplw   cr7,r3,r9
c00b7744:    41 be ff d0     beq     cr7,c00b7714 <link_path_walk+0x57c>
             mntput(nd->path.mnt);
c00b7748:    48 01 4d bd     bl      c00cc504 <mntput>
c00b774c:    4b ff ff c4     b       c00b7710 <link_path_walk+0x578>
             path_put(&nd->path);
             put_link(nd, link, *p);
             return PTR_ERR(s);
         }
         if (*s == '/') {
             if (!nd->root.mnt)
c00b7750:    81 3f 00 18     lwz     r9,24(r31)
c00b7754:    2f 89 00 00     cmpwi   cr7,r9,0
c00b7758:    41 9e 00 64     beq     cr7,c00b77bc <link_path_walk+0x624>
                 set_root(nd);
             path_put(&nd->path);
c00b775c:    7f e3 fb 78     mr      r3,r31
c00b7760:    4b ff f7 ad     bl      c00b6f0c <path_put>
             nd->path = nd->root;
c00b7764:    81 5f 00 18     lwz     r10,24(r31)
c00b7768:    81 7f 00 1c     lwz     r11,28(r31)
c00b776c:    91 5f 00 00     stw     r10,0(r31)
c00b7770:    91 7f 00 04     stw     r11,4(r31)
             path_get(&nd->root);
c00b7774:    7f 23 cb 78     mr      r3,r25
c00b7778:    4b ff ee 21     bl      c00b6598 <path_get>
             nd->flags |= LOOKUP_JUMPED;
c00b777c:    81 3f 00 24     lwz     r9,36(r31)
c00b7780:    61 29 10 00     ori     r9,r9,4096
c00b7784:    91 3f 00 24     stw     r9,36(r31)
c00b7788:    4b ff ff 1c     b       c00b76a4 <link_path_walk+0x50c>
     char *s;

     BUG_ON(nd->flags & LOOKUP_RCU);

     if (link->mnt == nd->path.mnt)
         mntget(link->mnt);
c00b778c:    48 01 4f 9d     bl      c00cc728 <mntget>
c00b7790:    4b ff fe 80     b       c00b7610 <link_path_walk+0x478>
             break;
         res = walk_component(nd, path, LOOKUP_FOLLOW);
         put_link(nd, &link, cookie);
     } while (res > 0);

     current->link_count--;
c00b7794:    81 42 02 88     lwz     r10,648(r2)
         if (err < 0)
             return err;

         if (err) {
             err = nested_symlink(&next, nd);
             if (err)
c00b7798:    2f 9e 00 00     cmpwi   cr7,r30,0
             break;
         res = walk_component(nd, path, LOOKUP_FOLLOW);
         put_link(nd, &link, cookie);
     } while (res > 0);

     current->link_count--;
c00b779c:    39 4a ff ff     addi    r10,r10,-1
c00b77a0:    91 42 02 88     stw     r10,648(r2)
     nd->depth--;
c00b77a4:    81 3f 00 34     lwz     r9,52(r31)
c00b77a8:    39 29 ff ff     addi    r9,r9,-1
c00b77ac:    91 3f 00 34     stw     r9,52(r31)
         if (err < 0)
             return err;

         if (err) {
             err = nested_symlink(&next, nd);
             if (err)
c00b77b0:    40 be fb 7c     bne     cr7,c00b732c <link_path_walk+0x194>
c00b77b4:    80 9f 00 04     lwz     r4,4(r31)
c00b77b8:    4b ff fb 58     b       c00b7310 <link_path_walk+0x178>
  * The various preempt_count add/sub methods
  */

static __always_inline void __preempt_count_add(int val)
{
     *preempt_count_ptr() += val;
c00b77bc:    81 37 00 0c     lwz     r9,12(r23)
     return status;
}

static __always_inline void set_root(struct nameidata *nd)
{
     get_fs_root(current->fs, &nd->root);
c00b77c0:    81 42 03 f0     lwz     r10,1008(r2)
c00b77c4:    39 29 00 01     addi    r9,r9,1
c00b77c8:    91 37 00 0c     stw     r9,12(r23)
extern int unshare_fs_struct(void);

static inline void get_fs_root(struct fs_struct *fs, struct path *root)
{
     spin_lock(&fs->lock);
     *root = fs->root;
c00b77cc:    81 6a 00 14     lwz     r11,20(r10)
c00b77d0:    81 4a 00 10     lwz     r10,16(r10)
c00b77d4:    91 7f 00 1c     stw     r11,28(r31)
c00b77d8:    91 5f 00 18     stw     r10,24(r31)
     path_get(root);
c00b77dc:    7f 23 cb 78     mr      r3,r25
c00b77e0:    4b ff ed b9     bl      c00b6598 <path_get>
     /*
      * Because of load-store architectures cannot do per-cpu atomic
      * operations; we cannot use PREEMPT_NEED_RESCHED because it might get
      * lost.
      */
     return !--*preempt_count_ptr() && tif_need_resched();
c00b77e4:    81 37 00 0c     lwz     r9,12(r23)
c00b77e8:    39 29 ff ff     addi    r9,r9,-1
c00b77ec:    2f 89 00 00     cmpwi   cr7,r9,0
c00b77f0:    91 37 00 0c     stw     r9,12(r23)
c00b77f4:    40 be ff 68     bne     cr7,c00b775c <link_path_walk+0x5c4>
c00b77f8:    81 37 00 4c     lwz     r9,76(r23)
c00b77fc:    71 24 00 04     andi.   r4,r9,4
c00b7800:    41 a2 ff 5c     beq     c00b775c <link_path_walk+0x5c4>
c00b7804:    48 2e ac b5     bl      c03a24b8 <preempt_schedule>
c00b7808:    4b ff ff 54     b       c00b775c <link_path_walk+0x5c4>
     if (!inode || d_is_negative(path->dentry))
         goto out_path_put;

     if (should_follow_link(path->dentry, follow)) {
         if (nd->flags & LOOKUP_RCU) {
             if (unlikely(nd->path.mnt != path->mnt ||
c00b780c:    81 5f 00 00     lwz     r10,0(r31)
c00b7810:    81 21 00 18     lwz     r9,24(r1)
c00b7814:    7f 8a 48 00     cmpw    cr7,r10,r9
c00b7818:    40 9e 01 d4     bne     cr7,c00b79ec <link_path_walk+0x854>
c00b781c:    7f e3 fb 78     mr      r3,r31
c00b7820:    4b ff f2 55     bl      c00b6a74 <unlazy_walk>
c00b7824:    2f 83 00 00     cmpwi   cr7,r3,0
c00b7828:    40 9e 01 c4     bne     cr7,c00b79ec <link_path_walk+0x854>
                      unlazy_walk(nd, path->dentry))) {
                 err = -ECHILD;
                 goto out_err;
             }
         }
         BUG_ON(inode != path->dentry->d_inode);
c00b782c:    81 21 00 1c     lwz     r9,28(r1)
c00b7830:    81 49 00 28     lwz     r10,40(r9)
c00b7834:    81 21 00 08     lwz     r9,8(r1)
c00b7838:    7d 49 4a 78     xor     r9,r10,r9
c00b783c:    7d 29 00 34     cntlzw  r9,r9
c00b7840:    55 29 d9 7e     rlwinm  r9,r9,27,5,31
c00b7844:    69 29 00 01     xori    r9,r9,1
c00b7848:    4b ff fc cc     b       c00b7514 <link_path_walk+0x37c>

     error = 0;
     s = nd_get_link(nd);
     if (s) {
         if (unlikely(IS_ERR(s))) {
             path_put(&nd->path);
c00b784c:    7f e3 fb 78     mr      r3,r31
c00b7850:    4b ff f6 bd     bl      c00b6f0c <path_put>
     nd->flags |= LOOKUP_JUMPED;
}

static inline void put_link(struct nameidata *nd, struct path *link, 
void *cookie)
{
     struct inode *inode = link->dentry->d_inode;
c00b7854:    80 61 00 0c     lwz     r3,12(r1)
     if (inode->i_op->put_link)
c00b7858:    81 23 00 28     lwz     r9,40(r3)
c00b785c:    81 29 00 10     lwz     r9,16(r9)
c00b7860:    81 29 00 14     lwz     r9,20(r9)
c00b7864:    2f 89 00 00     cmpwi   cr7,r9,0
c00b7868:    41 9e 00 14     beq     cr7,c00b787c <link_path_walk+0x6e4>
         inode->i_op->put_link(link->dentry, nd, cookie);
c00b786c:    7f e4 fb 78     mr      r4,r31
c00b7870:    7e a5 ab 78     mr      r5,r21
c00b7874:    7d 29 03 a6     mtctr   r9
c00b7878:    4e 80 04 21     bctrl
     path_put(link);
c00b787c:    38 61 00 08     addi    r3,r1,8
c00b7880:    4b ff f6 8d     bl      c00b6f0c <path_put>
             break;
         res = walk_component(nd, path, LOOKUP_FOLLOW);
         put_link(nd, &link, cookie);
     } while (res > 0);

     current->link_count--;
c00b7884:    81 42 02 88     lwz     r10,648(r2)
c00b7888:    39 4a ff ff     addi    r10,r10,-1
c00b788c:    91 42 02 88     stw     r10,648(r2)
     nd->depth--;
c00b7890:    81 3f 00 34     lwz     r9,52(r31)
c00b7894:    39 29 ff ff     addi    r9,r9,-1
c00b7898:    91 3f 00 34     stw     r9,52(r31)
c00b789c:    4b ff fa 90     b       c00b732c <link_path_walk+0x194>
     return inode_permission(nd->inode, MAY_EXEC);
}

static inline int handle_dots(struct nameidata *nd, int type)
{
     if (type == LAST_DOTDOT) {
c00b78a0:    2f 89 00 03     cmpwi   cr7,r9,3
c00b78a4:    40 9e 01 50     bne     cr7,c00b79f4 <link_path_walk+0x85c>
         if (nd->flags & LOOKUP_RCU) {
c00b78a8:    81 3f 00 24     lwz     r9,36(r31)
             if (follow_dotdot_rcu(nd))
c00b78ac:    7f e3 fb 78     mr      r3,r31
}

static inline int handle_dots(struct nameidata *nd, int type)
{
     if (type == LAST_DOTDOT) {
         if (nd->flags & LOOKUP_RCU) {
c00b78b0:    71 24 00 40     andi.   r4,r9,64
c00b78b4:    41 82 00 e8     beq     c00b799c <link_path_walk+0x804>
             if (follow_dotdot_rcu(nd))
c00b78b8:    4b ff df 89     bl      c00b5840 <follow_dotdot_rcu>
                 return -ECHILD;
c00b78bc:    30 63 ff ff     addic   r3,r3,-1
c00b78c0:    7c 63 19 10     subfe   r3,r3,r3
c00b78c4:    70 7e 00 0a     andi.   r30,r3,10
c00b78c8:    3b de ff f6     addi    r30,r30,-10
c00b78cc:    4b ff fc d8     b       c00b75a4 <link_path_walk+0x40c>
      */
     if (unlikely(nd->last_type != LAST_NORM))
         return handle_dots(nd, nd->last_type);
     err = lookup_fast(nd, path, &inode);
     if (unlikely(err)) {
         if (err < 0)
c00b78d0:    41 a0 fe 54     blt     c00b7724 <link_path_walk+0x58c>
             goto out_err;

         err = lookup_slow(nd, path);
c00b78d4:    7f e3 fb 78     mr      r3,r31
c00b78d8:    38 81 00 18     addi    r4,r1,24
c00b78dc:    4b ff e5 21     bl      c00b5dfc <lookup_slow>
         if (err < 0)
c00b78e0:    7c 7e 1b 79     mr.     r30,r3
c00b78e4:    41 a0 fe 40     blt     c00b7724 <link_path_walk+0x58c>
             goto out_err;

         inode = path->dentry->d_inode;
c00b78e8:    81 21 00 1c     lwz     r9,28(r1)
c00b78ec:    81 49 00 28     lwz     r10,40(r9)
c00b78f0:    91 41 00 20     stw     r10,32(r1)
c00b78f4:    4b ff fd f8     b       c00b76ec <link_path_walk+0x554>

     return error;

out_put_nd_path:
     *p = NULL;
     path_put(&nd->path);
c00b78f8:    7f e3 fb 78     mr      r3,r31
c00b78fc:    4b ff f6 11     bl      c00b6f0c <path_put>
     path_put(link);
c00b7900:    38 61 00 08     addi    r3,r1,8
c00b7904:    4b ff f6 09     bl      c00b6f0c <path_put>
     BUG_ON(nd->flags & LOOKUP_RCU);

     if (link->mnt == nd->path.mnt)
         mntget(link->mnt);

     error = -ELOOP;
c00b7908:    3b c0 ff d8     li      r30,-40
c00b790c:    4b ff ff 78     b       c00b7884 <link_path_walk+0x6ec>

     return error;

out_put_nd_path:
     *p = NULL;
     path_put(&nd->path);
c00b7910:    7f e3 fb 78     mr      r3,r31
c00b7914:    4b ff f5 f9     bl      c00b6f0c <path_put>
     path_put(link);
c00b7918:    38 61 00 08     addi    r3,r1,8
c00b791c:    4b ff f5 f1     bl      c00b6f0c <path_put>
     do {
         struct path link = *path;
         void *cookie;

         res = follow_link(&link, nd, &cookie);
         if (res)
c00b7920:    2f 95 00 00     cmpwi   cr7,r21,0
}

static inline long __must_check PTR_ERR(__force const void *ptr)
{
     return (long) ptr;
c00b7924:    7e be ab 78     mr      r30,r21
c00b7928:    40 9e ff 5c     bne     cr7,c00b7884 <link_path_walk+0x6ec>
c00b792c:    4b ff fd 98     b       c00b76c4 <link_path_walk+0x52c>
     err = -ENOENT;
     if (!inode || d_is_negative(path->dentry))
         goto out_path_put;

     if (should_follow_link(path->dentry, follow)) {
         if (nd->flags & LOOKUP_RCU) {
c00b7930:    81 3f 00 24     lwz     r9,36(r31)
c00b7934:    71 28 00 40     andi.   r8,r9,64
c00b7938:    40 82 00 24     bne     c00b795c <link_path_walk+0x7c4>
                      unlazy_walk(nd, path->dentry))) {
                 err = -ECHILD;
                 goto out_err;
             }
         }
         BUG_ON(inode != path->dentry->d_inode);
c00b793c:    81 24 00 28     lwz     r9,40(r4)
c00b7940:    7d 49 4a 78     xor     r9,r10,r9
c00b7944:    7d 29 00 34     cntlzw  r9,r9
c00b7948:    55 29 d9 7e     rlwinm  r9,r9,27,5,31
c00b794c:    69 29 00 01     xori    r9,r9,1
c00b7950:    0f 09 00 00     twnei   r9,0
         return 1;
c00b7954:    3b c0 00 01     li      r30,1
c00b7958:    4b ff fc 4c     b       c00b75a4 <link_path_walk+0x40c>
     if (!inode || d_is_negative(path->dentry))
         goto out_path_put;

     if (should_follow_link(path->dentry, follow)) {
         if (nd->flags & LOOKUP_RCU) {
             if (unlikely(nd->path.mnt != path->mnt ||
c00b795c:    81 5f 00 00     lwz     r10,0(r31)
c00b7960:    81 21 00 18     lwz     r9,24(r1)
c00b7964:    7f 8a 48 00     cmpw    cr7,r10,r9
c00b7968:    40 9e 00 94     bne     cr7,c00b79fc <link_path_walk+0x864>
c00b796c:    7f e3 fb 78     mr      r3,r31
c00b7970:    4b ff f1 05     bl      c00b6a74 <unlazy_walk>
c00b7974:    2f 83 00 00     cmpwi   cr7,r3,0
c00b7978:    40 9e 00 84     bne     cr7,c00b79fc <link_path_walk+0x864>
                      unlazy_walk(nd, path->dentry))) {
                 err = -ECHILD;
                 goto out_err;
             }
         }
         BUG_ON(inode != path->dentry->d_inode);
c00b797c:    81 21 00 1c     lwz     r9,28(r1)
c00b7980:    81 49 00 28     lwz     r10,40(r9)
c00b7984:    81 21 00 20     lwz     r9,32(r1)
c00b7988:    7d 49 4a 78     xor     r9,r10,r9
c00b798c:    7d 29 00 34     cntlzw  r9,r9
c00b7990:    55 29 d9 7e     rlwinm  r9,r9,27,5,31
c00b7994:    69 29 00 01     xori    r9,r9,1
c00b7998:    4b ff ff b8     b       c00b7950 <link_path_walk+0x7b8>
     if (type == LAST_DOTDOT) {
         if (nd->flags & LOOKUP_RCU) {
             if (follow_dotdot_rcu(nd))
                 return -ECHILD;
         } else
             follow_dotdot(nd);
c00b799c:    4b ff f6 e5     bl      c00b7080 <follow_dotdot>
     }
     return 0;
c00b79a0:    3b c0 00 00     li      r30,0
c00b79a4:    4b ff fc 00     b       c00b75a4 <link_path_walk+0x40c>
static inline int nested_symlink(struct path *path, struct nameidata *nd)
{
     int res;

     if (unlikely(current->link_count >= MAX_NESTED_LINKS)) {
         path_put_conditional(path, nd);
c00b79a8:    7f e4 fb 78     mr      r4,r31
c00b79ac:    38 61 00 18     addi    r3,r1,24
c00b79b0:    4b ff e3 f5     bl      c00b5da4 <path_put_conditional.isra.50>
         path_put(&nd->path);
c00b79b4:    7f e3 fb 78     mr      r3,r31
c00b79b8:    4b ff f5 55     bl      c00b6f0c <path_put>
         return -ELOOP;
c00b79bc:    38 60 ff d8     li      r3,-40
c00b79c0:    4b ff f9 70     b       c00b7330 <link_path_walk+0x198>
      */
     if (unlikely(nd->last_type != LAST_NORM))
         return handle_dots(nd, nd->last_type);
     err = lookup_fast(nd, path, &inode);
     if (unlikely(err)) {
         if (err < 0)
c00b79c4:    41 a0 f9 60     blt     c00b7324 <link_path_walk+0x18c>
             goto out_err;

         err = lookup_slow(nd, path);
c00b79c8:    7f e3 fb 78     mr      r3,r31
c00b79cc:    38 81 00 18     addi    r4,r1,24
c00b79d0:    4b ff e4 2d     bl      c00b5dfc <lookup_slow>
         if (err < 0)
c00b79d4:    7c 7e 1b 79     mr.     r30,r3
c00b79d8:    41 a0 f9 4c     blt     c00b7324 <link_path_walk+0x18c>
             goto out_err;

         inode = path->dentry->d_inode;
c00b79dc:    81 21 00 1c     lwz     r9,28(r1)
c00b79e0:    81 49 00 28     lwz     r10,40(r9)
c00b79e4:    91 41 00 08     stw     r10,8(r1)
c00b79e8:    4b ff f8 ec     b       c00b72d4 <link_path_walk+0x13c>

     if (should_follow_link(path->dentry, follow)) {
         if (nd->flags & LOOKUP_RCU) {
             if (unlikely(nd->path.mnt != path->mnt ||
                      unlazy_walk(nd, path->dentry))) {
                 err = -ECHILD;
c00b79ec:    3b c0 ff f6     li      r30,-10
c00b79f0:    4b ff f9 34     b       c00b7324 <link_path_walk+0x18c>
             if (follow_dotdot_rcu(nd))
                 return -ECHILD;
         } else
             follow_dotdot(nd);
     }
     return 0;
c00b79f4:    3b c0 00 00     li      r30,0
c00b79f8:    4b ff fb ac     b       c00b75a4 <link_path_walk+0x40c>

     if (should_follow_link(path->dentry, follow)) {
         if (nd->flags & LOOKUP_RCU) {
             if (unlikely(nd->path.mnt != path->mnt ||
                      unlazy_walk(nd, path->dentry))) {
                 err = -ECHILD;
c00b79fc:    3b c0 ff f6     li      r30,-10
c00b7a00:    4b ff fd 24     b       c00b7724 <link_path_walk+0x58c>

[59685.968909] Unable to handle kernel paging request for data at 
address 0x4f5f5079
[59685.981479] Faulting instruction address: 0xc00b74ec
[59685.990902] Oops: Kernel access of bad area, sig: 11 [#1]
[59685.996037] PREEMPT CMPC885
[59685.998833] CPU: 0 PID: 1019 Comm: SUO_ Not tainted 3.18.20 #49
[59686.006392] task: c66789a0 ti: c6456000 task.ti: c6456000
[59686.011719] NIP: c00b74ec LR: c00b74b4 CTR: c00fcc94
[59686.016631] REGS: c6457d10 TRAP: 0300   Not tainted  (3.18.20)
[59686.024098] MSR: 00009032 <EE,ME,IR,DR,RI>  CR: 22002482 XER: 00000000
[59686.030644] DAR: 4f5f5079 DSISR: c0000000
[59686.030644] GPR00: c00b74b4 c6457dc0 c66789a0 c105b410 c505b498 
c505b4d2 90f9ced3 00000031
[59686.030644] GPR08: 00000000 4f5f5069 c50605a0 227406f5 22002482 
101baac0 101b0000 1017b6d8
[59686.030644] GPR16: 1023961c 1017354c 1017b620 1014c608 10503284 
00000000 00000000 c6456000
[59686.030644] GPR24: 00100000 c6457ea0 00300000 00000004 fffff000 
c63fb02f 00000000 c6457e88
[59686.062616] NIP [c00b74ec] link_path_walk+0x414/0x86c
[59686.067595] LR [c00b74b4] link_path_walk+0x3dc/0x86c
[59686.072462] Call Trace:
[59686.074910] [c6457dc0] [c00b74b4] link_path_walk+0x3dc/0x86c (unreliable)
[59686.081627] [c6457e20] [c00b9d70] path_openat+0x90/0x678
[59686.086873] [c6457e80] [c00ba388] do_filp_open+0x30/0x8c
[59686.092128] [c6457f00] [c00abb48] do_sys_open+0x14c/0x238
[59686.097466] [c6457f40] [c000b294] ret_from_syscall+0x0/0x38
[59686.102923] Instruction dump:
[59686.105853] 7f834800 419e000c 48014f75 80610018 8081001c 81410020 
907f0000 909f0004
[59686.113513] 915f0020 3bc00000 8061000c 81230028 <81290010> 81290014 
2f890000 419e0014

[214067.708785] Unable to handle kernel paging request for data at 
address 0x93a10024
[214067.716082] Faulting instruction address: 0xc00b7350
[214067.721082] Oops: Kernel access of bad area, sig: 11 [#1]
[214067.726477] PREEMPT CMPC885
[214067.729360] CPU: 0 PID: 1021 Comm: SUO_ Not tainted 3.18.14 #43
[214067.737006] task: c6600e70 ti: c653e000 task.ti: c653e000
[214067.742420] NIP: c00b7350 LR: c00b7318 CTR: c00fcb04
[214067.747418] REGS: c653fd10 TRAP: 0300   Not tainted  (3.18.14)
[214067.754969] MSR: 00009032 <EE,ME,IR,DR,RI>  CR: 22002482 XER: 00000000
[214067.761608] DAR: 93a10024 DSISR: c0000000
[214067.761608] GPR00: c00b7318 c653fdc0 c6600e70 c105ac18 c505aca0 
c505acda 90f9ced3 00000031
[214067.761608] GPR08: 00000000 93a10014 c5060360 39d5d053 22002482 
101cae54 1017c030 105103ec
[214067.761608] GPR16: 101c0c38 00000003 10510120 1017c248 10239598 
00000000 00000000 c653e000
[214067.761608] GPR24: 00100000 c653fea0 00300000 00000004 fffff000 
c65f302f 00000000 c653fe88
[214067.793667] NIP [c00b7350] link_path_walk+0x414/0x86c
[214067.798730] LR [c00b7318] link_path_walk+0x3dc/0x86c
[214067.803681] Call Trace:
[214067.806219] [c653fdc0] [c00b7318] link_path_walk+0x3dc/0x86c 
(unreliable)
[214067.813017] [c653fe20] [c00b9bd4] path_openat+0x90/0x678
[214067.818352] [c653fe80] [c00ba1ec] do_filp_open+0x30/0x8c
[214067.823694] [c653ff00] [c00ab9ac] do_sys_open+0x14c/0x238
[214067.829120] [c653ff40] [c000b27c] ret_from_syscall+0x0/0x38
[214067.834658] Instruction dump:
[214067.837675] 7f834800 419e000c 48014fb5 80610018 8081001c 81410020 
907f0000 909f0004
[214067.845418] 915f0020 3bc00000 8061000c 81230028 <81290010> 81290014 
2f890000 419e0014
[214067.853353] ---[ end trace 78a545fb58576151 ]---

[205816.678044] Unable to handle kernel paging request for data at 
address 0x20202030
[205816.688395] Faulting instruction address: 0xc00b74ec
[205816.693912] Oops: Kernel access of bad area, sig: 11 [#1]
[205816.699098] PREEMPT CMPC885
[205816.701980] CPU: 0 PID: 1009 Comm: GVC_ Not tainted 3.18.20 #49
[205816.709627] task: c6655810 ti: c66b0000 task.ti: c66b0000
[205816.715038] NIP: c00b74ec LR: c00b74b4 CTR: c00fcc94
[205816.720037] REGS: c66b1d10 TRAP: 0300 Not tainted (3.18.20)
[205816.727589] MSR: 00009032 <EE,ME,IR,DR,RI> CR: 22002482 XER: 00000000
[205816.734221] DAR: 20202030 DSISR: c0000000
[205816.734221] GPR00: c00b74b4 c66b1dc0 c6655810 c105b388 c505b410 
c505b44b 3ac16eed 00000032
[205816.734221] GPR08: 00000000 20202020 c5061680 0e505267 22002482 
101baac0 00000000 1015a584
[205816.734221] GPR16: 1015a4ec 1015a56c 101b0508 101b08a4 10159f88 
00000000 00000000 c66b0000
[205816.734221] GPR24: 00100000 c66b1ea0 00300000 00000004 fffff000 
c6479030 00000000 c66b1e88
[205816.766277] NIP [c00b74ec] link_path_walk+0x414/0x86c
[205816.771343] LR [c00b74b4] link_path_walk+0x3dc/0x86c
[205816.776299] Call Trace:
[205816.778832] [c66b1dc0] [c00b74b4] link_path_walk+0x3dc/0x86c 
(unreliable)
[205816.785636] [c66b1e20] [c00b9d70] path_openat+0x90/0x678
[205816.790967] [c66b1e80] [c00ba388] do_filp_open+0x30/0x8c
[205816.796304] [c66b1f00] [c00abb48] do_sys_open+0x14c/0x238
[205816.801733] [c66b1f40] [c000b294] ret_from_syscall+0x0/0x38
[205816.807275] Instruction dump:
[205816.810292] 7f834800 419e000c 48014f75 80610018 8081001c 81410020 
907f0000 909f0004
[205816.818038] 915f0020 3bc00000 8061000c 81230028 <81290010> 81290014 
2f890000 419e0014

[219713.431174] Unable to handle kernel paging request for data at 
address 0x6e3d227e
[219713.438912] Faulting instruction address: 0xc00b7350
[219713.445717] Oops: Kernel access of bad area, sig: 11 [#1]
[219713.450862] PREEMPT CMPC885
[219713.453744] CPU: 0 PID: 1016 Comm: SUO_ Not tainted 3.18.14 #43
[219713.461390] task: c66b0e70 ti: c66ec000 task.ti: c66ec000
[219713.466803] NIP: c00b7350 LR: c00b7318 CTR: c00fcb04
[219713.471801] REGS: c66edd10 TRAP: 0300   Not tainted  (3.18.14)
[219713.479352] MSR: 00009032 <EE,ME,IR,DR,RI>  CR: 22002482 XER: 00000000
[219713.485989] DAR: 6e3d227e DSISR: c0000000
[219713.485989] GPR00: c00b7318 c66eddc0 c66b0e70 c105ab08 c505ab90 
c505abca 90f9ced3 00000031
[219713.485989] GPR08: 00000000 6e3d226e c5060360 0d2c06ce 22002482 
101cae54 1017c030 105103ec
[219713.485989] GPR16: 101c0c38 00000003 10510120 1017c248 10239598 
00000000 00000000 c66ec000
[219713.485989] GPR24: 00100000 c66edea0 00300000 00000004 fffff000 
c63f802f 00000000 c66ede88
[219713.518053] NIP [c00b7350] link_path_walk+0x414/0x86c
[219713.523116] LR [c00b7318] link_path_walk+0x3dc/0x86c
[219713.528067] Call Trace:
[219713.530601] [c66eddc0] [c00b7318] link_path_walk+0x3dc/0x86c 
(unreliable)
[219713.537401] [c66ede20] [c00b9bd4] path_openat+0x90/0x678
[219713.542735] [c66ede80] [c00ba1ec] do_filp_open+0x30/0x8c
[219713.548078] [c66edf00] [c00ab9ac] do_sys_open+0x14c/0x238
[219713.553503] [c66edf40] [c000b27c] ret_from_syscall+0x0/0x38
[219713.559041] Instruction dump:
[219713.562058] 7f834800 419e000c 48014fb5 80610018 8081001c 81410020 
907f0000 909f0004
[219713.569801] 915f0020 3bc00000 8061000c 81230028 <81290010> 81290014 
2f890000 419e0014