1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2 * vim:expandtab:shiftwidth=8:tabstop=8:
4 * Copyright (c) 2002, 2003 Cluster File Systems, Inc.
6 * This file is part of Lustre, http://www.lustre.org.
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.
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.
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.
21 * derived in small part from linux/fs/ext2/namei.c
23 * Copyright (C) 1991, 1992 Linus Torvalds
25 * Big-endian to little-endian byte-swapping/bitmaps by
26 * David S. Miller (davem@caip.rutgers.edu), 1995
27 * Directory entry file type support and forward compatibility hooks
28 * for B-tree directories by Theodore Ts'o (tytso@mit.edu), 1998
32 #include <linux/sched.h>
34 #include <linux/smp_lock.h>
35 #include <linux/quotaops.h>
36 #include <linux/highmem.h>
37 #include <linux/pagemap.h>
39 #define DEBUG_SUBSYSTEM S_LLITE
41 #include <linux/obd_support.h>
42 #include <linux/lustre_lite.h>
43 #include <linux/lustre_dlm.h>
44 #include <linux/lustre_version.h>
45 #include "llite_internal.h"
49 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
50 static int ll_test_inode(struct inode *inode, unsigned long ino, void *opaque)
52 static int ll_test_inode(struct inode *inode, void *opaque)
55 static int last_ino, last_gen, last_count;
56 struct lustre_md *md = opaque;
58 if (!(md->body->valid & (OBD_MD_FLGENER | OBD_MD_FLID))) {
59 CERROR("MDS body missing inum or generation\n");
63 if (last_ino == md->body->ino && last_gen == md->body->generation &&
68 CDEBUG(D_VFSTRACE, "compared %u/%u %u times\n",
69 last_ino, last_gen, last_count);
71 last_ino = md->body->ino;
72 last_gen = md->body->generation;
74 "comparing inode %p ino %lu/%u/%u to body %u/%u/%u\n",
75 inode, inode->i_ino, inode->i_generation,
76 ll_i2info(inode)->lli_mds,
77 md->body->ino, md->body->generation,
81 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
82 if (inode->i_ino != md->body->ino)
85 if (inode->i_generation != md->body->generation)
88 if (ll_i2info(inode)->lli_mds != md->body->mds)
90 /* Apply the attributes in 'opaque' to this inode */
91 ll_update_inode(inode, md);
95 extern struct dentry_operations ll_d_ops;
97 int ll_unlock(__u32 mode, struct lustre_handle *lockh)
101 ldlm_lock_decref(lockh, mode);
106 /* Get an inode by inode number (already instantiated by the intent lookup).
107 * Returns inode or NULL
109 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
110 int ll_set_inode(struct inode *inode, void *opaque)
112 ll_read_inode2(inode, opaque);
116 struct inode *ll_iget(struct super_block *sb, ino_t hash,
117 struct lustre_md *md)
122 inode = iget5_locked(sb, hash, ll_test_inode, ll_set_inode, md);
125 if (inode->i_state & I_NEW)
126 unlock_new_inode(inode);
127 CDEBUG(D_VFSTRACE, "inode: %lu/%u(%p)\n", inode->i_ino,
128 inode->i_generation, inode);
134 struct inode *ll_iget(struct super_block *sb, ino_t hash,
135 struct lustre_md *md)
139 inode = iget4(sb, hash, ll_test_inode, md);
141 CDEBUG(D_VFSTRACE, "inode: %lu/%u(%p)\n", inode->i_ino,
142 inode->i_generation, inode);
147 int ll_mdc_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc,
148 void *data, int flag)
151 struct lustre_handle lockh;
155 case LDLM_CB_BLOCKING:
156 ldlm_lock2handle(lock, &lockh);
157 rc = ldlm_cli_cancel(&lockh);
159 CDEBUG(D_INODE, "ldlm_cli_cancel: %d\n", rc);
163 case LDLM_CB_CANCELING: {
164 struct inode *inode = ll_inode_from_lock(lock);
165 __u64 bits = lock->l_policy_data.l_inodebits.bits;
167 /* For lookup locks: Invalidate all dentries associated with
168 this inode, for UPDATE locks - invalidate directory pages */
172 if (bits & MDS_INODELOCK_UPDATE)
173 clear_bit(LLI_F_HAVE_MDS_SIZE_LOCK,
174 &(ll_i2info(inode)->lli_flags));
177 if (lock->l_resource->lr_name.name[0] != inode->i_ino ||
178 lock->l_resource->lr_name.name[1] != inode->i_generation) {
179 LDLM_ERROR(lock, "data mismatch with ino %lu/%u(%p)",
180 inode->i_ino, inode->i_generation, inode);
183 /* If lookup lock is cancelled, we just drop the dentry and
184 this will cause us to reget data from MDS when we'd want to
185 access this dentry/inode again. If this is lock on
186 other parts of inode that is cancelled, we do not need to do
187 much (but need to discard data from readdir, if any), since
188 abscence of lock will cause ll_revalidate_it (called from
189 stat() and similar functions) to renew the data anyway */
190 if (S_ISDIR(inode->i_mode) &&
191 (bits & MDS_INODELOCK_UPDATE)) {
192 CDEBUG(D_INODE, "invalidating inode %lu/%u(%p)\n",
193 inode->i_ino, inode->i_generation, inode);
194 truncate_inode_pages(inode->i_mapping, 0);
197 if (inode->i_sb->s_root &&
198 inode != inode->i_sb->s_root->d_inode &&
199 (bits & MDS_INODELOCK_LOOKUP))
200 ll_unhash_aliases(inode);
211 int ll_mdc_cancel_unused(struct lustre_handle *conn, struct inode *inode,
212 int flags, void *opaque)
214 struct ldlm_res_id res_id =
215 { .name = {inode->i_ino, inode->i_generation} };
216 struct obd_device *obddev = class_conn2obd(conn);
219 RETURN(ldlm_cli_cancel_unused(obddev->obd_namespace, &res_id, flags,
223 /* Search "inode"'s alias list for a dentry that has the same name and parent as
224 * de. If found, return it. If not found, return de. */
225 struct dentry *ll_find_alias(struct inode *inode, struct dentry *de)
227 struct list_head *tmp;
229 spin_lock(&dcache_lock);
230 list_for_each(tmp, &inode->i_dentry) {
231 struct dentry *dentry = list_entry(tmp, struct dentry, d_alias);
233 /* We are called here with 'de' already on the aliases list. */
239 if (dentry->d_parent != de->d_parent)
242 if (dentry->d_name.len != de->d_name.len)
245 if (memcmp(dentry->d_name.name, de->d_name.name,
246 de->d_name.len) != 0)
249 if (!list_empty(&dentry->d_lru))
250 list_del_init(&dentry->d_lru);
252 hlist_del_init(&dentry->d_hash);
253 __d_rehash(dentry, 0); /* avoid taking dcache_lock inside */
254 spin_unlock(&dcache_lock);
255 atomic_inc(&dentry->d_count);
257 dentry->d_flags &= ~DCACHE_LUSTRE_INVALID;
258 CDEBUG(D_DENTRY, "alias dentry %*s (%p) parent %p inode %p "
259 "refc %d\n", de->d_name.len, de->d_name.name, de,
260 de->d_parent, de->d_inode, atomic_read(&de->d_count));
264 spin_unlock(&dcache_lock);
269 static int lookup_it_finish(struct ptlrpc_request *request, int offset,
270 struct lookup_intent *it, void *data)
272 struct it_cb_data *icbd = data;
273 struct dentry **de = icbd->icbd_childp;
274 struct inode *parent = icbd->icbd_parent;
275 struct ll_sb_info *sbi = ll_i2sbi(parent);
276 struct dentry *dentry = *de, *saved = *de;
277 struct inode *inode = NULL;
280 /* NB 1 request reference will be taken away by ll_intent_lock()
282 if (!it_disposition(it, DISP_LOOKUP_NEG)) {
285 rc = ll_prep_inode(sbi->ll_osc_exp, sbi->ll_mdc_exp,
286 &inode, request, offset, dentry->d_sb);
290 CDEBUG(D_DLMTRACE, "setting l_data to inode %p (%lu/%u)\n",
291 inode, inode->i_ino, inode->i_generation);
292 mdc_set_lock_data(NULL, &it->d.lustre.it_lock_handle, inode);
294 /* If this is a stat, get the authoritative file size */
295 if (it->it_op == IT_GETATTR && S_ISREG(inode->i_mode) &&
296 ll_i2info(inode)->lli_smd != NULL) {
297 struct lov_stripe_md *lsm = ll_i2info(inode)->lli_smd;
300 LASSERT(lsm->lsm_object_id != 0);
302 /* bug 2334: drop MDS lock before acquiring OST lock */
303 ll_intent_drop_lock(it);
305 rc = ll_glimpse_size(inode);
312 dentry = *de = ll_find_alias(inode, dentry);
317 dentry->d_op = &ll_d_ops;
320 if (dentry == saved) {
321 d_add(dentry, inode);
328 static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry,
329 struct nameidata *nd,
330 struct lookup_intent *it, int flags)
332 struct dentry *save = dentry, *retval;
334 struct it_cb_data icbd;
335 struct ptlrpc_request *req = NULL;
336 struct lookup_intent lookup_it = { .it_op = IT_LOOKUP };
340 if (dentry->d_name.len > EXT3_NAME_LEN)
341 RETURN(ERR_PTR(-ENAMETOOLONG));
343 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p),intent=%s\n",
344 dentry->d_name.name, parent->i_ino, parent->i_generation,
345 parent, LL_IT2STR(it));
347 if (d_mountpoint(dentry))
348 CERROR("Tell Peter, lookup on mtpt, it %s\n", LL_IT2STR(it));
351 nd->mnt->mnt_last_used = jiffies;
353 ll_frob_intent(&it, &lookup_it);
355 icbd.icbd_childp = &dentry;
356 icbd.icbd_parent = parent;
357 ll_inode2fid(&pfid, parent);
359 rc = md_intent_lock(ll_i2mdcexp(parent), &pfid,
360 dentry->d_name.name, dentry->d_name.len, NULL, 0,
361 NULL, it, flags, &req, ll_mdc_blocking_ast);
363 GOTO(out, retval = ERR_PTR(rc));
365 rc = lookup_it_finish(req, 1, it, &icbd);
367 ll_intent_release(it);
368 GOTO(out, retval = ERR_PTR(rc));
371 ll_lookup_finish_locks(it, dentry);
374 dentry->d_inode != NULL && dentry->d_inode->i_mode & S_ISUID &&
375 S_ISDIR(dentry->d_inode->i_mode) &&
376 (flags & LOOKUP_CONTINUE || (it->it_op & (IT_CHDIR | IT_OPEN))))
377 ll_dir_process_mount_object(dentry, nd->mnt);
380 GOTO(out, retval = NULL);
382 GOTO(out, retval = dentry);
385 ptlrpc_req_finished(req);
387 CDEBUG(D_INODE, "lookup 0x%p in %lu/%lu: %*s -> %lu/%lu\n",
389 (unsigned long) parent->i_ino,
390 (unsigned long) parent->i_generation,
391 dentry->d_name.len, dentry->d_name.name,
392 (unsigned long) dentry->d_inode->i_ino,
393 (unsigned long) dentry->d_inode->i_generation);
395 CDEBUG(D_INODE, "lookup 0x%p in %lu/%lu: %*s -> ??\n",
397 (unsigned long) parent->i_ino,
398 (unsigned long) parent->i_generation,
399 dentry->d_name.len, dentry->d_name.name);
403 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
404 static struct dentry *ll_lookup_nd(struct inode *parent, struct dentry *dentry,
405 struct nameidata *nd)
410 if (nd && nd->flags & LOOKUP_LAST && !(nd->flags & LOOKUP_LINK_NOTLAST))
411 de = ll_lookup_it(parent, dentry, nd, &nd->intent, nd->flags);
413 de = ll_lookup_it(parent, dentry, nd, NULL, 0);
419 /* We depend on "mode" being set with the proper file type/umask by now */
420 static struct inode *ll_create_node(struct inode *dir, const char *name,
421 int namelen, const void *data, int datalen,
422 int mode, __u64 extra,
423 struct lookup_intent *it)
425 struct inode *inode = NULL;
426 struct ptlrpc_request *request = NULL;
427 struct ll_sb_info *sbi = ll_i2sbi(dir);
431 LASSERT(it && it->d.lustre.it_disposition);
433 request = it->d.lustre.it_data;
434 rc = ll_prep_inode(sbi->ll_osc_exp, sbi->ll_mdc_exp,
435 &inode, request, 1, dir->i_sb);
437 GOTO(out, inode = ERR_PTR(rc));
439 LASSERT(list_empty(&inode->i_dentry));
441 /* We asked for a lock on the directory, but were granted a
442 * lock on the inode. Since we finally have an inode pointer,
443 * stuff it in the lock. */
444 CDEBUG(D_DLMTRACE, "setting l_ast_data to inode %p (%lu/%u)\n",
445 inode, inode->i_ino, inode->i_generation);
446 mdc_set_lock_data(NULL, &it->d.lustre.it_lock_handle, inode);
449 ptlrpc_req_finished(request);
454 * By the time this is called, we already have created the directory cache
455 * entry for the new file, but it is so far negative - it has no inode.
457 * We defer creating the OBD object(s) until open, to keep the intent and
458 * non-intent code paths similar, and also because we do not have the MDS
459 * inode number before calling ll_create_node() (which is needed for LOV),
460 * so we would need to do yet another RPC to the MDS to store the LOV EA
461 * data on the MDS. If needed, we would pass the PACKED lmm as data and
462 * lmm_size in datalen (the MDS still has code which will handle that).
464 * If the create succeeds, we fill in the inode information
465 * with d_instantiate().
467 static int ll_create_it(struct inode *dir, struct dentry *dentry, int mode,
468 struct lookup_intent *it)
471 struct ptlrpc_request *request = it->d.lustre.it_data;
472 struct obd_export *mdc_exp = ll_i2mdcexp(dir);
476 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p),intent=%s\n",
477 dentry->d_name.name, dir->i_ino, dir->i_generation, dir,
480 rc = it_open_error(DISP_OPEN_CREATE, it);
484 mdc_store_inode_generation(mdc_exp, request, MDS_REQ_INTENT_REC_OFF, 1);
485 inode = ll_create_node(dir, dentry->d_name.name, dentry->d_name.len,
486 NULL, 0, mode, 0, it);
488 RETURN(PTR_ERR(inode));
491 d_instantiate(dentry, inode);
495 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
496 static int ll_create_nd(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd)
498 return ll_create_it(dir, dentry, mode, &nd->intent);
502 static void ll_update_times(struct ptlrpc_request *request, int offset,
505 struct mds_body *body = lustre_msg_buf(request->rq_repmsg, offset,
509 if (body->valid & OBD_MD_FLMTIME &&
510 body->mtime > LTIME_S(inode->i_mtime)) {
511 CDEBUG(D_INODE, "setting ino %lu mtime from %lu to %u\n",
512 inode->i_ino, LTIME_S(inode->i_mtime), body->mtime);
513 LTIME_S(inode->i_mtime) = body->mtime;
515 if (body->valid & OBD_MD_FLCTIME &&
516 body->ctime > LTIME_S(inode->i_ctime))
517 LTIME_S(inode->i_ctime) = body->ctime;
520 static int ll_mknod_raw(struct nameidata *nd, int mode, dev_t rdev)
522 struct ptlrpc_request *request = NULL;
523 struct inode *dir = nd->dentry->d_inode;
524 const char *name = nd->last.name;
525 int len = nd->last.len;
526 struct ll_sb_info *sbi = ll_i2sbi(dir);
527 struct mdc_op_data op_data;
531 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
532 name, dir->i_ino, dir->i_generation, dir);
534 if (dir->i_nlink >= EXT3_LINK_MAX)
537 mode &= ~current->fs->umask;
539 switch (mode & S_IFMT) {
542 mode |= S_IFREG; /* for mode = 0 case, fallthrough */
547 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
548 err = md_create(sbi->ll_mdc_exp, &op_data, NULL, 0, mode,
549 current->fsuid, current->fsgid, rdev, &request);
551 ll_update_times(request, 0, dir);
552 ptlrpc_req_finished(request);
563 static int ll_mknod(struct inode *dir, struct dentry *child, int mode,
566 struct ptlrpc_request *request = NULL;
567 struct inode *inode = NULL;
568 const char *name = child->d_name.name;
569 int len = child->d_name.len;
570 struct ll_sb_info *sbi = ll_i2sbi(dir);
571 struct mdc_op_data op_data;
575 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
576 name, dir->i_ino, dir->i_generation, dir);
578 if (dir->i_nlink >= EXT3_LINK_MAX)
581 mode &= ~current->fs->umask;
583 switch (mode & S_IFMT) {
586 mode |= S_IFREG; /* for mode = 0 case, fallthrough */
591 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
592 err = md_create(sbi->ll_mdc_exp, &op_data, NULL, 0, mode,
593 current->fsuid, current->fsgid, rdev, &request);
597 ll_update_times(request, 0, dir);
599 err = ll_prep_inode(sbi->ll_osc_exp, sbi->ll_mdc_exp,
600 &inode, request, 0, child->d_sb);
611 d_instantiate(child, inode);
613 ptlrpc_req_finished(request);
617 static int ll_symlink_raw(struct nameidata *nd, const char *tgt)
619 struct inode *dir = nd->dentry->d_inode;
620 const char *name = nd->last.name;
621 int len = nd->last.len;
622 struct ptlrpc_request *request = NULL;
623 struct ll_sb_info *sbi = ll_i2sbi(dir);
624 struct mdc_op_data op_data;
628 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p),target=%s\n",
629 name, dir->i_ino, dir->i_generation, dir, tgt);
631 if (dir->i_nlink >= EXT3_LINK_MAX)
634 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
635 err = md_create(sbi->ll_mdc_exp, &op_data,
636 tgt, strlen(tgt) + 1, S_IFLNK | S_IRWXUGO,
637 current->fsuid, current->fsgid, 0, &request);
639 ll_update_times(request, 0, dir);
641 ptlrpc_req_finished(request);
645 static int ll_link_raw(struct nameidata *srcnd, struct nameidata *tgtnd)
647 struct inode *src = srcnd->dentry->d_inode;
648 struct inode *dir = tgtnd->dentry->d_inode;
649 const char *name = tgtnd->last.name;
650 int len = tgtnd->last.len;
651 struct ptlrpc_request *request = NULL;
652 struct mdc_op_data op_data;
654 struct ll_sb_info *sbi = ll_i2sbi(dir);
657 CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),dir=%lu/%u(%p),target=%s\n",
658 src->i_ino, src->i_generation, src,
659 dir->i_ino, dir->i_generation, dir, name);
661 ll_prepare_mdc_op_data(&op_data, src, dir, name, len, 0);
662 err = md_link(sbi->ll_mdc_exp, &op_data, &request);
664 ll_update_times(request, 0, dir);
665 ptlrpc_req_finished(request);
670 static int ll_mkdir_raw(struct nameidata *nd, int mode)
672 struct inode *dir = nd->dentry->d_inode;
673 const char *name = nd->last.name;
674 int len = nd->last.len;
675 struct ptlrpc_request *request = NULL;
676 struct ll_sb_info *sbi = ll_i2sbi(dir);
677 struct mdc_op_data op_data;
680 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
681 name, dir->i_ino, dir->i_generation, dir);
683 mode = (mode & (S_IRWXUGO|S_ISVTX) & ~current->fs->umask) | S_IFDIR;
684 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
685 err = md_create(sbi->ll_mdc_exp, &op_data, NULL, 0, mode,
686 current->fsuid, current->fsgid, 0, &request);
688 ll_update_times(request, 0, dir);
689 ptlrpc_req_finished(request);
693 static int ll_rmdir_raw(struct nameidata *nd)
695 struct inode *dir = nd->dentry->d_inode;
696 const char *name = nd->last.name;
697 int len = nd->last.len;
698 struct ptlrpc_request *request = NULL;
699 struct mdc_op_data op_data;
702 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
703 name, dir->i_ino, dir->i_generation, dir);
705 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, S_IFDIR);
706 rc = md_unlink(ll_i2sbi(dir)->ll_mdc_exp, &op_data, &request);
708 ll_update_times(request, 0, dir);
709 ptlrpc_req_finished(request);
713 int ll_objects_destroy(struct ptlrpc_request *request,
714 struct inode *dir, int offset)
716 struct mds_body *body;
717 struct lov_mds_md *eadata;
718 struct lov_stripe_md *lsm = NULL;
719 struct obd_trans_info oti = { 0 };
724 /* req is swabbed so this is safe */
725 body = lustre_msg_buf(request->rq_repmsg, 0, sizeof(*body));
727 if (!(body->valid & OBD_MD_FLEASIZE))
730 if (body->eadatasize == 0) {
731 CERROR("OBD_MD_FLEASIZE set but eadatasize zero\n");
732 GOTO(out, rc = -EPROTO);
735 /* The MDS sent back the EA because we unlinked the last reference
736 * to this file. Use this EA to unlink the objects on the OST.
737 * It's opaque so we don't swab here; we leave it to obd_unpackmd() to
738 * check it is complete and sensible. */
739 eadata = lustre_swab_repbuf(request, 1, body->eadatasize, NULL);
740 LASSERT(eadata != NULL);
741 if (eadata == NULL) {
742 CERROR("Can't unpack MDS EA data\n");
743 GOTO(out, rc = -EPROTO);
746 rc = obd_unpackmd(ll_i2obdexp(dir), &lsm, eadata, body->eadatasize);
748 CERROR("obd_unpackmd: %d\n", rc);
751 LASSERT(rc >= sizeof(*lsm));
755 GOTO(out_free_memmd, rc = -ENOMEM);
757 oa->o_id = lsm->lsm_object_id;
758 oa->o_gr = lsm->lsm_object_gr;
759 oa->o_mode = body->mode & S_IFMT;
760 oa->o_valid = OBD_MD_FLID | OBD_MD_FLTYPE | OBD_MD_FLGROUP;
762 if (body->valid & OBD_MD_FLCOOKIE) {
763 int length = sizeof(struct llog_cookie) *
764 lsm->lsm_stripe_count;
765 oa->o_valid |= OBD_MD_FLCOOKIE;
767 lustre_msg_buf(request->rq_repmsg, 2, length);
768 if (oti.oti_logcookies == NULL) {
769 oa->o_valid &= ~OBD_MD_FLCOOKIE;
770 body->valid &= ~OBD_MD_FLCOOKIE;
772 /* copy llog cookies to request to replay unlink
773 * so that the same llog file and records as those created
774 * during fail can be re-created while doing replay
777 memcpy(lustre_msg_buf(request->rq_reqmsg, offset, 0),
778 oti.oti_logcookies, length);
782 rc = obd_destroy(ll_i2obdexp(dir), oa, lsm, &oti);
785 CERROR("obd destroy objid "LPX64" error %d\n",
786 lsm->lsm_object_id, rc);
788 obd_free_memmd(ll_i2obdexp(dir), &lsm);
793 static int ll_unlink_raw(struct nameidata *nd)
795 struct inode *dir = nd->dentry->d_inode;
796 const char *name = nd->last.name;
797 int len = nd->last.len;
798 struct ptlrpc_request *request = NULL;
799 struct mdc_op_data op_data;
802 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
803 name, dir->i_ino, dir->i_generation, dir);
805 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
806 rc = md_unlink(ll_i2sbi(dir)->ll_mdc_exp, &op_data, &request);
809 ll_update_times(request, 0, dir);
811 rc = ll_objects_destroy(request, dir, 2);
813 ptlrpc_req_finished(request);
817 static int ll_rename_raw(struct nameidata *oldnd, struct nameidata *newnd)
819 struct inode *src = oldnd->dentry->d_inode;
820 struct inode *tgt = newnd->dentry->d_inode;
821 const char *oldname = oldnd->last.name;
822 int oldlen = oldnd->last.len;
823 const char *newname = newnd->last.name;
824 int newlen = newnd->last.len;
825 struct ptlrpc_request *request = NULL;
826 struct ll_sb_info *sbi = ll_i2sbi(src);
827 struct mdc_op_data op_data;
830 CDEBUG(D_VFSTRACE, "VFS Op:oldname=%s,src_dir=%lu/%u(%p),newname=%s,"
831 "tgt_dir=%lu/%u(%p)\n", oldname, src->i_ino, src->i_generation,
832 src, newname, tgt->i_ino, tgt->i_generation, tgt);
834 ll_prepare_mdc_op_data(&op_data, src, tgt, NULL, 0, 0);
835 err = md_rename(sbi->ll_mdc_exp, &op_data,
836 oldname, oldlen, newname, newlen, &request);
838 ll_update_times(request, 0, src);
839 ll_update_times(request, 0, tgt);
840 err = ll_objects_destroy(request, src, 3);
843 ptlrpc_req_finished(request);
848 struct inode_operations ll_dir_inode_operations = {
849 .link_raw = ll_link_raw,
850 .unlink_raw = ll_unlink_raw,
851 .symlink_raw = ll_symlink_raw,
852 .mkdir_raw = ll_mkdir_raw,
853 .rmdir_raw = ll_rmdir_raw,
854 .mknod_raw = ll_mknod_raw,
856 .rename_raw = ll_rename_raw,
857 .setattr = ll_setattr,
858 .setattr_raw = ll_setattr_raw,
859 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
860 .create_it = ll_create_it,
861 .lookup_it = ll_lookup_it,
862 .revalidate_it = ll_inode_revalidate_it,
864 .lookup = ll_lookup_nd,
865 .create = ll_create_nd,
866 .getattr_it = ll_getattr,