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.
23 #include <linux/sched.h>
25 #include <linux/smp_lock.h>
26 #include <linux/quotaops.h>
27 #include <linux/highmem.h>
28 #include <linux/pagemap.h>
30 #define DEBUG_SUBSYSTEM S_LLITE
32 #include <linux/obd_support.h>
33 #include <linux/lustre_lite.h>
34 #include <linux/lustre_dlm.h>
35 #include <linux/lustre_version.h>
36 #include "llite_internal.h"
40 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
41 static int ll_test_inode(struct inode *inode, unsigned long ino, void *opaque)
43 static int ll_test_inode(struct inode *inode, void *opaque)
46 static int last_ino, last_gen, last_count;
47 struct lustre_md *md = opaque;
49 if (!(md->body->valid & (OBD_MD_FLGENER | OBD_MD_FLID))) {
50 CERROR("MDS body missing inum or generation\n");
54 if (last_ino == md->body->ino && last_gen == md->body->generation &&
59 CDEBUG(D_VFSTRACE, "compared %u/%u %u times\n",
60 last_ino, last_gen, last_count);
62 last_ino = md->body->ino;
63 last_gen = md->body->generation;
65 "comparing inode %p ino %lu/%u to body "LPU64"/%u\n",
66 inode, inode->i_ino, inode->i_generation,
67 md->body->ino, md->body->generation);
70 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
71 if (inode->i_ino != md->body->ino)
74 if (inode->i_generation != md->body->generation)
77 /* Apply the attributes in 'opaque' to this inode */
78 ll_update_inode(inode, md->body, md->lsm);
82 extern struct dentry_operations ll_d_ops;
84 int ll_unlock(__u32 mode, struct lustre_handle *lockh)
88 ldlm_lock_decref(lockh, mode);
93 /* Get an inode by inode number (already instantiated by the intent lookup).
94 * Returns inode or NULL
96 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
97 int ll_set_inode(struct inode *inode, void *opaque)
99 ll_read_inode2(inode, opaque);
103 struct inode *ll_iget(struct super_block *sb, ino_t hash,
104 struct lustre_md *md)
109 inode = iget5_locked(sb, hash, ll_test_inode, ll_set_inode, md);
112 if (inode->i_state & I_NEW)
113 unlock_new_inode(inode);
114 CDEBUG(D_VFSTRACE, "inode: %lu/%u(%p)\n", inode->i_ino,
115 inode->i_generation, inode);
121 struct inode *ll_iget(struct super_block *sb, ino_t hash,
122 struct lustre_md *md)
126 inode = iget4(sb, hash, ll_test_inode, md);
128 CDEBUG(D_VFSTRACE, "inode: %lu/%u(%p)\n", inode->i_ino,
129 inode->i_generation, inode);
134 int ll_mdc_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc,
135 void *data, int flag)
138 struct lustre_handle lockh;
142 case LDLM_CB_BLOCKING:
143 ldlm_lock2handle(lock, &lockh);
144 rc = ldlm_cli_cancel(&lockh);
146 CDEBUG(D_INODE, "ldlm_cli_cancel: %d\n", rc);
150 case LDLM_CB_CANCELING: {
151 struct inode *inode = ll_inode_from_lock(lock);
153 /* Invalidate all dentries associated with this inode */
157 clear_bit(LLI_F_HAVE_MDS_SIZE_LOCK,
158 &(ll_i2info(inode)->lli_flags));
160 if (lock->l_resource->lr_name.name[0] != inode->i_ino ||
161 lock->l_resource->lr_name.name[1] != inode->i_generation) {
162 LDLM_ERROR(lock, "data mismatch with ino %lu/%u (%p)",
163 inode->i_ino, inode->i_generation, inode);
165 if (S_ISDIR(inode->i_mode)) {
166 CDEBUG(D_INODE, "invalidating inode %lu\n",
169 truncate_inode_pages(inode->i_mapping, 0);
172 if (inode->i_sb->s_root &&
173 inode != inode->i_sb->s_root->d_inode)
174 ll_unhash_aliases(inode);
185 int ll_mdc_cancel_unused(struct lustre_handle *conn, struct inode *inode,
186 int flags, void *opaque)
188 struct ldlm_res_id res_id =
189 { .name = {inode->i_ino, inode->i_generation} };
190 struct obd_device *obddev = class_conn2obd(conn);
193 RETURN(ldlm_cli_cancel_unused(obddev->obd_namespace, &res_id, flags,
198 void ll_prepare_mdc_op_data(struct mdc_op_data *data, struct inode *i1,
199 struct inode *i2, const char *name, int namelen,
204 ll_i2uctxt(&data->ctxt, i1, i2);
205 ll_inode2fid(&data->fid1, i1);
208 ll_inode2fid(&data->fid2, i2);
211 data->namelen = namelen;
212 data->create_mode = mode;
213 data->mod_time = CURRENT_SECONDS;
216 static void ll_d_add(struct dentry *de, struct inode *inode)
218 CDEBUG(D_DENTRY, "adding inode %p to dentry %p\n", inode, de);
220 if (!list_empty(&de->d_alias)) {
221 spin_unlock(&dcache_lock);
222 CERROR("dentry %.*s %p alias next %p, prev %p\n",
223 de->d_name.len, de->d_name.name, de,
224 de->d_alias.next, de->d_alias.prev);
228 list_add(&de->d_alias, &inode->i_dentry);
232 if (!d_unhashed(de)) {
233 spin_unlock(&dcache_lock);
234 CERROR("dentry %.*s %p hash next %p\n",
235 de->d_name.len, de->d_name.name, de, de->d_hash.next);
241 /* Search "inode"'s alias list for a dentry that has the same name and parent as
242 * de. If found, return it. If not found, return de. */
243 struct dentry *ll_find_alias(struct inode *inode, struct dentry *de)
245 struct list_head *tmp;
247 spin_lock(&dcache_lock);
248 list_for_each(tmp, &inode->i_dentry) {
249 struct dentry *dentry = list_entry(tmp, struct dentry, d_alias);
251 /* We are called here with 'de' already on the aliases list. */
257 if (dentry->d_parent != de->d_parent)
260 if (dentry->d_name.len != de->d_name.len)
263 if (memcmp(dentry->d_name.name, de->d_name.name,
264 de->d_name.len) != 0)
267 if (!list_empty(&dentry->d_lru))
268 list_del_init(&dentry->d_lru);
270 hlist_del_init(&dentry->d_hash);
271 __d_rehash(dentry, 0); /* avoid taking dcache_lock inside */
272 dentry->d_flags &= ~DCACHE_LUSTRE_INVALID;
273 atomic_inc(&dentry->d_count);
274 spin_unlock(&dcache_lock);
276 CDEBUG(D_DENTRY, "alias dentry %.*s (%p) parent %p inode %p "
277 "refc %d\n", de->d_name.len, de->d_name.name, de,
278 de->d_parent, de->d_inode, atomic_read(&de->d_count));
284 spin_unlock(&dcache_lock);
289 static int lookup_it_finish(struct ptlrpc_request *request, int offset,
290 struct lookup_intent *it, void *data)
292 struct it_cb_data *icbd = data;
293 struct dentry **de = icbd->icbd_childp;
294 struct inode *parent = icbd->icbd_parent;
295 struct ll_sb_info *sbi = ll_i2sbi(parent);
296 struct inode *inode = NULL;
299 /* NB 1 request reference will be taken away by ll_intent_lock()
301 if (!it_disposition(it, DISP_LOOKUP_NEG)) {
304 rc = ll_prep_inode(sbi->ll_osc_exp, &inode, request, offset,
309 CDEBUG(D_DLMTRACE, "setting l_data to inode %p (%lu/%u)\n",
310 inode, inode->i_ino, inode->i_generation);
311 mdc_set_lock_data(&it->d.lustre.it_lock_handle, inode);
313 /* If this is a stat, get the authoritative file size */
314 if (it->it_op == IT_GETATTR && S_ISREG(inode->i_mode) &&
315 ll_i2info(inode)->lli_smd != NULL) {
316 struct lov_stripe_md *lsm = ll_i2info(inode)->lli_smd;
319 LASSERT(lsm->lsm_object_id != 0);
321 /* bug 2334: drop MDS lock before acquiring OST lock */
322 ll_intent_drop_lock(it);
324 rc = ll_glimpse_size(inode);
331 *de = ll_find_alias(inode, *de);
334 spin_lock(&dcache_lock);
335 ll_d_add(*de, inode);
336 spin_unlock(&dcache_lock);
340 (*de)->d_op = &ll_d_ops;
346 static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry,
347 struct lookup_intent *it, int lookup_flags)
349 struct dentry *save = dentry, *retval;
351 struct ll_uctxt ctxt;
352 struct it_cb_data icbd;
353 struct ptlrpc_request *req = NULL;
354 struct lookup_intent lookup_it = { .it_op = IT_LOOKUP };
358 if (dentry->d_name.len > ll_i2sbi(parent)->ll_namelen)
359 RETURN(ERR_PTR(-ENAMETOOLONG));
361 CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),intent=%s\n",
362 dentry->d_name.len, dentry->d_name.name, parent->i_ino,
363 parent->i_generation, parent, LL_IT2STR(it));
365 if (d_mountpoint(dentry))
366 CERROR("Tell Peter, lookup on mtpt, it %s\n", LL_IT2STR(it));
368 ll_frob_intent(&it, &lookup_it);
370 icbd.icbd_childp = &dentry;
371 icbd.icbd_parent = parent;
372 ll_inode2fid(&pfid, parent);
373 ll_i2uctxt(&ctxt, parent, NULL);
375 rc = mdc_intent_lock(ll_i2mdcexp(parent), &ctxt, &pfid,
376 dentry->d_name.name, dentry->d_name.len, NULL, 0,
377 NULL, it, lookup_flags, &req, ll_mdc_blocking_ast);
379 GOTO(out, retval = ERR_PTR(rc));
381 rc = lookup_it_finish(req, 1, it, &icbd);
383 ll_intent_release(it);
384 GOTO(out, retval = ERR_PTR(rc));
387 ll_lookup_finish_locks(it, dentry);
390 GOTO(out, retval = NULL);
392 GOTO(out, retval = dentry);
395 ptlrpc_req_finished(req);
399 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
400 static struct dentry *ll_lookup_nd(struct inode *parent, struct dentry *dentry,
401 struct nameidata *nd)
406 if (nd && nd->flags & LOOKUP_LAST && !(nd->flags & LOOKUP_LINK_NOTLAST))
407 de = ll_lookup_it(parent, dentry, &nd->intent, nd->flags);
409 de = ll_lookup_it(parent, dentry, NULL, 0);
415 /* We depend on "mode" being set with the proper file type/umask by now */
416 static struct inode *ll_create_node(struct inode *dir, const char *name,
417 int namelen, const void *data, int datalen,
418 int mode, __u64 extra,
419 struct lookup_intent *it)
421 struct inode *inode = NULL;
422 struct ptlrpc_request *request = NULL;
423 struct ll_sb_info *sbi = ll_i2sbi(dir);
427 LASSERT(it && it->d.lustre.it_disposition);
429 request = it->d.lustre.it_data;
430 rc = ll_prep_inode(sbi->ll_osc_exp, &inode, request, 1, dir->i_sb);
432 GOTO(out, inode = ERR_PTR(rc));
434 LASSERT(list_empty(&inode->i_dentry));
436 /* We asked for a lock on the directory, but were granted a
437 * lock on the inode. Since we finally have an inode pointer,
438 * stuff it in the lock. */
439 CDEBUG(D_DLMTRACE, "setting l_ast_data to inode %p (%lu/%u)\n",
440 inode, inode->i_ino, inode->i_generation);
441 mdc_set_lock_data(&it->d.lustre.it_lock_handle, inode);
444 ptlrpc_req_finished(request);
449 * By the time this is called, we already have created the directory cache
450 * entry for the new file, but it is so far negative - it has no inode.
452 * We defer creating the OBD object(s) until open, to keep the intent and
453 * non-intent code paths similar, and also because we do not have the MDS
454 * inode number before calling ll_create_node() (which is needed for LOV),
455 * so we would need to do yet another RPC to the MDS to store the LOV EA
456 * data on the MDS. If needed, we would pass the PACKED lmm as data and
457 * lmm_size in datalen (the MDS still has code which will handle that).
459 * If the create succeeds, we fill in the inode information
460 * with d_instantiate().
462 static int ll_create_it(struct inode *dir, struct dentry *dentry, int mode,
463 struct lookup_intent *it)
466 struct ptlrpc_request *request = it->d.lustre.it_data;
470 CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),intent=%s\n",
471 dentry->d_name.len, dentry->d_name.name, dir->i_ino,
472 dir->i_generation, dir, LL_IT2STR(it));
474 rc = it_open_error(DISP_OPEN_CREATE, it);
478 mdc_store_inode_generation(request, 2, 1);
479 inode = ll_create_node(dir, dentry->d_name.name, dentry->d_name.len,
480 NULL, 0, mode, 0, it);
482 RETURN(PTR_ERR(inode));
485 d_instantiate(dentry, inode);
489 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
490 static int ll_create_nd(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd)
492 return ll_create_it(dir, dentry, mode, &nd->intent);
496 static void ll_update_times(struct ptlrpc_request *request, int offset,
499 struct mds_body *body = lustre_msg_buf(request->rq_repmsg, offset,
503 if (body->valid & OBD_MD_FLMTIME &&
504 body->mtime > LTIME_S(inode->i_mtime)) {
505 CDEBUG(D_INODE, "setting ino %lu mtime from %lu to "LPU64"\n",
506 inode->i_ino, LTIME_S(inode->i_mtime), body->mtime);
507 LTIME_S(inode->i_mtime) = body->mtime;
509 if (body->valid & OBD_MD_FLCTIME &&
510 body->ctime > LTIME_S(inode->i_ctime))
511 LTIME_S(inode->i_ctime) = body->ctime;
514 static int ll_mknod_raw(struct nameidata *nd, int mode, dev_t rdev)
516 struct ptlrpc_request *request = NULL;
517 struct inode *dir = nd->dentry->d_inode;
518 struct ll_sb_info *sbi = ll_i2sbi(dir);
519 struct mdc_op_data op_data;
523 CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p) mode %o dev %x\n",
524 nd->last.len, nd->last.name, dir->i_ino, dir->i_generation, dir,
527 mode &= ~current->fs->umask;
529 switch (mode & S_IFMT) {
532 mode |= S_IFREG; /* for mode = 0 case, fallthrough */
537 ll_prepare_mdc_op_data(&op_data, dir, NULL, nd->last.name,
539 err = mdc_create(sbi->ll_mdc_exp, &op_data, NULL, 0, mode,
540 current->fsuid, current->fsgid,
543 ll_update_times(request, 0, dir);
544 ptlrpc_req_finished(request);
555 static int ll_mknod(struct inode *dir, struct dentry *dchild, int mode,
558 struct ptlrpc_request *request = NULL;
559 struct inode *inode = NULL;
560 struct ll_sb_info *sbi = ll_i2sbi(dir);
561 struct mdc_op_data op_data;
565 CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
566 dchild->d_name.len, dchild->d_name.name,
567 dir->i_ino, dir->i_generation, dir);
569 mode &= ~current->fs->umask;
571 switch (mode & S_IFMT) {
574 mode |= S_IFREG; /* for mode = 0 case, fallthrough */
579 ll_prepare_mdc_op_data(&op_data, dir, NULL, dchild->d_name.name,
580 dchild->d_name.len, 0);
581 err = mdc_create(sbi->ll_mdc_exp, &op_data, NULL, 0, mode,
582 current->fsuid, current->fsgid,
587 ll_update_times(request, 0, dir);
589 err = ll_prep_inode(sbi->ll_osc_exp, &inode, request, 0,
601 d_instantiate(dchild, inode);
603 ptlrpc_req_finished(request);
607 static int ll_symlink_raw(struct nameidata *nd, const char *tgt)
609 struct inode *dir = nd->dentry->d_inode;
610 struct ptlrpc_request *request = NULL;
611 struct ll_sb_info *sbi = ll_i2sbi(dir);
612 struct mdc_op_data op_data;
616 CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),target=%s\n",
617 nd->last.len, nd->last.name, dir->i_ino, dir->i_generation,
620 ll_prepare_mdc_op_data(&op_data, dir, NULL, nd->last.name,
622 err = mdc_create(sbi->ll_mdc_exp, &op_data,
623 tgt, strlen(tgt) + 1, S_IFLNK | S_IRWXUGO,
624 current->fsuid, current->fsgid, 0, &request);
626 ll_update_times(request, 0, dir);
628 ptlrpc_req_finished(request);
632 static int ll_link_raw(struct nameidata *srcnd, struct nameidata *tgtnd)
634 struct inode *src = srcnd->dentry->d_inode;
635 struct inode *dir = tgtnd->dentry->d_inode;
636 struct ptlrpc_request *request = NULL;
637 struct mdc_op_data op_data;
639 struct ll_sb_info *sbi = ll_i2sbi(dir);
643 "VFS Op: inode=%lu/%u(%p), dir=%lu/%u(%p), target=%.*s\n",
644 src->i_ino, src->i_generation, src, dir->i_ino,
645 dir->i_generation, dir, tgtnd->last.len, tgtnd->last.name);
647 ll_prepare_mdc_op_data(&op_data, src, dir, tgtnd->last.name,
649 err = mdc_link(sbi->ll_mdc_exp, &op_data, &request);
651 ll_update_times(request, 0, dir);
653 ptlrpc_req_finished(request);
659 static int ll_mkdir_raw(struct nameidata *nd, int mode)
661 struct inode *dir = nd->dentry->d_inode;
662 struct ptlrpc_request *request = NULL;
663 struct ll_sb_info *sbi = ll_i2sbi(dir);
664 struct mdc_op_data op_data;
667 CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
668 nd->last.len, nd->last.name, dir->i_ino, dir->i_generation, dir);
670 mode = (mode & (S_IRWXUGO|S_ISVTX) & ~current->fs->umask) | S_IFDIR;
671 ll_prepare_mdc_op_data(&op_data, dir, NULL, nd->last.name,
673 err = mdc_create(sbi->ll_mdc_exp, &op_data, NULL, 0, mode,
674 current->fsuid, current->fsgid, 0, &request);
676 ll_update_times(request, 0, dir);
678 ptlrpc_req_finished(request);
682 static int ll_rmdir_raw(struct nameidata *nd)
684 struct inode *dir = nd->dentry->d_inode;
685 struct ptlrpc_request *request = NULL;
686 struct mdc_op_data op_data;
687 struct dentry *dentry;
690 CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
691 nd->last.len, nd->last.name, dir->i_ino, dir->i_generation, dir);
693 /* Check if we have something mounted at the dir we are going to delete
694 * In such a case there would always be dentry present. */
695 dentry = d_lookup(nd->dentry, &nd->last);
697 int mounted = d_mountpoint(dentry);
703 ll_prepare_mdc_op_data(&op_data, dir, NULL, nd->last.name,
704 nd->last.len, S_IFDIR);
705 rc = mdc_unlink(ll_i2sbi(dir)->ll_mdc_exp, &op_data, &request);
707 ll_update_times(request, 0, dir);
708 ptlrpc_req_finished(request);
712 int ll_objects_destroy(struct ptlrpc_request *request, struct inode *dir)
714 struct mds_body *body;
715 struct lov_mds_md *eadata;
716 struct lov_stripe_md *lsm = NULL;
717 struct obd_trans_info oti = { 0 };
722 /* req is swabbed so this is safe */
723 body = lustre_msg_buf(request->rq_repmsg, 0, sizeof(*body));
725 if (!(body->valid & OBD_MD_FLEASIZE))
728 if (body->eadatasize == 0) {
729 CERROR("OBD_MD_FLEASIZE set but eadatasize zero\n");
730 GOTO(out, rc = -EPROTO);
733 /* The MDS sent back the EA because we unlinked the last reference
734 * to this file. Use this EA to unlink the objects on the OST.
735 * It's opaque so we don't swab here; we leave it to obd_unpackmd() to
736 * check it is complete and sensible. */
737 eadata = lustre_swab_repbuf(request, 1, body->eadatasize, NULL);
738 LASSERT(eadata != NULL);
739 if (eadata == NULL) {
740 CERROR("Can't unpack MDS EA data\n");
741 GOTO(out, rc = -EPROTO);
744 rc = obd_unpackmd(ll_i2obdexp(dir), &lsm, eadata, body->eadatasize);
746 CERROR("obd_unpackmd: %d\n", rc);
749 LASSERT(rc >= sizeof(*lsm));
753 GOTO(out_free_memmd, rc = -ENOMEM);
755 oa->o_id = lsm->lsm_object_id;
756 oa->o_mode = body->mode & S_IFMT;
757 oa->o_valid = OBD_MD_FLID | OBD_MD_FLTYPE;
759 if (body->valid & OBD_MD_FLCOOKIE) {
760 oa->o_valid |= OBD_MD_FLCOOKIE;
762 lustre_msg_buf(request->rq_repmsg, 2,
763 sizeof(struct llog_cookie) *
764 lsm->lsm_stripe_count);
765 if (oti.oti_logcookies == NULL) {
766 oa->o_valid &= ~OBD_MD_FLCOOKIE;
767 body->valid &= ~OBD_MD_FLCOOKIE;
771 rc = obd_destroy(ll_i2obdexp(dir), oa, lsm, &oti);
774 CERROR("obd destroy objid "LPX64" error %d\n",
775 lsm->lsm_object_id, rc);
777 obd_free_memmd(ll_i2obdexp(dir), &lsm);
782 static int ll_unlink_raw(struct nameidata *nd)
784 struct inode *dir = nd->dentry->d_inode;
785 struct ptlrpc_request *request = NULL;
786 struct mdc_op_data op_data;
789 CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
790 nd->last.len, nd->last.name, dir->i_ino, dir->i_generation, dir);
792 ll_prepare_mdc_op_data(&op_data, dir, NULL, nd->last.name,
794 rc = mdc_unlink(ll_i2sbi(dir)->ll_mdc_exp, &op_data, &request);
798 ll_update_times(request, 0, dir);
800 rc = ll_objects_destroy(request, dir);
802 ptlrpc_req_finished(request);
806 static int ll_rename_raw(struct nameidata *srcnd, struct nameidata *tgtnd)
808 struct inode *src = srcnd->dentry->d_inode;
809 struct inode *tgt = tgtnd->dentry->d_inode;
810 struct ptlrpc_request *request = NULL;
811 struct ll_sb_info *sbi = ll_i2sbi(src);
812 struct mdc_op_data op_data;
815 CDEBUG(D_VFSTRACE,"VFS Op:oldname=%.*s,src_dir=%lu/%u(%p),newname=%.*s,"
816 "tgt_dir=%lu/%u(%p)\n", srcnd->last.len, srcnd->last.name,
817 src->i_ino, src->i_generation, src, tgtnd->last.len,
818 tgtnd->last.name, tgt->i_ino, tgt->i_generation, tgt);
820 ll_prepare_mdc_op_data(&op_data, src, tgt, NULL, 0, 0);
821 err = mdc_rename(sbi->ll_mdc_exp, &op_data,
822 srcnd->last.name, srcnd->last.len,
823 tgtnd->last.name, tgtnd->last.len, &request);
825 ll_update_times(request, 0, src);
826 ll_update_times(request, 0, tgt);
827 err = ll_objects_destroy(request, src);
830 ptlrpc_req_finished(request);
835 struct inode_operations ll_dir_inode_operations = {
836 .link_raw = ll_link_raw,
837 .unlink_raw = ll_unlink_raw,
838 .symlink_raw = ll_symlink_raw,
839 .mkdir_raw = ll_mkdir_raw,
840 .rmdir_raw = ll_rmdir_raw,
841 .mknod_raw = ll_mknod_raw,
843 .rename_raw = ll_rename_raw,
844 .setattr = ll_setattr,
845 .setattr_raw = ll_setattr_raw,
846 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
847 .create_it = ll_create_it,
848 .lookup_it = ll_lookup_it,
849 .revalidate_it = ll_inode_revalidate_it,
851 .lookup = ll_lookup_nd,
852 .create = ll_create_nd,
853 .getattr_it = ll_getattr,