linux/fs/namei.c
<<
>>
Prefs
   1/*
   2 *  linux/fs/namei.c
   3 *
   4 *  Copyright (C) 1991, 1992  Linus Torvalds
   5 */
   6
   7/*
   8 * Some corrections by tytso.
   9 */
  10
  11/* [Feb 1997 T. Schoebel-Theuer] Complete rewrite of the pathname
  12 * lookup logic.
  13 */
  14/* [Feb-Apr 2000, AV] Rewrite to the new namespace architecture.
  15 */
  16
  17#include <linux/init.h>
  18#include <linux/module.h>
  19#include <linux/slab.h>
  20#include <linux/fs.h>
  21#include <linux/namei.h>
  22#include <linux/quotaops.h>
  23#include <linux/pagemap.h>
  24#include <linux/fsnotify.h>
  25#include <linux/personality.h>
  26#include <linux/security.h>
  27#include <linux/syscalls.h>
  28#include <linux/mount.h>
  29#include <linux/audit.h>
  30#include <linux/capability.h>
  31#include <linux/file.h>
  32#include <linux/fcntl.h>
  33#include <linux/device_cgroup.h>
  34#include <asm/namei.h>
  35#include <asm/uaccess.h>
  36
  37#define ACC_MODE(x) ("\000\004\002\006"[(x)&O_ACCMODE])
  38
  39/* [Feb-1997 T. Schoebel-Theuer]
  40 * Fundamental changes in the pathname lookup mechanisms (namei)
  41 * were necessary because of omirr.  The reason is that omirr needs
  42 * to know the _real_ pathname, not the user-supplied one, in case
  43 * of symlinks (and also when transname replacements occur).
  44 *
  45 * The new code replaces the old recursive symlink resolution with
  46 * an iterative one (in case of non-nested symlink chains).  It does
  47 * this with calls to <fs>_follow_link().
  48 * As a side effect, dir_namei(), _namei() and follow_link() are now 
  49 * replaced with a single function lookup_dentry() that can handle all 
  50 * the special cases of the former code.
  51 *
  52 * With the new dcache, the pathname is stored at each inode, at least as
  53 * long as the refcount of the inode is positive.  As a side effect, the
  54 * size of the dcache depends on the inode cache and thus is dynamic.
  55 *
  56 * [29-Apr-1998 C. Scott Ananian] Updated above description of symlink
  57 * resolution to correspond with current state of the code.
  58 *
  59 * Note that the symlink resolution is not *completely* iterative.
  60 * There is still a significant amount of tail- and mid- recursion in
  61 * the algorithm.  Also, note that <fs>_readlink() is not used in
  62 * lookup_dentry(): lookup_dentry() on the result of <fs>_readlink()
  63 * may return different results than <fs>_follow_link().  Many virtual
  64 * filesystems (including /proc) exhibit this behavior.
  65 */
  66
  67/* [24-Feb-97 T. Schoebel-Theuer] Side effects caused by new implementation:
  68 * New symlink semantics: when open() is called with flags O_CREAT | O_EXCL
  69 * and the name already exists in form of a symlink, try to create the new
  70 * name indicated by the symlink. The old code always complained that the
  71 * name already exists, due to not following the symlink even if its target
  72 * is nonexistent.  The new semantics affects also mknod() and link() when
  73 * the name is a symlink pointing to a non-existant name.
  74 *
  75 * I don't know which semantics is the right one, since I have no access
  76 * to standards. But I found by trial that HP-UX 9.0 has the full "new"
  77 * semantics implemented, while SunOS 4.1.1 and Solaris (SunOS 5.4) have the
  78 * "old" one. Personally, I think the new semantics is much more logical.
  79 * Note that "ln old new" where "new" is a symlink pointing to a non-existing
  80 * file does succeed in both HP-UX and SunOs, but not in Solaris
  81 * and in the old Linux semantics.
  82 */
  83
  84/* [16-Dec-97 Kevin Buhr] For security reasons, we change some symlink
  85 * semantics.  See the comments in "open_namei" and "do_link" below.
  86 *
  87 * [10-Sep-98 Alan Modra] Another symlink change.
  88 */
  89
  90/* [Feb-Apr 2000 AV] Complete rewrite. Rules for symlinks:
  91 *      inside the path - always follow.
  92 *      in the last component in creation/removal/renaming - never follow.
  93 *      if LOOKUP_FOLLOW passed - follow.
  94 *      if the pathname has trailing slashes - follow.
  95 *      otherwise - don't follow.
  96 * (applied in that order).
  97 *
  98 * [Jun 2000 AV] Inconsistent behaviour of open() in case if flags==O_CREAT
  99 * restored for 2.4. This is the last surviving part of old 4.2BSD bug.
 100 * During the 2.4 we need to fix the userland stuff depending on it -
 101 * hopefully we will be able to get rid of that wart in 2.5. So far only
 102 * XEmacs seems to be relying on it...
 103 */
 104/*
 105 * [Sep 2001 AV] Single-semaphore locking scheme (kudos to David Holland)
 106 * implemented.  Let's see if raised priority of ->s_vfs_rename_mutex gives
 107 * any extra contention...
 108 */
 109
 110static int __link_path_walk(const char *name, struct nameidata *nd);
 111
 112/* In order to reduce some races, while at the same time doing additional
 113 * checking and hopefully speeding things up, we copy filenames to the
 114 * kernel data space before using them..
 115 *
 116 * POSIX.1 2.4: an empty pathname is invalid (ENOENT).
 117 * PATH_MAX includes the nul terminator --RR.
 118 */
 119static int do_getname(const char __user *filename, char *page)
 120{
 121        int retval;
 122        unsigned long len = PATH_MAX;
 123
 124        if (!segment_eq(get_fs(), KERNEL_DS)) {
 125                if ((unsigned long) filename >= TASK_SIZE)
 126                        return -EFAULT;
 127                if (TASK_SIZE - (unsigned long) filename < PATH_MAX)
 128                        len = TASK_SIZE - (unsigned long) filename;
 129        }
 130
 131        retval = strncpy_from_user(page, filename, len);
 132        if (retval > 0) {
 133                if (retval < len)
 134                        return 0;
 135                return -ENAMETOOLONG;
 136        } else if (!retval)
 137                retval = -ENOENT;
 138        return retval;
 139}
 140
 141char * getname(const char __user * filename)
 142{
 143        char *tmp, *result;
 144
 145        result = ERR_PTR(-ENOMEM);
 146        tmp = __getname();
 147        if (tmp)  {
 148                int retval = do_getname(filename, tmp);
 149
 150                result = tmp;
 151                if (retval < 0) {
 152                        __putname(tmp);
 153                        result = ERR_PTR(retval);
 154                }
 155        }
 156        audit_getname(result);
 157        return result;
 158}
 159
 160#ifdef CONFIG_AUDITSYSCALL
 161void putname(const char *name)
 162{
 163        if (unlikely(!audit_dummy_context()))
 164                audit_putname(name);
 165        else
 166                __putname(name);
 167}
 168EXPORT_SYMBOL(putname);
 169#endif
 170
 171
 172/**
 173 * generic_permission  -  check for access rights on a Posix-like filesystem
 174 * @inode:      inode to check access rights for
 175 * @mask:       right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
 176 * @check_acl:  optional callback to check for Posix ACLs
 177 *
 178 * Used to check for read/write/execute permissions on a file.
 179 * We use "fsuid" for this, letting us set arbitrary permissions
 180 * for filesystem access without changing the "normal" uids which
 181 * are used for other things..
 182 */
 183int generic_permission(struct inode *inode, int mask,
 184                int (*check_acl)(struct inode *inode, int mask))
 185{
 186        umode_t                 mode = inode->i_mode;
 187
 188        if (current->fsuid == inode->i_uid)
 189                mode >>= 6;
 190        else {
 191                if (IS_POSIXACL(inode) && (mode & S_IRWXG) && check_acl) {
 192                        int error = check_acl(inode, mask);
 193                        if (error == -EACCES)
 194                                goto check_capabilities;
 195                        else if (error != -EAGAIN)
 196                                return error;
 197                }
 198
 199                if (in_group_p(inode->i_gid))
 200                        mode >>= 3;
 201        }
 202
 203        /*
 204         * If the DACs are ok we don't need any capability check.
 205         */
 206        if (((mode & mask & (MAY_READ|MAY_WRITE|MAY_EXEC)) == mask))
 207                return 0;
 208
 209 check_capabilities:
 210        /*
 211         * Read/write DACs are always overridable.
 212         * Executable DACs are overridable if at least one exec bit is set.
 213         */
 214        if (!(mask & MAY_EXEC) ||
 215            (inode->i_mode & S_IXUGO) || S_ISDIR(inode->i_mode))
 216                if (capable(CAP_DAC_OVERRIDE))
 217                        return 0;
 218
 219        /*
 220         * Searching includes executable on directories, else just read.
 221         */
 222        if (mask == MAY_READ || (S_ISDIR(inode->i_mode) && !(mask & MAY_WRITE)))
 223                if (capable(CAP_DAC_READ_SEARCH))
 224                        return 0;
 225
 226        return -EACCES;
 227}
 228
 229int permission(struct inode *inode, int mask, struct nameidata *nd)
 230{
 231        int retval, submask;
 232        struct vfsmount *mnt = NULL;
 233
 234        if (nd)
 235                mnt = nd->path.mnt;
 236
 237        if (mask & MAY_WRITE) {
 238                umode_t mode = inode->i_mode;
 239
 240                /*
 241                 * Nobody gets write access to a read-only fs.
 242                 */
 243                if (IS_RDONLY(inode) &&
 244                    (S_ISREG(mode) || S_ISDIR(mode) || S_ISLNK(mode)))
 245                        return -EROFS;
 246
 247                /*
 248                 * Nobody gets write access to an immutable file.
 249                 */
 250                if (IS_IMMUTABLE(inode))
 251                        return -EACCES;
 252        }
 253
 254        if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode)) {
 255                /*
 256                 * MAY_EXEC on regular files is denied if the fs is mounted
 257                 * with the "noexec" flag.
 258                 */
 259                if (mnt && (mnt->mnt_flags & MNT_NOEXEC))
 260                        return -EACCES;
 261        }
 262
 263        /* Ordinary permission routines do not understand MAY_APPEND. */
 264        submask = mask & ~MAY_APPEND;
 265        if (inode->i_op && inode->i_op->permission) {
 266                retval = inode->i_op->permission(inode, submask, nd);
 267                if (!retval) {
 268                        /*
 269                         * Exec permission on a regular file is denied if none
 270                         * of the execute bits are set.
 271                         *
 272                         * This check should be done by the ->permission()
 273                         * method.
 274                         */
 275                        if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode) &&
 276                            !(inode->i_mode & S_IXUGO))
 277                                return -EACCES;
 278                }
 279        } else {
 280                retval = generic_permission(inode, submask, NULL);
 281        }
 282        if (retval)
 283                return retval;
 284
 285        retval = devcgroup_inode_permission(inode, mask);
 286        if (retval)
 287                return retval;
 288
 289        return security_inode_permission(inode, mask, nd);
 290}
 291
 292/**
 293 * vfs_permission  -  check for access rights to a given path
 294 * @nd:         lookup result that describes the path
 295 * @mask:       right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
 296 *
 297 * Used to check for read/write/execute permissions on a path.
 298 * We use "fsuid" for this, letting us set arbitrary permissions
 299 * for filesystem access without changing the "normal" uids which
 300 * are used for other things.
 301 */
 302int vfs_permission(struct nameidata *nd, int mask)
 303{
 304        return permission(nd->path.dentry->d_inode, mask, nd);
 305}
 306
 307/**
 308 * file_permission  -  check for additional access rights to a given file
 309 * @file:       file to check access rights for
 310 * @mask:       right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC)
 311 *
 312 * Used to check for read/write/execute permissions on an already opened
 313 * file.
 314 *
 315 * Note:
 316 *      Do not use this function in new code.  All access checks should
 317 *      be done using vfs_permission().
 318 */
 319int file_permission(struct file *file, int mask)
 320{
 321        return permission(file->f_path.dentry->d_inode, mask, NULL);
 322}
 323
 324/*
 325 * get_write_access() gets write permission for a file.
 326 * put_write_access() releases this write permission.
 327 * This is used for regular files.
 328 * We cannot support write (and maybe mmap read-write shared) accesses and
 329 * MAP_DENYWRITE mmappings simultaneously. The i_writecount field of an inode
 330 * can have the following values:
 331 * 0: no writers, no VM_DENYWRITE mappings
 332 * < 0: (-i_writecount) vm_area_structs with VM_DENYWRITE set exist
 333 * > 0: (i_writecount) users are writing to the file.
 334 *
 335 * Normally we operate on that counter with atomic_{inc,dec} and it's safe
 336 * except for the cases where we don't hold i_writecount yet. Then we need to
 337 * use {get,deny}_write_access() - these functions check the sign and refuse
 338 * to do the change if sign is wrong. Exclusion between them is provided by
 339 * the inode->i_lock spinlock.
 340 */
 341
 342int get_write_access(struct inode * inode)
 343{
 344        spin_lock(&inode->i_lock);
 345        if (atomic_read(&inode->i_writecount) < 0) {
 346                spin_unlock(&inode->i_lock);
 347                return -ETXTBSY;
 348        }
 349        atomic_inc(&inode->i_writecount);
 350        spin_unlock(&inode->i_lock);
 351
 352        return 0;
 353}
 354
 355int deny_write_access(struct file * file)
 356{
 357        struct inode *inode = file->f_path.dentry->d_inode;
 358
 359        spin_lock(&inode->i_lock);
 360        if (atomic_read(&inode->i_writecount) > 0) {
 361                spin_unlock(&inode->i_lock);
 362                return -ETXTBSY;
 363        }
 364        atomic_dec(&inode->i_writecount);
 365        spin_unlock(&inode->i_lock);
 366
 367        return 0;
 368}
 369
 370/**
 371 * path_get - get a reference to a path
 372 * @path: path to get the reference to
 373 *
 374 * Given a path increment the reference count to the dentry and the vfsmount.
 375 */
 376void path_get(struct path *path)
 377{
 378        mntget(path->mnt);
 379        dget(path->dentry);
 380}
 381EXPORT_SYMBOL(path_get);
 382
 383/**
 384 * path_put - put a reference to a path
 385 * @path: path to put the reference to
 386 *
 387 * Given a path decrement the reference count to the dentry and the vfsmount.
 388 */
 389void path_put(struct path *path)
 390{
 391        dput(path->dentry);
 392        mntput(path->mnt);
 393}
 394EXPORT_SYMBOL(path_put);
 395
 396/**
 397 * release_open_intent - free up open intent resources
 398 * @nd: pointer to nameidata
 399 */
 400void release_open_intent(struct nameidata *nd)
 401{
 402        if (nd->intent.open.file->f_path.dentry == NULL)
 403                put_filp(nd->intent.open.file);
 404        else
 405                fput(nd->intent.open.file);
 406}
 407
 408static inline struct dentry *
 409do_revalidate(struct dentry *dentry, struct nameidata *nd)
 410{
 411        int status = dentry->d_op->d_revalidate(dentry, nd);
 412        if (unlikely(status <= 0)) {
 413                /*
 414                 * The dentry failed validation.
 415                 * If d_revalidate returned 0 attempt to invalidate
 416                 * the dentry otherwise d_revalidate is asking us
 417                 * to return a fail status.
 418                 */
 419                if (!status) {
 420                        if (!d_invalidate(dentry)) {
 421                                dput(dentry);
 422                                dentry = NULL;
 423                        }
 424                } else {
 425                        dput(dentry);
 426                        dentry = ERR_PTR(status);
 427                }
 428        }
 429        return dentry;
 430}
 431
 432/*
 433 * Internal lookup() using the new generic dcache.
 434 * SMP-safe
 435 */
 436static struct dentry * cached_lookup(struct dentry * parent, struct qstr * name, struct nameidata *nd)
 437{
 438        struct dentry * dentry = __d_lookup(parent, name);
 439
 440        /* lockess __d_lookup may fail due to concurrent d_move() 
 441         * in some unrelated directory, so try with d_lookup
 442         */
 443        if (!dentry)
 444                dentry = d_lookup(parent, name);
 445
 446        if (dentry && dentry->d_op && dentry->d_op->d_revalidate)
 447                dentry = do_revalidate(dentry, nd);
 448
 449        return dentry;
 450}
 451
 452/*
 453 * Short-cut version of permission(), for calling by
 454 * path_walk(), when dcache lock is held.  Combines parts
 455 * of permission() and generic_permission(), and tests ONLY for
 456 * MAY_EXEC permission.
 457 *
 458 * If appropriate, check DAC only.  If not appropriate, or
 459 * short-cut DAC fails, then call permission() to do more
 460 * complete permission check.
 461 */
 462static int exec_permission_lite(struct inode *inode,
 463                                       struct nameidata *nd)
 464{
 465        umode_t mode = inode->i_mode;
 466
 467        if (inode->i_op && inode->i_op->permission)
 468                return -EAGAIN;
 469
 470        if (current->fsuid == inode->i_uid)
 471                mode >>= 6;
 472        else if (in_group_p(inode->i_gid))
 473                mode >>= 3;
 474
 475        if (mode & MAY_EXEC)
 476                goto ok;
 477
 478        if ((inode->i_mode & S_IXUGO) && capable(CAP_DAC_OVERRIDE))
 479                goto ok;
 480
 481        if (S_ISDIR(inode->i_mode) && capable(CAP_DAC_OVERRIDE))
 482                goto ok;
 483
 484        if (S_ISDIR(inode->i_mode) && capable(CAP_DAC_READ_SEARCH))
 485                goto ok;
 486
 487        return -EACCES;
 488ok:
 489        return security_inode_permission(inode, MAY_EXEC, nd);
 490}
 491
 492/*
 493 * This is called when everything else fails, and we actually have
 494 * to go to the low-level filesystem to find out what we should do..
 495 *
 496 * We get the directory semaphore, and after getting that we also
 497 * make sure that nobody added the entry to the dcache in the meantime..
 498 * SMP-safe
 499 */
 500static struct dentry * real_lookup(struct dentry * parent, struct qstr * name, struct nameidata *nd)
 501{
 502        struct dentry * result;
 503        struct inode *dir = parent->d_inode;
 504
 505        mutex_lock(&dir->i_mutex);
 506        /*
 507         * First re-do the cached lookup just in case it was created
 508         * while we waited for the directory semaphore..
 509         *
 510         * FIXME! This could use version numbering or similar to
 511         * avoid unnecessary cache lookups.
 512         *
 513         * The "dcache_lock" is purely to protect the RCU list walker
 514         * from concurrent renames at this point (we mustn't get false
 515         * negatives from the RCU list walk here, unlike the optimistic
 516         * fast walk).
 517         *
 518         * so doing d_lookup() (with seqlock), instead of lockfree __d_lookup
 519         */
 520        result = d_lookup(parent, name);
 521        if (!result) {
 522                struct dentry *dentry;
 523
 524                /* Don't create child dentry for a dead directory. */
 525                result = ERR_PTR(-ENOENT);
 526                if (IS_DEADDIR(dir))
 527                        goto out_unlock;
 528
 529                dentry = d_alloc(parent, name);
 530                result = ERR_PTR(-ENOMEM);
 531                if (dentry) {
 532                        result = dir->i_op->lookup(dir, dentry, nd);
 533                        if (result)
 534                                dput(dentry);
 535                        else
 536                                result = dentry;
 537                }
 538out_unlock:
 539                mutex_unlock(&dir->i_mutex);
 540                return result;
 541        }
 542
 543        /*
 544         * Uhhuh! Nasty case: the cache was re-populated while
 545         * we waited on the semaphore. Need to revalidate.
 546         */
 547        mutex_unlock(&dir->i_mutex);
 548        if (result->d_op && result->d_op->d_revalidate) {
 549                result = do_revalidate(result, nd);
 550                if (!result)
 551                        result = ERR_PTR(-ENOENT);
 552        }
 553        return result;
 554}
 555
 556static int __emul_lookup_dentry(const char *, struct nameidata *);
 557
 558/* SMP-safe */
 559static __always_inline int
 560walk_init_root(const char *name, struct nameidata *nd)
 561{
 562        struct fs_struct *fs = current->fs;
 563
 564        read_lock(&fs->lock);
 565        if (fs->altroot.dentry && !(nd->flags & LOOKUP_NOALT)) {
 566                nd->path = fs->altroot;
 567                path_get(&fs->altroot);
 568                read_unlock(&fs->lock);
 569                if (__emul_lookup_dentry(name,nd))
 570                        return 0;
 571                read_lock(&fs->lock);
 572        }
 573        nd->path = fs->root;
 574        path_get(&fs->root);
 575        read_unlock(&fs->lock);
 576        return 1;
 577}
 578
 579/*
 580 * Wrapper to retry pathname resolution whenever the underlying
 581 * file system returns an ESTALE.
 582 *
 583 * Retry the whole path once, forcing real lookup requests
 584 * instead of relying on the dcache.
 585 */
 586static __always_inline int link_path_walk(const char *name, struct nameidata *nd)
 587{
 588        struct path save = nd->path;
 589        int result;
 590
 591        /* make sure the stuff we saved doesn't go away */
 592        path_get(&save);
 593
 594        result = __link_path_walk(name, nd);
 595        if (result == -ESTALE) {
 596                /* nd->path had been dropped */
 597                nd->path = save;
 598                path_get(&nd->path);
 599                nd->flags |= LOOKUP_REVAL;
 600                result = __link_path_walk(name, nd);
 601        }
 602
 603        path_put(&save);
 604
 605        return result;
 606}
 607
 608static __always_inline int __vfs_follow_link(struct nameidata *nd, const char *link)
 609{
 610        int res = 0;
 611        char *name;
 612        if (IS_ERR(link))
 613                goto fail;
 614
 615        if (*link == '/') {
 616                path_put(&nd->path);
 617                if (!walk_init_root(link, nd))
 618                        /* weird __emul_prefix() stuff did it */
 619                        goto out;
 620        }
 621        res = link_path_walk(link, nd);
 622out:
 623        if (nd->depth || res || nd->last_type!=LAST_NORM)
 624                return res;
 625        /*
 626         * If it is an iterative symlinks resolution in open_namei() we
 627         * have to copy the last component. And all that crap because of
 628         * bloody create() on broken symlinks. Furrfu...
 629         */
 630        name = __getname();
 631        if (unlikely(!name)) {
 632                path_put(&nd->path);
 633                return -ENOMEM;
 634        }
 635        strcpy(name, nd->last.name);
 636        nd->last.name = name;
 637        return 0;
 638fail:
 639        path_put(&nd->path);
 640        return PTR_ERR(link);
 641}
 642
 643static void path_put_conditional(struct path *path, struct nameidata *nd)
 644{
 645        dput(path->dentry);
 646        if (path->mnt != nd->path.mnt)
 647                mntput(path->mnt);
 648}
 649
 650static inline void path_to_nameidata(struct path *path, struct nameidata *nd)
 651{
 652        dput(nd->path.dentry);
 653        if (nd->path.mnt != path->mnt)
 654                mntput(nd->path.mnt);
 655        nd->path.mnt = path->mnt;
 656        nd->path.dentry = path->dentry;
 657}
 658
 659static __always_inline int __do_follow_link(struct path *path, struct nameidata *nd)
 660{
 661        int error;
 662        void *cookie;
 663        struct dentry *dentry = path->dentry;
 664
 665        touch_atime(path->mnt, dentry);
 666        nd_set_link(nd, NULL);
 667
 668        if (path->mnt != nd->path.mnt) {
 669                path_to_nameidata(path, nd);
 670                dget(dentry);
 671        }
 672        mntget(path->mnt);
 673        cookie = dentry->d_inode->i_op->follow_link(dentry, nd);
 674        error = PTR_ERR(cookie);
 675        if (!IS_ERR(cookie)) {
 676                char *s = nd_get_link(nd);
 677                error = 0;
 678                if (s)
 679                        error = __vfs_follow_link(nd, s);
 680                if (dentry->d_inode->i_op->put_link)
 681                        dentry->d_inode->i_op->put_link(dentry, nd, cookie);
 682        }
 683        path_put(path);
 684
 685        return error;
 686}
 687
 688/*
 689 * This limits recursive symlink follows to 8, while
 690 * limiting consecutive symlinks to 40.
 691 *
 692 * Without that kind of total limit, nasty chains of consecutive
 693 * symlinks can cause almost arbitrarily long lookups. 
 694 */
 695static inline int do_follow_link(struct path *path, struct nameidata *nd)
 696{
 697        int err = -ELOOP;
 698        if (current->link_count >= MAX_NESTED_LINKS)
 699                goto loop;
 700        if (current->total_link_count >= 40)
 701                goto loop;
 702        BUG_ON(nd->depth >= MAX_NESTED_LINKS);
 703        cond_resched();
 704        err = security_inode_follow_link(path->dentry, nd);
 705        if (err)
 706                goto loop;
 707        current->link_count++;
 708        current->total_link_count++;
 709        nd->depth++;
 710        err = __do_follow_link(path, nd);
 711        current->link_count--;
 712        nd->depth--;
 713        return err;
 714loop:
 715        path_put_conditional(path, nd);
 716        path_put(&nd->path);
 717        return err;
 718}
 719
 720int follow_up(struct vfsmount **mnt, struct dentry **dentry)
 721{
 722        struct vfsmount *parent;
 723        struct dentry *mountpoint;
 724        spin_lock(&vfsmount_lock);
 725        parent=(*mnt)->mnt_parent;
 726        if (parent == *mnt) {
 727                spin_unlock(&vfsmount_lock);
 728                return 0;
 729        }
 730        mntget(parent);
 731        mountpoint=dget((*mnt)->mnt_mountpoint);
 732        spin_unlock(&vfsmount_lock);
 733        dput(*dentry);
 734        *dentry = mountpoint;
 735        mntput(*mnt);
 736        *mnt = parent;
 737        return 1;
 738}
 739
 740/* no need for dcache_lock, as serialization is taken care in
 741 * namespace.c
 742 */
 743static int __follow_mount(struct path *path)
 744{
 745        int res = 0;
 746        while (d_mountpoint(path->dentry)) {
 747                struct vfsmount *mounted = lookup_mnt(path->mnt, path->dentry);
 748                if (!mounted)
 749                        break;
 750                dput(path->dentry);
 751                if (res)
 752                        mntput(path->mnt);
 753                path->mnt = mounted;
 754                path->dentry = dget(mounted->mnt_root);
 755                res = 1;
 756        }
 757        return res;
 758}
 759
 760static void follow_mount(struct vfsmount **mnt, struct dentry **dentry)
 761{
 762        while (d_mountpoint(*dentry)) {
 763                struct vfsmount *mounted = lookup_mnt(*mnt, *dentry);
 764                if (!mounted)
 765                        break;
 766                dput(*dentry);
 767                mntput(*mnt);
 768                *mnt = mounted;
 769                *dentry = dget(mounted->mnt_root);
 770        }
 771}
 772
 773/* no need for dcache_lock, as serialization is taken care in
 774 * namespace.c
 775 */
 776int follow_down(struct vfsmount **mnt, struct dentry **dentry)
 777{
 778        struct vfsmount *mounted;
 779
 780        mounted = lookup_mnt(*mnt, *dentry);
 781        if (mounted) {
 782                dput(*dentry);
 783                mntput(*mnt);
 784                *mnt = mounted;
 785                *dentry = dget(mounted->mnt_root);
 786                return 1;
 787        }
 788        return 0;
 789}
 790
 791static __always_inline void follow_dotdot(struct nameidata *nd)
 792{
 793        struct fs_struct *fs = current->fs;
 794
 795        while(1) {
 796                struct vfsmount *parent;
 797                struct dentry *old = nd->path.dentry;
 798
 799                read_lock(&fs->lock);
 800                if (nd->path.dentry == fs->root.dentry &&
 801                    nd->path.mnt == fs->root.mnt) {
 802                        read_unlock(&fs->lock);
 803                        break;
 804                }
 805                read_unlock(&fs->lock);
 806                spin_lock(&dcache_lock);
 807                if (nd->path.dentry != nd->path.mnt->mnt_root) {
 808                        nd->path.dentry = dget(nd->path.dentry->d_parent);
 809                        spin_unlock(&dcache_lock);
 810                        dput(old);
 811                        break;
 812                }
 813                spin_unlock(&dcache_lock);
 814                spin_lock(&vfsmount_lock);
 815                parent = nd->path.mnt->mnt_parent;
 816                if (parent == nd->path.mnt) {
 817                        spin_unlock(&vfsmount_lock);
 818                        break;
 819                }
 820                mntget(parent);
 821                nd->path.dentry = dget(nd->path.mnt->mnt_mountpoint);
 822                spin_unlock(&vfsmount_lock);
 823                dput(old);
 824                mntput(nd->path.mnt);
 825                nd->path.mnt = parent;
 826        }
 827        follow_mount(&nd->path.mnt, &nd->path.dentry);
 828}
 829
 830/*
 831 *  It's more convoluted than I'd like it to be, but... it's still fairly
 832 *  small and for now I'd prefer to have fast path as straight as possible.
 833 *  It _is_ time-critical.
 834 */
 835static int do_lookup(struct nameidata *nd, struct qstr *name,
 836                     struct path *path)
 837{
 838        struct vfsmount *mnt = nd->path.mnt;
 839        struct dentry *dentry = __d_lookup(nd->path.dentry, name);
 840
 841        if (!dentry)
 842                goto need_lookup;
 843        if (dentry->d_op && dentry->d_op->d_revalidate)
 844                goto need_revalidate;
 845done:
 846        path->mnt = mnt;
 847        path->dentry = dentry;
 848        __follow_mount(path);
 849        return 0;
 850
 851need_lookup:
 852        dentry = real_lookup(nd->path.dentry, name, nd);
 853        if (IS_ERR(dentry))
 854                goto fail;
 855        goto done;
 856
 857need_revalidate:
 858        dentry = do_revalidate(dentry, nd);
 859        if (!dentry)
 860                goto need_lookup;
 861        if (IS_ERR(dentry))
 862                goto fail;
 863        goto done;
 864
 865fail:
 866        return PTR_ERR(dentry);
 867}
 868
 869/*
 870 * Name resolution.
 871 * This is the basic name resolution function, turning a pathname into
 872 * the final dentry. We expect 'base' to be positive and a directory.
 873 *
 874 * Returns 0 and nd will have valid dentry and mnt on success.
 875 * Returns error and drops reference to input namei data on failure.
 876 */
 877static int __link_path_walk(const char *name, struct nameidata *nd)
 878{
 879        struct path next;
 880        struct inode *inode;
 881        int err;
 882        unsigned int lookup_flags = nd->flags;
 883        
 884        while (*name=='/')
 885                name++;
 886        if (!*name)
 887                goto return_reval;
 888
 889        inode = nd->path.dentry->d_inode;
 890        if (nd->depth)
 891                lookup_flags = LOOKUP_FOLLOW | (nd->flags & LOOKUP_CONTINUE);
 892
 893        /* At this point we know we have a real path component. */
 894        for(;;) {
 895                unsigned long hash;
 896                struct qstr this;
 897                unsigned int c;
 898
 899                nd->flags |= LOOKUP_CONTINUE;
 900                err = exec_permission_lite(inode, nd);
 901                if (err == -EAGAIN)
 902                        err = vfs_permission(nd, MAY_EXEC);
 903                if (err)
 904                        break;
 905
 906                this.name = name;
 907                c = *(const unsigned char *)name;
 908
 909                hash = init_name_hash();
 910                do {
 911                        name++;
 912                        hash = partial_name_hash(c, hash);
 913                        c = *(const unsigned char *)name;
 914                } while (c && (c != '/'));
 915                this.len = name - (const char *) this.name;
 916                this.hash = end_name_hash(hash);
 917
 918                /* remove trailing slashes? */
 919                if (!c)
 920                        goto last_component;
 921                while (*++name == '/');
 922                if (!*name)
 923                        goto last_with_slashes;
 924
 925                /*
 926                 * "." and ".." are special - ".." especially so because it has
 927                 * to be able to know about the current root directory and
 928                 * parent relationships.
 929                 */
 930                if (this.name[0] == '.') switch (this.len) {
 931                        default:
 932                                break;
 933                        case 2: 
 934                                if (this.name[1] != '.')
 935                                        break;
 936                                follow_dotdot(nd);
 937                                inode = nd->path.dentry->d_inode;
 938                                /* fallthrough */
 939                        case 1:
 940                                continue;
 941                }
 942                /*
 943                 * See if the low-level filesystem might want
 944                 * to use its own hash..
 945                 */
 946                if (nd->path.dentry->d_op && nd->path.dentry->d_op->d_hash) {
 947                        err = nd->path.dentry->d_op->d_hash(nd->path.dentry,
 948                                                            &this);
 949                        if (err < 0)
 950                                break;
 951                }
 952                /* This does the actual lookups.. */
 953                err = do_lookup(nd, &this, &next);
 954                if (err)
 955                        break;
 956
 957                err = -ENOENT;
 958                inode = next.dentry->d_inode;
 959                if (!inode)
 960                        goto out_dput;
 961                err = -ENOTDIR; 
 962                if (!inode->i_op)
 963                        goto out_dput;
 964
 965                if (inode->i_op->follow_link) {
 966                        err = do_follow_link(&next, nd);
 967                        if (err)
 968                                goto return_err;
 969                        err = -ENOENT;
 970                        inode = nd->path.dentry->d_inode;
 971                        if (!inode)
 972                                break;
 973                        err = -ENOTDIR; 
 974                        if (!inode->i_op)
 975                                break;
 976                } else
 977                        path_to_nameidata(&next, nd);
 978                err = -ENOTDIR; 
 979                if (!inode->i_op->lookup)
 980                        break;
 981                continue;
 982                /* here ends the main loop */
 983
 984last_with_slashes:
 985                lookup_flags |= LOOKUP_FOLLOW | LOOKUP_DIRECTORY;
 986last_component:
 987                /* Clear LOOKUP_CONTINUE iff it was previously unset */
 988                nd->flags &= lookup_flags | ~LOOKUP_CONTINUE;
 989                if (lookup_flags & LOOKUP_PARENT)
 990                        goto lookup_parent;
 991                if (this.name[0] == '.') switch (this.len) {
 992                        default:
 993                                break;
 994                        case 2: 
 995                                if (this.name[1] != '.')
 996                                        break;
 997                                follow_dotdot(nd);
 998                                inode = nd->path.dentry->d_inode;
 999                                /* fallthrough */
1000                        case 1:
1001                                goto return_reval;
1002                }
1003                if (nd->path.dentry->d_op && nd->path.dentry->d_op->d_hash) {
1004                        err = nd->path.dentry->d_op->d_hash(nd->path.dentry,
1005                                                            &this);
1006                        if (err < 0)
1007                                break;
1008                }
1009                err = do_lookup(nd, &this, &next);
1010                if (err)
1011                        break;
1012                inode = next.dentry->d_inode;
1013                if ((lookup_flags & LOOKUP_FOLLOW)
1014                    && inode && inode->i_op && inode->i_op->follow_link) {
1015                        err = do_follow_link(&next, nd);
1016                        if (err)
1017                                goto return_err;
1018                        inode = nd->path.dentry->d_inode;
1019                } else
1020                        path_to_nameidata(&next, nd);
1021                err = -ENOENT;
1022                if (!inode)
1023                        break;
1024                if (lookup_flags & LOOKUP_DIRECTORY) {
1025                        err = -ENOTDIR; 
1026                        if (!inode->i_op || !inode->i_op->lookup)
1027                                break;
1028                }
1029                goto return_base;
1030lookup_parent:
1031                nd->last = this;
1032                nd->last_type = LAST_NORM;
1033                if (this.name[0] != '.')
1034                        goto return_base;
1035                if (this.len == 1)
1036                        nd->last_type = LAST_DOT;
1037                else if (this.len == 2 && this.name[1] == '.')
1038                        nd->last_type = LAST_DOTDOT;
1039                else
1040                        goto return_base;
1041return_reval:
1042                /*
1043                 * We bypassed the ordinary revalidation routines.
1044                 * We may need to check the cached dentry for staleness.
1045                 */
1046                if (nd->path.dentry && nd->path.dentry->d_sb &&
1047                    (nd->path.dentry->d_sb->s_type->fs_flags & FS_REVAL_DOT)) {
1048                        err = -ESTALE;
1049                        /* Note: we do not d_invalidate() */
1050                        if (!nd->path.dentry->d_op->d_revalidate(
1051                                        nd->path.dentry, nd))
1052                                break;
1053                }
1054return_base:
1055                return 0;
1056out_dput:
1057                path_put_conditional(&next, nd);
1058                break;
1059        }
1060        path_put(&nd->path);
1061return_err:
1062        return err;
1063}
1064
1065static int path_walk(const char *name, struct nameidata *nd)
1066{
1067        current->total_link_count = 0;
1068        return link_path_walk(name, nd);
1069}
1070
1071/* 
1072 * SMP-safe: Returns 1 and nd will have valid dentry and mnt, if
1073 * everything is done. Returns 0 and drops input nd, if lookup failed;
1074 */
1075static int __emul_lookup_dentry(const char *name, struct nameidata *nd)
1076{
1077        if (path_walk(name, nd))
1078                return 0;               /* something went wrong... */
1079
1080        if (!nd->path.dentry->d_inode ||
1081            S_ISDIR(nd->path.dentry->d_inode->i_mode)) {
1082                struct path old_path = nd->path;
1083                struct qstr last = nd->last;
1084                int last_type = nd->last_type;
1085                struct fs_struct *fs = current->fs;
1086
1087                /*
1088                 * NAME was not found in alternate root or it's a directory.
1089                 * Try to find it in the normal root:
1090                 */
1091                nd->last_type = LAST_ROOT;
1092                read_lock(&fs->lock);
1093                nd->path = fs->root;
1094                path_get(&fs->root);
1095                read_unlock(&fs->lock);
1096                if (path_walk(name, nd) == 0) {
1097                        if (nd->path.dentry->d_inode) {
1098                                path_put(&old_path);
1099                                return 1;
1100                        }
1101                        path_put(&nd->path);
1102                }
1103                nd->path = old_path;
1104                nd->last = last;
1105                nd->last_type = last_type;
1106        }
1107        return 1;
1108}
1109
1110void set_fs_altroot(void)
1111{
1112        char *emul = __emul_prefix();
1113        struct nameidata nd;
1114        struct path path = {}, old_path;
1115        int err;
1116        struct fs_struct *fs = current->fs;
1117
1118        if (!emul)
1119                goto set_it;
1120        err = path_lookup(emul, LOOKUP_FOLLOW|LOOKUP_DIRECTORY|LOOKUP_NOALT, &nd);
1121        if (!err)
1122                path = nd.path;
1123set_it:
1124        write_lock(&fs->lock);
1125        old_path = fs->altroot;
1126        fs->altroot = path;
1127        write_unlock(&fs->lock);
1128        if (old_path.dentry)
1129                path_put(&old_path);
1130}
1131
1132/* Returns 0 and nd will be valid on success; Retuns error, otherwise. */
1133static int do_path_lookup(int dfd, const char *name,
1134                                unsigned int flags, struct nameidata *nd)
1135{
1136        int retval = 0;
1137        int fput_needed;
1138        struct file *file;
1139        struct fs_struct *fs = current->fs;
1140
1141        nd->last_type = LAST_ROOT; /* if there are only slashes... */
1142        nd->flags = flags;
1143        nd->depth = 0;
1144
1145        if (*name=='/') {
1146                read_lock(&fs->lock);
1147                if (fs->altroot.dentry && !(nd->flags & LOOKUP_NOALT)) {
1148                        nd->path = fs->altroot;
1149                        path_get(&fs->altroot);
1150                        read_unlock(&fs->lock);
1151                        if (__emul_lookup_dentry(name,nd))
1152                                goto out; /* found in altroot */
1153                        read_lock(&fs->lock);
1154                }
1155                nd->path = fs->root;
1156                path_get(&fs->root);
1157                read_unlock(&fs->lock);
1158        } else if (dfd == AT_FDCWD) {
1159                read_lock(&fs->lock);
1160                nd->path = fs->pwd;
1161                path_get(&fs->pwd);
1162                read_unlock(&fs->lock);
1163        } else {
1164                struct dentry *dentry;
1165
1166                file = fget_light(dfd, &fput_needed);
1167                retval = -EBADF;
1168                if (!file)
1169                        goto out_fail;
1170
1171                dentry = file->f_path.dentry;
1172
1173                retval = -ENOTDIR;
1174                if (!S_ISDIR(dentry->d_inode->i_mode))
1175                        goto fput_fail;
1176
1177                retval = file_permission(file, MAY_EXEC);
1178                if (retval)
1179                        goto fput_fail;
1180
1181                nd->path = file->f_path;
1182                path_get(&file->f_path);
1183
1184                fput_light(file, fput_needed);
1185        }
1186
1187        retval = path_walk(name, nd);
1188out:
1189        if (unlikely(!retval && !audit_dummy_context() && nd->path.dentry &&
1190                                nd->path.dentry->d_inode))
1191                audit_inode(name, nd->path.dentry);
1192out_fail:
1193        return retval;
1194
1195fput_fail:
1196        fput_light(file, fput_needed);
1197        goto out_fail;
1198}
1199
1200int path_lookup(const char *name, unsigned int flags,
1201                        struct nameidata *nd)
1202{
1203        return do_path_lookup(AT_FDCWD, name, flags, nd);
1204}
1205
1206/**
1207 * vfs_path_lookup - lookup a file path relative to a dentry-vfsmount pair
1208 * @dentry:  pointer to dentry of the base directory
1209 * @mnt: pointer to vfs mount of the base directory
1210 * @name: pointer to file name
1211 * @flags: lookup flags
1212 * @nd: pointer to nameidata
1213 */
1214int vfs_path_lookup(struct dentry *dentry, struct vfsmount *mnt,
1215                    const char *name, unsigned int flags,
1216                    struct nameidata *nd)
1217{
1218        int retval;
1219
1220        /* same as do_path_lookup */
1221        nd->last_type = LAST_ROOT;
1222        nd->flags = flags;
1223        nd->depth = 0;
1224
1225        nd->path.dentry = dentry;
1226        nd->path.mnt = mnt;
1227        path_get(&nd->path);
1228
1229        retval = path_walk(name, nd);
1230        if (unlikely(!retval && !audit_dummy_context() && nd->path.dentry &&
1231                                nd->path.dentry->d_inode))
1232                audit_inode(name, nd->path.dentry);
1233
1234        return retval;
1235
1236}
1237
1238static int __path_lookup_intent_open(int dfd, const char *name,
1239                unsigned int lookup_flags, struct nameidata *nd,
1240                int open_flags, int create_mode)
1241{
1242        struct file *filp = get_empty_filp();
1243        int err;
1244
1245        if (filp == NULL)
1246                return -ENFILE;
1247        nd->intent.open.file = filp;
1248        nd->intent.open.flags = open_flags;
1249        nd->intent.open.create_mode = create_mode;
1250        err = do_path_lookup(dfd, name, lookup_flags|LOOKUP_OPEN, nd);
1251        if (IS_ERR(nd->intent.open.file)) {
1252                if (err == 0) {
1253                        err = PTR_ERR(nd->intent.open.file);
1254                        path_put(&nd->path);
1255                }
1256        } else if (err != 0)
1257                release_open_intent(nd);
1258        return err;
1259}
1260
1261/**
1262 * path_lookup_open - lookup a file path with open intent
1263 * @dfd: the directory to use as base, or AT_FDCWD
1264 * @name: pointer to file name
1265 * @lookup_flags: lookup intent flags
1266 * @nd: pointer to nameidata
1267 * @open_flags: open intent flags
1268 */
1269int path_lookup_open(int dfd, const char *name, unsigned int lookup_flags,
1270                struct nameidata *nd, int open_flags)
1271{
1272        return __path_lookup_intent_open(dfd, name, lookup_flags, nd,
1273                        open_flags, 0);
1274}
1275
1276/**
1277 * path_lookup_create - lookup a file path with open + create intent
1278 * @dfd: the directory to use as base, or AT_FDCWD
1279 * @name: pointer to file name
1280 * @lookup_flags: lookup intent flags
1281 * @nd: pointer to nameidata
1282 * @open_flags: open intent flags
1283 * @create_mode: create intent flags
1284 */
1285static int path_lookup_create(int dfd, const char *name,
1286                              unsigned int lookup_flags, struct nameidata *nd,
1287                              int open_flags, int create_mode)
1288{
1289        return __path_lookup_intent_open(dfd, name, lookup_flags|LOOKUP_CREATE,
1290                        nd, open_flags, create_mode);
1291}
1292
1293int __user_path_lookup_open(const char __user *name, unsigned int lookup_flags,
1294                struct nameidata *nd, int open_flags)
1295{
1296        char *tmp = getname(name);
1297        int err = PTR_ERR(tmp);
1298
1299        if (!IS_ERR(tmp)) {
1300                err = __path_lookup_intent_open(AT_FDCWD, tmp, lookup_flags, nd, open_flags, 0);
1301                putname(tmp);
1302        }
1303        return err;
1304}
1305
1306static struct dentry *__lookup_hash(struct qstr *name,
1307                struct dentry *base, struct nameidata *nd)
1308{
1309        struct dentry *dentry;
1310        struct inode *inode;
1311        int err;
1312
1313        inode = base->d_inode;
1314
1315        /*
1316         * See if the low-level filesystem might want
1317         * to use its own hash..
1318         */
1319        if (base->d_op && base->d_op->d_hash) {
1320                err = base->d_op->d_hash(base, name);
1321                dentry = ERR_PTR(err);
1322                if (err < 0)
1323                        goto out;
1324        }
1325
1326        dentry = cached_lookup(base, name, nd);
1327        if (!dentry) {
1328                struct dentry *new;
1329
1330                /* Don't create child dentry for a dead directory. */
1331                dentry = ERR_PTR(-ENOENT);
1332                if (IS_DEADDIR(inode))
1333                        goto out;
1334
1335                new = d_alloc(base, name);
1336                dentry = ERR_PTR(-ENOMEM);
1337                if (!new)
1338                        goto out;
1339                dentry = inode->i_op->lookup(inode, new, nd);
1340                if (!dentry)
1341                        dentry = new;
1342                else
1343                        dput(new);
1344        }
1345out:
1346        return dentry;
1347}
1348
1349/*
1350 * Restricted form of lookup. Doesn't follow links, single-component only,
1351 * needs parent already locked. Doesn't follow mounts.
1352 * SMP-safe.
1353 */
1354static struct dentry *lookup_hash(struct nameidata *nd)
1355{
1356        int err;
1357
1358        err = permission(nd->path.dentry->d_inode, MAY_EXEC, nd);
1359        if (err)
1360                return ERR_PTR(err);
1361        return __lookup_hash(&nd->last, nd->path.dentry, nd);
1362}
1363
1364static int __lookup_one_len(const char *name, struct qstr *this,
1365                struct dentry *base, int len)
1366{
1367        unsigned long hash;
1368        unsigned int c;
1369
1370        this->name = name;
1371        this->len = len;
1372        if (!len)
1373                return -EACCES;
1374
1375        hash = init_name_hash();
1376        while (len--) {
1377                c = *(const unsigned char *)name++;
1378                if (c == '/' || c == '\0')
1379                        return -EACCES;
1380                hash = partial_name_hash(c, hash);
1381        }
1382        this->hash = end_name_hash(hash);
1383        return 0;
1384}
1385
1386/**
1387 * lookup_one_len - filesystem helper to lookup single pathname component
1388 * @name:       pathname component to lookup
1389 * @base:       base directory to lookup from
1390 * @len:        maximum length @len should be interpreted to
1391 *
1392 * Note that this routine is purely a helper for filesystem usage and should
1393 * not be called by generic code.  Also note that by using this function the
1394 * nameidata argument is passed to the filesystem methods and a filesystem
1395 * using this helper needs to be prepared for that.
1396 */
1397struct dentry *lookup_one_len(const char *name, struct dentry *base, int len)
1398{
1399        int err;
1400        struct qstr this;
1401
1402        err = __lookup_one_len(name, &this, base, len);
1403        if (err)
1404                return ERR_PTR(err);
1405
1406        err = permission(base->d_inode, MAY_EXEC, NULL);
1407        if (err)
1408                return ERR_PTR(err);
1409        return __lookup_hash(&this, base, NULL);
1410}
1411
1412/**
1413 * lookup_one_noperm - bad hack for sysfs
1414 * @name:       pathname component to lookup
1415 * @base:       base directory to lookup from
1416 *
1417 * This is a variant of lookup_one_len that doesn't perform any permission
1418 * checks.   It's a horrible hack to work around the braindead sysfs
1419 * architecture and should not be used anywhere else.
1420 *
1421 * DON'T USE THIS FUNCTION EVER, thanks.
1422 */
1423struct dentry *lookup_one_noperm(const char *name, struct dentry *base)
1424{
1425        int err;
1426        struct qstr this;
1427
1428        err = __lookup_one_len(name, &this, base, strlen(name));
1429        if (err)
1430                return ERR_PTR(err);
1431        return __lookup_hash(&this, base, NULL);
1432}
1433
1434int __user_walk_fd(int dfd, const char __user *name, unsigned flags,
1435                            struct nameidata *nd)
1436{
1437        char *tmp = getname(name);
1438        int err = PTR_ERR(tmp);
1439
1440        if (!IS_ERR(tmp)) {
1441                err = do_path_lookup(dfd, tmp, flags, nd);
1442                putname(tmp);
1443        }
1444        return err;
1445}
1446
1447int __user_walk(const char __user *name, unsigned flags, struct nameidata *nd)
1448{
1449        return __user_walk_fd(AT_FDCWD, name, flags, nd);
1450}
1451
1452/*
1453 * It's inline, so penalty for filesystems that don't use sticky bit is
1454 * minimal.
1455 */
1456static inline int check_sticky(struct inode *dir, struct inode *inode)
1457{
1458        if (!(dir->i_mode & S_ISVTX))
1459                return 0;
1460        if (inode->i_uid == current->fsuid)
1461                return 0;
1462        if (dir->i_uid == current->fsuid)
1463                return 0;
1464        return !capable(CAP_FOWNER);
1465}
1466
1467/*
1468 *      Check whether we can remove a link victim from directory dir, check
1469 *  whether the type of victim is right.
1470 *  1. We can't do it if dir is read-only (done in permission())
1471 *  2. We should have write and exec permissions on dir
1472 *  3. We can't remove anything from append-only dir
1473 *  4. We can't do anything with immutable dir (done in permission())
1474 *  5. If the sticky bit on dir is set we should either
1475 *      a. be owner of dir, or
1476 *      b. be owner of victim, or
1477 *      c. have CAP_FOWNER capability
1478 *  6. If the victim is append-only or immutable we can't do antyhing with
1479 *     links pointing to it.
1480 *  7. If we were asked to remove a directory and victim isn't one - ENOTDIR.
1481 *  8. If we were asked to remove a non-directory and victim isn't one - EISDIR.
1482 *  9. We can't remove a root or mountpoint.
1483 * 10. We don't allow removal of NFS sillyrenamed files; it's handled by
1484 *     nfs_async_unlink().
1485 */
1486static int may_delete(struct inode *dir,struct dentry *victim,int isdir)
1487{
1488        int error;
1489
1490        if (!victim->d_inode)
1491                return -ENOENT;
1492
1493        BUG_ON(victim->d_parent->d_inode != dir);
1494        audit_inode_child(victim->d_name.name, victim, dir);
1495
1496        error = permission(dir,MAY_WRITE | MAY_EXEC, NULL);
1497        if (error)
1498                return error;
1499        if (IS_APPEND(dir))
1500                return -EPERM;
1501        if (check_sticky(dir, victim->d_inode)||IS_APPEND(victim->d_inode)||
1502            IS_IMMUTABLE(victim->d_inode))
1503                return -EPERM;
1504        if (isdir) {
1505                if (!S_ISDIR(victim->d_inode->i_mode))
1506                        return -ENOTDIR;
1507                if (IS_ROOT(victim))
1508                        return -EBUSY;
1509        } else if (S_ISDIR(victim->d_inode->i_mode))
1510                return -EISDIR;
1511        if (IS_DEADDIR(dir))
1512                return -ENOENT;
1513        if (victim->d_flags & DCACHE_NFSFS_RENAMED)
1514                return -EBUSY;
1515        return 0;
1516}
1517
1518/*      Check whether we can create an object with dentry child in directory
1519 *  dir.
1520 *  1. We can't do it if child already exists (open has special treatment for
1521 *     this case, but since we are inlined it's OK)
1522 *  2. We can't do it if dir is read-only (done in permission())
1523 *  3. We should have write and exec permissions on dir
1524 *  4. We can't do it if dir is immutable (done in permission())
1525 */
1526static inline int may_create(struct inode *dir, struct dentry *child,
1527                             struct nameidata *nd)
1528{
1529        if (child->d_inode)
1530                return -EEXIST;
1531        if (IS_DEADDIR(dir))
1532                return -ENOENT;
1533        return permission(dir,MAY_WRITE | MAY_EXEC, nd);
1534}
1535
1536/* 
1537 * O_DIRECTORY translates into forcing a directory lookup.
1538 */
1539static inline int lookup_flags(unsigned int f)
1540{
1541        unsigned long retval = LOOKUP_FOLLOW;
1542
1543        if (f & O_NOFOLLOW)
1544                retval &= ~LOOKUP_FOLLOW;
1545        
1546        if (f & O_DIRECTORY)
1547                retval |= LOOKUP_DIRECTORY;
1548
1549        return retval;
1550}
1551
1552/*
1553 * p1 and p2 should be directories on the same fs.
1554 */
1555struct dentry *lock_rename(struct dentry *p1, struct dentry *p2)
1556{
1557        struct dentry *p;
1558
1559        if (p1 == p2) {
1560                mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
1561                return NULL;
1562        }
1563
1564        mutex_lock(&p1->d_inode->i_sb->s_vfs_rename_mutex);
1565
1566        for (p = p1; p->d_parent != p; p = p->d_parent) {
1567                if (p->d_parent == p2) {
1568                        mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_PARENT);
1569                        mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_CHILD);
1570                        return p;
1571                }
1572        }
1573
1574        for (p = p2; p->d_parent != p; p = p->d_parent) {
1575                if (p->d_parent == p1) {
1576                        mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
1577                        mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_CHILD);
1578                        return p;
1579                }
1580        }
1581
1582        mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT);
1583        mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_CHILD);
1584        return NULL;
1585}
1586
1587void unlock_rename(struct dentry *p1, struct dentry *p2)
1588{
1589        mutex_unlock(&p1->d_inode->i_mutex);
1590        if (p1 != p2) {
1591                mutex_unlock(&p2->d_inode->i_mutex);
1592                mutex_unlock(&p1->d_inode->i_sb->s_vfs_rename_mutex);
1593        }
1594}
1595
1596int vfs_create(struct inode *dir, struct dentry *dentry, int mode,
1597                struct nameidata *nd)
1598{
1599        int error = may_create(dir, dentry, nd);
1600
1601        if (error)
1602                return error;
1603
1604        if (!dir->i_op || !dir->i_op->create)
1605                return -EACCES; /* shouldn't it be ENOSYS? */
1606        mode &= S_IALLUGO;
1607        mode |= S_IFREG;
1608        error = security_inode_create(dir, dentry, mode);
1609        if (error)
1610                return error;
1611        DQUOT_INIT(dir);
1612        error = dir->i_op->create(dir, dentry, mode, nd);
1613        if (!error)
1614                fsnotify_create(dir, dentry);
1615        return error;
1616}
1617
1618int may_open(struct nameidata *nd, int acc_mode, int flag)
1619{
1620        struct dentry *dentry = nd->path.dentry;
1621        struct inode *inode = dentry->d_inode;
1622        int error;
1623
1624        if (!inode)
1625                return -ENOENT;
1626
1627        if (S_ISLNK(inode->i_mode))
1628                return -ELOOP;
1629        
1630        if (S_ISDIR(inode->i_mode) && (acc_mode & MAY_WRITE))
1631                return -EISDIR;
1632
1633        /*
1634         * FIFO's, sockets and device files are special: they don't
1635         * actually live on the filesystem itself, and as such you
1636         * can write to them even if the filesystem is read-only.
1637         */
1638        if (S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
1639                flag &= ~O_TRUNC;
1640        } else if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) {
1641                if (nd->path.mnt->mnt_flags & MNT_NODEV)
1642                        return -EACCES;
1643
1644                flag &= ~O_TRUNC;
1645        }
1646
1647        error = vfs_permission(nd, acc_mode);
1648        if (error)
1649                return error;
1650        /*
1651         * An append-only file must be opened in append mode for writing.
1652         */
1653        if (IS_APPEND(inode)) {
1654                if  ((flag & FMODE_WRITE) && !(flag & O_APPEND))
1655                        return -EPERM;
1656                if (flag & O_TRUNC)
1657                        return -EPERM;
1658        }
1659
1660        /* O_NOATIME can only be set by the owner or superuser */
1661        if (flag & O_NOATIME)
1662                if (!is_owner_or_cap(inode))
1663                        return -EPERM;
1664
1665        /*
1666         * Ensure there are no outstanding leases on the file.
1667         */
1668        error = break_lease(inode, flag);
1669        if (error)
1670                return error;
1671
1672        if (flag & O_TRUNC) {
1673                error = get_write_access(inode);
1674                if (error)
1675                        return error;
1676
1677                /*
1678                 * Refuse to truncate files with mandatory locks held on them.
1679                 */
1680                error = locks_verify_locked(inode);
1681                if (!error) {
1682                        DQUOT_INIT(inode);
1683
1684                        error = do_truncate(dentry, 0,
1685                                            ATTR_MTIME|ATTR_CTIME|ATTR_OPEN,
1686                                            NULL);
1687                }
1688                put_write_access(inode);
1689                if (error)
1690                        return error;
1691        } else
1692                if (flag & FMODE_WRITE)
1693                        DQUOT_INIT(inode);
1694
1695        return 0;
1696}
1697
1698/*
1699 * Be careful about ever adding any more callers of this
1700 * function.  Its flags must be in the namei format, not
1701 * what get passed to sys_open().
1702 */
1703static int __open_namei_create(struct nameidata *nd, struct path *path,
1704                                int flag, int mode)
1705{
1706        int error;
1707        struct dentry *dir = nd->path.dentry;
1708
1709        if (!IS_POSIXACL(dir->d_inode))
1710                mode &= ~current->fs->umask;
1711        error = vfs_create(dir->d_inode, path->dentry, mode, nd);
1712        mutex_unlock(&dir->d_inode->i_mutex);
1713        dput(nd->path.dentry);
1714        nd->path.dentry = path->dentry;
1715        if (error)
1716                return error;
1717        /* Don't check for write permission, don't truncate */
1718        return may_open(nd, 0, flag & ~O_TRUNC);
1719}
1720
1721/*
1722 * Note that while the flag value (low two bits) for sys_open means:
1723 *      00 - read-only
1724 *      01 - write-only
1725 *      10 - read-write
1726 *      11 - special
1727 * it is changed into
1728 *      00 - no permissions needed
1729 *      01 - read-permission
1730 *      10 - write-permission
1731 *      11 - read-write
1732 * for the internal routines (ie open_namei()/follow_link() etc)
1733 * This is more logical, and also allows the 00 "no perm needed"
1734 * to be used for symlinks (where the permissions are checked
1735 * later).
1736 *
1737*/
1738static inline int open_to_namei_flags(int flag)
1739{
1740        if ((flag+1) & O_ACCMODE)
1741                flag++;
1742        return flag;
1743}
1744
1745static int open_will_write_to_fs(int flag, struct inode *inode)
1746{
1747        /*
1748         * We'll never write to the fs underlying
1749         * a device file.
1750         */
1751        if (special_file(inode->i_mode))
1752                return 0;
1753        return (flag & O_TRUNC);
1754}
1755
1756/*
1757 * Note that the low bits of the passed in "open_flag"
1758 * are not the same as in the local variable "flag". See
1759 * open_to_namei_flags() for more details.
1760 */
1761struct file *do_filp_open(int dfd, const char *pathname,
1762                int open_flag, int mode)
1763{
1764        struct file *filp;
1765        struct nameidata nd;
1766        int acc_mode, error;
1767        struct path path;
1768        struct dentry *dir;
1769        int count = 0;
1770        int will_write;
1771        int flag = open_to_namei_flags(open_flag);
1772
1773        acc_mode = ACC_MODE(flag);
1774
1775        /* O_TRUNC implies we need access checks for write permissions */
1776        if (flag & O_TRUNC)
1777                acc_mode |= MAY_WRITE;
1778
1779        /* Allow the LSM permission hook to distinguish append 
1780           access from general write access. */
1781        if (flag & O_APPEND)
1782                acc_mode |= MAY_APPEND;
1783
1784        /*
1785         * The simplest case - just a plain lookup.
1786         */
1787        if (!(flag & O_CREAT)) {
1788                error = path_lookup_open(dfd, pathname, lookup_flags(flag),
1789                                         &nd, flag);
1790                if (error)
1791                        return ERR_PTR(error);
1792                goto ok;
1793        }
1794
1795        /*
1796         * Create - we need to know the parent.
1797         */
1798        error = path_lookup_create(dfd, pathname, LOOKUP_PARENT,
1799                                   &nd, flag, mode);
1800        if (error)
1801                return ERR_PTR(error);
1802
1803        /*
1804         * We have the parent and last component. First of all, check
1805         * that we are not asked to creat(2) an obvious directory - that
1806         * will not do.
1807         */
1808        error = -EISDIR;
1809        if (nd.last_type != LAST_NORM || nd.last.name[nd.last.len])
1810                goto exit;
1811
1812        dir = nd.path.dentry;
1813        nd.flags &= ~LOOKUP_PARENT;
1814        mutex_lock(&dir->d_inode->i_mutex);
1815        path.dentry = lookup_hash(&nd);
1816        path.mnt = nd.path.mnt;
1817
1818do_last:
1819        error = PTR_ERR(path.dentry);
1820        if (IS_ERR(path.dentry)) {
1821                mutex_unlock(&dir->d_inode->i_mutex);
1822                goto exit;
1823        }
1824
1825        if (IS_ERR(nd.intent.open.file)) {
1826                error = PTR_ERR(nd.intent.open.file);
1827                goto exit_mutex_unlock;
1828        }
1829
1830        /* Negative dentry, just create the file */
1831        if (!path.dentry->d_inode) {
1832                /*
1833                 * This write is needed to ensure that a
1834                 * ro->rw transition does not occur between
1835                 * the time when the file is created and when
1836                 * a permanent write count is taken through
1837                 * the 'struct file' in nameidata_to_filp().
1838                 */
1839                error = mnt_want_write(nd.path.mnt);
1840                if (error)
1841                        goto exit_mutex_unlock;
1842                error = __open_namei_create(&nd, &path, flag, mode);
1843                if (error) {
1844                        mnt_drop_write(nd.path.mnt);
1845                        goto exit;
1846                }
1847                filp = nameidata_to_filp(&nd, open_flag);
1848                mnt_drop_write(nd.path.mnt);
1849                return filp;
1850        }
1851
1852        /*
1853         * It already exists.
1854         */
1855        mutex_unlock(&dir->d_inode->i_mutex);
1856        audit_inode(pathname, path.dentry);
1857
1858        error = -EEXIST;
1859        if (flag & O_EXCL)
1860                goto exit_dput;
1861
1862        if (__follow_mount(&path)) {
1863                error = -ELOOP;
1864                if (flag & O_NOFOLLOW)
1865                        goto exit_dput;
1866        }
1867
1868        error = -ENOENT;
1869        if (!path.dentry->d_inode)
1870                goto exit_dput;
1871        if (path.dentry->d_inode->i_op && path.dentry->d_inode->i_op->follow_link)
1872                goto do_link;
1873
1874        path_to_nameidata(&path, &nd);
1875        error = -EISDIR;
1876        if (path.dentry->d_inode && S_ISDIR(path.dentry->d_inode->i_mode))
1877                goto exit;
1878ok:
1879        /*
1880         * Consider:
1881         * 1. may_open() truncates a file
1882         * 2. a rw->ro mount transition occurs
1883         * 3. nameidata_to_filp() fails due to
1884         *    the ro mount.
1885         * That would be inconsistent, and should
1886         * be avoided. Taking this mnt write here
1887         * ensures that (2) can not occur.
1888         */
1889        will_write = open_will_write_to_fs(flag, nd.path.dentry->d_inode);
1890        if (will_write) {
1891                error = mnt_want_write(nd.path.mnt);
1892                if (error)
1893                        goto exit;
1894        }
1895        error = may_open(&nd, acc_mode, flag);
1896        if (error) {
1897                if (will_write)
1898                        mnt_drop_write(nd.path.mnt);
1899                goto exit;
1900        }
1901        filp = nameidata_to_filp(&nd, open_flag);
1902        /*
1903         * It is now safe to drop the mnt write
1904         * because the filp has had a write taken
1905         * on its behalf.
1906         */
1907        if (will_write)
1908                mnt_drop_write(nd.path.mnt);
1909        return filp;
1910
1911exit_mutex_unlock:
1912        mutex_unlock(&dir->d_inode->i_mutex);
1913exit_dput:
1914        path_put_conditional(&path, &nd);
1915exit:
1916        if (!IS_ERR(nd.intent.open.file))
1917                release_open_intent(&nd);
1918        path_put(&nd.path);
1919        return ERR_PTR(error);
1920
1921do_link:
1922        error = -ELOOP;
1923        if (flag & O_NOFOLLOW)
1924                goto exit_dput;
1925        /*
1926         * This is subtle. Instead of calling do_follow_link() we do the
1927         * thing by hands. The reason is that this way we have zero link_count
1928         * and path_walk() (called from ->follow_link) honoring LOOKUP_PARENT.
1929         * After that we have the parent and last component, i.e.
1930         * we are in the same situation as after the first path_walk().
1931         * Well, almost - if the last component is normal we get its copy
1932         * stored in nd->last.name and we will have to putname() it when we
1933         * are done. Procfs-like symlinks just set LAST_BIND.
1934         */
1935        nd.flags |= LOOKUP_PARENT;
1936        error = security_inode_follow_link(path.dentry, &nd);
1937        if (error)
1938                goto exit_dput;
1939        error = __do_follow_link(&path, &nd);
1940        if (error) {
1941                /* Does someone understand code flow here? Or it is only
1942                 * me so stupid? Anathema to whoever designed this non-sense
1943                 * with "intent.open".
1944                 */
1945                release_open_intent(&nd);
1946                return ERR_PTR(error);
1947        }
1948        nd.flags &= ~LOOKUP_PARENT;
1949        if (nd.last_type == LAST_BIND)
1950                goto ok;
1951        error = -EISDIR;
1952        if (nd.last_type != LAST_NORM)
1953                goto exit;
1954        if (nd.last.name[nd.last.len]) {
1955                __putname(nd.last.name);
1956                goto exit;
1957        }
1958        error = -ELOOP;
1959        if (count++==32) {
1960                __putname(nd.last.name);
1961                goto exit;
1962        }
1963        dir = nd.path.dentry;
1964        mutex_lock(&dir->d_inode->i_mutex);
1965        path.dentry = lookup_hash(&nd);
1966        path.mnt = nd.path.mnt;
1967        __putname(nd.last.name);
1968        goto do_last;
1969}
1970
1971/**
1972 * filp_open - open file and return file pointer
1973 *
1974 * @filename:   path to open
1975 * @flags:      open flags as per the open(2) second argument
1976 * @mode:       mode for the new file if O_CREAT is set, else ignored
1977 *
1978 * This is the helper to open a file from kernelspace if you really
1979 * have to.  But in generally you should not do this, so please move
1980 * along, nothing to see here..
1981 */
1982struct file *filp_open(const char *filename, int flags, int mode)
1983{
1984        return do_filp_open(AT_FDCWD, filename, flags, mode);
1985}
1986EXPORT_SYMBOL(filp_open);
1987
1988/**
1989 * lookup_create - lookup a dentry, creating it if it doesn't exist
1990 * @nd: nameidata info
1991 * @is_dir: directory flag
1992 *
1993 * Simple function to lookup and return a dentry and create it
1994 * if it doesn't exist.  Is SMP-safe.
1995 *
1996 * Returns with nd->path.dentry->d_inode->i_mutex locked.
1997 */
1998struct dentry *lookup_create(struct nameidata *nd, int is_dir)
1999{
2000        struct dentry *dentry = ERR_PTR(-EEXIST);
2001
2002        mutex_lock_nested(&nd->path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
2003        /*
2004         * Yucky last component or no last component at all?
2005         * (foo/., foo/.., /////)
2006         */
2007        if (nd->last_type != LAST_NORM)
2008                goto fail;
2009        nd->flags &= ~LOOKUP_PARENT;
2010        nd->flags |= LOOKUP_CREATE;
2011        nd->intent.open.flags = O_EXCL;
2012
2013        /*
2014         * Do the final lookup.
2015         */
2016        dentry = lookup_hash(nd);
2017        if (IS_ERR(dentry))
2018                goto fail;
2019
2020        if (dentry->d_inode)
2021                goto eexist;
2022        /*
2023         * Special case - lookup gave negative, but... we had foo/bar/
2024         * From the vfs_mknod() POV we just have a negative dentry -
2025         * all is fine. Let's be bastards - you had / on the end, you've
2026         * been asking for (non-existent) directory. -ENOENT for you.
2027         */
2028        if (unlikely(!is_dir && nd->last.name[nd->last.len])) {
2029                dput(dentry);
2030                dentry = ERR_PTR(-ENOENT);
2031        }
2032        return dentry;
2033eexist:
2034        dput(dentry);
2035        dentry = ERR_PTR(-EEXIST);
2036fail:
2037        return dentry;
2038}
2039EXPORT_SYMBOL_GPL(lookup_create);
2040
2041int vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
2042{
2043        int error = may_create(dir, dentry, NULL);
2044
2045        if (error)
2046                return error;
2047
2048        if ((S_ISCHR(mode) || S_ISBLK(mode)) && !capable(CAP_MKNOD))
2049                return -EPERM;
2050
2051        if (!dir->i_op || !dir->i_op->mknod)
2052                return -EPERM;
2053
2054        error = devcgroup_inode_mknod(mode, dev);
2055        if (error)
2056                return error;
2057
2058        error = security_inode_mknod(dir, dentry, mode, dev);
2059        if (error)
2060                return error;
2061
2062        DQUOT_INIT(dir);
2063        error = dir->i_op->mknod(dir, dentry, mode, dev);
2064        if (!error)
2065                fsnotify_create(dir, dentry);
2066        return error;
2067}
2068
2069static int may_mknod(mode_t mode)
2070{
2071        switch (mode & S_IFMT) {
2072        case S_IFREG:
2073        case S_IFCHR:
2074        case S_IFBLK:
2075        case S_IFIFO:
2076        case S_IFSOCK:
2077        case 0: /* zero mode translates to S_IFREG */
2078                return 0;
2079        case S_IFDIR:
2080                return -EPERM;
2081        default:
2082                return -EINVAL;
2083        }
2084}
2085
2086asmlinkage long sys_mknodat(int dfd, const char __user *filename, int mode,
2087                                unsigned dev)
2088{
2089        int error = 0;
2090        char * tmp;
2091        struct dentry * dentry;
2092        struct nameidata nd;
2093
2094        if (S_ISDIR(mode))
2095                return -EPERM;
2096        tmp = getname(filename);
2097        if (IS_ERR(tmp))
2098                return PTR_ERR(tmp);
2099
2100        error = do_path_lookup(dfd, tmp, LOOKUP_PARENT, &nd);
2101        if (error)
2102                goto out;
2103        dentry = lookup_create(&nd, 0);
2104        if (IS_ERR(dentry)) {
2105                error = PTR_ERR(dentry);
2106                goto out_unlock;
2107        }
2108        if (!IS_POSIXACL(nd.path.dentry->d_inode))
2109                mode &= ~current->fs->umask;
2110        error = may_mknod(mode);
2111        if (error)
2112                goto out_dput;
2113        error = mnt_want_write(nd.path.mnt);
2114        if (error)
2115                goto out_dput;
2116        switch (mode & S_IFMT) {
2117                case 0: case S_IFREG:
2118                        error = vfs_create(nd.path.dentry->d_inode,dentry,mode,&nd);
2119                        break;
2120                case S_IFCHR: case S_IFBLK:
2121                        error = vfs_mknod(nd.path.dentry->d_inode,dentry,mode,
2122                                        new_decode_dev(dev));
2123                        break;
2124                case S_IFIFO: case S_IFSOCK:
2125                        error = vfs_mknod(nd.path.dentry->d_inode,dentry,mode,0);
2126                        break;
2127        }
2128        mnt_drop_write(nd.path.mnt);
2129out_dput:
2130        dput(dentry);
2131out_unlock:
2132        mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2133        path_put(&nd.path);
2134out:
2135        putname(tmp);
2136
2137        return error;
2138}
2139
2140asmlinkage long sys_mknod(const char __user *filename, int mode, unsigned dev)
2141{
2142        return sys_mknodat(AT_FDCWD, filename, mode, dev);
2143}
2144
2145int vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
2146{
2147        int error = may_create(dir, dentry, NULL);
2148
2149        if (error)
2150                return error;
2151
2152        if (!dir->i_op || !dir->i_op->mkdir)
2153                return -EPERM;
2154
2155        mode &= (S_IRWXUGO|S_ISVTX);
2156        error = security_inode_mkdir(dir, dentry, mode);
2157        if (error)
2158                return error;
2159
2160        DQUOT_INIT(dir);
2161        error = dir->i_op->mkdir(dir, dentry, mode);
2162        if (!error)
2163                fsnotify_mkdir(dir, dentry);
2164        return error;
2165}
2166
2167asmlinkage long sys_mkdirat(int dfd, const char __user *pathname, int mode)
2168{
2169        int error = 0;
2170        char * tmp;
2171        struct dentry *dentry;
2172        struct nameidata nd;
2173
2174        tmp = getname(pathname);
2175        error = PTR_ERR(tmp);
2176        if (IS_ERR(tmp))
2177                goto out_err;
2178
2179        error = do_path_lookup(dfd, tmp, LOOKUP_PARENT, &nd);
2180        if (error)
2181                goto out;
2182        dentry = lookup_create(&nd, 1);
2183        error = PTR_ERR(dentry);
2184        if (IS_ERR(dentry))
2185                goto out_unlock;
2186
2187        if (!IS_POSIXACL(nd.path.dentry->d_inode))
2188                mode &= ~current->fs->umask;
2189        error = mnt_want_write(nd.path.mnt);
2190        if (error)
2191                goto out_dput;
2192        error = vfs_mkdir(nd.path.dentry->d_inode, dentry, mode);
2193        mnt_drop_write(nd.path.mnt);
2194out_dput:
2195        dput(dentry);
2196out_unlock:
2197        mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2198        path_put(&nd.path);
2199out:
2200        putname(tmp);
2201out_err:
2202        return error;
2203}
2204
2205asmlinkage long sys_mkdir(const char __user *pathname, int mode)
2206{
2207        return sys_mkdirat(AT_FDCWD, pathname, mode);
2208}
2209
2210/*
2211 * We try to drop the dentry early: we should have
2212 * a usage count of 2 if we're the only user of this
2213 * dentry, and if that is true (possibly after pruning
2214 * the dcache), then we drop the dentry now.
2215 *
2216 * A low-level filesystem can, if it choses, legally
2217 * do a
2218 *
2219 *      if (!d_unhashed(dentry))
2220 *              return -EBUSY;
2221 *
2222 * if it cannot handle the case of removing a directory
2223 * that is still in use by something else..
2224 */
2225void dentry_unhash(struct dentry *dentry)
2226{
2227        dget(dentry);
2228        shrink_dcache_parent(dentry);
2229        spin_lock(&dcache_lock);
2230        spin_lock(&dentry->d_lock);
2231        if (atomic_read(&dentry->d_count) == 2)
2232                __d_drop(dentry);
2233        spin_unlock(&dentry->d_lock);
2234        spin_unlock(&dcache_lock);
2235}
2236
2237int vfs_rmdir(struct inode *dir, struct dentry *dentry)
2238{
2239        int error = may_delete(dir, dentry, 1);
2240
2241        if (error)
2242                return error;
2243
2244        if (!dir->i_op || !dir->i_op->rmdir)
2245                return -EPERM;
2246
2247        DQUOT_INIT(dir);
2248
2249        mutex_lock(&dentry->d_inode->i_mutex);
2250        dentry_unhash(dentry);
2251        if (d_mountpoint(dentry))
2252                error = -EBUSY;
2253        else {
2254                error = security_inode_rmdir(dir, dentry);
2255                if (!error) {
2256                        error = dir->i_op->rmdir(dir, dentry);
2257                        if (!error)
2258                                dentry->d_inode->i_flags |= S_DEAD;
2259                }
2260        }
2261        mutex_unlock(&dentry->d_inode->i_mutex);
2262        if (!error) {
2263                d_delete(dentry);
2264        }
2265        dput(dentry);
2266
2267        return error;
2268}
2269
2270static long do_rmdir(int dfd, const char __user *pathname)
2271{
2272        int error = 0;
2273        char * name;
2274        struct dentry *dentry;
2275        struct nameidata nd;
2276
2277        name = getname(pathname);
2278        if(IS_ERR(name))
2279                return PTR_ERR(name);
2280
2281        error = do_path_lookup(dfd, name, LOOKUP_PARENT, &nd);
2282        if (error)
2283                goto exit;
2284
2285        switch(nd.last_type) {
2286                case LAST_DOTDOT:
2287                        error = -ENOTEMPTY;
2288                        goto exit1;
2289                case LAST_DOT:
2290                        error = -EINVAL;
2291                        goto exit1;
2292                case LAST_ROOT:
2293                        error = -EBUSY;
2294                        goto exit1;
2295        }
2296        mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
2297        dentry = lookup_hash(&nd);
2298        error = PTR_ERR(dentry);
2299        if (IS_ERR(dentry))
2300                goto exit2;
2301        error = mnt_want_write(nd.path.mnt);
2302        if (error)
2303                goto exit3;
2304        error = vfs_rmdir(nd.path.dentry->d_inode, dentry);
2305        mnt_drop_write(nd.path.mnt);
2306exit3:
2307        dput(dentry);
2308exit2:
2309        mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2310exit1:
2311        path_put(&nd.path);
2312exit:
2313        putname(name);
2314        return error;
2315}
2316
2317asmlinkage long sys_rmdir(const char __user *pathname)
2318{
2319        return do_rmdir(AT_FDCWD, pathname);
2320}
2321
2322int vfs_unlink(struct inode *dir, struct dentry *dentry)
2323{
2324        int error = may_delete(dir, dentry, 0);
2325
2326        if (error)
2327                return error;
2328
2329        if (!dir->i_op || !dir->i_op->unlink)
2330                return -EPERM;
2331
2332        DQUOT_INIT(dir);
2333
2334        mutex_lock(&dentry->d_inode->i_mutex);
2335        if (d_mountpoint(dentry))
2336                error = -EBUSY;
2337        else {
2338                error = security_inode_unlink(dir, dentry);
2339                if (!error)
2340                        error = dir->i_op->unlink(dir, dentry);
2341        }
2342        mutex_unlock(&dentry->d_inode->i_mutex);
2343
2344        /* We don't d_delete() NFS sillyrenamed files--they still exist. */
2345        if (!error && !(dentry->d_flags & DCACHE_NFSFS_RENAMED)) {
2346                fsnotify_link_count(dentry->d_inode);
2347                d_delete(dentry);
2348        }
2349
2350        return error;
2351}
2352
2353/*
2354 * Make sure that the actual truncation of the file will occur outside its
2355 * directory's i_mutex.  Truncate can take a long time if there is a lot of
2356 * writeout happening, and we don't want to prevent access to the directory
2357 * while waiting on the I/O.
2358 */
2359static long do_unlinkat(int dfd, const char __user *pathname)
2360{
2361        int error = 0;
2362        char * name;
2363        struct dentry *dentry;
2364        struct nameidata nd;
2365        struct inode *inode = NULL;
2366
2367        name = getname(pathname);
2368        if(IS_ERR(name))
2369                return PTR_ERR(name);
2370
2371        error = do_path_lookup(dfd, name, LOOKUP_PARENT, &nd);
2372        if (error)
2373                goto exit;
2374        error = -EISDIR;
2375        if (nd.last_type != LAST_NORM)
2376                goto exit1;
2377        mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
2378        dentry = lookup_hash(&nd);
2379        error = PTR_ERR(dentry);
2380        if (!IS_ERR(dentry)) {
2381                /* Why not before? Because we want correct error value */
2382                if (nd.last.name[nd.last.len])
2383                        goto slashes;
2384                inode = dentry->d_inode;
2385                if (inode)
2386                        atomic_inc(&inode->i_count);
2387                error = mnt_want_write(nd.path.mnt);
2388                if (error)
2389                        goto exit2;
2390                error = vfs_unlink(nd.path.dentry->d_inode, dentry);
2391                mnt_drop_write(nd.path.mnt);
2392        exit2:
2393                dput(dentry);
2394        }
2395        mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2396        if (inode)
2397                iput(inode);    /* truncate the inode here */
2398exit1:
2399        path_put(&nd.path);
2400exit:
2401        putname(name);
2402        return error;
2403
2404slashes:
2405        error = !dentry->d_inode ? -ENOENT :
2406                S_ISDIR(dentry->d_inode->i_mode) ? -EISDIR : -ENOTDIR;
2407        goto exit2;
2408}
2409
2410asmlinkage long sys_unlinkat(int dfd, const char __user *pathname, int flag)
2411{
2412        if ((flag & ~AT_REMOVEDIR) != 0)
2413                return -EINVAL;
2414
2415        if (flag & AT_REMOVEDIR)
2416                return do_rmdir(dfd, pathname);
2417
2418        return do_unlinkat(dfd, pathname);
2419}
2420
2421asmlinkage long sys_unlink(const char __user *pathname)
2422{
2423        return do_unlinkat(AT_FDCWD, pathname);
2424}
2425
2426int vfs_symlink(struct inode *dir, struct dentry *dentry, const char *oldname, int mode)
2427{
2428        int error = may_create(dir, dentry, NULL);
2429
2430        if (error)
2431                return error;
2432
2433        if (!dir->i_op || !dir->i_op->symlink)
2434                return -EPERM;
2435
2436        error = security_inode_symlink(dir, dentry, oldname);
2437        if (error)
2438                return error;
2439
2440        DQUOT_INIT(dir);
2441        error = dir->i_op->symlink(dir, dentry, oldname);
2442        if (!error)
2443                fsnotify_create(dir, dentry);
2444        return error;
2445}
2446
2447asmlinkage long sys_symlinkat(const char __user *oldname,
2448                              int newdfd, const char __user *newname)
2449{
2450        int error = 0;
2451        char * from;
2452        char * to;
2453        struct dentry *dentry;
2454        struct nameidata nd;
2455
2456        from = getname(oldname);
2457        if(IS_ERR(from))
2458                return PTR_ERR(from);
2459        to = getname(newname);
2460        error = PTR_ERR(to);
2461        if (IS_ERR(to))
2462                goto out_putname;
2463
2464        error = do_path_lookup(newdfd, to, LOOKUP_PARENT, &nd);
2465        if (error)
2466                goto out;
2467        dentry = lookup_create(&nd, 0);
2468        error = PTR_ERR(dentry);
2469        if (IS_ERR(dentry))
2470                goto out_unlock;
2471
2472        error = mnt_want_write(nd.path.mnt);
2473        if (error)
2474                goto out_dput;
2475        error = vfs_symlink(nd.path.dentry->d_inode, dentry, from, S_IALLUGO);
2476        mnt_drop_write(nd.path.mnt);
2477out_dput:
2478        dput(dentry);
2479out_unlock:
2480        mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2481        path_put(&nd.path);
2482out:
2483        putname(to);
2484out_putname:
2485        putname(from);
2486        return error;
2487}
2488
2489asmlinkage long sys_symlink(const char __user *oldname, const char __user *newname)
2490{
2491        return sys_symlinkat(oldname, AT_FDCWD, newname);
2492}
2493
2494int vfs_link(struct dentry *old_dentry, struct inode *dir, struct dentry *new_dentry)
2495{
2496        struct inode *inode = old_dentry->d_inode;
2497        int error;
2498
2499        if (!inode)
2500                return -ENOENT;
2501
2502        error = may_create(dir, new_dentry, NULL);
2503        if (error)
2504                return error;
2505
2506        if (dir->i_sb != inode->i_sb)
2507                return -EXDEV;
2508
2509        /*
2510         * A link to an append-only or immutable file cannot be created.
2511         */
2512        if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
2513                return -EPERM;
2514        if (!dir->i_op || !dir->i_op->link)
2515                return -EPERM;
2516        if (S_ISDIR(old_dentry->d_inode->i_mode))
2517                return -EPERM;
2518
2519        error = security_inode_link(old_dentry, dir, new_dentry);
2520        if (error)
2521                return error;
2522
2523        mutex_lock(&old_dentry->d_inode->i_mutex);
2524        DQUOT_INIT(dir);
2525        error = dir->i_op->link(old_dentry, dir, new_dentry);
2526        mutex_unlock(&old_dentry->d_inode->i_mutex);
2527        if (!error)
2528                fsnotify_link(dir, old_dentry->d_inode, new_dentry);
2529        return error;
2530}
2531
2532/*
2533 * Hardlinks are often used in delicate situations.  We avoid
2534 * security-related surprises by not following symlinks on the
2535 * newname.  --KAB
2536 *
2537 * We don't follow them on the oldname either to be compatible
2538 * with linux 2.0, and to avoid hard-linking to directories
2539 * and other special files.  --ADM
2540 */
2541asmlinkage long sys_linkat(int olddfd, const char __user *oldname,
2542                           int newdfd, const char __user *newname,
2543                           int flags)
2544{
2545        struct dentry *new_dentry;
2546        struct nameidata nd, old_nd;
2547        int error;
2548        char * to;
2549
2550        if ((flags & ~AT_SYMLINK_FOLLOW) != 0)
2551                return -EINVAL;
2552
2553        to = getname(newname);
2554        if (IS_ERR(to))
2555                return PTR_ERR(to);
2556
2557        error = __user_walk_fd(olddfd, oldname,
2558                               flags & AT_SYMLINK_FOLLOW ? LOOKUP_FOLLOW : 0,
2559                               &old_nd);
2560        if (error)
2561                goto exit;
2562        error = do_path_lookup(newdfd, to, LOOKUP_PARENT, &nd);
2563        if (error)
2564                goto out;
2565        error = -EXDEV;
2566        if (old_nd.path.mnt != nd.path.mnt)
2567                goto out_release;
2568        new_dentry = lookup_create(&nd, 0);
2569        error = PTR_ERR(new_dentry);
2570        if (IS_ERR(new_dentry))
2571                goto out_unlock;
2572        error = mnt_want_write(nd.path.mnt);
2573        if (error)
2574                goto out_dput;
2575        error = vfs_link(old_nd.path.dentry, nd.path.dentry->d_inode, new_dentry);
2576        mnt_drop_write(nd.path.mnt);
2577out_dput:
2578        dput(new_dentry);
2579out_unlock:
2580        mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
2581out_release:
2582        path_put(&nd.path);
2583out:
2584        path_put(&old_nd.path);
2585exit:
2586        putname(to);
2587
2588        return error;
2589}
2590
2591asmlinkage long sys_link(const char __user *oldname, const char __user *newname)
2592{
2593        return sys_linkat(AT_FDCWD, oldname, AT_FDCWD, newname, 0);
2594}
2595
2596/*
2597 * The worst of all namespace operations - renaming directory. "Perverted"
2598 * doesn't even start to describe it. Somebody in UCB had a heck of a trip...
2599 * Problems:
2600 *      a) we can get into loop creation. Check is done in is_subdir().
2601 *      b) race potential - two innocent renames can create a loop together.
2602 *         That's where 4.4 screws up. Current fix: serialization on
2603 *         sb->s_vfs_rename_mutex. We might be more accurate, but that's another
2604 *         story.
2605 *      c) we have to lock _three_ objects - parents and victim (if it exists).
2606 *         And that - after we got ->i_mutex on parents (until then we don't know
2607 *         whether the target exists).  Solution: try to be smart with locking
2608 *         order for inodes.  We rely on the fact that tree topology may change
2609 *         only under ->s_vfs_rename_mutex _and_ that parent of the object we
2610 *         move will be locked.  Thus we can rank directories by the tree
2611 *         (ancestors first) and rank all non-directories after them.
2612 *         That works since everybody except rename does "lock parent, lookup,
2613 *         lock child" and rename is under ->s_vfs_rename_mutex.
2614 *         HOWEVER, it relies on the assumption that any object with ->lookup()
2615 *         has no more than 1 dentry.  If "hybrid" objects will ever appear,
2616 *         we'd better make sure that there's no link(2) for them.
2617 *      d) some filesystems don't support opened-but-unlinked directories,
2618 *         either because of layout or because they are not ready to deal with
2619 *         all cases correctly. The latter will be fixed (taking this sort of
2620 *         stuff into VFS), but the former is not going away. Solution: the same
2621 *         trick as in rmdir().
2622 *      e) conversion from fhandle to dentry may come in the wrong moment - when
2623 *         we are removing the target. Solution: we will have to grab ->i_mutex
2624 *         in the fhandle_to_dentry code. [FIXME - current nfsfh.c relies on
2625 *         ->i_mutex on parents, which works but leads to some truely excessive
2626 *         locking].
2627 */
2628static int vfs_rename_dir(struct inode *old_dir, struct dentry *old_dentry,
2629                          struct inode *new_dir, struct dentry *new_dentry)
2630{
2631        int error = 0;
2632        struct inode *target;
2633
2634        /*
2635         * If we are going to change the parent - check write permissions,
2636         * we'll need to flip '..'.
2637         */
2638        if (new_dir != old_dir) {
2639                error = permission(old_dentry->d_inode, MAY_WRITE, NULL);
2640                if (error)
2641                        return error;
2642        }
2643
2644        error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry);
2645        if (error)
2646                return error;
2647
2648        target = new_dentry->d_inode;
2649        if (target) {
2650                mutex_lock(&target->i_mutex);
2651                dentry_unhash(new_dentry);
2652        }
2653        if (d_mountpoint(old_dentry)||d_mountpoint(new_dentry))
2654                error = -EBUSY;
2655        else 
2656                error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry);
2657        if (target) {
2658                if (!error)
2659                        target->i_flags |= S_DEAD;
2660                mutex_unlock(&target->i_mutex);
2661                if (d_unhashed(new_dentry))
2662                        d_rehash(new_dentry);
2663                dput(new_dentry);
2664        }
2665        if (!error)
2666                if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE))
2667                        d_move(old_dentry,new_dentry);
2668        return error;
2669}
2670
2671static int vfs_rename_other(struct inode *old_dir, struct dentry *old_dentry,
2672                            struct inode *new_dir, struct dentry *new_dentry)
2673{
2674        struct inode *target;
2675        int error;
2676
2677        error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry);
2678        if (error)
2679                return error;
2680
2681        dget(new_dentry);
2682        target = new_dentry->d_inode;
2683        if (target)
2684                mutex_lock(&target->i_mutex);
2685        if (d_mountpoint(old_dentry)||d_mountpoint(new_dentry))
2686                error = -EBUSY;
2687        else
2688                error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry);
2689        if (!error) {
2690                if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE))
2691                        d_move(old_dentry, new_dentry);
2692        }
2693        if (target)
2694                mutex_unlock(&target->i_mutex);
2695        dput(new_dentry);
2696        return error;
2697}
2698
2699int vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
2700               struct inode *new_dir, struct dentry *new_dentry)
2701{
2702        int error;
2703        int is_dir = S_ISDIR(old_dentry->d_inode->i_mode);
2704        const char *old_name;
2705
2706        if (old_dentry->d_inode == new_dentry->d_inode)
2707                return 0;
2708 
2709        error = may_delete(old_dir, old_dentry, is_dir);
2710        if (error)
2711                return error;
2712
2713        if (!new_dentry->d_inode)
2714                error = may_create(new_dir, new_dentry, NULL);
2715        else
2716                error = may_delete(new_dir, new_dentry, is_dir);
2717        if (error)
2718                return error;
2719
2720        if (!old_dir->i_op || !old_dir->i_op->rename)
2721                return -EPERM;
2722
2723        DQUOT_INIT(old_dir);
2724        DQUOT_INIT(new_dir);
2725
2726        old_name = fsnotify_oldname_init(old_dentry->d_name.name);
2727
2728        if (is_dir)
2729                error = vfs_rename_dir(old_dir,old_dentry,new_dir,new_dentry);
2730        else
2731                error = vfs_rename_other(old_dir,old_dentry,new_dir,new_dentry);
2732        if (!error) {
2733                const char *new_name = old_dentry->d_name.name;
2734                fsnotify_move(old_dir, new_dir, old_name, new_name, is_dir,
2735                              new_dentry->d_inode, old_dentry);
2736        }
2737        fsnotify_oldname_free(old_name);
2738
2739        return error;
2740}
2741
2742static int do_rename(int olddfd, const char *oldname,
2743                        int newdfd, const char *newname)
2744{
2745        int error = 0;
2746        struct dentry * old_dir, * new_dir;
2747        struct dentry * old_dentry, *new_dentry;
2748        struct dentry * trap;
2749        struct nameidata oldnd, newnd;
2750
2751        error = do_path_lookup(olddfd, oldname, LOOKUP_PARENT, &oldnd);
2752        if (error)
2753                goto exit;
2754
2755        error = do_path_lookup(newdfd, newname, LOOKUP_PARENT, &newnd);
2756        if (error)
2757                goto exit1;
2758
2759        error = -EXDEV;
2760        if (oldnd.path.mnt != newnd.path.mnt)
2761                goto exit2;
2762
2763        old_dir = oldnd.path.dentry;
2764        error = -EBUSY;
2765        if (oldnd.last_type != LAST_NORM)
2766                goto exit2;
2767
2768        new_dir = newnd.path.dentry;
2769        if (newnd.last_type != LAST_NORM)
2770                goto exit2;
2771
2772        trap = lock_rename(new_dir, old_dir);
2773
2774        old_dentry = lookup_hash(&oldnd);
2775        error = PTR_ERR(old_dentry);
2776        if (IS_ERR(old_dentry))
2777                goto exit3;
2778        /* source must exist */
2779        error = -ENOENT;
2780        if (!old_dentry->d_inode)
2781                goto exit4;
2782        /* unless the source is a directory trailing slashes give -ENOTDIR */
2783        if (!S_ISDIR(old_dentry->d_inode->i_mode)) {
2784                error = -ENOTDIR;
2785                if (oldnd.last.name[oldnd.last.len])
2786                        goto exit4;
2787                if (newnd.last.name[newnd.last.len])
2788                        goto exit4;
2789        }
2790        /* source should not be ancestor of target */
2791        error = -EINVAL;
2792        if (old_dentry == trap)
2793                goto exit4;
2794        new_dentry = lookup_hash(&newnd);
2795        error = PTR_ERR(new_dentry);
2796        if (IS_ERR(new_dentry))
2797                goto exit4;
2798        /* target should not be an ancestor of source */
2799        error = -ENOTEMPTY;
2800        if (new_dentry == trap)
2801                goto exit5;
2802
2803        error = mnt_want_write(oldnd.path.mnt);
2804        if (error)
2805                goto exit5;
2806        error = vfs_rename(old_dir->d_inode, old_dentry,
2807                                   new_dir->d_inode, new_dentry);
2808        mnt_drop_write(oldnd.path.mnt);
2809exit5:
2810        dput(new_dentry);
2811exit4:
2812        dput(old_dentry);
2813exit3:
2814        unlock_rename(new_dir, old_dir);
2815exit2:
2816        path_put(&newnd.path);
2817exit1:
2818        path_put(&oldnd.path);
2819exit:
2820        return error;
2821}
2822
2823asmlinkage long sys_renameat(int olddfd, const char __user *oldname,
2824                             int newdfd, const char __user *newname)
2825{
2826        int error;
2827        char * from;
2828        char * to;
2829
2830        from = getname(oldname);
2831        if(IS_ERR(from))
2832                return PTR_ERR(from);
2833        to = getname(newname);
2834        error = PTR_ERR(to);
2835        if (!IS_ERR(to)) {
2836                error = do_rename(olddfd, from, newdfd, to);
2837                putname(to);
2838        }
2839        putname(from);
2840        return error;
2841}
2842
2843asmlinkage long sys_rename(const char __user *oldname, const char __user *newname)
2844{
2845        return sys_renameat(AT_FDCWD, oldname, AT_FDCWD, newname);
2846}
2847
2848int vfs_readlink(struct dentry *dentry, char __user *buffer, int buflen, const char *link)
2849{
2850        int len;
2851
2852        len = PTR_ERR(link);
2853        if (IS_ERR(link))
2854                goto out;
2855
2856        len = strlen(link);
2857        if (len > (unsigned) buflen)
2858                len = buflen;
2859        if (copy_to_user(buffer, link, len))
2860                len = -EFAULT;
2861out:
2862        return len;
2863}
2864
2865/*
2866 * A helper for ->readlink().  This should be used *ONLY* for symlinks that
2867 * have ->follow_link() touching nd only in nd_set_link().  Using (or not
2868 * using) it for any given inode is up to filesystem.
2869 */
2870int generic_readlink(struct dentry *dentry, char __user *buffer, int buflen)
2871{
2872        struct nameidata nd;
2873        void *cookie;
2874        int res;
2875
2876        nd.depth = 0;
2877        cookie = dentry->d_inode->i_op->follow_link(dentry, &nd);
2878        if (IS_ERR(cookie))
2879                return PTR_ERR(cookie);
2880
2881        res = vfs_readlink(dentry, buffer, buflen, nd_get_link(&nd));
2882        if (dentry->d_inode->i_op->put_link)
2883                dentry->d_inode->i_op->put_link(dentry, &nd, cookie);
2884        return res;
2885}
2886
2887int vfs_follow_link(struct nameidata *nd, const char *link)
2888{
2889        return __vfs_follow_link(nd, link);
2890}
2891
2892/* get the link contents into pagecache */
2893static char *page_getlink(struct dentry * dentry, struct page **ppage)
2894{
2895        struct page * page;
2896        struct address_space *mapping = dentry->d_inode->i_mapping;
2897        page = read_mapping_page(mapping, 0, NULL);
2898        if (IS_ERR(page))
2899                return (char*)page;
2900        *ppage = page;
2901        return kmap(page);
2902}
2903
2904int page_readlink(struct dentry *dentry, char __user *buffer, int buflen)
2905{
2906        struct page *page = NULL;
2907        char *s = page_getlink(dentry, &page);
2908        int res = vfs_readlink(dentry,buffer,buflen,s);
2909        if (page) {
2910                kunmap(page);
2911                page_cache_release(page);
2912        }
2913        return res;
2914}
2915
2916void *page_follow_link_light(struct dentry *dentry, struct nameidata *nd)
2917{
2918        struct page *page = NULL;
2919        nd_set_link(nd, page_getlink(dentry, &page));
2920        return page;
2921}
2922
2923void page_put_link(struct dentry *dentry, struct nameidata *nd, void *cookie)
2924{
2925        struct page *page = cookie;
2926
2927        if (page) {
2928                kunmap(page);
2929                page_cache_release(page);
2930        }
2931}
2932
2933int __page_symlink(struct inode *inode, const char *symname, int len,
2934                gfp_t gfp_mask)
2935{
2936        struct address_space *mapping = inode->i_mapping;
2937        struct page *page;
2938        void *fsdata;
2939        int err;
2940        char *kaddr;
2941
2942retry:
2943        err = pagecache_write_begin(NULL, mapping, 0, len-1,
2944                                AOP_FLAG_UNINTERRUPTIBLE, &page, &fsdata);
2945        if (err)
2946                goto fail;
2947
2948        kaddr = kmap_atomic(page, KM_USER0);
2949        memcpy(kaddr, symname, len-1);
2950        kunmap_atomic(kaddr, KM_USER0);
2951
2952        err = pagecache_write_end(NULL, mapping, 0, len-1, len-1,
2953                                                        page, fsdata);
2954        if (err < 0)
2955                goto fail;
2956        if (err < len-1)
2957                goto retry;
2958
2959        mark_inode_dirty(inode);
2960        return 0;
2961fail:
2962        return err;
2963}
2964
2965int page_symlink(struct inode *inode, const char *symname, int len)
2966{
2967        return __page_symlink(inode, symname, len,
2968                        mapping_gfp_mask(inode->i_mapping));
2969}
2970
2971const struct inode_operations page_symlink_inode_operations = {
2972        .readlink       = generic_readlink,
2973        .follow_link    = page_follow_link_light,
2974        .put_link       = page_put_link,
2975};
2976
2977EXPORT_SYMBOL(__user_walk);
2978EXPORT_SYMBOL(__user_walk_fd);
2979EXPORT_SYMBOL(follow_down);
2980EXPORT_SYMBOL(follow_up);
2981EXPORT_SYMBOL(get_write_access); /* binfmt_aout */
2982EXPORT_SYMBOL(getname);
2983EXPORT_SYMBOL(lock_rename);
2984EXPORT_SYMBOL(lookup_one_len);
2985EXPORT_SYMBOL(page_follow_link_light);
2986EXPORT_SYMBOL(page_put_link);
2987EXPORT_SYMBOL(page_readlink);
2988EXPORT_SYMBOL(__page_symlink);
2989EXPORT_SYMBOL(page_symlink);
2990EXPORT_SYMBOL(page_symlink_inode_operations);
2991EXPORT_SYMBOL(path_lookup);
2992EXPORT_SYMBOL(vfs_path_lookup);
2993EXPORT_SYMBOL(permission);
2994EXPORT_SYMBOL(vfs_permission);
2995EXPORT_SYMBOL(file_permission);
2996EXPORT_SYMBOL(unlock_rename);
2997EXPORT_SYMBOL(vfs_create);
2998EXPORT_SYMBOL(vfs_follow_link);
2999EXPORT_SYMBOL(vfs_link);
3000EXPORT_SYMBOL(vfs_mkdir);
3001EXPORT_SYMBOL(vfs_mknod);
3002EXPORT_SYMBOL(generic_permission);
3003EXPORT_SYMBOL(vfs_readlink);
3004EXPORT_SYMBOL(vfs_rename);
3005EXPORT_SYMBOL(vfs_rmdir);
3006EXPORT_SYMBOL(vfs_symlink);
3007EXPORT_SYMBOL(vfs_unlink);
3008EXPORT_SYMBOL(dentry_unhash);
3009EXPORT_SYMBOL(generic_readlink);
3010
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.