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)
121 struct timeval tstart, now;
123 do_gettimeofday(&tstart);
126 inode = iget5_locked(sb, hash, ll_test_inode, ll_set_inode, md);
129 if (inode->i_state & I_NEW)
130 unlock_new_inode(inode);
131 CDEBUG(D_VFSTRACE, "inode: %lu/%u(%p)\n", inode->i_ino,
132 inode->i_generation, inode);
135 /* XXX: debugging for 7346 -bzzz */
136 do_gettimeofday(&now);
137 if (now.tv_sec - tstart.tv_sec > obd_timeout / 2) {
138 struct ll_inode_info *lli = ll_i2info(inode);
139 CDEBUG(D_ERROR, "waiting for inode 0x%p "DLID4" took %ds\n",
140 inode, OLID4(&lli->lli_id),
141 (int) (now.tv_sec - tstart.tv_sec));
142 portals_debug_dumplog();
148 struct inode *ll_iget(struct super_block *sb, ino_t hash,
149 struct lustre_md *md)
153 inode = iget4(sb, hash, ll_test_inode, md);
155 CDEBUG(D_VFSTRACE, "inode: %lu/%u(%p)\n", inode->i_ino,
156 inode->i_generation, inode);
161 int ll_mdc_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc,
162 void *data, int flag)
165 struct lustre_handle lockh;
169 case LDLM_CB_BLOCKING:
170 ldlm_lock2handle(lock, &lockh);
171 rc = ldlm_cli_cancel(&lockh);
173 CDEBUG(D_INODE, "ldlm_cli_cancel: %d\n", rc);
177 case LDLM_CB_CANCELING: {
178 struct inode *inode = ll_inode_from_lock(lock);
179 struct ll_inode_info *li = ll_i2info(inode);
180 __u64 bits = lock->l_policy_data.l_inodebits.bits;
182 /* For lookup locks: Invalidate all dentries associated with
183 this inode, for UPDATE locks - invalidate directory pages */
187 if (lock->l_resource->lr_name.name[0] != id_fid(&li->lli_id) ||
188 lock->l_resource->lr_name.name[1] != id_group(&li->lli_id)) {
189 LDLM_ERROR(lock, "data mismatch with object %lu/%lu",
190 (unsigned long)id_fid(&li->lli_id),
191 (unsigned long)id_group(&li->lli_id));
194 if (bits & MDS_INODELOCK_OPEN) {
196 switch (lock->l_req_mode) {
207 CERROR("Unexpected lock mode for OPEN lock "
208 "%d, inode %ld\n", lock->l_req_mode,
211 ll_md_real_close(ll_i2mdexp(inode), inode, flags);
214 if ((bits & MDS_INODELOCK_UPDATE) && LLI_HAVE_FLSIZE(inode)) {
215 CDEBUG(D_OTHER, "isize for %lu/%u(%p) from mds "
216 "is not actual\n", inode->i_ino,
217 inode->i_generation, inode);
218 clear_bit(LLI_F_HAVE_MDS_SIZE_LOCK,
219 &(ll_i2info(inode)->lli_flags));
223 /* If lookup lock is cancelled, we just drop the dentry and
224 this will cause us to reget data from MDS when we'd want to
225 access this dentry/inode again. If this is lock on
226 other parts of inode that is cancelled, we do not need to do
227 much (but need to discard data from readdir, if any), since
228 abscence of lock will cause ll_revalidate_it (called from
229 stat() and similar functions) to renew the data anyway */
230 if (S_ISDIR(inode->i_mode) &&
231 (bits & MDS_INODELOCK_UPDATE)) {
232 CDEBUG(D_INODE, "invalidating inode %lu/%u(%p)\n",
233 inode->i_ino, inode->i_generation, inode);
234 truncate_inode_pages(inode->i_mapping, 0);
237 ll_inode_invalidate_acl(inode);
239 if (inode->i_sb->s_root &&
240 inode != inode->i_sb->s_root->d_inode &&
241 (bits & MDS_INODELOCK_LOOKUP))
242 ll_unhash_aliases(inode);
253 /* Search "inode"'s alias list for a dentry that has the same name and parent as
254 * de. If found, return it. If not found, return de. */
255 struct dentry *ll_find_alias(struct inode *inode, struct dentry *de)
257 struct list_head *tmp;
259 spin_lock(&dcache_lock);
260 list_for_each(tmp, &inode->i_dentry) {
261 struct dentry *dentry = list_entry(tmp, struct dentry, d_alias);
263 /* We are called here with 'de' already on the aliases list. */
269 if (dentry->d_parent != de->d_parent)
272 if (dentry->d_name.len != de->d_name.len)
275 if (memcmp(dentry->d_name.name, de->d_name.name,
276 de->d_name.len) != 0)
279 if (!list_empty(&dentry->d_lru))
280 list_del_init(&dentry->d_lru);
282 hlist_del_init(&dentry->d_hash);
283 __d_rehash(dentry); /* avoid taking dcache_lock inside */
284 spin_unlock(&dcache_lock);
285 atomic_inc(&dentry->d_count);
287 dentry->d_flags &= ~DCACHE_LUSTRE_INVALID;
288 CDEBUG(D_DENTRY, "alias dentry %*s (%p) parent %p inode %p "
289 "refc %d\n", de->d_name.len, de->d_name.name, de,
290 de->d_parent, de->d_inode, atomic_read(&de->d_count));
294 spin_unlock(&dcache_lock);
299 static int lookup_it_finish(struct ptlrpc_request *request, int offset,
300 struct lookup_intent *it, void *data)
302 struct it_cb_data *icbd = data;
303 struct dentry **de = icbd->icbd_childp;
304 struct inode *parent = icbd->icbd_parent;
305 struct ll_sb_info *sbi = ll_i2sbi(parent);
306 struct dentry *dentry = *de, *saved = *de;
307 struct inode *inode = NULL;
310 /* NB 1 request reference will be taken away by ll_intent_lock()
312 if (!it_disposition(it, DISP_LOOKUP_NEG)) {
315 rc = ll_prep_inode(sbi->ll_dt_exp, sbi->ll_md_exp,
316 &inode, request, offset, dentry->d_sb);
320 CDEBUG(D_DLMTRACE, "setting l_data to inode %p (%lu/%u)\n",
321 inode, inode->i_ino, inode->i_generation);
323 mdc_set_lock_data(NULL, &LUSTRE_IT(it)->it_lock_handle, inode);
325 /* If this is a stat, get the authoritative file size */
326 if (it->it_op == IT_GETATTR && S_ISREG(inode->i_mode) &&
327 ll_i2info(inode)->lli_smd != NULL) {
328 struct lov_stripe_md *lsm = ll_i2info(inode)->lli_smd;
331 LASSERT(lsm->lsm_object_id != 0);
333 /* bug 2334: drop MDS lock before acquiring OST lock */
334 ll_intent_drop_lock(it);
336 if (!LLI_HAVE_FLSIZE(inode)) {
337 CDEBUG(D_INODE, "retrieve size from OSS\n");
338 rc = ll_glimpse_size(inode);
346 dentry = *de = ll_find_alias(inode, dentry);
351 dentry->d_op = &ll_d_ops;
355 d_add(dentry, inode);
360 static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry,
361 struct nameidata *nd, int flags)
363 struct lookup_intent *it = flags ? &nd->intent.open : NULL;
364 struct lookup_intent lookup_it = { .it_op = IT_LOOKUP };
365 struct dentry *save = dentry, *retval;
366 struct ptlrpc_request *req = NULL;
367 int rc, gns_it, gns_flags;
368 struct it_cb_data icbd;
369 struct lustre_id pid;
372 if (dentry->d_name.len > EXT3_NAME_LEN)
373 RETURN(ERR_PTR(-ENAMETOOLONG));
375 CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),intent=%s\n",
376 dentry->d_name.len, dentry->d_name.name, parent->i_ino,
377 parent->i_generation, parent, LL_IT2STR(it));
379 if (d_mountpoint(dentry))
380 CERROR("Tell Peter, lookup on mtpt, it %s\n", LL_IT2STR(it));
383 nd->mnt->mnt_last_used = jiffies;
385 gns_it = nd ? nd->intent.open.it_op : IT_OPEN;
386 gns_flags = nd ? nd->flags : LOOKUP_CONTINUE;
387 ll_frob_intent(&it, &lookup_it);
389 icbd.icbd_childp = &dentry;
390 icbd.icbd_parent = parent;
391 ll_inode2id(&pid, parent);
393 /*ONLY need key for open_create file*/
394 rc = ll_crypto_init_it_key(parent, it);
396 GOTO(out, retval = ERR_PTR(rc));
398 rc = md_intent_lock(ll_i2mdexp(parent), &pid,
399 (char *)dentry->d_name.name, dentry->d_name.len,
400 NULL, 0, NULL, it, flags, &req,
401 ll_mdc_blocking_ast);
403 GOTO(out, retval = ERR_PTR(rc));
405 rc = lookup_it_finish(req, 1, it, &icbd);
407 ll_intent_release(it);
408 GOTO(out, retval = ERR_PTR(rc));
411 ll_lookup_finish_locks(it, dentry);
413 if (nd && dentry->d_inode != NULL &&
414 dentry->d_inode->i_mode & S_ISUID && S_ISDIR(dentry->d_inode->i_mode) &&
415 ((gns_flags & LOOKUP_CONTINUE) || (gns_it & (IT_CHDIR | IT_OPEN))))
417 CDEBUG(D_DENTRY, "possible GNS dentry %*s %p found, "
418 "mounting it\n", (int)dentry->d_name.len,
419 dentry->d_name.name, dentry);
421 rc = ll_gns_mount_object(dentry, nd->mnt);
424 * just reporting about GNS failures, lookup() is
425 * successful, do not stop it.
427 * GNS failure may be that object is found in SUID bit
428 * marked dir but it is not regular file and we should
429 * lookup further until we find correct mount
430 * object. This will allow to perform GNS mount is the
431 * following case for instance:
433 * /mnt/lustre/gns_mount/.mntinfo/.mntinfo/..../.mntinfo
434 * where all ".mntinfo" are dirs and only last one is
437 CDEBUG(D_DENTRY, "failed to mount %*s, err %d\n",
438 (int)dentry->d_name.len, dentry->d_name.name, rc);
443 GOTO(out, retval = NULL);
445 GOTO(out, retval = dentry);
448 ptlrpc_req_finished(req);
449 if (it == &lookup_it)
450 ll_intent_release(it);
452 CDEBUG(D_INODE, "lookup 0x%p in %lu/%lu: %*s -> %lu/%lu\n",
454 (unsigned long) parent->i_ino,
455 (unsigned long) parent->i_generation,
456 dentry->d_name.len, dentry->d_name.name,
457 (unsigned long) dentry->d_inode->i_ino,
458 (unsigned long) dentry->d_inode->i_generation);
460 CDEBUG(D_INODE, "lookup 0x%p in %lu/%lu: %*s -> ??\n",
462 (unsigned long) parent->i_ino,
463 (unsigned long) parent->i_generation,
464 dentry->d_name.len, dentry->d_name.name);
468 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
469 static struct dentry *ll_lookup_nd(struct inode *parent, struct dentry *dentry,
470 struct nameidata *nd)
475 if (nd && nd->flags & LOOKUP_LAST && !(nd->flags & LOOKUP_LINK_NOTLAST))
476 de = ll_lookup_it(parent, dentry, nd, nd->flags);
478 de = ll_lookup_it(parent, dentry, nd, 0);
484 /* We depend on "mode" being set with the proper file type/umask by now */
485 static struct inode *ll_create_node(struct inode *dir, const char *name,
486 int namelen, const void *data, int datalen,
487 int mode, __u64 extra,
488 struct lookup_intent *it)
490 struct inode *inode = NULL;
491 struct ptlrpc_request *request = NULL;
492 struct ll_sb_info *sbi = ll_i2sbi(dir);
497 LASSERT(it && LUSTRE_IT(it)->it_disposition);
499 request = LUSTRE_IT(it)->it_data;
500 rc = ll_prep_inode(sbi->ll_dt_exp, sbi->ll_md_exp,
501 &inode, request, 1, dir->i_sb);
503 GOTO(out, inode = ERR_PTR(rc));
505 LASSERT(list_empty(&inode->i_dentry));
507 /* We asked for a lock on the directory, but were granted a
508 * lock on the inode. Since we finally have an inode pointer,
509 * stuff it in the lock. */
510 CDEBUG(D_DLMTRACE, "setting l_ast_data to inode %p (%lu/%u)\n",
511 inode, inode->i_ino, inode->i_generation);
512 mdc_set_lock_data(NULL, &LUSTRE_IT(it)->it_lock_handle, inode);
515 ptlrpc_req_finished(request);
520 * By the time this is called, we already have created the directory cache
521 * entry for the new file, but it is so far negative - it has no inode.
523 * We defer creating the OBD object(s) until open, to keep the intent and
524 * non-intent code paths similar, and also because we do not have the MDS
525 * inode number before calling ll_create_node() (which is needed for LOV),
526 * so we would need to do yet another RPC to the MDS to store the LOV EA
527 * data on the MDS. If needed, we would pass the PACKED lmm as data and
528 * lmm_size in datalen (the MDS still has code which will handle that).
530 * If the create succeeds, we fill in the inode information
531 * with d_instantiate().
533 static int ll_create_it(struct inode *dir, struct dentry *dentry, int mode,
534 struct lookup_intent *it)
537 struct ptlrpc_request *request = LUSTRE_IT(it)->it_data;
538 struct obd_export *md_exp = ll_i2mdexp(dir);
542 CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),intent=%s\n",
543 dentry->d_name.len, dentry->d_name.name, dir->i_ino,
544 dir->i_generation, dir, LL_IT2STR(it));
546 rc = it_open_error(DISP_OPEN_CREATE, it);
550 mdc_store_inode_generation(md_exp, request, MDS_REQ_INTENT_REC_OFF, 1);
551 inode = ll_create_node(dir, (char *)dentry->d_name.name,
552 dentry->d_name.len, NULL, 0, mode, 0, it);
554 RETURN(PTR_ERR(inode));
556 d_instantiate(dentry, inode);
560 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
561 static int ll_create_nd(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd)
563 return ll_create_it(dir, dentry, mode, &nd->intent.open);
567 static void ll_update_times(struct ptlrpc_request *request, int offset,
570 struct mds_body *body = lustre_msg_buf(request->rq_repmsg, offset,
574 if (body->valid & OBD_MD_FLMTIME &&
575 body->mtime > LTIME_S(inode->i_mtime)) {
576 CDEBUG(D_INODE, "setting ino %lu mtime from %lu to %u\n",
577 inode->i_ino, LTIME_S(inode->i_mtime), body->mtime);
578 LTIME_S(inode->i_mtime) = body->mtime;
580 if (body->valid & OBD_MD_FLCTIME &&
581 body->ctime > LTIME_S(inode->i_ctime))
582 LTIME_S(inode->i_ctime) = body->ctime;
585 static int ll_mknod_raw(struct nameidata *nd, int mode, dev_t rdev)
587 struct ptlrpc_request *request = NULL;
588 struct inode *dir = nd->dentry->d_inode;
589 struct ll_sb_info *sbi = ll_i2sbi(dir);
590 struct mdc_op_data *op_data;
591 int err = -EMLINK, key_size = 0;
595 CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
596 nd->last.len, nd->last.name, dir->i_ino,
597 dir->i_generation, dir);
599 mode &= ~current->fs->umask;
601 switch (mode & S_IFMT) {
604 mode |= S_IFREG; /* for mode = 0 case, fallthrough */
605 ll_crypto_create_key(dir, mode, &key, &key_size);
610 OBD_ALLOC(op_data, sizeof(*op_data));
613 ll_prepare_mdc_data(op_data, dir, NULL,
614 (char *)nd->last.name,
616 err = md_create(sbi->ll_md_exp, op_data, key, key_size, mode,
617 current->fsuid, current->fsgid, rdev,
619 OBD_FREE(op_data, sizeof(*op_data));
621 ll_update_times(request, 0, dir);
622 ptlrpc_req_finished(request);
631 OBD_FREE(key, key_size);
635 static int ll_mknod(struct inode *dir, struct dentry *dchild,
636 int mode, ll_dev_t rdev)
638 struct ptlrpc_request *request = NULL;
639 struct inode *inode = NULL;
640 struct ll_sb_info *sbi = ll_i2sbi(dir);
641 struct mdc_op_data *op_data;
645 CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
646 dchild->d_name.len, dchild->d_name.name,
647 dir->i_ino, dir->i_generation, dir);
649 mode &= ~current->fs->umask;
651 switch (mode & S_IFMT) {
654 mode |= S_IFREG; /* for mode = 0 case, fallthrough */
660 OBD_ALLOC(op_data, sizeof(*op_data));
664 ll_prepare_mdc_data(op_data, dir, NULL,
665 (char *)dchild->d_name.name,
666 dchild->d_name.len, 0);
668 err = md_create(sbi->ll_md_exp, op_data, NULL, 0, mode,
669 current->fsuid, current->fsgid, rdev,
671 OBD_FREE(op_data, sizeof(*op_data));
675 ll_update_times(request, 0, dir);
676 err = ll_prep_inode(sbi->ll_dt_exp, sbi->ll_md_exp,
677 &inode, request, 0, dchild->d_sb);
688 d_instantiate(dchild, inode);
691 ptlrpc_req_finished(request);
695 static int ll_symlink_raw(struct nameidata *nd, const char *tgt)
697 const char *name = (char *)nd->last.name;
698 struct inode *dir = nd->dentry->d_inode;
699 struct ptlrpc_request *request = NULL;
700 struct ll_sb_info *sbi = ll_i2sbi(dir);
701 struct mdc_op_data *op_data;
702 int len = nd->last.len;
706 CDEBUG(D_VFSTRACE, "VFS Op:name=%*s,dir=%lu/%u(%p),target=%s\n",
707 nd->last.len, nd->last.name, dir->i_ino, dir->i_generation,
710 if (dir->i_nlink >= EXT3_LINK_MAX)
713 OBD_ALLOC(op_data, sizeof(*op_data));
716 ll_prepare_mdc_data(op_data, dir, NULL, name, len, 0);
718 err = md_create(sbi->ll_md_exp, op_data,
719 tgt, strlen(tgt) + 1, S_IFLNK | S_IRWXUGO,
720 current->fsuid, current->fsgid, 0, &request);
721 OBD_FREE(op_data, sizeof(*op_data));
723 ll_update_times(request, 0, dir);
725 ptlrpc_req_finished(request);
729 static int ll_link_raw(struct nameidata *srcnd, struct nameidata *tgtnd)
731 struct inode *src = srcnd->dentry->d_inode;
732 struct inode *dir = tgtnd->dentry->d_inode;
733 struct ptlrpc_request *request = NULL;
734 struct ll_sb_info *sbi = ll_i2sbi(dir);
735 struct mdc_op_data *op_data;
740 "VFS Op: inode=%lu/%u(%p), dir=%lu/%u(%p), target=%.*s\n",
741 src->i_ino, src->i_generation, src, dir->i_ino,
742 dir->i_generation, dir, tgtnd->last.len, tgtnd->last.name);
744 OBD_ALLOC(op_data, sizeof(*op_data));
748 ll_prepare_mdc_data(op_data, src, dir,
749 (char *)tgtnd->last.name,
752 err = md_link(sbi->ll_md_exp, op_data, &request);
753 OBD_FREE(op_data, sizeof(*op_data));
755 ll_update_times(request, 0, dir);
756 ptlrpc_req_finished(request);
761 static int ll_mkdir_raw(struct nameidata *nd, int mode)
763 struct inode *dir = nd->dentry->d_inode;
764 struct ptlrpc_request *request = NULL;
765 struct ll_sb_info *sbi = ll_i2sbi(dir);
766 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, dir->i_generation, dir);
772 mode = (mode & (S_IRWXUGO|S_ISVTX) & ~current->fs->umask) | S_IFDIR;
773 OBD_ALLOC(op_data, sizeof(*op_data));
777 ll_prepare_mdc_data(op_data, dir, NULL,
778 (char *)nd->last.name,
781 err = md_create(sbi->ll_md_exp, op_data, NULL, 0, mode,
782 current->fsuid, current->fsgid, 0, &request);
783 OBD_FREE(op_data, sizeof(*op_data));
785 ll_update_times(request, 0, dir);
786 ptlrpc_req_finished(request);
790 static int ll_rmdir_raw(struct nameidata *nd)
792 struct inode *dir = nd->dentry->d_inode;
793 struct ptlrpc_request *request = NULL;
794 struct mdc_op_data *op_data;
798 CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
799 nd->last.len, nd->last.name, dir->i_ino,
800 dir->i_generation, dir);
802 OBD_ALLOC(op_data, sizeof(*op_data));
806 ll_prepare_mdc_data(op_data, dir, NULL,
807 (char *)nd->last.name,
808 nd->last.len, S_IFDIR);
810 rc = md_unlink(ll_i2sbi(dir)->ll_md_exp, op_data, &request);
811 OBD_FREE(op_data, sizeof(*op_data));
813 ll_update_times(request, 0, dir);
814 ptlrpc_req_finished(request);
818 static int ll_unlink_raw(struct nameidata *nd)
820 struct inode *dir = nd->dentry->d_inode;
821 struct ptlrpc_request *request = NULL;
822 struct mdc_op_data *op_data;
825 CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
826 nd->last.len, nd->last.name, dir->i_ino,
827 dir->i_generation, dir);
829 OBD_ALLOC(op_data, sizeof(*op_data));
832 ll_prepare_mdc_data(op_data, dir, NULL,
833 (char *)nd->last.name, nd->last.len, 0);
834 rc = md_unlink(ll_i2sbi(dir)->ll_md_exp, op_data, &request);
835 OBD_FREE(op_data, sizeof(*op_data));
838 ll_update_times(request, 0, dir);
841 ptlrpc_req_finished(request);
845 static int ll_rename_raw(struct nameidata *srcnd, struct nameidata *tgtnd)
847 struct inode *src = srcnd->dentry->d_inode;
848 struct inode *tgt = tgtnd->dentry->d_inode;
849 struct ptlrpc_request *request = NULL;
850 struct ll_sb_info *sbi = ll_i2sbi(src);
851 struct mdc_op_data *op_data;
855 if (srcnd->mnt != tgtnd->mnt)
858 CDEBUG(D_VFSTRACE,"VFS Op:oldname=%.*s,src_dir=%lu/%u(%p),newname=%.*s,"
859 "tgt_dir=%lu/%u(%p)\n", srcnd->last.len, srcnd->last.name,
860 src->i_ino, src->i_generation, src, tgtnd->last.len,
861 tgtnd->last.name, tgt->i_ino, tgt->i_generation, tgt);
863 OBD_ALLOC(op_data, sizeof(*op_data));
866 ll_prepare_mdc_data(op_data, src, tgt, NULL, 0, 0);
867 err = md_rename(sbi->ll_md_exp, op_data, (char *)srcnd->last.name,
868 srcnd->last.len, (char *)tgtnd->last.name,
869 tgtnd->last.len, &request);
870 OBD_FREE(op_data, sizeof(*op_data));
872 ll_update_times(request, 0, src);
873 ll_update_times(request, 0, tgt);
876 ptlrpc_req_finished(request);
880 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
881 #define LLITE_IT_RAWOPS (IT_MKNOD|IT_MKDIR|IT_SYMLINK|IT_LINK|IT_UNLINK|IT_RMDIR|IT_RENAME)
882 static int ll_rawop_from_intent(struct nameidata *nd)
886 if (!nd || !(nd->intent.open.op & LLITE_IT_RAWOPS))
889 switch (nd->intent.open.op) {
891 error = ll_mknod_raw(nd, nd->intent.open.create_mode,
892 nd->intent.open.create.dev);
895 error = ll_mkdir_raw(nd, nd->intent.open.create_mode);
898 error = ll_rmdir_raw(nd);
901 error = ll_unlink_raw(nd);
904 LASSERT(nd->intent.open.create.link);
905 error = ll_symlink_raw(nd, nd->intent.open.create.link);
908 error = ll_link_raw(nd->intent.open.create.source_nd, nd);
911 LASSERT(nd->intent.open.create.source_nd);
912 error = ll_rename_raw(nd->intent.open.create.source_nd, nd);
917 if (error != -EOPNOTSUPP)
918 nd->intent.open.flags |= IT_STATUS_RAW;
924 struct inode_operations ll_dir_inode_operations = {
926 .setattr = ll_setattr,
927 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
928 .create_it = ll_create_it,
929 .lookup_it = ll_lookup_it,
930 .revalidate_it = ll_inode_revalidate_it,
932 .lookup = ll_lookup_nd,
933 .create = ll_create_nd,
934 .getattr = ll_getattr,
935 .endparentlookup = ll_rawop_from_intent,
937 .setxattr = ll_setxattr,
938 .getxattr = ll_getxattr,
939 .listxattr = ll_listxattr,
940 .removexattr = ll_removexattr,
941 .permission = ll_inode_permission,