lkml.org 
[lkml]   [2015]   [Nov]   [20]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    /
    From
    SubjectRecurring Oops in link_path_walk()
    Date
    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




    \
     
     \ /
      Last update: 2015-11-20 18:41    [W:5.782 / U:1.064 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site