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)
91 /* Apply the attributes in 'opaque' to this inode */
92 ll_update_inode(inode, md);
96 extern struct dentry_operations ll_d_ops;
98 int ll_unlock(__u32 mode, struct lustre_handle *lockh)
102 ldlm_lock_decref(lockh, mode);
107 /* Get an inode by inode number (already instantiated by the intent lookup).
108 * Returns inode or NULL
110 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
111 int ll_set_inode(struct inode *inode, void *opaque)
113 ll_read_inode2(inode, opaque);
117 struct inode *ll_iget(struct super_block *sb, ino_t hash,
118 struct lustre_md *md)
123 inode = iget5_locked(sb, hash, ll_test_inode, ll_set_inode, md);
126 if (inode->i_state & I_NEW)
127 unlock_new_inode(inode);
128 CDEBUG(D_VFSTRACE, "inode: %lu/%u(%p)\n", inode->i_ino,
129 inode->i_generation, inode);
135 struct inode *ll_iget(struct super_block *sb, ino_t hash,
136 struct lustre_md *md)
140 inode = iget4(sb, hash, ll_test_inode, md);
142 CDEBUG(D_VFSTRACE, "inode: %lu/%u(%p)\n", inode->i_ino,
143 inode->i_generation, inode);
148 int ll_mdc_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc,
149 void *data, int flag)
152 struct lustre_handle lockh;
156 case LDLM_CB_BLOCKING:
157 ldlm_lock2handle(lock, &lockh);
158 rc = ldlm_cli_cancel(&lockh);
160 CDEBUG(D_INODE, "ldlm_cli_cancel: %d\n", rc);
164 case LDLM_CB_CANCELING: {
165 struct inode *inode = ll_inode_from_lock(lock);
166 __u64 bits = lock->l_policy_data.l_inodebits.bits;
168 /* For lookup locks: Invalidate all dentries associated with
169 this inode, for UPDATE locks - invalidate directory pages */
173 if (bits & MDS_INODELOCK_UPDATE)
174 clear_bit(LLI_F_HAVE_MDS_SIZE_LOCK,
175 &(ll_i2info(inode)->lli_flags));
178 if (lock->l_resource->lr_name.name[0] != inode->i_ino ||
179 lock->l_resource->lr_name.name[1] != inode->i_generation) {
180 LDLM_ERROR(lock, "data mismatch with ino %lu/%u",
181 inode->i_ino, inode->i_generation);
184 /* If lookup lock is cancelled, we just drop the dentry and
185 this will cause us to reget data from MDS when we'd want to
186 access this dentry/inode again. If this is lock on
187 other parts of inode that is cancelled, we do not need to do
188 much (but need to discard data from readdir, if any), since
189 abscence of lock will cause ll_revalidate_it (called from
190 stat() and similar functions) to renew the data anyway */
191 if (S_ISDIR(inode->i_mode) &&
192 (bits & MDS_INODELOCK_UPDATE)) {
193 CDEBUG(D_INODE, "invalidating inode %lu\n",
196 truncate_inode_pages(inode->i_mapping, 0);
199 if (inode->i_sb->s_root &&
200 inode != inode->i_sb->s_root->d_inode &&
201 (bits & MDS_INODELOCK_LOOKUP))
202 ll_unhash_aliases(inode);
213 int ll_mdc_cancel_unused(struct lustre_handle *conn, struct inode *inode,
214 int flags, void *opaque)
216 struct ldlm_res_id res_id =
217 { .name = {inode->i_ino, inode->i_generation} };
218 struct obd_device *obddev = class_conn2obd(conn);
221 RETURN(ldlm_cli_cancel_unused(obddev->obd_namespace, &res_id, flags,
225 /* Search "inode"'s alias list for a dentry that has the same name and parent as
226 * de. If found, return it. If not found, return de. */
227 struct dentry *ll_find_alias(struct inode *inode, struct dentry *de)
229 struct list_head *tmp;
231 spin_lock(&dcache_lock);
232 list_for_each(tmp, &inode->i_dentry) {
233 struct dentry *dentry = list_entry(tmp, struct dentry, d_alias);
235 /* We are called here with 'de' already on the aliases list. */
241 if (dentry->d_parent != de->d_parent)
244 if (dentry->d_name.len != de->d_name.len)
247 if (memcmp(dentry->d_name.name, de->d_name.name,
248 de->d_name.len) != 0)
251 if (!list_empty(&dentry->d_lru))
252 list_del_init(&dentry->d_lru);
254 hlist_del_init(&dentry->d_hash);
255 __d_rehash(dentry, 0); /* avoid taking dcache_lock inside */
256 spin_unlock(&dcache_lock);
257 atomic_inc(&dentry->d_count);
259 dentry->d_flags &= ~DCACHE_LUSTRE_INVALID;
260 CDEBUG(D_DENTRY, "alias dentry %*s (%p) parent %p inode %p "
261 "refc %d\n", de->d_name.len, de->d_name.name, de,
262 de->d_parent, de->d_inode, atomic_read(&de->d_count));
266 spin_unlock(&dcache_lock);
271 static int lookup_it_finish(struct ptlrpc_request *request, int offset,
272 struct lookup_intent *it, void *data)
274 struct it_cb_data *icbd = data;
275 struct dentry **de = icbd->icbd_childp;
276 struct inode *parent = icbd->icbd_parent;
277 struct ll_sb_info *sbi = ll_i2sbi(parent);
278 struct dentry *dentry = *de, *saved = *de;
279 struct inode *inode = NULL;
282 /* NB 1 request reference will be taken away by ll_intent_lock()
284 if (!it_disposition(it, DISP_LOOKUP_NEG)) {
287 rc = ll_prep_inode(sbi->ll_osc_exp, sbi->ll_mdc_exp,
288 &inode, request, offset, dentry->d_sb);
292 CDEBUG(D_DLMTRACE, "setting l_data to inode %p (%lu/%u)\n",
293 inode, inode->i_ino, inode->i_generation);
294 mdc_set_lock_data(NULL, &it->d.lustre.it_lock_handle, inode);
296 /* If this is a stat, get the authoritative file size */
297 if (it->it_op == IT_GETATTR && S_ISREG(inode->i_mode) &&
298 ll_i2info(inode)->lli_smd != NULL) {
299 struct lov_stripe_md *lsm = ll_i2info(inode)->lli_smd;
303 LASSERT(lsm->lsm_object_id != 0);
305 /* bug 2334: drop MDS lock before acquiring OST lock */
306 ll_intent_drop_lock(it);
308 rc = ll_glimpse_size(inode, &lvb);
313 inode->i_size = lvb.lvb_size;
316 dentry = *de = ll_find_alias(inode, dentry);
321 dentry->d_op = &ll_d_ops;
324 if (dentry == saved) {
325 d_add(dentry, inode);
332 static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry,
333 struct nameidata *nd,
334 struct lookup_intent *it, int flags)
336 struct dentry *save = dentry, *retval;
338 struct ll_uctxt ctxt;
339 struct it_cb_data icbd;
340 struct ptlrpc_request *req = NULL;
341 struct lookup_intent lookup_it = { .it_op = IT_LOOKUP };
345 if (dentry->d_name.len > EXT3_NAME_LEN)
346 RETURN(ERR_PTR(-ENAMETOOLONG));
348 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p),intent=%s\n",
349 dentry->d_name.name, parent->i_ino, parent->i_generation,
350 parent, LL_IT2STR(it));
352 if (d_mountpoint(dentry))
353 CERROR("Tell Peter, lookup on mtpt, it %s\n", LL_IT2STR(it));
356 nd->mnt->mnt_last_used = jiffies;
358 ll_frob_intent(&it, &lookup_it);
360 icbd.icbd_childp = &dentry;
361 icbd.icbd_parent = parent;
362 ll_inode2fid(&pfid, parent);
363 ll_i2uctxt(&ctxt, parent, NULL);
365 rc = md_intent_lock(ll_i2mdcexp(parent), &ctxt, &pfid,
366 dentry->d_name.name, dentry->d_name.len, NULL, 0,
367 NULL, it, flags, &req, ll_mdc_blocking_ast);
369 GOTO(out, retval = ERR_PTR(rc));
371 rc = lookup_it_finish(req, 1, it, &icbd);
373 ll_intent_release(it);
374 GOTO(out, retval = ERR_PTR(rc));
377 ll_lookup_finish_locks(it, dentry);
380 dentry->d_inode != NULL && dentry->d_inode->i_mode & S_ISUID &&
381 (flags & LOOKUP_CONTINUE || (it->it_op & (IT_CHDIR | IT_OPEN))))
382 ll_dir_process_mount_object(dentry, nd->mnt);
385 GOTO(out, retval = NULL);
387 GOTO(out, retval = dentry);
390 ptlrpc_req_finished(req);
392 CDEBUG(D_INODE, "lookup 0x%p in %lu/%lu: %*s -> %lu/%lu\n",
394 (unsigned long) parent->i_ino,
395 (unsigned long) parent->i_generation,
396 dentry->d_name.len, dentry->d_name.name,
397 (unsigned long) dentry->d_inode->i_ino,
398 (unsigned long) dentry->d_inode->i_generation);
400 CDEBUG(D_INODE, "lookup 0x%p in %lu/%lu: %*s -> ??\n",
402 (unsigned long) parent->i_ino,
403 (unsigned long) parent->i_generation,
404 dentry->d_name.len, dentry->d_name.name);
408 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
409 static struct dentry *ll_lookup_nd(struct inode *parent, struct dentry *dentry,
410 struct nameidata *nd)
415 if (nd && nd->flags & LOOKUP_LAST && !(nd->flags & LOOKUP_LINK_NOTLAST))
416 de = ll_lookup_it(parent, dentry, nd, &nd->intent, nd->flags);
418 de = ll_lookup_it(parent, dentry, nd, NULL, 0);
424 /* We depend on "mode" being set with the proper file type/umask by now */
425 static struct inode *ll_create_node(struct inode *dir, const char *name,
426 int namelen, const void *data, int datalen,
427 int mode, __u64 extra,
428 struct lookup_intent *it)
430 struct inode *inode = NULL;
431 struct ptlrpc_request *request = NULL;
432 struct ll_sb_info *sbi = ll_i2sbi(dir);
436 LASSERT(it && it->d.lustre.it_disposition);
438 request = it->d.lustre.it_data;
439 rc = ll_prep_inode(sbi->ll_osc_exp, sbi->ll_mdc_exp,
440 &inode, request, 1, dir->i_sb);
442 GOTO(out, inode = ERR_PTR(rc));
444 LASSERT(list_empty(&inode->i_dentry));
446 /* We asked for a lock on the directory, but were granted a
447 * lock on the inode. Since we finally have an inode pointer,
448 * stuff it in the lock. */
449 CDEBUG(D_DLMTRACE, "setting l_ast_data to inode %p (%lu/%u)\n",
450 inode, inode->i_ino, inode->i_generation);
451 mdc_set_lock_data(NULL, &it->d.lustre.it_lock_handle, inode);
454 ptlrpc_req_finished(request);
459 * By the time this is called, we already have created the directory cache
460 * entry for the new file, but it is so far negative - it has no inode.
462 * We defer creating the OBD object(s) until open, to keep the intent and
463 * non-intent code paths similar, and also because we do not have the MDS
464 * inode number before calling ll_create_node() (which is needed for LOV),
465 * so we would need to do yet another RPC to the MDS to store the LOV EA
466 * data on the MDS. If needed, we would pass the PACKED lmm as data and
467 * lmm_size in datalen (the MDS still has code which will handle that).
469 * If the create succeeds, we fill in the inode information
470 * with d_instantiate().
472 static int ll_create_it(struct inode *dir, struct dentry *dentry, int mode,
473 struct lookup_intent *it)
476 struct ptlrpc_request *request = it->d.lustre.it_data;
477 struct obd_export *mdc_exp = ll_i2mdcexp(dir);
481 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p),intent=%s\n",
482 dentry->d_name.name, dir->i_ino, dir->i_generation, dir,
485 rc = it_open_error(DISP_OPEN_CREATE, it);
489 mdc_store_inode_generation(mdc_exp, request, 2, 1);
490 inode = ll_create_node(dir, dentry->d_name.name, dentry->d_name.len,
491 NULL, 0, mode, 0, it);
493 RETURN(PTR_ERR(inode));
496 d_instantiate(dentry, inode);
500 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
501 static int ll_create_nd(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd)
503 return ll_create_it(dir, dentry, mode, &nd->intent);
507 static int ll_mknod_raw(struct nameidata *nd, int mode, dev_t rdev)
509 struct ptlrpc_request *request = NULL;
510 struct inode *dir = nd->dentry->d_inode;
511 const char *name = nd->last.name;
512 int len = nd->last.len;
513 struct ll_sb_info *sbi = ll_i2sbi(dir);
514 struct mdc_op_data op_data;
518 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
519 name, dir->i_ino, dir->i_generation, dir);
521 if (dir->i_nlink >= EXT3_LINK_MAX)
524 mode &= ~current->fs->umask;
526 switch (mode & S_IFMT) {
529 mode |= S_IFREG; /* for mode = 0 case, fallthrough */
534 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
535 err = md_create(sbi->ll_mdc_exp, &op_data, NULL, 0, mode,
536 current->fsuid, current->fsgid, rdev, &request);
537 ptlrpc_req_finished(request);
548 static int ll_mknod(struct inode *dir, struct dentry *child, int mode,
551 struct ptlrpc_request *request = NULL;
552 struct inode *inode = NULL;
553 const char *name = child->d_name.name;
554 int len = child->d_name.len;
555 struct ll_sb_info *sbi = ll_i2sbi(dir);
556 struct mdc_op_data op_data;
560 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
561 name, dir->i_ino, dir->i_generation, dir);
563 if (dir->i_nlink >= EXT3_LINK_MAX)
566 mode &= ~current->fs->umask;
568 switch (mode & S_IFMT) {
571 mode |= S_IFREG; /* for mode = 0 case, fallthrough */
576 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
577 err = md_create(sbi->ll_mdc_exp, &op_data, NULL, 0, mode,
578 current->fsuid, current->fsgid, rdev, &request);
579 err = ll_prep_inode(sbi->ll_osc_exp, sbi->ll_mdc_exp,
580 &inode, request, 0, child->d_sb);
591 d_instantiate(child, inode);
593 ptlrpc_req_finished(request);
597 static int ll_symlink_raw(struct nameidata *nd, const char *tgt)
599 struct inode *dir = nd->dentry->d_inode;
600 const char *name = nd->last.name;
601 int len = nd->last.len;
602 struct ptlrpc_request *request = NULL;
603 struct ll_sb_info *sbi = ll_i2sbi(dir);
604 struct mdc_op_data op_data;
608 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p),target=%s\n",
609 name, dir->i_ino, dir->i_generation, dir, tgt);
611 if (dir->i_nlink >= EXT3_LINK_MAX)
614 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
615 err = md_create(sbi->ll_mdc_exp, &op_data,
616 tgt, strlen(tgt) + 1, S_IFLNK | S_IRWXUGO,
617 current->fsuid, current->fsgid, 0, &request);
618 ptlrpc_req_finished(request);
622 static int ll_link_raw(struct nameidata *srcnd, struct nameidata *tgtnd)
624 struct inode *src = srcnd->dentry->d_inode;
625 struct inode *dir = tgtnd->dentry->d_inode;
626 const char *name = tgtnd->last.name;
627 int len = tgtnd->last.len;
628 struct ptlrpc_request *request = NULL;
629 struct mdc_op_data op_data;
631 struct ll_sb_info *sbi = ll_i2sbi(dir);
634 CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),dir=%lu/%u(%p),target=%s\n",
635 src->i_ino, src->i_generation, src,
636 dir->i_ino, dir->i_generation, dir, name);
638 ll_prepare_mdc_op_data(&op_data, src, dir, name, len, 0);
639 err = md_link(sbi->ll_mdc_exp, &op_data, &request);
640 ptlrpc_req_finished(request);
646 static int ll_mkdir_raw(struct nameidata *nd, int mode)
648 struct inode *dir = nd->dentry->d_inode;
649 const char *name = nd->last.name;
650 int len = nd->last.len;
651 struct ptlrpc_request *request = NULL;
652 struct ll_sb_info *sbi = ll_i2sbi(dir);
653 struct mdc_op_data op_data;
656 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
657 name, dir->i_ino, dir->i_generation, dir);
659 mode = (mode & (S_IRWXUGO|S_ISVTX) & ~current->fs->umask) | S_IFDIR;
660 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
661 err = md_create(sbi->ll_mdc_exp, &op_data, NULL, 0, mode,
662 current->fsuid, current->fsgid, 0, &request);
663 ptlrpc_req_finished(request);
667 static int ll_rmdir_raw(struct nameidata *nd)
669 struct inode *dir = nd->dentry->d_inode;
670 const char *name = nd->last.name;
671 int len = nd->last.len;
672 struct ptlrpc_request *request = NULL;
673 struct mdc_op_data op_data;
676 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
677 name, dir->i_ino, dir->i_generation, dir);
679 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, S_IFDIR);
680 rc = md_unlink(ll_i2sbi(dir)->ll_mdc_exp, &op_data, &request);
681 ptlrpc_req_finished(request);
685 int ll_objects_destroy(struct ptlrpc_request *request, struct inode *dir)
687 struct mds_body *body;
688 struct lov_mds_md *eadata;
689 struct lov_stripe_md *lsm = NULL;
690 struct obd_trans_info oti = { 0 };
695 /* req is swabbed so this is safe */
696 body = lustre_msg_buf(request->rq_repmsg, 0, sizeof(*body));
698 if (!(body->valid & OBD_MD_FLEASIZE))
701 if (body->eadatasize == 0) {
702 CERROR("OBD_MD_FLEASIZE set but eadatasize zero\n");
703 GOTO(out, rc = -EPROTO);
706 /* The MDS sent back the EA because we unlinked the last reference
707 * to this file. Use this EA to unlink the objects on the OST.
708 * It's opaque so we don't swab here; we leave it to obd_unpackmd() to
709 * check it is complete and sensible. */
710 eadata = lustre_swab_repbuf(request, 1, body->eadatasize, NULL);
711 LASSERT(eadata != NULL);
712 if (eadata == NULL) {
713 CERROR("Can't unpack MDS EA data\n");
714 GOTO(out, rc = -EPROTO);
717 rc = obd_unpackmd(ll_i2obdexp(dir), &lsm, eadata, body->eadatasize);
719 CERROR("obd_unpackmd: %d\n", rc);
722 LASSERT(rc >= sizeof(*lsm));
726 GOTO(out_free_memmd, rc = -ENOMEM);
728 oa->o_id = lsm->lsm_object_id;
729 oa->o_gr = lsm->lsm_object_gr;
730 oa->o_mode = body->mode & S_IFMT;
731 oa->o_valid = OBD_MD_FLID | OBD_MD_FLTYPE | OBD_MD_FLGROUP;
733 if (body->valid & OBD_MD_FLCOOKIE) {
734 oa->o_valid |= OBD_MD_FLCOOKIE;
736 lustre_msg_buf(request->rq_repmsg, 2,
737 sizeof(struct llog_cookie) *
738 lsm->lsm_stripe_count);
739 if (oti.oti_logcookies == NULL) {
740 oa->o_valid &= ~OBD_MD_FLCOOKIE;
741 body->valid &= ~OBD_MD_FLCOOKIE;
745 rc = obd_destroy(ll_i2obdexp(dir), oa, lsm, &oti);
748 CERROR("obd destroy objid "LPX64" error %d\n",
749 lsm->lsm_object_id, rc);
751 obd_free_memmd(ll_i2obdexp(dir), &lsm);
756 static int ll_unlink_raw(struct nameidata *nd)
758 struct inode *dir = nd->dentry->d_inode;
759 const char *name = nd->last.name;
760 int len = nd->last.len;
761 struct ptlrpc_request *request = NULL;
762 struct mdc_op_data op_data;
765 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
766 name, dir->i_ino, dir->i_generation, dir);
768 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
769 rc = md_unlink(ll_i2sbi(dir)->ll_mdc_exp, &op_data, &request);
773 rc = ll_objects_destroy(request, dir);
775 ptlrpc_req_finished(request);
779 static int ll_rename_raw(struct nameidata *oldnd, struct nameidata *newnd)
781 struct inode *src = oldnd->dentry->d_inode;
782 struct inode *tgt = newnd->dentry->d_inode;
783 const char *oldname = oldnd->last.name;
784 int oldlen = oldnd->last.len;
785 const char *newname = newnd->last.name;
786 int newlen = newnd->last.len;
787 struct ptlrpc_request *request = NULL;
788 struct ll_sb_info *sbi = ll_i2sbi(src);
789 struct mdc_op_data op_data;
792 CDEBUG(D_VFSTRACE, "VFS Op:oldname=%s,src_dir=%lu/%u(%p),newname=%s,"
793 "tgt_dir=%lu/%u(%p)\n", oldname, src->i_ino, src->i_generation,
794 src, newname, tgt->i_ino, tgt->i_generation, tgt);
796 ll_prepare_mdc_op_data(&op_data, src, tgt, NULL, 0, 0);
797 err = md_rename(sbi->ll_mdc_exp, &op_data,
798 oldname, oldlen, newname, newlen, &request);
800 err = ll_objects_destroy(request, src);
803 ptlrpc_req_finished(request);
808 struct inode_operations ll_dir_inode_operations = {
809 .link_raw = ll_link_raw,
810 .unlink_raw = ll_unlink_raw,
811 .symlink_raw = ll_symlink_raw,
812 .mkdir_raw = ll_mkdir_raw,
813 .rmdir_raw = ll_rmdir_raw,
814 .mknod_raw = ll_mknod_raw,
816 .rename_raw = ll_rename_raw,
817 .setattr = ll_setattr,
818 .setattr_raw = ll_setattr_raw,
819 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
820 .create_it = ll_create_it,
821 .lookup_it = ll_lookup_it,
822 .revalidate_it = ll_inode_revalidate_it,
824 .lookup = ll_lookup_nd,
825 .create = ll_create_nd,
826 .getattr_it = ll_getattr,