lustre/llite/dcache.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  *  Copyright (c) 2001-2003 Cluster File Systems, Inc.
   5  *
   6  *   This file is part of Lustre, http://www.lustre.org.
   7  *
   8  *   Lustre is free software; you can redistribute it and/or
   9  *   modify it under the terms of version 2 of the GNU General Public
  10  *   License as published by the Free Software Foundation.
  11  *
  12  *   Lustre is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *   GNU General Public License for more details.
  16  *
  17  *   You should have received a copy of the GNU General Public License
  18  *   along with Lustre; if not, write to the Free Software
  19  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 #include <linux/fs.h>
  23 #include <linux/sched.h>
  24 #include <linux/smp_lock.h>
  25 #include <linux/quotaops.h>
  26
  27 #define DEBUG_SUBSYSTEM S_LLITE
  28
  29 #include <linux/obd_support.h>
  30 #include <linux/lustre_lite.h>
  31 #include <linux/lustre_idl.h>
  32 #include <linux/lustre_dlm.h>
  33 #include <linux/lustre_version.h>
  34
  35 #include "llite_internal.h"
  36
  37 /* should NOT be called with the dcache lock, see fs/dcache.c */
  38 static void ll_release(struct dentry *de)
  39 {
  40         struct ll_dentry_data *lld;
  41         ENTRY;
  42         LASSERT(de != NULL);
  43
  44         CDEBUG(D_DENTRY, "releasing dentry %p\n", de);
  45
  46         lld = ll_d2d(de);
  47         if (lld) { /* Root dentry does not have ll_dentry_data */
  48                 LASSERT(lld->lld_cwd_count == 0);
  49                 LASSERT(lld->lld_mnt_count == 0);
  50                 OBD_FREE(de->d_fsdata, sizeof(struct ll_dentry_data));
  51         }
  52
  53         EXIT;
  54 }
  55
  56 /* Compare if two dentries are the same.  Don't match if the existing dentry
  57  * is marked DCACHE_LUSTRE_INVALID.  Returns 1 if different, 0 if the same.
  58  *
  59  * This avoids a race where ll_lookup_it() instantiates a dentry, but we get
  60  * an AST before calling d_revalidate_it().  The dentry still exists (marked
  61  * INVALID) so d_lookup() matches it, but we have no lock on it (so
  62  * lock_match() fails) and we spin around real_lookup(). */
  63 static int ll_dcompare(struct dentry *parent, struct qstr *d_name,
  64                        struct qstr *name){
  65         struct dentry *dchild;
  66         ENTRY;
  67
  68         if (d_name->len != name->len)
  69                 RETURN(1);
  70
  71         if (memcmp(d_name->name, name->name, name->len))
  72                 RETURN(1);
  73
  74         dchild = container_of(d_name, struct dentry, d_name); /* ugh */
  75         if (dchild->d_flags & DCACHE_LUSTRE_INVALID) {
  76                 CDEBUG(D_DENTRY,"INVALID dentry %p not matched, was bug 3784\n",
  77                        dchild);
  78                 RETURN(1);
  79         }
  80
  81         RETURN(0);
  82 }
  83
  84 /* should NOT be called with the dcache lock, see fs/dcache.c */
  85 static int ll_ddelete(struct dentry *de)
  86 {
  87         ENTRY;
  88         LASSERT(de);
  89         CDEBUG(D_DENTRY, "%s dentry %*s (%p, parent %p, inode %p) %s%s\n",
  90                (de->d_flags & DCACHE_LUSTRE_INVALID ? "deleting" : "keeping"),
  91                de->d_name.len, de->d_name.name, de, de->d_parent, de->d_inode,
  92                d_unhashed(de) ? "" : "hashed,",
  93                list_empty(&de->d_subdirs) ? "" : "subdirs");
  94         RETURN(0);
  95 }
  96
  97 void ll_set_dd(struct dentry *de)
  98 {
  99         ENTRY;
 100         LASSERT(de != NULL);
 101
 102         CDEBUG(D_DENTRY, "ldd on dentry %.*s (%p) parent %p inode %p refc %d\n",
 103                de->d_name.len, de->d_name.name, de, de->d_parent, de->d_inode,
 104                atomic_read(&de->d_count));
 105         lock_kernel();
 106         if (de->d_fsdata == NULL) {
 107                 OBD_ALLOC(de->d_fsdata, sizeof(struct ll_dentry_data));
 108         }
 109         unlock_kernel();
 110
 111         EXIT;
 112 }
 113
 114 void ll_intent_drop_lock(struct lookup_intent *it)
 115 {
 116         struct lustre_handle *handle;
 117         struct lustre_intent_data *itdata = LUSTRE_IT(it);
 118
 119         if (it->it_op && itdata && itdata->it_lock_mode) {
 120                 handle = (struct lustre_handle *)&itdata->it_lock_handle;
 121                 CDEBUG(D_DLMTRACE, "releasing lock with cookie "LPX64
 122                        " from it %p\n", handle->cookie, it);
 123                 ldlm_lock_decref(handle, itdata->it_lock_mode);
 124
 125                 /* bug 494: intent_release may be called multiple times, from
 126                  * this thread and we don't want to double-decref this lock */
 127                 itdata->it_lock_mode = 0;
 128         }
 129 }
 130
 131 void ll_intent_release(struct lookup_intent *it)
 132 {
 133         ENTRY;
 134
 135         ll_intent_drop_lock(it);
 136         it->it_magic = 0;
 137         it->it_op_release = 0;
 138         ll_intent_free(it);
 139         EXIT;
 140 }
 141
 142 void ll_unhash_aliases(struct inode *inode)
 143 {
 144         struct list_head *tmp, *head;
 145         struct ll_sb_info *sbi;
 146         ENTRY;
 147
 148         if (inode == NULL) {
 149                 CERROR("unexpected NULL inode, tell phil\n");
 150                 EXIT;
 151                 return;
 152         }
 153
 154         CDEBUG(D_INODE, "marking dentries for ino %lu/%u(%p) invalid\n",
 155                inode->i_ino, inode->i_generation, inode);
 156
 157         sbi = ll_i2sbi(inode);
 158         head = &inode->i_dentry;
 159 restart:
 160         spin_lock(&dcache_lock);
 161         tmp = head;
 162         while ((tmp = tmp->next) != head) {
 163                 struct dentry *dentry = list_entry(tmp, struct dentry, d_alias);
 164                 if (atomic_read(&dentry->d_count) == 0) {
 165                         CDEBUG(D_DENTRY, "deleting dentry %.*s (%p) parent %p "
 166                                "inode %p\n", dentry->d_name.len,
 167                                dentry->d_name.name, dentry, dentry->d_parent,
 168                                dentry->d_inode);
 169                         dget_locked(dentry);
 170                         __d_drop(dentry);
 171                         spin_unlock(&dcache_lock);
 172                         dput(dentry);
 173                         goto restart;
 174                 } else if (!(dentry->d_flags & DCACHE_LUSTRE_INVALID)) {
 175                         CDEBUG(D_DENTRY, "unhashing dentry %.*s (%p) parent %p "
 176                                "inode %p refc %d\n", dentry->d_name.len,
 177                                dentry->d_name.name, dentry, dentry->d_parent,
 178                                dentry->d_inode, atomic_read(&dentry->d_count));
 179                         hlist_del_init(&dentry->d_hash);
 180                         dentry->d_flags |= DCACHE_LUSTRE_INVALID;
 181                         hlist_add_head(&dentry->d_hash,
 182                                        &sbi->ll_orphan_dentry_list);
 183                 }
 184         }
 185         spin_unlock(&dcache_lock);
 186         EXIT;
 187 }
 188
 189 extern struct dentry *ll_find_alias(struct inode *, struct dentry *);
 190
 191 int revalidate_it_finish(struct ptlrpc_request *request, int offset,
 192                          struct lookup_intent *it, struct dentry *de)
 193 {
 194         struct ll_sb_info *sbi;
 195         int rc = 0;
 196         ENTRY;
 197
 198         if (!request)
 199                 RETURN(0);
 200
 201         if (it_disposition(it, DISP_LOOKUP_NEG))
 202                 RETURN(-ENOENT);
 203
 204         sbi = ll_i2sbi(de->d_inode);
 205         rc = ll_prep_inode(sbi->ll_dt_exp, sbi->ll_md_exp,
 206                            &de->d_inode, request, offset, NULL);
 207
 208         RETURN(rc);
 209 }
 210
 211 void ll_lookup_finish_locks(struct lookup_intent *it, struct dentry *dentry)
 212 {
 213         LASSERT(it != NULL);
 214         LASSERT(dentry != NULL);
 215
 216         if (LUSTRE_IT(it)->it_lock_mode && dentry->d_inode != NULL) {
 217                 struct inode *inode = dentry->d_inode;
 218                 CDEBUG(D_DLMTRACE, "setting l_data to inode %p (%lu/%u)\n",
 219                        inode, inode->i_ino, inode->i_generation);
 220                 mdc_set_lock_data(NULL, &LUSTRE_IT(it)->it_lock_handle, inode);
 221         }
 222
 223         /* drop lookup or getattr locks immediately */
 224         if (it->it_op == IT_LOOKUP || it->it_op == IT_GETATTR ||
 225             it->it_op == IT_CHDIR) {
 226 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 227                 /*
 228                  * on 2.6 there are situations when several lookups and
 229                  * revalidations may be requested during single operation.
 230                  * Therefore, we don't release intent here -bzzz
 231                  */
 232                 ll_intent_drop_lock(it);
 233 #else
 234                 ll_intent_release(it);
 235 #endif
 236         }
 237 }
 238
 239 void ll_frob_intent(struct lookup_intent **itp, struct lookup_intent *deft)
 240 {
 241         struct lookup_intent *it = *itp;
 242
 243 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 244         if (it) {
 245                 LASSERTF(it->it_magic == INTENT_MAGIC, "bad intent magic: %x\n",
 246                          it->it_magic);
 247         }
 248 #endif
 249
 250         if (!it || it->it_op == IT_GETXATTR)
 251                 it = *itp = deft;
 252
 253         if (it->d.fs_data)
 254                 return;
 255
 256         if (ll_intent_alloc(it)) {
 257                 CERROR("Failed to allocate memory for lustre specific intent "
 258                        "data\n");
 259                 /* XXX: we cannot return status just yet */
 260                 LBUG();
 261         }
 262 }
 263
 264 int ll_intent_alloc(struct lookup_intent *it)
 265 {
 266         if (it->d.fs_data) {
 267                 CERROR("Intent alloc on already allocated intent\n");
 268                 return 0;
 269         }
 270         OBD_SLAB_ALLOC(it->d.fs_data, ll_intent_slab, SLAB_KERNEL,
 271                        sizeof(struct lustre_intent_data));
 272         if (!it->d.fs_data) {
 273                 CERROR("Failed to allocate memory for lustre specific intent "
 274                        "data\n");
 275                 return -ENOMEM;
 276         }
 277
 278         it->it_op_release = ll_intent_release;
 279         return 0;
 280 }
 281
 282 void ll_intent_free(struct lookup_intent *it)
 283 {
 284         if (it->d.fs_data) {
 285                 OBD_SLAB_FREE(it->d.fs_data, ll_intent_slab,
 286                               sizeof(struct lustre_intent_data));
 287                 it->d.fs_data = NULL;
 288         }
 289 }
 290
 291 static inline int
 292 ll_special_name(struct dentry *de)
 293 {
 294         if (de->d_name.name[0] == '.') switch (de->d_name.len) {
 295                 case 2:
 296                         if (de->d_name.name[1] == '.')
 297                                 return 1;
 298                 case 1:
 299                         return 1;
 300                 default:
 301                         return 0;
 302         }
 303         return 0;
 304 }
 305
 306 int ll_revalidate_it(struct dentry *de, int flags, struct nameidata *nd,
 307                      struct lookup_intent *it)
 308 {
 309         struct lookup_intent lookup_it = { .it_op = IT_LOOKUP };
 310         struct ptlrpc_request *req = NULL;
 311         int gns_it, gns_flags, rc = 0;
 312         struct obd_export *exp;
 313         struct it_cb_data icbd;
 314         struct lustre_id pid;
 315         struct lustre_id cid;
 316         ENTRY;
 317
 318         CDEBUG(D_VFSTRACE, "VFS Op:name=%s (%p), intent=%s\n", de->d_name.name,
 319                de, LL_IT2STR(it));
 320
 321         /* Cached negative dentries are unsafe for now - look them up again */
 322         if (de->d_inode == NULL)
 323                 RETURN(0);
 324
 325         /*
 326          * root of the tree is always valid, attributes would be fixed in
 327          * ll_inode_revalidate_it()
 328          */
 329         if (de->d_sb->s_root == de)
 330                 RETURN(1);
 331
 332         CDEBUG(D_INODE, "revalidate 0x%p: %*s -> %lu/%lu\n",
 333                de, de->d_name.len, de->d_name.name,
 334                (unsigned long) de->d_inode->i_ino,
 335                (unsigned long) de->d_inode->i_generation);
 336
 337         exp = ll_i2mdexp(de->d_inode);
 338         ll_inode2id(&pid, de->d_parent->d_inode);
 339         ll_inode2id(&cid, de->d_inode);
 340         LASSERT(id_fid(&cid) != 0);
 341
 342         icbd.icbd_parent = de->d_parent->d_inode;
 343         icbd.icbd_childp = &de;
 344
 345         /*
 346          * never execute intents for mount points. Attributes will be fixed up
 347          * in ll_inode_revalidate_it().
 348          */
 349         if (d_mountpoint(de))
 350                 RETURN(1);
 351
 352         if (nd != NULL)
 353                 nd->mnt->mnt_last_used = jiffies;
 354
 355         OBD_FAIL_TIMEOUT(OBD_FAIL_MDC_REVALIDATE_PAUSE, 5);
 356         gns_it = nd ? nd->intent.open.it_op : IT_OPEN;
 357         gns_flags = nd ? nd->flags : LOOKUP_CONTINUE;
 358
 359         if (it && it->it_op == IT_GETATTR)
 360                 it = NULL; /* will use it_lookup */
 361         else if (it && (it->it_op == IT_OPEN) && de->d_inode) {
 362                 /* open lock stuff */
 363                 struct inode *inode = de->d_inode;
 364                 struct ll_inode_info *lli = ll_i2info(inode);
 365                 struct obd_client_handle **och_p;
 366                 __u64 *och_usecount;
 367                 struct obd_device *obddev;
 368                 struct lustre_handle lockh;
 369                 int flags = LDLM_FL_BLOCK_GRANTED;
 370                 ldlm_policy_data_t policy = {.l_inodebits = {MDS_INODELOCK_OPEN}};
 371                 struct ldlm_res_id file_res_id = {.name = {id_fid(&lli->lli_id),
 372                                                            id_group(&lli->lli_id)}};
 373                 int lockmode;
 374
 375                 if (it->it_flags & FMODE_WRITE) {
 376                         och_p = &lli->lli_mds_write_och;
 377                         och_usecount = &lli->lli_open_fd_write_count;
 378                         lockmode = LCK_CW;
 379                 } else if (it->it_flags & FMODE_EXEC) {
 380                         och_p = &lli->lli_mds_exec_och;
 381                         och_usecount = &lli->lli_open_fd_exec_count;
 382                         lockmode = LCK_PR;
 383                 } else {
 384                         och_p = &lli->lli_mds_read_och;
 385                         och_usecount = &lli->lli_open_fd_read_count;
 386                         lockmode = LCK_CR;
 387                 }
 388
 389                 /* Check for the proper lock */
 390                 obddev = md_get_real_obd(exp, &lli->lli_id);
 391                 if (!ldlm_lock_match(obddev->obd_namespace, flags, &file_res_id,
 392                                      LDLM_IBITS, &policy, lockmode, &lockh))
 393                         goto do_lock;
 394                 down(&lli->lli_och_sem);
 395                 if (*och_p) { /* Everything is open already, do nothing */
 396                         /*(*och_usecount)++;  Do not let them steal our open
 397                                               handle from under us */
 398                         /* XXX The code above was my original idea, but in case
 399                            we have the handle, but we cannot use it due to later
 400                            checks (e.g. O_CREAT|O_EXCL flags set), nobody
 401                            would decrement counter increased here. So we just
 402                            hope the lock won't be invalidated in between. But
 403                            if it would be, we'll reopen the open request to
 404                            MDS later during file open path */
 405                         up(&lli->lli_och_sem);
 406                         if (ll_intent_alloc(it))
 407                                 LBUG();
 408                         memcpy(&LUSTRE_IT(it)->it_lock_handle, &lockh,
 409                                sizeof(lockh));
 410                         LUSTRE_IT(it)->it_lock_mode = lockmode;
 411
 412                         /*
 413                          * we do not check here for possible GNS dentry as if
 414                          * file is opened on it, it is mounted already and we do
 415                          * not need do anything. --umka
 416                          */
 417                         RETURN(1);
 418                 } else {
 419                         /* Hm, interesting. Lock is present, but no open
 420                            handle? */
 421                         up(&lli->lli_och_sem);
 422                         ldlm_lock_decref(&lockh, lockmode);
 423                 }
 424         }
 425
 426 do_lock:
 427         ll_frob_intent(&it, &lookup_it);
 428         LASSERT(it != NULL);
 429
 430         rc = md_intent_lock(exp, &pid, de->d_name.name, de->d_name.len,
 431                             NULL, 0, &cid, it, flags, &req, ll_mdc_blocking_ast);
 432         /* If req is NULL, then md_intent_lock() only tried to do a lock match;
 433          * if all was well, it will return 1 if it found locks, 0 otherwise. */
 434         if (req == NULL && rc >= 0) {
 435                 if (!rc)
 436                         goto do_lookup;
 437                 GOTO(out, rc);
 438         }
 439
 440         if (rc < 0) {
 441                 if (rc != -ESTALE) {
 442                         CDEBUG(D_INFO, "ll_intent_lock(): rc %d : it->it_status "
 443                                "%d\n", rc, LUSTRE_IT(it)->it_status);
 444                 }
 445                 GOTO(out, rc = 0);
 446         }
 447 revalidate_finish:
 448         rc = revalidate_it_finish(req, 1, it, de);
 449         if (rc != 0) {
 450                 ll_intent_release(it);
 451                 GOTO(out, rc = 0);
 452         }
 453         rc = 1;
 454
 455         /* unfortunately ll_intent_lock may cause a callback and revoke our
 456            dentry */
 457         spin_lock(&dcache_lock);
 458         hlist_del_init(&de->d_hash);
 459         __d_rehash(de);
 460         spin_unlock(&dcache_lock);
 461
 462         GOTO(out, rc);
 463 out:
 464         /* If we had succesful it lookup on mds, but it happened to be negative,
 465            we do not free request as it will be reused during lookup (see
 466            comment in mdc/mdc_locks.c::mdc_intent_lock(). But if
 467            request was not completed, we need to free it. (bug 5154) */
 468         if (req != NULL && (rc == 1 || !it_disposition(it, DISP_ENQ_COMPLETE))) {
 469                 ptlrpc_req_finished(req);
 470                 req = NULL;
 471         }
 472
 473         if (rc == 0) {
 474                 if (it == &lookup_it)
 475                         ll_intent_release(it);
 476
 477                 ll_unhash_aliases(de->d_inode);
 478                 RETURN(0);
 479         }
 480
 481         /*
 482          * if we found that this is possible GNS mount and dentry is still valid
 483          * and may be used by system, we drop the lock and return 0, that means
 484          * that re-lookup is needed. Such a way we cause real mounting only in
 485          * lookup control path, which is always made with parent's i_sem taken.
 486          * --umka
 487          */
 488         if (nd && atomic_read(&ll_i2sbi(de->d_inode)->ll_gns_enabled) &&
 489             (de->d_inode->i_mode & S_ISUID) && S_ISDIR(de->d_inode->i_mode) &&
 490             (gns_flags & LOOKUP_CONTINUE || (gns_it & (IT_CHDIR | IT_OPEN)))) {
 491                 /*
 492                  * special "." and ".." has to be always revalidated because
 493                  * they never should be passed to lookup()
 494                  */
 495                 if (!ll_special_name(de)) {
 496                         CDEBUG(D_DENTRY, "possible GNS dentry %*s %p found, "
 497                                "causing mounting\n", (int)de->d_name.len,
 498                                de->d_name.name, de);
 499
 500                         LASSERT(req == NULL);
 501                         if (it == &lookup_it) {
 502                                 ll_intent_release(it);
 503                         } else {
 504                                 ll_intent_drop_lock(it);
 505                         }
 506                         ll_unhash_aliases(de->d_inode);
 507                         RETURN(0);
 508                 }
 509         }
 510
 511         CDEBUG(D_DENTRY, "revalidated dentry %*s (%p) parent %p "
 512                "inode %p refc %d\n", de->d_name.len,
 513                de->d_name.name, de, de->d_parent, de->d_inode,
 514                atomic_read(&de->d_count));
 515
 516         if (it == &lookup_it)
 517                 ll_intent_release(it);
 518         else
 519                 ll_lookup_finish_locks(it, de);
 520
 521         de->d_flags &= ~DCACHE_LUSTRE_INVALID;
 522         return rc;
 523
 524 do_lookup:
 525         if (it != &lookup_it) {
 526                 ll_intent_release(it);
 527                 it = &lookup_it;
 528                 if (ll_intent_alloc(it))
 529                         LBUG();
 530         }
 531
 532         // We did that already, right?  ll_inode2id(&pid, de->d_parent->d_inode);
 533         rc = md_intent_lock(exp, &pid, de->d_name.name,
 534                             de->d_name.len, NULL, 0, NULL,
 535                             it, 0, &req, ll_mdc_blocking_ast);
 536         if (rc >= 0) {
 537                 struct mds_body *mds_body = lustre_msg_buf(req->rq_repmsg, 1,
 538                                                            sizeof(*mds_body));
 539
 540                 /* See if we got same inode, if not - return error */
 541                 if (id_equal_stc(&cid, &mds_body->id1))
 542                         goto revalidate_finish;
 543         }
 544
 545         GOTO(out, rc = 0);
 546 }
 547
 548 /*static*/ void ll_pin(struct dentry *de, struct vfsmount *mnt, int flag)
 549 {
 550         struct inode *inode= de->d_inode;
 551         struct ll_sb_info *sbi = ll_i2sbi(inode);
 552         struct ll_dentry_data *ldd = ll_d2d(de);
 553         struct obd_client_handle *handle;
 554         int rc = 0;
 555         ENTRY;
 556         LASSERT(ldd);
 557
 558         lock_kernel();
 559         /* Strictly speaking this introduces an additional race: the
 560          * increments should wait until the rpc has returned.
 561          * However, given that at present the function is void, this
 562          * issue is moot. */
 563         if (flag == 1 && (++ldd->lld_mnt_count) > 1) {
 564                 unlock_kernel();
 565                 EXIT;
 566                 return;
 567         }
 568
 569         if (flag == 0 && (++ldd->lld_cwd_count) > 1) {
 570                 unlock_kernel();
 571                 EXIT;
 572                 return;
 573         }
 574         unlock_kernel();
 575
 576         handle = (flag) ? &ldd->lld_mnt_och : &ldd->lld_cwd_och;
 577         rc = obd_pin(sbi->ll_md_exp, inode->i_ino, inode->i_generation,
 578                      inode->i_mode & S_IFMT, handle, flag);
 579
 580         if (rc) {
 581                 lock_kernel();
 582                 memset(handle, 0, sizeof(*handle));
 583                 if (flag == 0)
 584                         ldd->lld_cwd_count--;
 585                 else
 586                         ldd->lld_mnt_count--;
 587                 unlock_kernel();
 588         }
 589
 590         EXIT;
 591         return;
 592 }
 593
 594 /*static*/ void ll_unpin(struct dentry *de, struct vfsmount *mnt, int flag)
 595 {
 596         struct ll_sb_info *sbi = ll_i2sbi(de->d_inode);
 597         struct ll_dentry_data *ldd = ll_d2d(de);
 598         struct obd_client_handle handle;
 599         int count, rc = 0;
 600         ENTRY;
 601         LASSERT(ldd);
 602
 603         lock_kernel();
 604         /* Strictly speaking this introduces an additional race: the
 605          * increments should wait until the rpc has returned.
 606          * However, given that at present the function is void, this
 607          * issue is moot. */
 608         handle = (flag) ? ldd->lld_mnt_och : ldd->lld_cwd_och;
 609         if (handle.och_magic != OBD_CLIENT_HANDLE_MAGIC) {
 610                 /* the "pin" failed */
 611                 unlock_kernel();
 612                 EXIT;
 613                 return;
 614         }
 615
 616         if (flag)
 617                 count = --ldd->lld_mnt_count;
 618         else
 619                 count = --ldd->lld_cwd_count;
 620         unlock_kernel();
 621
 622         if (count != 0) {
 623                 EXIT;
 624                 return;
 625         }
 626
 627         rc = obd_unpin(sbi->ll_md_exp, &handle, flag);
 628         EXIT;
 629 }
 630
 631 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 632 static int ll_revalidate_nd(struct dentry *dentry, struct nameidata *nd)
 633 {
 634         int rc;
 635         ENTRY;
 636
 637         if (nd && nd->flags & LOOKUP_LAST && !(nd->flags & LOOKUP_LINK_NOTLAST))
 638                 rc = ll_revalidate_it(dentry, nd->flags, nd, &nd->intent.open);
 639         else
 640                 rc = ll_revalidate_it(dentry, 0, nd, NULL);
 641
 642         RETURN(rc);
 643 }
 644 #endif
 645
 646 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
 647 static void ll_dentry_iput(struct dentry *dentry, struct inode *inode)
 648 {
 649         struct ll_sb_info *sbi = ll_i2sbi(inode);
 650         struct lustre_id parent, child;
 651
 652         LASSERT(dentry->d_parent && dentry->d_parent->d_inode);
 653         ll_inode2id(&parent, dentry->d_parent->d_inode);
 654         ll_inode2id(&child, inode);
 655         md_change_cbdata_name(sbi->ll_md_exp, &parent,
 656                               (char *)dentry->d_name.name,
 657                               dentry->d_name.len, &child,
 658                               null_if_equal, inode);
 659         iput(inode);
 660 }
 661 #else
 662 static void ll_dentry_iput(struct dentry *dentry, struct inode *inode)
 663 {
 664         struct ll_sb_info *sbi = ll_i2sbi(inode);
 665         struct lustre_id parent, child;
 666
 667         if (dentry->d_parent != dentry) {
 668                 /* Do not do this for root of the tree */
 669                 LASSERT(dentry->d_parent && dentry->d_parent->d_inode);
 670                 ll_inode2id(&parent, dentry->d_parent->d_inode);
 671                 ll_inode2id(&child, inode);
 672                 md_change_cbdata_name(sbi->ll_md_exp, &parent,
 673                                       (char *)dentry->d_name.name,
 674                                       dentry->d_name.len, &child,
 675                                       null_if_equal, inode);
 676         }
 677         iput(inode);
 678
 679 }
 680 #endif
 681
 682 struct dentry_operations ll_d_ops = {
 683 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
 684         .d_revalidate = ll_revalidate_nd,
 685 #else
 686         .d_revalidate_it = ll_revalidate_it,
 687 #endif
 688         .d_release = ll_release,
 689         /*.d_iput = ll_dentry_iput,*/
 690         .d_delete = ll_ddelete,
 691         .d_compare = ll_dcompare,
 692 #if 0
 693         .d_pin = ll_pin,
 694         .d_unpin = ll_unpin,
 695 #endif
 696 };