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 == id_ino(&md->body->id1) &&
64 last_gen == id_gen(&md->body->id1) &&
69 CDEBUG(D_VFSTRACE, "compared %u/%u %u times\n",
70 last_ino, last_gen, last_count);
72 last_ino = id_ino(&md->body->id1);
73 last_gen = id_gen(&md->body->id1);
75 "comparing inode %p ino "DLID4" to body "DLID4"\n",
76 inode, OLID4(&ll_i2info(inode)->lli_id),
77 OLID4(&md->body->id1));
80 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
81 if (inode->i_ino != id_ino(&md->body->id1))
84 if (inode->i_generation != id_gen(&md->body->id1))
87 if (id_group(&ll_i2info(inode)->lli_id) != id_group(&md->body->id1))
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);
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 struct ll_inode_info *li = ll_i2info(inode);
167 __u64 bits = lock->l_policy_data.l_inodebits.bits;
169 /* For lookup locks: Invalidate all dentries associated with
170 this inode, for UPDATE locks - invalidate directory pages */
172 if (bits & MDS_INODELOCK_OPEN)
173 LDLM_ERROR(lock, "null inode");
177 if (lock->l_resource->lr_name.name[0] != id_fid(&li->lli_id) ||
178 lock->l_resource->lr_name.name[1] != id_group(&li->lli_id)) {
179 LDLM_ERROR(lock, "data mismatch with object %lu/%lu",
180 (unsigned long)id_fid(&li->lli_id),
181 (unsigned long)id_group(&li->lli_id));
184 if (bits & MDS_INODELOCK_OPEN) {
186 switch (lock->l_req_mode) {
197 CERROR("Unexpected lock mode for OPEN lock "
198 "%d, inode %ld\n", lock->l_req_mode,
201 ll_md_real_close(ll_i2mdexp(inode), inode, flags);
204 if (bits & MDS_INODELOCK_UPDATE)
205 clear_bit(LLI_F_HAVE_MDS_SIZE_LOCK,
206 &(ll_i2info(inode)->lli_flags));
209 /* If lookup lock is cancelled, we just drop the dentry and
210 this will cause us to reget data from MDS when we'd want to
211 access this dentry/inode again. If this is lock on
212 other parts of inode that is cancelled, we do not need to do
213 much (but need to discard data from readdir, if any), since
214 abscence of lock will cause ll_revalidate_it (called from
215 stat() and similar functions) to renew the data anyway */
216 if (S_ISDIR(inode->i_mode) &&
217 (bits & MDS_INODELOCK_UPDATE)) {
218 CDEBUG(D_INODE, "invalidating inode %lu/%u(%p)\n",
219 inode->i_ino, inode->i_generation, inode);
220 truncate_inode_pages(inode->i_mapping, 0);
223 if (inode->i_sb->s_root &&
224 inode != inode->i_sb->s_root->d_inode &&
225 (bits & MDS_INODELOCK_LOOKUP))
226 ll_unhash_aliases(inode);
237 /* Search "inode"'s alias list for a dentry that has the same name and parent as
238 * de. If found, return it. If not found, return de. */
239 struct dentry *ll_find_alias(struct inode *inode, struct dentry *de)
241 struct list_head *tmp;
243 spin_lock(&dcache_lock);
244 list_for_each(tmp, &inode->i_dentry) {
245 struct dentry *dentry = list_entry(tmp, struct dentry, d_alias);
247 /* We are called here with 'de' already on the aliases list. */
253 if (dentry->d_parent != de->d_parent)
256 if (dentry->d_name.len != de->d_name.len)
259 if (memcmp(dentry->d_name.name, de->d_name.name,
260 de->d_name.len) != 0)
263 if (!list_empty(&dentry->d_lru))
264 list_del_init(&dentry->d_lru);
266 hlist_del_init(&dentry->d_hash);
267 __d_rehash(dentry); /* avoid taking dcache_lock inside */
268 spin_unlock(&dcache_lock);
269 atomic_inc(&dentry->d_count);
271 dentry->d_flags &= ~DCACHE_LUSTRE_INVALID;
272 CDEBUG(D_DENTRY, "alias dentry %*s (%p) parent %p inode %p "
273 "refc %d\n", de->d_name.len, de->d_name.name, de,
274 de->d_parent, de->d_inode, atomic_read(&de->d_count));
278 spin_unlock(&dcache_lock);
283 static int lookup_it_finish(struct ptlrpc_request *request, int offset,
284 struct lookup_intent *it, void *data)
286 struct it_cb_data *icbd = data;
287 struct dentry **de = icbd->icbd_childp;
288 struct inode *parent = icbd->icbd_parent;
289 struct ll_sb_info *sbi = ll_i2sbi(parent);
290 struct dentry *dentry = *de, *saved = *de;
291 struct inode *inode = NULL;
294 /* NB 1 request reference will be taken away by ll_intent_lock()
296 if (!it_disposition(it, DISP_LOOKUP_NEG)) {
299 rc = ll_prep_inode(sbi->ll_dt_exp, sbi->ll_md_exp,
300 &inode, request, offset, dentry->d_sb);
304 CDEBUG(D_DLMTRACE, "setting l_data to inode %p (%lu/%u)\n",
305 inode, inode->i_ino, inode->i_generation);
307 mdc_set_lock_data(NULL, &LUSTRE_IT(it)->it_lock_handle, inode);
309 /* If this is a stat, get the authoritative file size */
310 if (it->it_op == IT_GETATTR && S_ISREG(inode->i_mode) &&
311 ll_i2info(inode)->lli_smd != NULL) {
312 struct lov_stripe_md *lsm = ll_i2info(inode)->lli_smd;
315 LASSERT(lsm->lsm_object_id != 0);
317 /* bug 2334: drop MDS lock before acquiring OST lock */
318 ll_intent_drop_lock(it);
320 rc = ll_glimpse_size(inode);
327 dentry = *de = ll_find_alias(inode, dentry);
332 dentry->d_op = &ll_d_ops;
336 d_add(dentry, inode);
341 static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry,
342 struct nameidata *nd, int flags)
344 struct lookup_intent *it = flags ? &nd->intent.open : NULL;
345 struct lookup_intent lookup_it = { .it_op = IT_LOOKUP };
346 struct dentry *save = dentry, *retval;
347 struct ptlrpc_request *req = NULL;
348 int rc, gns_it, gns_flags;
349 struct it_cb_data icbd;
350 struct lustre_id pid;
353 if (dentry->d_name.len > EXT3_NAME_LEN)
354 RETURN(ERR_PTR(-ENAMETOOLONG));
356 CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),intent=%s\n",
357 dentry->d_name.len, dentry->d_name.name, parent->i_ino,
358 parent->i_generation, parent, LL_IT2STR(it));
360 if (d_mountpoint(dentry))
361 CERROR("Tell Peter, lookup on mtpt, it %s\n", LL_IT2STR(it));
364 nd->mnt->mnt_last_used = jiffies;
366 gns_it = nd ? nd->intent.open.it_op : IT_OPEN;
367 gns_flags = nd ? nd->flags : LOOKUP_CONTINUE;
368 ll_frob_intent(&it, &lookup_it);
370 icbd.icbd_childp = &dentry;
371 icbd.icbd_parent = parent;
372 ll_inode2id(&pid, parent);
374 rc = md_intent_lock(ll_i2mdexp(parent), &pid, (char *)dentry->d_name.name,
375 dentry->d_name.len, NULL, 0, NULL, it, flags, &req,
376 ll_mdc_blocking_ast);
378 GOTO(out, retval = ERR_PTR(rc));
380 rc = lookup_it_finish(req, 1, it, &icbd);
382 ll_intent_release(it);
383 GOTO(out, retval = ERR_PTR(rc));
386 ll_lookup_finish_locks(it, dentry);
388 if (nd && dentry->d_inode != NULL &&
389 dentry->d_inode->i_mode & S_ISUID && S_ISDIR(dentry->d_inode->i_mode) &&
390 ((gns_flags & LOOKUP_CONTINUE) || (gns_it & (IT_CHDIR | IT_OPEN))))
392 CDEBUG(D_DENTRY, "possible GNS dentry %*s %p found, "
393 "mounting it\n", (int)dentry->d_name.len,
394 dentry->d_name.name, dentry);
396 rc = ll_gns_mount_object(dentry, nd->mnt);
399 * just reporting about GNS failures, lookup() is
400 * successful, do not stop it.
402 * GNS failure may be that object is found in SUID bit
403 * marked dir but it is not regular file and we should
404 * lookup further until we find correct mount
405 * object. This will allow to perform GNS mount is the
406 * following case for instance:
408 * /mnt/lustre/gns_mount/.mntinfo/.mntinfo/..../.mntinfo
409 * where all ".mntinfo" are dirs and only last one is
412 CDEBUG(D_DENTRY, "failed to mount %*s, err %d\n",
413 (int)dentry->d_name.len, dentry->d_name.name, rc);
418 GOTO(out, retval = NULL);
420 GOTO(out, retval = dentry);
423 ptlrpc_req_finished(req);
424 if (it == &lookup_it)
425 ll_intent_release(it);
427 CDEBUG(D_INODE, "lookup 0x%p in %lu/%lu: %*s -> %lu/%lu\n",
429 (unsigned long) parent->i_ino,
430 (unsigned long) parent->i_generation,
431 dentry->d_name.len, dentry->d_name.name,
432 (unsigned long) dentry->d_inode->i_ino,
433 (unsigned long) dentry->d_inode->i_generation);
435 CDEBUG(D_INODE, "lookup 0x%p in %lu/%lu: %*s -> ??\n",
437 (unsigned long) parent->i_ino,
438 (unsigned long) parent->i_generation,
439 dentry->d_name.len, dentry->d_name.name);
443 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
444 static struct dentry *ll_lookup_nd(struct inode *parent, struct dentry *dentry,
445 struct nameidata *nd)
450 if (nd && nd->flags & LOOKUP_LAST && !(nd->flags & LOOKUP_LINK_NOTLAST))
451 de = ll_lookup_it(parent, dentry, nd, nd->flags);
453 de = ll_lookup_it(parent, dentry, nd, 0);
459 /* We depend on "mode" being set with the proper file type/umask by now */
460 static struct inode *ll_create_node(struct inode *dir, const char *name,
461 int namelen, const void *data, int datalen,
462 int mode, __u64 extra,
463 struct lookup_intent *it)
465 struct inode *inode = NULL;
466 struct ptlrpc_request *request = NULL;
467 struct ll_sb_info *sbi = ll_i2sbi(dir);
472 LASSERT(it && LUSTRE_IT(it)->it_disposition);
474 request = LUSTRE_IT(it)->it_data;
475 rc = ll_prep_inode(sbi->ll_dt_exp, sbi->ll_md_exp,
476 &inode, request, 1, dir->i_sb);
478 GOTO(out, inode = ERR_PTR(rc));
480 LASSERT(list_empty(&inode->i_dentry));
482 /* We asked for a lock on the directory, but were granted a
483 * lock on the inode. Since we finally have an inode pointer,
484 * stuff it in the lock. */
485 CDEBUG(D_DLMTRACE, "setting l_ast_data to inode %p (%lu/%u)\n",
486 inode, inode->i_ino, inode->i_generation);
487 mdc_set_lock_data(NULL, &LUSTRE_IT(it)->it_lock_handle, inode);
490 ptlrpc_req_finished(request);
495 * By the time this is called, we already have created the directory cache
496 * entry for the new file, but it is so far negative - it has no inode.
498 * We defer creating the OBD object(s) until open, to keep the intent and
499 * non-intent code paths similar, and also because we do not have the MDS
500 * inode number before calling ll_create_node() (which is needed for LOV),
501 * so we would need to do yet another RPC to the MDS to store the LOV EA
502 * data on the MDS. If needed, we would pass the PACKED lmm as data and
503 * lmm_size in datalen (the MDS still has code which will handle that).
505 * If the create succeeds, we fill in the inode information
506 * with d_instantiate().
508 static int ll_create_it(struct inode *dir, struct dentry *dentry, int mode,
509 struct lookup_intent *it)
512 struct ptlrpc_request *request = LUSTRE_IT(it)->it_data;
513 struct obd_export *md_exp = ll_i2mdexp(dir);
517 CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),intent=%s\n",
518 dentry->d_name.len, dentry->d_name.name, dir->i_ino,
519 dir->i_generation, dir, LL_IT2STR(it));
521 rc = it_open_error(DISP_OPEN_CREATE, it);
525 mdc_store_inode_generation(md_exp, request, MDS_REQ_INTENT_REC_OFF, 1);
526 inode = ll_create_node(dir, (char *)dentry->d_name.name,
527 dentry->d_name.len, NULL, 0, mode, 0, it);
529 RETURN(PTR_ERR(inode));
531 d_instantiate(dentry, inode);
535 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
536 static int ll_create_nd(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd)
538 return ll_create_it(dir, dentry, mode, &nd->intent.open);
542 static void ll_update_times(struct ptlrpc_request *request, int offset,
545 struct mds_body *body = lustre_msg_buf(request->rq_repmsg, offset,
549 if (body->valid & OBD_MD_FLMTIME &&
550 body->mtime > LTIME_S(inode->i_mtime)) {
551 CDEBUG(D_INODE, "setting ino %lu mtime from %lu to %u\n",
552 inode->i_ino, LTIME_S(inode->i_mtime), body->mtime);
553 LTIME_S(inode->i_mtime) = body->mtime;
555 if (body->valid & OBD_MD_FLCTIME &&
556 body->ctime > LTIME_S(inode->i_ctime))
557 LTIME_S(inode->i_ctime) = body->ctime;
560 static int ll_mknod_raw(struct nameidata *nd, int mode, dev_t rdev)
562 struct ptlrpc_request *request = NULL;
563 struct inode *dir = nd->dentry->d_inode;
564 struct ll_sb_info *sbi = ll_i2sbi(dir);
565 struct mdc_op_data *op_data;
569 CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
570 nd->last.len, nd->last.name, dir->i_ino,
571 dir->i_generation, dir);
573 mode &= ~current->fs->umask;
575 switch (mode & S_IFMT) {
578 mode |= S_IFREG; /* for mode = 0 case, fallthrough */
583 OBD_ALLOC(op_data, sizeof(*op_data));
586 ll_prepare_mdc_data(op_data, dir, NULL,
587 (char *)nd->last.name,
590 err = md_create(sbi->ll_md_exp, op_data, NULL, 0, mode,
591 current->fsuid, current->fsgid, rdev,
593 OBD_FREE(op_data, sizeof(*op_data));
595 ll_update_times(request, 0, dir);
596 ptlrpc_req_finished(request);
607 static int ll_mknod(struct inode *dir, struct dentry *dchild,
608 int mode, ll_dev_t rdev)
610 struct ptlrpc_request *request = NULL;
611 struct inode *inode = NULL;
612 struct ll_sb_info *sbi = ll_i2sbi(dir);
613 struct mdc_op_data *op_data;
617 CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
618 dchild->d_name.len, dchild->d_name.name,
619 dir->i_ino, dir->i_generation, dir);
621 mode &= ~current->fs->umask;
623 switch (mode & S_IFMT) {
626 mode |= S_IFREG; /* for mode = 0 case, fallthrough */
631 OBD_ALLOC(op_data, sizeof(*op_data));
635 ll_prepare_mdc_data(op_data, dir, NULL,
636 (char *)dchild->d_name.name,
637 dchild->d_name.len, 0);
639 err = md_create(sbi->ll_md_exp, op_data, NULL, 0, mode,
640 current->fsuid, current->fsgid, rdev,
642 OBD_FREE(op_data, sizeof(*op_data));
646 ll_update_times(request, 0, dir);
647 err = ll_prep_inode(sbi->ll_dt_exp, sbi->ll_md_exp,
648 &inode, request, 0, dchild->d_sb);
659 d_instantiate(dchild, inode);
662 ptlrpc_req_finished(request);
666 static int ll_symlink_raw(struct nameidata *nd, const char *tgt)
668 const char *name = (char *)nd->last.name;
669 struct inode *dir = nd->dentry->d_inode;
670 struct ptlrpc_request *request = NULL;
671 struct ll_sb_info *sbi = ll_i2sbi(dir);
672 struct mdc_op_data *op_data;
673 int len = nd->last.len;
677 CDEBUG(D_VFSTRACE, "VFS Op:name=%*s,dir=%lu/%u(%p),target=%s\n",
678 nd->last.len, nd->last.name, dir->i_ino, dir->i_generation,
681 if (dir->i_nlink >= EXT3_LINK_MAX)
684 OBD_ALLOC(op_data, sizeof(*op_data));
687 ll_prepare_mdc_data(op_data, dir, NULL, name, len, 0);
689 err = md_create(sbi->ll_md_exp, op_data,
690 tgt, strlen(tgt) + 1, S_IFLNK | S_IRWXUGO,
691 current->fsuid, current->fsgid, 0, &request);
692 OBD_FREE(op_data, sizeof(*op_data));
694 ll_update_times(request, 0, dir);
696 ptlrpc_req_finished(request);
700 static int ll_link_raw(struct nameidata *srcnd, struct nameidata *tgtnd)
702 struct inode *src = srcnd->dentry->d_inode;
703 struct inode *dir = tgtnd->dentry->d_inode;
704 struct ptlrpc_request *request = NULL;
705 struct ll_sb_info *sbi = ll_i2sbi(dir);
706 struct mdc_op_data *op_data;
711 "VFS Op: inode=%lu/%u(%p), dir=%lu/%u(%p), target=%.*s\n",
712 src->i_ino, src->i_generation, src, dir->i_ino,
713 dir->i_generation, dir, tgtnd->last.len, tgtnd->last.name);
715 OBD_ALLOC(op_data, sizeof(*op_data));
719 ll_prepare_mdc_data(op_data, src, dir,
720 (char *)tgtnd->last.name,
723 err = md_link(sbi->ll_md_exp, op_data, &request);
724 OBD_FREE(op_data, sizeof(*op_data));
726 ll_update_times(request, 0, dir);
727 ptlrpc_req_finished(request);
732 static int ll_mkdir_raw(struct nameidata *nd, int mode)
734 struct inode *dir = nd->dentry->d_inode;
735 struct ptlrpc_request *request = NULL;
736 struct ll_sb_info *sbi = ll_i2sbi(dir);
737 struct mdc_op_data *op_data;
740 CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
741 nd->last.len, nd->last.name, dir->i_ino, dir->i_generation, dir);
743 mode = (mode & (S_IRWXUGO|S_ISVTX) & ~current->fs->umask) | S_IFDIR;
744 OBD_ALLOC(op_data, sizeof(*op_data));
748 ll_prepare_mdc_data(op_data, dir, NULL,
749 (char *)nd->last.name,
752 err = md_create(sbi->ll_md_exp, op_data, NULL, 0, mode,
753 current->fsuid, current->fsgid, 0, &request);
754 OBD_FREE(op_data, sizeof(*op_data));
756 ll_update_times(request, 0, dir);
757 ptlrpc_req_finished(request);
761 static int ll_rmdir_raw(struct nameidata *nd)
763 struct inode *dir = nd->dentry->d_inode;
764 struct ptlrpc_request *request = NULL;
765 struct mdc_op_data *op_data;
769 CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
770 nd->last.len, nd->last.name, dir->i_ino,
771 dir->i_generation, dir);
773 OBD_ALLOC(op_data, sizeof(*op_data));
777 ll_prepare_mdc_data(op_data, dir, NULL,
778 (char *)nd->last.name,
779 nd->last.len, S_IFDIR);
781 rc = md_unlink(ll_i2sbi(dir)->ll_md_exp, op_data, &request);
782 OBD_FREE(op_data, sizeof(*op_data));
784 ll_update_times(request, 0, dir);
785 ptlrpc_req_finished(request);
789 static int ll_unlink_raw(struct nameidata *nd)
791 struct inode *dir = nd->dentry->d_inode;
792 struct ptlrpc_request *request = NULL;
793 struct mdc_op_data *op_data;
796 CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
797 nd->last.len, nd->last.name, dir->i_ino,
798 dir->i_generation, dir);
800 OBD_ALLOC(op_data, sizeof(*op_data));
803 ll_prepare_mdc_data(op_data, dir, NULL,
804 (char *)nd->last.name, nd->last.len, 0);
805 rc = md_unlink(ll_i2sbi(dir)->ll_md_exp, op_data, &request);
806 OBD_FREE(op_data, sizeof(*op_data));
809 ll_update_times(request, 0, dir);
812 ptlrpc_req_finished(request);
816 static int ll_rename_raw(struct nameidata *srcnd, struct nameidata *tgtnd)
818 struct inode *src = srcnd->dentry->d_inode;
819 struct inode *tgt = tgtnd->dentry->d_inode;
820 struct ptlrpc_request *request = NULL;
821 struct ll_sb_info *sbi = ll_i2sbi(src);
822 struct mdc_op_data *op_data;
826 if (srcnd->mnt != tgtnd->mnt)
829 CDEBUG(D_VFSTRACE,"VFS Op:oldname=%.*s,src_dir=%lu/%u(%p),newname=%.*s,"
830 "tgt_dir=%lu/%u(%p)\n", srcnd->last.len, srcnd->last.name,
831 src->i_ino, src->i_generation, src, tgtnd->last.len,
832 tgtnd->last.name, tgt->i_ino, tgt->i_generation, tgt);
834 OBD_ALLOC(op_data, sizeof(*op_data));
837 ll_prepare_mdc_data(op_data, src, tgt, NULL, 0, 0);
838 err = md_rename(sbi->ll_md_exp, op_data, (char *)srcnd->last.name,
839 srcnd->last.len, (char *)tgtnd->last.name,
840 tgtnd->last.len, &request);
841 OBD_FREE(op_data, sizeof(*op_data));
843 ll_update_times(request, 0, src);
844 ll_update_times(request, 0, tgt);
847 ptlrpc_req_finished(request);
851 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
852 #define LLITE_IT_RAWOPS (IT_MKNOD|IT_MKDIR|IT_SYMLINK|IT_LINK|IT_UNLINK|IT_RMDIR|IT_RENAME)
853 static int ll_rawop_from_intent(struct nameidata *nd)
857 if (!nd || !(nd->intent.open.op & LLITE_IT_RAWOPS))
860 switch (nd->intent.open.op) {
862 error = ll_mknod_raw(nd, nd->intent.open.create_mode,
863 nd->intent.open.create.dev);
866 error = ll_mkdir_raw(nd, nd->intent.open.create_mode);
869 error = ll_rmdir_raw(nd);
872 error = ll_unlink_raw(nd);
875 LASSERT(nd->intent.open.create.link);
876 error = ll_symlink_raw(nd, nd->intent.open.create.link);
879 error = ll_link_raw(nd->intent.open.create.source_nd, nd);
882 LASSERT(nd->intent.open.create.source_nd);
883 error = ll_rename_raw(nd->intent.open.create.source_nd, nd);
888 if (error != -EOPNOTSUPP)
889 nd->intent.open.flags |= IT_STATUS_RAW;
895 struct inode_operations ll_dir_inode_operations = {
897 .setattr = ll_setattr,
898 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
899 .create_it = ll_create_it,
900 .lookup_it = ll_lookup_it,
901 .revalidate_it = ll_inode_revalidate_it,
903 .lookup = ll_lookup_nd,
904 .create = ll_create_nd,
905 .getattr = ll_getattr,
906 .endparentlookup = ll_rawop_from_intent,
908 .setxattr = ll_setxattr,
909 .getxattr = ll_getxattr,
910 .listxattr = ll_listxattr,
911 .removexattr = ll_removexattr,
912 .permission = ll_inode_permission,