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