Ignore:
Timestamp:
Apr 16, 2017, 3:07:01 PM (5 weeks ago)
Author:
brainslayer
Message:

update

File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/linux/universal/linux-3.18/net/unix/af_unix.c

    r30256 r31869  
    941941}
    942942
    943 static int unix_mknod(struct dentry *dentry, struct path *path, umode_t mode,
    944                       struct path *res)
    945 {
    946         int err;
    947 
    948         err = security_path_mknod(path, dentry, mode, 0);
     943static int unix_mknod(const char *sun_path, umode_t mode, struct path *res)
     944{
     945        struct dentry *dentry;
     946        struct path path;
     947        int err = 0;
     948        /*
     949         * Get the parent directory, calculate the hash for last
     950         * component.
     951         */
     952        dentry = kern_path_create(AT_FDCWD, sun_path, &path, 0);
     953        err = PTR_ERR(dentry);
     954        if (IS_ERR(dentry))
     955                return err;
     956
     957        /*
     958         * All right, let's create it.
     959         */
     960        err = security_path_mknod(&path, dentry, mode, 0);
    949961        if (!err) {
    950                 err = vfs_mknod(d_inode(path->dentry), dentry, mode, 0);
     962                err = vfs_mknod(d_inode(path.dentry), dentry, mode, 0);
    951963                if (!err) {
    952                         res->mnt = mntget(path->mnt);
     964                        res->mnt = mntget(path.mnt);
    953965                        res->dentry = dget(dentry);
    954966                }
    955967        }
    956 
     968        done_path_create(&path, dentry);
    957969        return err;
    958970}
     
    965977        struct sockaddr_un *sunaddr = (struct sockaddr_un *)uaddr;
    966978        char *sun_path = sunaddr->sun_path;
    967         int err, name_err;
     979        int err;
    968980        unsigned int hash;
    969981        struct unix_address *addr;
    970982        struct hlist_head *list;
    971         struct path path;
    972         struct dentry *dentry;
    973983
    974984        err = -EINVAL;
     
    986996        addr_len = err;
    987997
    988         name_err = 0;
    989         dentry = NULL;
    990         if (sun_path[0]) {
    991                 /* Get the parent directory, calculate the hash for last
    992                  * component.
    993                  */
    994                 dentry = kern_path_create(AT_FDCWD, sun_path, &path, 0);
    995 
    996                 if (IS_ERR(dentry)) {
    997                         /* delay report until after 'already bound' check */
    998                         name_err = PTR_ERR(dentry);
    999                         dentry = NULL;
    1000                 }
    1001         }
    1002 
    1003998        err = mutex_lock_interruptible(&u->readlock);
    1004999        if (err)
    1005                 goto out_path;
     1000                goto out;
    10061001
    10071002        err = -EINVAL;
    10081003        if (u->addr)
    10091004                goto out_up;
    1010 
    1011         if (name_err) {
    1012                 err = name_err == -EEXIST ? -EADDRINUSE : name_err;
    1013                 goto out_up;
    1014         }
    10151005
    10161006        err = -ENOMEM;
     
    10241014        atomic_set(&addr->refcnt, 1);
    10251015
    1026         if (dentry) {
    1027                 struct path u_path;
     1016        if (sun_path[0]) {
     1017                struct path path;
    10281018                umode_t mode = S_IFSOCK |
    10291019                       (SOCK_INODE(sock)->i_mode & ~current_umask());
    1030                 err = unix_mknod(dentry, &path, mode, &u_path);
     1020                err = unix_mknod(sun_path, mode, &path);
    10311021                if (err) {
    10321022                        if (err == -EEXIST)
     
    10361026                }
    10371027                addr->hash = UNIX_HASH_SIZE;
    1038                 hash = d_backing_inode(dentry)->i_ino & (UNIX_HASH_SIZE - 1);
     1028                hash = d_backing_inode(path.dentry)->i_ino & (UNIX_HASH_SIZE-1);
    10391029                spin_lock(&unix_table_lock);
    1040                 u->path = u_path;
     1030                u->path = path;
    10411031                list = &unix_socket_table[hash];
    10421032        } else {
     
    10611051out_up:
    10621052        mutex_unlock(&u->readlock);
    1063 out_path:
    1064         if (dentry)
    1065                 done_path_create(&path, dentry);
    1066 
    10671053out:
    10681054        return err;
Note: See TracChangeset for help on using the changeset viewer.