lustre/llite/dcache.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  * GPL HEADER START
   5  *
   6  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 only,
  10  * as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License version 2 for more details (a copy is included
  16  * in the LICENSE file that accompanied this code).
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * version 2 along with this program; If not, see
  20  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
  21  *
  22  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  23  * CA 95054 USA or visit www.sun.com if you need additional information or
  24  * have any questions.
  25  *
  26  * GPL HEADER END
  27  */
  28 /*
  29  * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
  30  * Use is subject to license terms.
  31  *
  32  * Copyright (c) 2011, Whamcloud, Inc.
  33  */
  34 /*
  35  * This file is part of Lustre, http://www.lustre.org/
  36  * Lustre is a trademark of Sun Microsystems, Inc.
  37  */
  38
  39 #include <linux/fs.h>
  40 #include <linux/sched.h>
  41 #include <linux/smp_lock.h>
  42 #include <linux/quotaops.h>
  43
  44 #define DEBUG_SUBSYSTEM S_LLITE
  45
  46 #include <obd_support.h>
  47 #include <lustre_lite.h>
  48 #include <lustre/lustre_idl.h>
  49 #include <lustre_dlm.h>
  50 //#include <lustre_ver.h>
  51 //#include <lustre_version.h>
  52
  53 #include "llite_internal.h"
  54
  55 cfs_spinlock_t ll_lookup_lock = CFS_SPIN_LOCK_UNLOCKED;
  56
  57 /* should NOT be called with the dcache lock, see fs/dcache.c */
  58 static void ll_release(struct dentry *de)
  59 {
  60         struct ll_dentry_data *lld;
  61         ENTRY;
  62         LASSERT(de != NULL);
  63         lld = ll_d2d(de);
  64         if (lld == NULL) /* NFS copies the de->d_op methods (bug 4655) */
  65                 RETURN_EXIT;
  66
  67         if (lld->lld_it) {
  68                 ll_intent_release(lld->lld_it);
  69                 OBD_FREE(lld->lld_it, sizeof(*lld->lld_it));
  70         }
  71         LASSERT(lld->lld_cwd_count == 0);
  72         LASSERT(lld->lld_mnt_count == 0);
  73         OBD_FREE(de->d_fsdata, sizeof(*lld));
  74
  75         EXIT;
  76 }
  77
  78 /* Compare if two dentries are the same.  Don't match if the existing dentry
  79  * is marked DCACHE_LUSTRE_INVALID.  Returns 1 if different, 0 if the same.
  80  *
  81  * This avoids a race where ll_lookup_it() instantiates a dentry, but we get
  82  * an AST before calling d_revalidate_it().  The dentry still exists (marked
  83  * INVALID) so d_lookup() matches it, but we have no lock on it (so
  84  * lock_match() fails) and we spin around real_lookup(). */
  85 int ll_dcompare(struct dentry *parent, struct qstr *d_name, struct qstr *name)
  86 {
  87         struct dentry *dchild;
  88         ENTRY;
  89
  90         if (d_name->len != name->len)
  91                 RETURN(1);
  92
  93         if (memcmp(d_name->name, name->name, name->len))
  94                 RETURN(1);
  95
  96         /* XXX: d_name must be in-dentry structure */
  97         dchild = container_of(d_name, struct dentry, d_name); /* ugh */
  98
  99         CDEBUG(D_DENTRY,"found name %.*s(%p) - flags %d/%x - refc %d\n",
 100                name->len, name->name, dchild,
 101                d_mountpoint(dchild), dchild->d_flags & DCACHE_LUSTRE_INVALID,
 102                atomic_read(&dchild->d_count));
 103
 104          /* mountpoint is always valid */
 105         if (d_mountpoint(dchild))
 106                 RETURN(0);
 107
 108         if (dchild->d_flags & DCACHE_LUSTRE_INVALID)
 109                 RETURN(1);
 110
 111         RETURN(0);
 112 }
 113
 114 static inline int return_if_equal(struct ldlm_lock *lock, void *data)
 115 {
 116         if ((lock->l_flags &
 117              (LDLM_FL_CANCELING | LDLM_FL_DISCARD_DATA)) ==
 118             (LDLM_FL_CANCELING | LDLM_FL_DISCARD_DATA))
 119                 return LDLM_ITER_CONTINUE;
 120         return LDLM_ITER_STOP;
 121 }
 122
 123 /* find any ldlm lock of the inode in mdc and lov
 124  * return 0    not find
 125  *        1    find one
 126  *      < 0    error */
 127 static int find_cbdata(struct inode *inode)
 128 {
 129         struct ll_inode_info *lli = ll_i2info(inode);
 130         struct ll_sb_info *sbi = ll_i2sbi(inode);
 131         int rc = 0;
 132         ENTRY;
 133
 134         LASSERT(inode);
 135         rc = md_find_cbdata(sbi->ll_md_exp, ll_inode2fid(inode),
 136                             return_if_equal, NULL);
 137         if (rc != 0)
 138                  RETURN(rc);
 139
 140         if (lli->lli_smd)
 141                 rc = obd_find_cbdata(sbi->ll_dt_exp, lli->lli_smd,
 142                                      return_if_equal, NULL);
 143
 144         RETURN(rc);
 145 }
 146
 147 /**
 148  * Called when last reference to a dentry is dropped and dcache wants to know
 149  * whether or not it should cache it:
 150  * - return 1 to delete the dentry immediately
 151  * - return 0 to cache the dentry
 152  * Should NOT be called with the dcache lock, see fs/dcache.c
 153  */
 154 static int ll_ddelete(struct dentry *de)
 155 {
 156         ENTRY;
 157         LASSERT(de);
 158
 159         CDEBUG(D_DENTRY, "%s dentry %.*s (%p, parent %p, inode %p) %s%s\n",
 160                (de->d_flags & DCACHE_LUSTRE_INVALID ? "deleting" : "keeping"),
 161                de->d_name.len, de->d_name.name, de, de->d_parent, de->d_inode,
 162                d_unhashed(de) ? "" : "hashed,",
 163                list_empty(&de->d_subdirs) ? "" : "subdirs");
 164
 165         /* if not ldlm lock for this inode, set i_nlink to 0 so that
 166          * this inode can be recycled later b=20433 */
 167         LASSERT(atomic_read(&de->d_count) == 0);
 168         if (de->d_inode && !find_cbdata(de->d_inode))
 169                 de->d_inode->i_nlink = 0;
 170
 171         if (de->d_flags & DCACHE_LUSTRE_INVALID)
 172                 RETURN(1);
 173
 174         RETURN(0);
 175 }
 176
 177 static int ll_set_dd(struct dentry *de)
 178 {
 179         ENTRY;
 180         LASSERT(de != NULL);
 181
 182         CDEBUG(D_DENTRY, "ldd on dentry %.*s (%p) parent %p inode %p refc %d\n",
 183                de->d_name.len, de->d_name.name, de, de->d_parent, de->d_inode,
 184                atomic_read(&de->d_count));
 185
 186         if (de->d_fsdata == NULL) {
 187                 struct ll_dentry_data *lld;
 188
 189                 OBD_ALLOC_PTR(lld);
 190                 if (likely(lld != NULL)) {
 191                         lock_dentry(de);
 192                         if (likely(de->d_fsdata == NULL))
 193                                 de->d_fsdata = lld;
 194                         else
 195                                 OBD_FREE_PTR(lld);
 196                         unlock_dentry(de);
 197                 } else {
 198                         RETURN(-ENOMEM);
 199                 }
 200         }
 201
 202         RETURN(0);
 203 }
 204
 205 int ll_dops_init(struct dentry *de, int block, int init_sa)
 206 {
 207         struct ll_dentry_data *lld = ll_d2d(de);
 208         int rc = 0;
 209
 210         if (lld == NULL && block != 0) {
 211                 rc = ll_set_dd(de);
 212                 if (rc)
 213                         return rc;
 214
 215                 lld = ll_d2d(de);
 216         }
 217
 218         if (lld != NULL && init_sa != 0)
 219                 lld->lld_sa_generation = 0;
 220
 221         de->d_op = &ll_d_ops;
 222         return rc;
 223 }
 224
 225 void ll_intent_drop_lock(struct lookup_intent *it)
 226 {
 227         struct lustre_handle *handle;
 228
 229         if (it->it_op && it->d.lustre.it_lock_mode) {
 230                 handle = (struct lustre_handle *)&it->d.lustre.it_lock_handle;
 231                 CDEBUG(D_DLMTRACE, "releasing lock with cookie "LPX64
 232                        " from it %p\n", handle->cookie, it);
 233                 ldlm_lock_decref(handle, it->d.lustre.it_lock_mode);
 234
 235                 /* bug 494: intent_release may be called multiple times, from
 236                  * this thread and we don't want to double-decref this lock */
 237                 it->d.lustre.it_lock_mode = 0;
 238         }
 239 }
 240
 241 void ll_intent_release(struct lookup_intent *it)
 242 {
 243         ENTRY;
 244
 245         CDEBUG(D_INFO, "intent %p released\n", it);
 246         ll_intent_drop_lock(it);
 247         /* We are still holding extra reference on a request, need to free it */
 248         if (it_disposition(it, DISP_ENQ_OPEN_REF))
 249                  ptlrpc_req_finished(it->d.lustre.it_data); /* ll_file_open */
 250         if (it_disposition(it, DISP_ENQ_CREATE_REF)) /* create rec */
 251                 ptlrpc_req_finished(it->d.lustre.it_data);
 252         if (it_disposition(it, DISP_ENQ_COMPLETE)) /* saved req from revalidate
 253                                                     * to lookup */
 254                 ptlrpc_req_finished(it->d.lustre.it_data);
 255
 256         it->d.lustre.it_disposition = 0;
 257         it->d.lustre.it_data = NULL;
 258         EXIT;
 259 }
 260
 261 /* Drop dentry if it is not used already, unhash otherwise.
 262    Should be called with dcache lock held!
 263    Returns: 1 if dentry was dropped, 0 if unhashed. */
 264 int ll_drop_dentry(struct dentry *dentry)
 265 {
 266         lock_dentry(dentry);
 267         if (atomic_read(&dentry->d_count) == 0) {
 268                 CDEBUG(D_DENTRY, "deleting dentry %.*s (%p) parent %p "
 269                        "inode %p\n", dentry->d_name.len,
 270                        dentry->d_name.name, dentry, dentry->d_parent,
 271                        dentry->d_inode);
 272                 dget_locked(dentry);
 273                 __d_drop(dentry);
 274                 unlock_dentry(dentry);
 275                 spin_unlock(&dcache_lock);
 276                 cfs_spin_unlock(&ll_lookup_lock);
 277                 dput(dentry);
 278                 cfs_spin_lock(&ll_lookup_lock);
 279                 spin_lock(&dcache_lock);
 280                 return 1;
 281         }
 282         /* disconected dentry can not be find without lookup, because we
 283          * not need his to unhash or mark invalid. */
 284         if (dentry->d_flags & DCACHE_DISCONNECTED) {
 285                 unlock_dentry(dentry);
 286                 RETURN (0);
 287         }
 288
 289         if (!(dentry->d_flags & DCACHE_LUSTRE_INVALID)) {
 290                 CDEBUG(D_DENTRY, "unhashing dentry %.*s (%p) parent %p "
 291                        "inode %p refc %d\n", dentry->d_name.len,
 292                        dentry->d_name.name, dentry, dentry->d_parent,
 293                        dentry->d_inode, atomic_read(&dentry->d_count));
 294                 /* actually we don't unhash the dentry, rather just
 295                  * mark it inaccessible for to __d_lookup(). otherwise
 296                  * sys_getcwd() could return -ENOENT -bzzz */
 297                 dentry->d_flags |= DCACHE_LUSTRE_INVALID;
 298                 if (!dentry->d_inode || !S_ISDIR(dentry->d_inode->i_mode))
 299                         __d_drop(dentry);
 300         }
 301         unlock_dentry(dentry);
 302         return 0;
 303 }
 304
 305 void ll_unhash_aliases(struct inode *inode)
 306 {
 307         struct list_head *tmp, *head;
 308         ENTRY;
 309
 310         if (inode == NULL) {
 311                 CERROR("unexpected NULL inode, tell phil\n");
 312                 return;
 313         }
 314
 315         CDEBUG(D_INODE, "marking dentries for ino %lu/%u(%p) invalid\n",
 316                inode->i_ino, inode->i_generation, inode);
 317
 318         head = &inode->i_dentry;
 319         cfs_spin_lock(&ll_lookup_lock);
 320         spin_lock(&dcache_lock);
 321 restart:
 322         tmp = head;
 323         while ((tmp = tmp->next) != head) {
 324                 struct dentry *dentry = list_entry(tmp, struct dentry, d_alias);
 325
 326                 CDEBUG(D_DENTRY, "dentry in drop %.*s (%p) parent %p "
 327                        "inode %p flags %d\n", dentry->d_name.len,
 328                        dentry->d_name.name, dentry, dentry->d_parent,
 329                        dentry->d_inode, dentry->d_flags);
 330
 331                 if (dentry->d_name.len == 1 && dentry->d_name.name[0] == '/') {
 332                         CERROR("called on root (?) dentry=%p, inode=%p "
 333                                "ino=%lu\n", dentry, inode, inode->i_ino);
 334                         lustre_dump_dentry(dentry, 1);
 335                         libcfs_debug_dumpstack(NULL);
 336                 }
 337
 338                 if (ll_drop_dentry(dentry))
 339                           goto restart;
 340         }
 341         spin_unlock(&dcache_lock);
 342         cfs_spin_unlock(&ll_lookup_lock);
 343
 344         EXIT;
 345 }
 346
 347 int ll_revalidate_it_finish(struct ptlrpc_request *request,
 348                             struct lookup_intent *it,
 349                             struct dentry *de)
 350 {
 351         int rc = 0;
 352         ENTRY;
 353
 354         if (!request)
 355                 RETURN(0);
 356
 357         if (it_disposition(it, DISP_LOOKUP_NEG))
 358                 RETURN(-ENOENT);
 359
 360         rc = ll_prep_inode(&de->d_inode, request, NULL);
 361
 362         RETURN(rc);
 363 }
 364
 365 void ll_lookup_finish_locks(struct lookup_intent *it, struct dentry *dentry)
 366 {
 367         LASSERT(it != NULL);
 368         LASSERT(dentry != NULL);
 369
 370         if (it->d.lustre.it_lock_mode && dentry->d_inode != NULL) {
 371                 struct inode *inode = dentry->d_inode;
 372                 struct ll_sb_info *sbi = ll_i2sbi(dentry->d_inode);
 373
 374                 CDEBUG(D_DLMTRACE, "setting l_data to inode %p (%lu/%u)\n",
 375                        inode, inode->i_ino, inode->i_generation);
 376                 ll_set_lock_data(sbi->ll_md_exp, inode, it, NULL);
 377         }
 378
 379         /* drop lookup or getattr locks immediately */
 380         if (it->it_op == IT_LOOKUP || it->it_op == IT_GETATTR) {
 381                 /* on 2.6 there are situation when several lookups and
 382                  * revalidations may be requested during single operation.
 383                  * therefore, we don't release intent here -bzzz */
 384                 ll_intent_drop_lock(it);
 385         }
 386 }
 387
 388 void ll_frob_intent(struct lookup_intent **itp, struct lookup_intent *deft)
 389 {
 390         struct lookup_intent *it = *itp;
 391
 392         if (!it || it->it_op == IT_GETXATTR)
 393                 it = *itp = deft;
 394
 395 }
 396
 397 int ll_revalidate_it(struct dentry *de, int lookup_flags,
 398                      struct lookup_intent *it)
 399 {
 400         struct md_op_data *op_data;
 401         struct ptlrpc_request *req = NULL;
 402         struct lookup_intent lookup_it = { .it_op = IT_LOOKUP };
 403         struct obd_export *exp;
 404         struct inode *parent = de->d_parent->d_inode;
 405         int rc;
 406
 407         ENTRY;
 408         CDEBUG(D_VFSTRACE, "VFS Op:name=%s,intent=%s\n", de->d_name.name,
 409                LL_IT2STR(it));
 410
 411         if (de->d_inode == NULL) {
 412                 __u64 ibits;
 413
 414                 /* We can only use negative dentries if this is stat or lookup,
 415                    for opens and stuff we do need to query server. */
 416                 /* If there is IT_CREAT in intent op set, then we must throw
 417                    away this negative dentry and actually do the request to
 418                    kernel to create whatever needs to be created (if possible)*/
 419                 if (it && (it->it_op & IT_CREAT))
 420                         RETURN(0);
 421
 422                 if (de->d_flags & DCACHE_LUSTRE_INVALID)
 423                         RETURN(0);
 424
 425                 ibits = MDS_INODELOCK_UPDATE;
 426                 rc = ll_have_md_lock(parent, &ibits, LCK_MINMODE);
 427                 GOTO(out_sa, rc);
 428         }
 429
 430         /* Never execute intents for mount points.
 431          * Attributes will be fixed up in ll_inode_revalidate_it */
 432         if (d_mountpoint(de))
 433                 GOTO(out_sa, rc = 1);
 434
 435         /* need to get attributes in case root got changed from other client */
 436         if (de == de->d_sb->s_root) {
 437                 rc = __ll_inode_revalidate_it(de, it, MDS_INODELOCK_LOOKUP);
 438                 if (rc == 0)
 439                         rc = 1;
 440                 GOTO(out_sa, rc);
 441         }
 442
 443         exp = ll_i2mdexp(de->d_inode);
 444
 445         OBD_FAIL_TIMEOUT(OBD_FAIL_MDC_REVALIDATE_PAUSE, 5);
 446         ll_frob_intent(&it, &lookup_it);
 447         LASSERT(it);
 448
 449         if (it->it_op == IT_LOOKUP && !(de->d_flags & DCACHE_LUSTRE_INVALID))
 450                 RETURN(1);
 451
 452         if ((it->it_op == IT_OPEN) && de->d_inode) {
 453                 struct inode *inode = de->d_inode;
 454                 struct ll_inode_info *lli = ll_i2info(inode);
 455                 struct obd_client_handle **och_p;
 456                 __u64 *och_usecount;
 457                 __u64 ibits;
 458
 459                 /*
 460                  * We used to check for MDS_INODELOCK_OPEN here, but in fact
 461                  * just having LOOKUP lock is enough to justify inode is the
 462                  * same. And if inode is the same and we have suitable
 463                  * openhandle, then there is no point in doing another OPEN RPC
 464                  * just to throw away newly received openhandle.  There are no
 465                  * security implications too, if file owner or access mode is
 466                  * change, LOOKUP lock is revoked.
 467                  */
 468
 469
 470                 if (it->it_flags & FMODE_WRITE) {
 471                         och_p = &lli->lli_mds_write_och;
 472                         och_usecount = &lli->lli_open_fd_write_count;
 473                 } else if (it->it_flags & FMODE_EXEC) {
 474                         och_p = &lli->lli_mds_exec_och;
 475                         och_usecount = &lli->lli_open_fd_exec_count;
 476                 } else {
 477                         och_p = &lli->lli_mds_read_och;
 478                         och_usecount = &lli->lli_open_fd_read_count;
 479                 }
 480                 /* Check for the proper lock. */
 481                 ibits = MDS_INODELOCK_LOOKUP;
 482                 if (!ll_have_md_lock(inode, &ibits, LCK_MINMODE))
 483                         goto do_lock;
 484                 cfs_down(&lli->lli_och_sem);
 485                 if (*och_p) { /* Everything is open already, do nothing */
 486                         /*(*och_usecount)++;  Do not let them steal our open
 487                           handle from under us */
 488                         SET_BUT_UNUSED(och_usecount);
 489                         /* XXX The code above was my original idea, but in case
 490                            we have the handle, but we cannot use it due to later
 491                            checks (e.g. O_CREAT|O_EXCL flags set), nobody
 492                            would decrement counter increased here. So we just
 493                            hope the lock won't be invalidated in between. But
 494                            if it would be, we'll reopen the open request to
 495                            MDS later during file open path */
 496                         cfs_up(&lli->lli_och_sem);
 497                         RETURN(1);
 498                 } else {
 499                         cfs_up(&lli->lli_och_sem);
 500                 }
 501         }
 502
 503         if (it->it_op == IT_GETATTR) {
 504                 rc = ll_statahead_enter(parent, &de, 0);
 505                 if (rc == 1)
 506                         goto mark;
 507         }
 508
 509 do_lock:
 510         op_data = ll_prep_md_op_data(NULL, parent, de->d_inode,
 511                                      de->d_name.name, de->d_name.len,
 512                                      0, LUSTRE_OPC_ANY, NULL);
 513         if (IS_ERR(op_data))
 514                 RETURN(PTR_ERR(op_data));
 515
 516         it->it_create_mode &= ~cfs_curproc_umask();
 517         it->it_create_mode |= M_CHECK_STALE;
 518         rc = md_intent_lock(exp, op_data, NULL, 0, it,
 519                             lookup_flags,
 520                             &req, ll_md_blocking_ast, 0);
 521         it->it_create_mode &= ~M_CHECK_STALE;
 522         ll_finish_md_op_data(op_data);
 523
 524         /* If req is NULL, then md_intent_lock only tried to do a lock match;
 525          * if all was well, it will return 1 if it found locks, 0 otherwise. */
 526         if (req == NULL && rc >= 0) {
 527                 if (!rc)
 528                         goto do_lookup;
 529                 GOTO(out, rc);
 530         }
 531
 532         if (rc < 0) {
 533                 if (rc != -ESTALE) {
 534                         CDEBUG(D_INFO, "ll_intent_lock: rc %d : it->it_status "
 535                                "%d\n", rc, it->d.lustre.it_status);
 536                 }
 537                 GOTO(out, rc = 0);
 538         }
 539
 540 revalidate_finish:
 541         rc = ll_revalidate_it_finish(req, it, de);
 542         if (rc != 0) {
 543                 if (rc != -ESTALE && rc != -ENOENT)
 544                         ll_intent_release(it);
 545                 GOTO(out, rc = 0);
 546         }
 547
 548         if ((it->it_op & IT_OPEN) && de->d_inode &&
 549             !S_ISREG(de->d_inode->i_mode) &&
 550             !S_ISDIR(de->d_inode->i_mode)) {
 551                 ll_release_openhandle(de, it);
 552         }
 553         rc = 1;
 554
 555         /* unfortunately ll_intent_lock may cause a callback and revoke our
 556          * dentry */
 557         ll_dentry_rehash(de, 0);
 558
 559 out:
 560         /* We do not free request as it may be reused during following lookup
 561          * (see comment in mdc/mdc_locks.c::mdc_intent_lock()), request will
 562          * be freed in ll_lookup_it or in ll_intent_release. But if
 563          * request was not completed, we need to free it. (bug 5154, 9903) */
 564         if (req != NULL && !it_disposition(it, DISP_ENQ_COMPLETE))
 565                 ptlrpc_req_finished(req);
 566         if (rc == 0) {
 567                 ll_unhash_aliases(de->d_inode);
 568                 /* done in ll_unhash_aliases()
 569                    dentry->d_flags |= DCACHE_LUSTRE_INVALID; */
 570         } else {
 571                 __u64 bits = 0;
 572
 573                 CDEBUG(D_DENTRY, "revalidated dentry %.*s (%p) parent %p "
 574                        "inode %p refc %d\n", de->d_name.len,
 575                        de->d_name.name, de, de->d_parent, de->d_inode,
 576                        atomic_read(&de->d_count));
 577                 ll_set_lock_data(exp, de->d_inode, it, &bits);
 578                 ll_dentry_reset_flags(de, bits);
 579                 ll_lookup_finish_locks(it, de);
 580         }
 581
 582 mark:
 583         if (it != NULL && it->it_op == IT_GETATTR && rc > 0)
 584                 ll_statahead_mark(parent, de);
 585         RETURN(rc);
 586
 587         /*
 588          * This part is here to combat evil-evil race in real_lookup on 2.6
 589          * kernels.  The race details are: We enter do_lookup() looking for some
 590          * name, there is nothing in dcache for this name yet and d_lookup()
 591          * returns NULL.  We proceed to real_lookup(), and while we do this,
 592          * another process does open on the same file we looking up (most simple
 593          * reproducer), open succeeds and the dentry is added. Now back to
 594          * us. In real_lookup() we do d_lookup() again and suddenly find the
 595          * dentry, so we call d_revalidate on it, but there is no lock, so
 596          * without this code we would return 0, but unpatched real_lookup just
 597          * returns -ENOENT in such a case instead of retrying the lookup. Once
 598          * this is dealt with in real_lookup(), all of this ugly mess can go and
 599          * we can just check locks in ->d_revalidate without doing any RPCs
 600          * ever.
 601          */
 602 do_lookup:
 603         if (it != &lookup_it) {
 604                 /* MDS_INODELOCK_UPDATE needed for IT_GETATTR case. */
 605                 if (it->it_op == IT_GETATTR)
 606                         lookup_it.it_op = IT_GETATTR;
 607                 ll_lookup_finish_locks(it, de);
 608                 it = &lookup_it;
 609         }
 610
 611         /* Do real lookup here. */
 612         op_data = ll_prep_md_op_data(NULL, parent, NULL, de->d_name.name,
 613                                      de->d_name.len, 0, (it->it_op & IT_CREAT ?
 614                                                          LUSTRE_OPC_CREATE :
 615                                                          LUSTRE_OPC_ANY), NULL);
 616         if (IS_ERR(op_data))
 617                 RETURN(PTR_ERR(op_data));
 618
 619         rc = md_intent_lock(exp, op_data, NULL, 0,  it, 0, &req,
 620                             ll_md_blocking_ast, 0);
 621         if (rc >= 0) {
 622                 struct mdt_body *mdt_body;
 623                 struct lu_fid fid = {.f_seq = 0, .f_oid = 0, .f_ver = 0};
 624                 mdt_body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
 625
 626                 if (de->d_inode)
 627                         fid = *ll_inode2fid(de->d_inode);
 628
 629                 /* see if we got same inode, if not - return error */
 630                 if (lu_fid_eq(&fid, &mdt_body->fid1)) {
 631                         ll_finish_md_op_data(op_data);
 632                         op_data = NULL;
 633                         goto revalidate_finish;
 634                 }
 635                 ll_intent_release(it);
 636         }
 637         ll_finish_md_op_data(op_data);
 638         GOTO(out, rc = 0);
 639
 640 out_sa:
 641         /*
 642          * For rc == 1 case, should not return directly to prevent losing
 643          * statahead windows; for rc == 0 case, the "lookup" will be done later.
 644          */
 645         if (it != NULL && it->it_op == IT_GETATTR && rc == 1)
 646                 ll_statahead_enter(parent, &de, 1);
 647         goto mark;
 648 }
 649
 650 int ll_revalidate_nd(struct dentry *dentry, struct nameidata *nd)
 651 {
 652         int rc;
 653         ENTRY;
 654
 655         if (nd && !(nd->flags & (LOOKUP_CONTINUE|LOOKUP_PARENT))) {
 656                 struct lookup_intent *it;
 657
 658                 it = ll_convert_intent(&nd->intent.open, nd->flags);
 659                 if (IS_ERR(it))
 660                         RETURN(0);
 661
 662                 if (it->it_op == (IT_OPEN|IT_CREAT) &&
 663                     nd->intent.open.flags & O_EXCL) {
 664                         CDEBUG(D_VFSTRACE, "create O_EXCL, returning 0\n");
 665                         rc = 0;
 666                         goto out_it;
 667                 }
 668
 669                 rc = ll_revalidate_it(dentry, nd->flags, it);
 670
 671                 if (rc && (nd->flags & LOOKUP_OPEN) &&
 672                     it_disposition(it, DISP_OPEN_OPEN)) {/*Open*/
 673 #ifdef HAVE_FILE_IN_STRUCT_INTENT
 674 // XXX Code duplication with ll_lookup_nd
 675                         if (S_ISFIFO(dentry->d_inode->i_mode)) {
 676                                 // We cannot call open here as it would
 677                                 // deadlock.
 678                                 ptlrpc_req_finished(
 679                                                (struct ptlrpc_request *)
 680                                                   it->d.lustre.it_data);
 681                         } else {
 682 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,17))
 683 /* 2.6.1[456] have a bug in open_namei() that forgets to check
 684  * nd->intent.open.file for error, so we need to return it as lookup's result
 685  * instead */
 686                                 struct file *filp;
 687
 688                                 nd->intent.open.file->private_data = it;
 689                                 filp = lookup_instantiate_filp(nd, dentry,NULL);
 690                                 if (IS_ERR(filp)) {
 691                                         rc = PTR_ERR(filp);
 692                                 }
 693 #else
 694                                 nd->intent.open.file->private_data = it;
 695                                 (void)lookup_instantiate_filp(nd, dentry,NULL);
 696 #endif
 697                         }
 698 #else
 699                         ll_release_openhandle(dentry, it);
 700 #endif /* HAVE_FILE_IN_STRUCT_INTENT */
 701                 }
 702                 if (!rc && (nd->flags & LOOKUP_CREATE) &&
 703                     it_disposition(it, DISP_OPEN_CREATE)) {
 704                         /* We created something but we may only return
 705                          * negative dentry here, so save request in dentry,
 706                          * if lookup will be called later on, it will
 707                          * pick the request, otherwise it would be freed
 708                          * with dentry */
 709                         ll_d2d(dentry)->lld_it = it;
 710                         it = NULL; /* avoid freeing */
 711                 }
 712
 713 out_it:
 714                 if (it) {
 715                         ll_intent_release(it);
 716                         OBD_FREE(it, sizeof(*it));
 717                 }
 718         } else {
 719                 rc = ll_revalidate_it(dentry, 0, NULL);
 720         }
 721
 722         RETURN(rc);
 723 }
 724
 725 void ll_d_iput(struct dentry *de, struct inode *inode)
 726 {
 727         LASSERT(inode);
 728         if (!find_cbdata(inode))
 729                 inode->i_nlink = 0;
 730         iput(inode);
 731 }
 732
 733 struct dentry_operations ll_d_ops = {
 734         .d_revalidate = ll_revalidate_nd,
 735         .d_release = ll_release,
 736         .d_delete  = ll_ddelete,
 737         .d_iput    = ll_d_iput,
 738         .d_compare = ll_dcompare,
 739 };