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 S_ISDIR(dentry->d_inode->i_mode) &&
382 (flags & LOOKUP_CONTINUE || (it->it_op & (IT_CHDIR | IT_OPEN))))
383 ll_dir_process_mount_object(dentry, nd->mnt);
386 GOTO(out, retval = NULL);
388 GOTO(out, retval = dentry);
391 ptlrpc_req_finished(req);
393 CDEBUG(D_INODE, "lookup 0x%p in %lu/%lu: %*s -> %lu/%lu\n",
395 (unsigned long) parent->i_ino,
396 (unsigned long) parent->i_generation,
397 dentry->d_name.len, dentry->d_name.name,
398 (unsigned long) dentry->d_inode->i_ino,
399 (unsigned long) dentry->d_inode->i_generation);
401 CDEBUG(D_INODE, "lookup 0x%p in %lu/%lu: %*s -> ??\n",
403 (unsigned long) parent->i_ino,
404 (unsigned long) parent->i_generation,
405 dentry->d_name.len, dentry->d_name.name);
409 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
410 static struct dentry *ll_lookup_nd(struct inode *parent, struct dentry *dentry,
411 struct nameidata *nd)
416 if (nd && nd->flags & LOOKUP_LAST && !(nd->flags & LOOKUP_LINK_NOTLAST))
417 de = ll_lookup_it(parent, dentry, nd, &nd->intent, nd->flags);
419 de = ll_lookup_it(parent, dentry, nd, NULL, 0);
425 /* We depend on "mode" being set with the proper file type/umask by now */
426 static struct inode *ll_create_node(struct inode *dir, const char *name,
427 int namelen, const void *data, int datalen,
428 int mode, __u64 extra,
429 struct lookup_intent *it)
431 struct inode *inode = NULL;
432 struct ptlrpc_request *request = NULL;
433 struct ll_sb_info *sbi = ll_i2sbi(dir);
437 LASSERT(it && it->d.lustre.it_disposition);
439 request = it->d.lustre.it_data;
440 rc = ll_prep_inode(sbi->ll_osc_exp, sbi->ll_mdc_exp,
441 &inode, request, 1, dir->i_sb);
443 GOTO(out, inode = ERR_PTR(rc));
445 LASSERT(list_empty(&inode->i_dentry));
447 /* We asked for a lock on the directory, but were granted a
448 * lock on the inode. Since we finally have an inode pointer,
449 * stuff it in the lock. */
450 CDEBUG(D_DLMTRACE, "setting l_ast_data to inode %p (%lu/%u)\n",
451 inode, inode->i_ino, inode->i_generation);
452 mdc_set_lock_data(NULL, &it->d.lustre.it_lock_handle, inode);
455 ptlrpc_req_finished(request);
460 * By the time this is called, we already have created the directory cache
461 * entry for the new file, but it is so far negative - it has no inode.
463 * We defer creating the OBD object(s) until open, to keep the intent and
464 * non-intent code paths similar, and also because we do not have the MDS
465 * inode number before calling ll_create_node() (which is needed for LOV),
466 * so we would need to do yet another RPC to the MDS to store the LOV EA
467 * data on the MDS. If needed, we would pass the PACKED lmm as data and
468 * lmm_size in datalen (the MDS still has code which will handle that).
470 * If the create succeeds, we fill in the inode information
471 * with d_instantiate().
473 static int ll_create_it(struct inode *dir, struct dentry *dentry, int mode,
474 struct lookup_intent *it)
477 struct ptlrpc_request *request = it->d.lustre.it_data;
478 struct obd_export *mdc_exp = ll_i2mdcexp(dir);
482 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p),intent=%s\n",
483 dentry->d_name.name, dir->i_ino, dir->i_generation, dir,
486 rc = it_open_error(DISP_OPEN_CREATE, it);
490 mdc_store_inode_generation(mdc_exp, request, 2, 1);
491 inode = ll_create_node(dir, dentry->d_name.name, dentry->d_name.len,
492 NULL, 0, mode, 0, it);
494 RETURN(PTR_ERR(inode));
497 d_instantiate(dentry, inode);
501 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
502 static int ll_create_nd(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd)
504 return ll_create_it(dir, dentry, mode, &nd->intent);
508 static int ll_mknod_raw(struct nameidata *nd, int mode, dev_t rdev)
510 struct ptlrpc_request *request = NULL;
511 struct inode *dir = nd->dentry->d_inode;
512 const char *name = nd->last.name;
513 int len = nd->last.len;
514 struct ll_sb_info *sbi = ll_i2sbi(dir);
515 struct mdc_op_data op_data;
519 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
520 name, dir->i_ino, dir->i_generation, dir);
522 if (dir->i_nlink >= EXT3_LINK_MAX)
525 mode &= ~current->fs->umask;
527 switch (mode & S_IFMT) {
530 mode |= S_IFREG; /* for mode = 0 case, fallthrough */
535 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
536 err = md_create(sbi->ll_mdc_exp, &op_data, NULL, 0, mode,
537 current->fsuid, current->fsgid, rdev, &request);
538 ptlrpc_req_finished(request);
549 static int ll_mknod(struct inode *dir, struct dentry *child, int mode,
552 struct ptlrpc_request *request = NULL;
553 struct inode *inode = NULL;
554 const char *name = child->d_name.name;
555 int len = child->d_name.len;
556 struct ll_sb_info *sbi = ll_i2sbi(dir);
557 struct mdc_op_data op_data;
561 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
562 name, dir->i_ino, dir->i_generation, dir);
564 if (dir->i_nlink >= EXT3_LINK_MAX)
567 mode &= ~current->fs->umask;
569 switch (mode & S_IFMT) {
572 mode |= S_IFREG; /* for mode = 0 case, fallthrough */
577 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
578 err = md_create(sbi->ll_mdc_exp, &op_data, NULL, 0, mode,
579 current->fsuid, current->fsgid, rdev, &request);
580 err = ll_prep_inode(sbi->ll_osc_exp, sbi->ll_mdc_exp,
581 &inode, request, 0, child->d_sb);
592 d_instantiate(child, inode);
594 ptlrpc_req_finished(request);
598 static int ll_symlink_raw(struct nameidata *nd, const char *tgt)
600 struct inode *dir = nd->dentry->d_inode;
601 const char *name = nd->last.name;
602 int len = nd->last.len;
603 struct ptlrpc_request *request = NULL;
604 struct ll_sb_info *sbi = ll_i2sbi(dir);
605 struct mdc_op_data op_data;
609 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p),target=%s\n",
610 name, dir->i_ino, dir->i_generation, dir, tgt);
612 if (dir->i_nlink >= EXT3_LINK_MAX)
615 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
616 err = md_create(sbi->ll_mdc_exp, &op_data,
617 tgt, strlen(tgt) + 1, S_IFLNK | S_IRWXUGO,
618 current->fsuid, current->fsgid, 0, &request);
619 ptlrpc_req_finished(request);
623 static int ll_link_raw(struct nameidata *srcnd, struct nameidata *tgtnd)
625 struct inode *src = srcnd->dentry->d_inode;
626 struct inode *dir = tgtnd->dentry->d_inode;
627 const char *name = tgtnd->last.name;
628 int len = tgtnd->last.len;
629 struct ptlrpc_request *request = NULL;
630 struct mdc_op_data op_data;
632 struct ll_sb_info *sbi = ll_i2sbi(dir);
635 CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),dir=%lu/%u(%p),target=%s\n",
636 src->i_ino, src->i_generation, src,
637 dir->i_ino, dir->i_generation, dir, name);
639 ll_prepare_mdc_op_data(&op_data, src, dir, name, len, 0);
640 err = md_link(sbi->ll_mdc_exp, &op_data, &request);
641 ptlrpc_req_finished(request);
647 static int ll_mkdir_raw(struct nameidata *nd, int mode)
649 struct inode *dir = nd->dentry->d_inode;
650 const char *name = nd->last.name;
651 int len = nd->last.len;
652 struct ptlrpc_request *request = NULL;
653 struct ll_sb_info *sbi = ll_i2sbi(dir);
654 struct mdc_op_data op_data;
657 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
658 name, dir->i_ino, dir->i_generation, dir);
660 mode = (mode & (S_IRWXUGO|S_ISVTX) & ~current->fs->umask) | S_IFDIR;
661 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
662 err = md_create(sbi->ll_mdc_exp, &op_data, NULL, 0, mode,
663 current->fsuid, current->fsgid, 0, &request);
664 ptlrpc_req_finished(request);
668 static int ll_rmdir_raw(struct nameidata *nd)
670 struct inode *dir = nd->dentry->d_inode;
671 const char *name = nd->last.name;
672 int len = nd->last.len;
673 struct ptlrpc_request *request = NULL;
674 struct mdc_op_data op_data;
677 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
678 name, dir->i_ino, dir->i_generation, dir);
680 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, S_IFDIR);
681 rc = md_unlink(ll_i2sbi(dir)->ll_mdc_exp, &op_data, &request);
682 ptlrpc_req_finished(request);
686 int ll_objects_destroy(struct ptlrpc_request *request,
687 struct inode *dir, int offset)
689 struct mds_body *body;
690 struct lov_mds_md *eadata;
691 struct lov_stripe_md *lsm = NULL;
692 struct obd_trans_info oti = { 0 };
697 /* req is swabbed so this is safe */
698 body = lustre_msg_buf(request->rq_repmsg, 0, sizeof(*body));
700 if (!(body->valid & OBD_MD_FLEASIZE))
703 if (body->eadatasize == 0) {
704 CERROR("OBD_MD_FLEASIZE set but eadatasize zero\n");
705 GOTO(out, rc = -EPROTO);
708 /* The MDS sent back the EA because we unlinked the last reference
709 * to this file. Use this EA to unlink the objects on the OST.
710 * It's opaque so we don't swab here; we leave it to obd_unpackmd() to
711 * check it is complete and sensible. */
712 eadata = lustre_swab_repbuf(request, 1, body->eadatasize, NULL);
713 LASSERT(eadata != NULL);
714 if (eadata == NULL) {
715 CERROR("Can't unpack MDS EA data\n");
716 GOTO(out, rc = -EPROTO);
719 rc = obd_unpackmd(ll_i2obdexp(dir), &lsm, eadata, body->eadatasize);
721 CERROR("obd_unpackmd: %d\n", rc);
724 LASSERT(rc >= sizeof(*lsm));
728 GOTO(out_free_memmd, rc = -ENOMEM);
730 oa->o_id = lsm->lsm_object_id;
731 oa->o_gr = lsm->lsm_object_gr;
732 oa->o_mode = body->mode & S_IFMT;
733 oa->o_valid = OBD_MD_FLID | OBD_MD_FLTYPE | OBD_MD_FLGROUP;
735 if (body->valid & OBD_MD_FLCOOKIE) {
736 int length = sizeof(struct llog_cookie) *
737 lsm->lsm_stripe_count;
738 oa->o_valid |= OBD_MD_FLCOOKIE;
740 lustre_msg_buf(request->rq_repmsg, 2, length);
741 if (oti.oti_logcookies == NULL) {
742 oa->o_valid &= ~OBD_MD_FLCOOKIE;
743 body->valid &= ~OBD_MD_FLCOOKIE;
745 /* copy llog cookies to request to replay unlink
746 * so that the same llog file and records as those created
747 * during fail can be re-created while doing replay
750 memcpy(lustre_msg_buf(request->rq_reqmsg, offset, 0),
751 oti.oti_logcookies, length);
755 rc = obd_destroy(ll_i2obdexp(dir), oa, lsm, &oti);
758 CERROR("obd destroy objid "LPX64" error %d\n",
759 lsm->lsm_object_id, rc);
761 obd_free_memmd(ll_i2obdexp(dir), &lsm);
766 static int ll_unlink_raw(struct nameidata *nd)
768 struct inode *dir = nd->dentry->d_inode;
769 const char *name = nd->last.name;
770 int len = nd->last.len;
771 struct ptlrpc_request *request = NULL;
772 struct mdc_op_data op_data;
775 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
776 name, dir->i_ino, dir->i_generation, dir);
778 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
779 rc = md_unlink(ll_i2sbi(dir)->ll_mdc_exp, &op_data, &request);
783 rc = ll_objects_destroy(request, dir, 2);
785 ptlrpc_req_finished(request);
789 static int ll_rename_raw(struct nameidata *oldnd, struct nameidata *newnd)
791 struct inode *src = oldnd->dentry->d_inode;
792 struct inode *tgt = newnd->dentry->d_inode;
793 const char *oldname = oldnd->last.name;
794 int oldlen = oldnd->last.len;
795 const char *newname = newnd->last.name;
796 int newlen = newnd->last.len;
797 struct ptlrpc_request *request = NULL;
798 struct ll_sb_info *sbi = ll_i2sbi(src);
799 struct mdc_op_data op_data;
802 CDEBUG(D_VFSTRACE, "VFS Op:oldname=%s,src_dir=%lu/%u(%p),newname=%s,"
803 "tgt_dir=%lu/%u(%p)\n", oldname, src->i_ino, src->i_generation,
804 src, newname, tgt->i_ino, tgt->i_generation, tgt);
806 ll_prepare_mdc_op_data(&op_data, src, tgt, NULL, 0, 0);
807 err = md_rename(sbi->ll_mdc_exp, &op_data,
808 oldname, oldlen, newname, newlen, &request);
810 err = ll_objects_destroy(request, src, 3);
813 ptlrpc_req_finished(request);
818 struct inode_operations ll_dir_inode_operations = {
819 .link_raw = ll_link_raw,
820 .unlink_raw = ll_unlink_raw,
821 .symlink_raw = ll_symlink_raw,
822 .mkdir_raw = ll_mkdir_raw,
823 .rmdir_raw = ll_rmdir_raw,
824 .mknod_raw = ll_mknod_raw,
826 .rename_raw = ll_rename_raw,
827 .setattr = ll_setattr,
828 .setattr_raw = ll_setattr_raw,
829 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
830 .create_it = ll_create_it,
831 .lookup_it = ll_lookup_it,
832 .revalidate_it = ll_inode_revalidate_it,
834 .lookup = ll_lookup_nd,
835 .create = ll_create_nd,
836 .getattr_it = ll_getattr,