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",
180 inode->i_ino, inode->i_generation);
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\n",
195 truncate_inode_pages(inode->i_mapping, 0);
198 if (inode->i_sb->s_root &&
199 inode != inode->i_sb->s_root->d_inode &&
200 (bits & MDS_INODELOCK_LOOKUP))
201 ll_unhash_aliases(inode);
212 int ll_mdc_cancel_unused(struct lustre_handle *conn, struct inode *inode,
213 int flags, void *opaque)
215 struct ldlm_res_id res_id =
216 { .name = {inode->i_ino, inode->i_generation} };
217 struct obd_device *obddev = class_conn2obd(conn);
220 RETURN(ldlm_cli_cancel_unused(obddev->obd_namespace, &res_id, flags,
224 /* Search "inode"'s alias list for a dentry that has the same name and parent as
225 * de. If found, return it. If not found, return de. */
226 struct dentry *ll_find_alias(struct inode *inode, struct dentry *de)
228 struct list_head *tmp;
230 spin_lock(&dcache_lock);
231 list_for_each(tmp, &inode->i_dentry) {
232 struct dentry *dentry = list_entry(tmp, struct dentry, d_alias);
234 /* We are called here with 'de' already on the aliases list. */
240 if (dentry->d_parent != de->d_parent)
243 if (dentry->d_name.len != de->d_name.len)
246 if (memcmp(dentry->d_name.name, de->d_name.name,
247 de->d_name.len) != 0)
250 if (!list_empty(&dentry->d_lru))
251 list_del_init(&dentry->d_lru);
253 hlist_del_init(&dentry->d_hash);
254 __d_rehash(dentry, 0); /* avoid taking dcache_lock inside */
255 spin_unlock(&dcache_lock);
256 atomic_inc(&dentry->d_count);
258 dentry->d_flags &= ~DCACHE_LUSTRE_INVALID;
259 CDEBUG(D_DENTRY, "alias dentry %*s (%p) parent %p inode %p "
260 "refc %d\n", de->d_name.len, de->d_name.name, de,
261 de->d_parent, de->d_inode, atomic_read(&de->d_count));
265 spin_unlock(&dcache_lock);
270 static int lookup_it_finish(struct ptlrpc_request *request, int offset,
271 struct lookup_intent *it, void *data)
273 struct it_cb_data *icbd = data;
274 struct dentry **de = icbd->icbd_childp;
275 struct inode *parent = icbd->icbd_parent;
276 struct ll_sb_info *sbi = ll_i2sbi(parent);
277 struct dentry *dentry = *de, *saved = *de;
278 struct inode *inode = NULL;
281 /* NB 1 request reference will be taken away by ll_intent_lock()
283 if (!it_disposition(it, DISP_LOOKUP_NEG)) {
286 rc = ll_prep_inode(sbi->ll_osc_exp, sbi->ll_mdc_exp,
287 &inode, request, offset, dentry->d_sb);
291 CDEBUG(D_DLMTRACE, "setting l_data to inode %p (%lu/%u)\n",
292 inode, inode->i_ino, inode->i_generation);
293 mdc_set_lock_data(NULL, &it->d.lustre.it_lock_handle, inode);
295 /* If this is a stat, get the authoritative file size */
296 if (it->it_op == IT_GETATTR && S_ISREG(inode->i_mode) &&
297 ll_i2info(inode)->lli_smd != NULL) {
298 struct lov_stripe_md *lsm = ll_i2info(inode)->lli_smd;
302 LASSERT(lsm->lsm_object_id != 0);
304 /* bug 2334: drop MDS lock before acquiring OST lock */
305 ll_intent_drop_lock(it);
307 rc = ll_glimpse_size(inode, &lvb);
312 inode->i_size = lvb.lvb_size;
315 dentry = *de = ll_find_alias(inode, dentry);
320 dentry->d_op = &ll_d_ops;
323 if (dentry == saved) {
324 d_add(dentry, inode);
331 static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry,
332 struct nameidata *nd,
333 struct lookup_intent *it, int flags)
335 struct dentry *save = dentry, *retval;
337 struct it_cb_data icbd;
338 struct ptlrpc_request *req = NULL;
339 struct lookup_intent lookup_it = { .it_op = IT_LOOKUP };
343 if (dentry->d_name.len > EXT3_NAME_LEN)
344 RETURN(ERR_PTR(-ENAMETOOLONG));
346 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p),intent=%s\n",
347 dentry->d_name.name, parent->i_ino, parent->i_generation,
348 parent, LL_IT2STR(it));
350 if (d_mountpoint(dentry))
351 CERROR("Tell Peter, lookup on mtpt, it %s\n", LL_IT2STR(it));
354 nd->mnt->mnt_last_used = jiffies;
356 ll_frob_intent(&it, &lookup_it);
358 icbd.icbd_childp = &dentry;
359 icbd.icbd_parent = parent;
360 ll_inode2fid(&pfid, parent);
362 rc = md_intent_lock(ll_i2mdcexp(parent), &pfid,
363 dentry->d_name.name, dentry->d_name.len, NULL, 0,
364 NULL, it, flags, &req, ll_mdc_blocking_ast);
366 GOTO(out, retval = ERR_PTR(rc));
368 rc = lookup_it_finish(req, 1, it, &icbd);
370 ll_intent_release(it);
371 GOTO(out, retval = ERR_PTR(rc));
374 ll_lookup_finish_locks(it, dentry);
377 dentry->d_inode != NULL && dentry->d_inode->i_mode & S_ISUID &&
378 S_ISDIR(dentry->d_inode->i_mode) &&
379 (flags & LOOKUP_CONTINUE || (it->it_op & (IT_CHDIR | IT_OPEN))))
380 ll_dir_process_mount_object(dentry, nd->mnt);
383 GOTO(out, retval = NULL);
385 GOTO(out, retval = dentry);
388 ptlrpc_req_finished(req);
390 CDEBUG(D_INODE, "lookup 0x%p in %lu/%lu: %*s -> %lu/%lu\n",
392 (unsigned long) parent->i_ino,
393 (unsigned long) parent->i_generation,
394 dentry->d_name.len, dentry->d_name.name,
395 (unsigned long) dentry->d_inode->i_ino,
396 (unsigned long) dentry->d_inode->i_generation);
398 CDEBUG(D_INODE, "lookup 0x%p in %lu/%lu: %*s -> ??\n",
400 (unsigned long) parent->i_ino,
401 (unsigned long) parent->i_generation,
402 dentry->d_name.len, dentry->d_name.name);
406 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
407 static struct dentry *ll_lookup_nd(struct inode *parent, struct dentry *dentry,
408 struct nameidata *nd)
413 if (nd && nd->flags & LOOKUP_LAST && !(nd->flags & LOOKUP_LINK_NOTLAST))
414 de = ll_lookup_it(parent, dentry, nd, &nd->intent, nd->flags);
416 de = ll_lookup_it(parent, dentry, nd, NULL, 0);
422 /* We depend on "mode" being set with the proper file type/umask by now */
423 static struct inode *ll_create_node(struct inode *dir, const char *name,
424 int namelen, const void *data, int datalen,
425 int mode, __u64 extra,
426 struct lookup_intent *it)
428 struct inode *inode = NULL;
429 struct ptlrpc_request *request = NULL;
430 struct ll_sb_info *sbi = ll_i2sbi(dir);
434 LASSERT(it && it->d.lustre.it_disposition);
436 request = it->d.lustre.it_data;
437 rc = ll_prep_inode(sbi->ll_osc_exp, sbi->ll_mdc_exp,
438 &inode, request, 1, dir->i_sb);
440 GOTO(out, inode = ERR_PTR(rc));
442 LASSERT(list_empty(&inode->i_dentry));
444 /* We asked for a lock on the directory, but were granted a
445 * lock on the inode. Since we finally have an inode pointer,
446 * stuff it in the lock. */
447 CDEBUG(D_DLMTRACE, "setting l_ast_data to inode %p (%lu/%u)\n",
448 inode, inode->i_ino, inode->i_generation);
449 mdc_set_lock_data(NULL, &it->d.lustre.it_lock_handle, inode);
452 ptlrpc_req_finished(request);
457 * By the time this is called, we already have created the directory cache
458 * entry for the new file, but it is so far negative - it has no inode.
460 * We defer creating the OBD object(s) until open, to keep the intent and
461 * non-intent code paths similar, and also because we do not have the MDS
462 * inode number before calling ll_create_node() (which is needed for LOV),
463 * so we would need to do yet another RPC to the MDS to store the LOV EA
464 * data on the MDS. If needed, we would pass the PACKED lmm as data and
465 * lmm_size in datalen (the MDS still has code which will handle that).
467 * If the create succeeds, we fill in the inode information
468 * with d_instantiate().
470 static int ll_create_it(struct inode *dir, struct dentry *dentry, int mode,
471 struct lookup_intent *it)
474 struct ptlrpc_request *request = it->d.lustre.it_data;
475 struct obd_export *mdc_exp = ll_i2mdcexp(dir);
479 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p),intent=%s\n",
480 dentry->d_name.name, dir->i_ino, dir->i_generation, dir,
483 rc = it_open_error(DISP_OPEN_CREATE, it);
487 mdc_store_inode_generation(mdc_exp, request, MDS_REQ_INTENT_REC_OFF, 1);
488 inode = ll_create_node(dir, dentry->d_name.name, dentry->d_name.len,
489 NULL, 0, mode, 0, it);
491 RETURN(PTR_ERR(inode));
494 d_instantiate(dentry, inode);
498 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
499 static int ll_create_nd(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd)
501 return ll_create_it(dir, dentry, mode, &nd->intent);
505 static int ll_mknod_raw(struct nameidata *nd, int mode, dev_t rdev)
507 struct ptlrpc_request *request = NULL;
508 struct inode *dir = nd->dentry->d_inode;
509 const char *name = nd->last.name;
510 int len = nd->last.len;
511 struct ll_sb_info *sbi = ll_i2sbi(dir);
512 struct mdc_op_data op_data;
516 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
517 name, dir->i_ino, dir->i_generation, dir);
519 if (dir->i_nlink >= EXT3_LINK_MAX)
522 mode &= ~current->fs->umask;
524 switch (mode & S_IFMT) {
527 mode |= S_IFREG; /* for mode = 0 case, fallthrough */
532 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
533 err = md_create(sbi->ll_mdc_exp, &op_data, NULL, 0, mode,
534 current->fsuid, current->fsgid, rdev, &request);
535 ptlrpc_req_finished(request);
546 static int ll_mknod(struct inode *dir, struct dentry *child, int mode,
549 struct ptlrpc_request *request = NULL;
550 struct inode *inode = NULL;
551 const char *name = child->d_name.name;
552 int len = child->d_name.len;
553 struct ll_sb_info *sbi = ll_i2sbi(dir);
554 struct mdc_op_data op_data;
558 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
559 name, dir->i_ino, dir->i_generation, dir);
561 if (dir->i_nlink >= EXT3_LINK_MAX)
564 mode &= ~current->fs->umask;
566 switch (mode & S_IFMT) {
569 mode |= S_IFREG; /* for mode = 0 case, fallthrough */
574 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
575 err = md_create(sbi->ll_mdc_exp, &op_data, NULL, 0, mode,
576 current->fsuid, current->fsgid, rdev, &request);
577 err = ll_prep_inode(sbi->ll_osc_exp, sbi->ll_mdc_exp,
578 &inode, request, 0, child->d_sb);
589 d_instantiate(child, inode);
591 ptlrpc_req_finished(request);
595 static int ll_symlink_raw(struct nameidata *nd, const char *tgt)
597 struct inode *dir = nd->dentry->d_inode;
598 const char *name = nd->last.name;
599 int len = nd->last.len;
600 struct ptlrpc_request *request = NULL;
601 struct ll_sb_info *sbi = ll_i2sbi(dir);
602 struct mdc_op_data op_data;
606 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p),target=%s\n",
607 name, dir->i_ino, dir->i_generation, dir, tgt);
609 if (dir->i_nlink >= EXT3_LINK_MAX)
612 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
613 err = md_create(sbi->ll_mdc_exp, &op_data,
614 tgt, strlen(tgt) + 1, S_IFLNK | S_IRWXUGO,
615 current->fsuid, current->fsgid, 0, &request);
616 ptlrpc_req_finished(request);
620 static int ll_link_raw(struct nameidata *srcnd, struct nameidata *tgtnd)
622 struct inode *src = srcnd->dentry->d_inode;
623 struct inode *dir = tgtnd->dentry->d_inode;
624 const char *name = tgtnd->last.name;
625 int len = tgtnd->last.len;
626 struct ptlrpc_request *request = NULL;
627 struct mdc_op_data op_data;
629 struct ll_sb_info *sbi = ll_i2sbi(dir);
632 CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),dir=%lu/%u(%p),target=%s\n",
633 src->i_ino, src->i_generation, src,
634 dir->i_ino, dir->i_generation, dir, name);
636 ll_prepare_mdc_op_data(&op_data, src, dir, name, len, 0);
637 err = md_link(sbi->ll_mdc_exp, &op_data, &request);
638 ptlrpc_req_finished(request);
644 static int ll_mkdir_raw(struct nameidata *nd, int mode)
646 struct inode *dir = nd->dentry->d_inode;
647 const char *name = nd->last.name;
648 int len = nd->last.len;
649 struct ptlrpc_request *request = NULL;
650 struct ll_sb_info *sbi = ll_i2sbi(dir);
651 struct mdc_op_data op_data;
654 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
655 name, dir->i_ino, dir->i_generation, dir);
657 mode = (mode & (S_IRWXUGO|S_ISVTX) & ~current->fs->umask) | S_IFDIR;
658 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
659 err = md_create(sbi->ll_mdc_exp, &op_data, NULL, 0, mode,
660 current->fsuid, current->fsgid, 0, &request);
661 ptlrpc_req_finished(request);
665 static int ll_rmdir_raw(struct nameidata *nd)
667 struct inode *dir = nd->dentry->d_inode;
668 const char *name = nd->last.name;
669 int len = nd->last.len;
670 struct ptlrpc_request *request = NULL;
671 struct mdc_op_data op_data;
674 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
675 name, dir->i_ino, dir->i_generation, dir);
677 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, S_IFDIR);
678 rc = md_unlink(ll_i2sbi(dir)->ll_mdc_exp, &op_data, &request);
679 ptlrpc_req_finished(request);
683 int ll_objects_destroy(struct ptlrpc_request *request,
684 struct inode *dir, int offset)
686 struct mds_body *body;
687 struct lov_mds_md *eadata;
688 struct lov_stripe_md *lsm = NULL;
689 struct obd_trans_info oti = { 0 };
694 /* req is swabbed so this is safe */
695 body = lustre_msg_buf(request->rq_repmsg, 0, sizeof(*body));
697 if (!(body->valid & OBD_MD_FLEASIZE))
700 if (body->eadatasize == 0) {
701 CERROR("OBD_MD_FLEASIZE set but eadatasize zero\n");
702 GOTO(out, rc = -EPROTO);
705 /* The MDS sent back the EA because we unlinked the last reference
706 * to this file. Use this EA to unlink the objects on the OST.
707 * It's opaque so we don't swab here; we leave it to obd_unpackmd() to
708 * check it is complete and sensible. */
709 eadata = lustre_swab_repbuf(request, 1, body->eadatasize, NULL);
710 LASSERT(eadata != NULL);
711 if (eadata == NULL) {
712 CERROR("Can't unpack MDS EA data\n");
713 GOTO(out, rc = -EPROTO);
716 rc = obd_unpackmd(ll_i2obdexp(dir), &lsm, eadata, body->eadatasize);
718 CERROR("obd_unpackmd: %d\n", rc);
721 LASSERT(rc >= sizeof(*lsm));
725 GOTO(out_free_memmd, rc = -ENOMEM);
727 oa->o_id = lsm->lsm_object_id;
728 oa->o_gr = lsm->lsm_object_gr;
729 oa->o_mode = body->mode & S_IFMT;
730 oa->o_valid = OBD_MD_FLID | OBD_MD_FLTYPE | OBD_MD_FLGROUP;
732 if (body->valid & OBD_MD_FLCOOKIE) {
733 int length = sizeof(struct llog_cookie) *
734 lsm->lsm_stripe_count;
735 oa->o_valid |= OBD_MD_FLCOOKIE;
737 lustre_msg_buf(request->rq_repmsg, 2, length);
738 if (oti.oti_logcookies == NULL) {
739 oa->o_valid &= ~OBD_MD_FLCOOKIE;
740 body->valid &= ~OBD_MD_FLCOOKIE;
742 /* copy llog cookies to request to replay unlink
743 * so that the same llog file and records as those created
744 * during fail can be re-created while doing replay
747 memcpy(lustre_msg_buf(request->rq_reqmsg, offset, 0),
748 oti.oti_logcookies, length);
752 rc = obd_destroy(ll_i2obdexp(dir), oa, lsm, &oti);
755 CERROR("obd destroy objid "LPX64" error %d\n",
756 lsm->lsm_object_id, rc);
758 obd_free_memmd(ll_i2obdexp(dir), &lsm);
763 static int ll_unlink_raw(struct nameidata *nd)
765 struct inode *dir = nd->dentry->d_inode;
766 const char *name = nd->last.name;
767 int len = nd->last.len;
768 struct ptlrpc_request *request = NULL;
769 struct mdc_op_data op_data;
772 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
773 name, dir->i_ino, dir->i_generation, dir);
775 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
776 rc = md_unlink(ll_i2sbi(dir)->ll_mdc_exp, &op_data, &request);
780 rc = ll_objects_destroy(request, dir, 2);
782 ptlrpc_req_finished(request);
786 static int ll_rename_raw(struct nameidata *oldnd, struct nameidata *newnd)
788 struct inode *src = oldnd->dentry->d_inode;
789 struct inode *tgt = newnd->dentry->d_inode;
790 const char *oldname = oldnd->last.name;
791 int oldlen = oldnd->last.len;
792 const char *newname = newnd->last.name;
793 int newlen = newnd->last.len;
794 struct ptlrpc_request *request = NULL;
795 struct ll_sb_info *sbi = ll_i2sbi(src);
796 struct mdc_op_data op_data;
799 CDEBUG(D_VFSTRACE, "VFS Op:oldname=%s,src_dir=%lu/%u(%p),newname=%s,"
800 "tgt_dir=%lu/%u(%p)\n", oldname, src->i_ino, src->i_generation,
801 src, newname, tgt->i_ino, tgt->i_generation, tgt);
803 ll_prepare_mdc_op_data(&op_data, src, tgt, NULL, 0, 0);
804 err = md_rename(sbi->ll_mdc_exp, &op_data,
805 oldname, oldlen, newname, newlen, &request);
807 err = ll_objects_destroy(request, src, 3);
810 ptlrpc_req_finished(request);
815 struct inode_operations ll_dir_inode_operations = {
816 .link_raw = ll_link_raw,
817 .unlink_raw = ll_unlink_raw,
818 .symlink_raw = ll_symlink_raw,
819 .mkdir_raw = ll_mkdir_raw,
820 .rmdir_raw = ll_rmdir_raw,
821 .mknod_raw = ll_mknod_raw,
823 .rename_raw = ll_rename_raw,
824 .setattr = ll_setattr,
825 .setattr_raw = ll_setattr_raw,
826 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
827 .create_it = ll_create_it,
828 .lookup_it = ll_lookup_it,
829 .revalidate_it = ll_inode_revalidate_it,
831 .lookup = ll_lookup_nd,
832 .create = ll_create_nd,
833 .getattr_it = ll_getattr,