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 */
174 if (lock->l_resource->lr_name.name[0] != id_fid(&li->lli_id) ||
175 lock->l_resource->lr_name.name[1] != id_group(&li->lli_id)) {
176 LDLM_ERROR(lock, "data mismatch with object %lu/%lu",
177 (unsigned long)id_fid(&li->lli_id),
178 (unsigned long)id_group(&li->lli_id));
181 if (bits & MDS_INODELOCK_OPEN) {
183 switch (lock->l_req_mode) {
194 CERROR("Unexpected lock mode for OPEN lock "
195 "%d, inode %ld\n", lock->l_req_mode,
198 ll_md_real_close(ll_i2mdexp(inode), inode, flags);
201 if ((bits & MDS_INODELOCK_UPDATE) && LLI_HAVE_FLSIZE(inode)) {
202 CDEBUG(D_OTHER, "isize for %lu/%u(%p) from mds "
203 "is not actual\n", inode->i_ino,
204 inode->i_generation, inode);
205 clear_bit(LLI_F_HAVE_MDS_SIZE_LOCK,
206 &(ll_i2info(inode)->lli_flags));
210 /* If lookup lock is cancelled, we just drop the dentry and
211 this will cause us to reget data from MDS when we'd want to
212 access this dentry/inode again. If this is lock on
213 other parts of inode that is cancelled, we do not need to do
214 much (but need to discard data from readdir, if any), since
215 abscence of lock will cause ll_revalidate_it (called from
216 stat() and similar functions) to renew the data anyway */
217 if (S_ISDIR(inode->i_mode) &&
218 (bits & MDS_INODELOCK_UPDATE)) {
219 CDEBUG(D_INODE, "invalidating inode %lu/%u(%p)\n",
220 inode->i_ino, inode->i_generation, inode);
221 truncate_inode_pages(inode->i_mapping, 0);
224 ll_inode_invalidate_acl(inode);
226 if (inode->i_sb->s_root &&
227 inode != inode->i_sb->s_root->d_inode &&
228 (bits & MDS_INODELOCK_LOOKUP))
229 ll_unhash_aliases(inode);
240 /* Search "inode"'s alias list for a dentry that has the same name and parent as
241 * de. If found, return it. If not found, return de. */
242 struct dentry *ll_find_alias(struct inode *inode, struct dentry *de)
244 struct list_head *tmp;
246 spin_lock(&dcache_lock);
247 list_for_each(tmp, &inode->i_dentry) {
248 struct dentry *dentry = list_entry(tmp, struct dentry, d_alias);
250 /* We are called here with 'de' already on the aliases list. */
256 if (dentry->d_parent != de->d_parent)
259 if (dentry->d_name.len != de->d_name.len)
262 if (memcmp(dentry->d_name.name, de->d_name.name,
263 de->d_name.len) != 0)
266 if (!list_empty(&dentry->d_lru))
267 list_del_init(&dentry->d_lru);
269 hlist_del_init(&dentry->d_hash);
270 __d_rehash(dentry); /* avoid taking dcache_lock inside */
271 spin_unlock(&dcache_lock);
272 atomic_inc(&dentry->d_count);
274 dentry->d_flags &= ~DCACHE_LUSTRE_INVALID;
275 CDEBUG(D_DENTRY, "alias dentry %*s (%p) parent %p inode %p "
276 "refc %d\n", de->d_name.len, de->d_name.name, de,
277 de->d_parent, de->d_inode, atomic_read(&de->d_count));
281 spin_unlock(&dcache_lock);
286 static int lookup_it_finish(struct ptlrpc_request *request, int offset,
287 struct lookup_intent *it, void *data)
289 struct it_cb_data *icbd = data;
290 struct dentry **de = icbd->icbd_childp;
291 struct inode *parent = icbd->icbd_parent;
292 struct ll_sb_info *sbi = ll_i2sbi(parent);
293 struct dentry *dentry = *de, *saved = *de;
294 struct inode *inode = NULL;
297 /* NB 1 request reference will be taken away by ll_intent_lock()
299 if (!it_disposition(it, DISP_LOOKUP_NEG)) {
302 rc = ll_prep_inode(sbi->ll_dt_exp, sbi->ll_md_exp,
303 &inode, request, offset, dentry->d_sb);
307 CDEBUG(D_DLMTRACE, "setting l_data to inode %p (%lu/%u)\n",
308 inode, inode->i_ino, inode->i_generation);
310 mdc_set_lock_data(NULL, &LUSTRE_IT(it)->it_lock_handle, inode);
312 /* If this is a stat, get the authoritative file size */
313 if (it->it_op == IT_GETATTR && S_ISREG(inode->i_mode) &&
314 ll_i2info(inode)->lli_smd != NULL) {
315 struct lov_stripe_md *lsm = ll_i2info(inode)->lli_smd;
318 LASSERT(lsm->lsm_object_id != 0);
320 /* bug 2334: drop MDS lock before acquiring OST lock */
321 ll_intent_drop_lock(it);
323 if (!LLI_HAVE_FLSIZE(inode)) {
324 CDEBUG(D_INODE, "retrieve size from OSS\n");
325 rc = ll_glimpse_size(inode);
333 dentry = *de = ll_find_alias(inode, dentry);
338 dentry->d_op = &ll_d_ops;
342 d_add(dentry, inode);
347 static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry,
348 struct nameidata *nd, int flags)
350 struct lookup_intent *it = flags ? &nd->intent.open : NULL;
351 struct lookup_intent lookup_it = { .it_op = IT_LOOKUP };
352 struct dentry *save = dentry, *retval;
353 struct ptlrpc_request *req = NULL;
354 int rc, gns_it, gns_flags;
355 struct it_cb_data icbd;
356 struct lustre_id pid;
359 if (dentry->d_name.len > EXT3_NAME_LEN)
360 RETURN(ERR_PTR(-ENAMETOOLONG));
362 CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),intent=%s\n",
363 dentry->d_name.len, dentry->d_name.name, parent->i_ino,
364 parent->i_generation, parent, LL_IT2STR(it));
366 if (d_mountpoint(dentry))
367 CERROR("Tell Peter, lookup on mtpt, it %s\n", LL_IT2STR(it));
370 nd->mnt->mnt_last_used = jiffies;
372 gns_it = nd ? nd->intent.open.it_op : IT_OPEN;
373 gns_flags = nd ? nd->flags : LOOKUP_CONTINUE;
374 ll_frob_intent(&it, &lookup_it);
376 icbd.icbd_childp = &dentry;
377 icbd.icbd_parent = parent;
378 ll_inode2id(&pid, parent);
380 /*ONLY need key for open_create file*/
381 rc = ll_crypto_init_it_key(parent, it);
383 GOTO(out, retval = ERR_PTR(rc));
385 rc = md_intent_lock(ll_i2mdexp(parent), &pid,
386 (char *)dentry->d_name.name, dentry->d_name.len,
387 NULL, 0, NULL, it, flags, &req,
388 ll_mdc_blocking_ast);
390 GOTO(out, retval = ERR_PTR(rc));
392 rc = lookup_it_finish(req, 1, it, &icbd);
394 ll_intent_release(it);
395 GOTO(out, retval = ERR_PTR(rc));
398 ll_lookup_finish_locks(it, dentry);
400 if (nd && dentry->d_inode != NULL &&
401 dentry->d_inode->i_mode & S_ISUID && S_ISDIR(dentry->d_inode->i_mode) &&
402 ((gns_flags & LOOKUP_CONTINUE) || (gns_it & (IT_CHDIR | IT_OPEN))))
404 CDEBUG(D_DENTRY, "possible GNS dentry %*s %p found, "
405 "mounting it\n", (int)dentry->d_name.len,
406 dentry->d_name.name, dentry);
408 rc = ll_gns_mount_object(dentry, nd->mnt);
411 * just reporting about GNS failures, lookup() is
412 * successful, do not stop it.
414 * GNS failure may be that object is found in SUID bit
415 * marked dir but it is not regular file and we should
416 * lookup further until we find correct mount
417 * object. This will allow to perform GNS mount is the
418 * following case for instance:
420 * /mnt/lustre/gns_mount/.mntinfo/.mntinfo/..../.mntinfo
421 * where all ".mntinfo" are dirs and only last one is
424 CDEBUG(D_DENTRY, "failed to mount %*s, err %d\n",
425 (int)dentry->d_name.len, dentry->d_name.name, rc);
430 GOTO(out, retval = NULL);
432 GOTO(out, retval = dentry);
435 ptlrpc_req_finished(req);
436 if (it == &lookup_it)
437 ll_intent_release(it);
439 CDEBUG(D_INODE, "lookup 0x%p in %lu/%lu: %*s -> %lu/%lu\n",
441 (unsigned long) parent->i_ino,
442 (unsigned long) parent->i_generation,
443 dentry->d_name.len, dentry->d_name.name,
444 (unsigned long) dentry->d_inode->i_ino,
445 (unsigned long) dentry->d_inode->i_generation);
447 CDEBUG(D_INODE, "lookup 0x%p in %lu/%lu: %*s -> ??\n",
449 (unsigned long) parent->i_ino,
450 (unsigned long) parent->i_generation,
451 dentry->d_name.len, dentry->d_name.name);
455 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
456 static struct dentry *ll_lookup_nd(struct inode *parent, struct dentry *dentry,
457 struct nameidata *nd)
462 if (nd && nd->flags & LOOKUP_LAST && !(nd->flags & LOOKUP_LINK_NOTLAST))
463 de = ll_lookup_it(parent, dentry, nd, nd->flags);
465 de = ll_lookup_it(parent, dentry, nd, 0);
471 /* We depend on "mode" being set with the proper file type/umask by now */
472 static struct inode *ll_create_node(struct inode *dir, const char *name,
473 int namelen, const void *data, int datalen,
474 int mode, __u64 extra,
475 struct lookup_intent *it)
477 struct inode *inode = NULL;
478 struct ptlrpc_request *request = NULL;
479 struct ll_sb_info *sbi = ll_i2sbi(dir);
484 LASSERT(it && LUSTRE_IT(it)->it_disposition);
486 request = LUSTRE_IT(it)->it_data;
487 rc = ll_prep_inode(sbi->ll_dt_exp, sbi->ll_md_exp,
488 &inode, request, 1, dir->i_sb);
490 GOTO(out, inode = ERR_PTR(rc));
492 LASSERT(list_empty(&inode->i_dentry));
494 /* We asked for a lock on the directory, but were granted a
495 * lock on the inode. Since we finally have an inode pointer,
496 * stuff it in the lock. */
497 CDEBUG(D_DLMTRACE, "setting l_ast_data to inode %p (%lu/%u)\n",
498 inode, inode->i_ino, inode->i_generation);
499 mdc_set_lock_data(NULL, &LUSTRE_IT(it)->it_lock_handle, inode);
502 ptlrpc_req_finished(request);
507 * By the time this is called, we already have created the directory cache
508 * entry for the new file, but it is so far negative - it has no inode.
510 * We defer creating the OBD object(s) until open, to keep the intent and
511 * non-intent code paths similar, and also because we do not have the MDS
512 * inode number before calling ll_create_node() (which is needed for LOV),
513 * so we would need to do yet another RPC to the MDS to store the LOV EA
514 * data on the MDS. If needed, we would pass the PACKED lmm as data and
515 * lmm_size in datalen (the MDS still has code which will handle that).
517 * If the create succeeds, we fill in the inode information
518 * with d_instantiate().
520 static int ll_create_it(struct inode *dir, struct dentry *dentry, int mode,
521 struct lookup_intent *it)
524 struct ptlrpc_request *request = LUSTRE_IT(it)->it_data;
525 struct obd_export *md_exp = ll_i2mdexp(dir);
529 CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p),intent=%s\n",
530 dentry->d_name.len, dentry->d_name.name, dir->i_ino,
531 dir->i_generation, dir, LL_IT2STR(it));
533 rc = it_open_error(DISP_OPEN_CREATE, it);
537 mdc_store_inode_generation(md_exp, request, MDS_REQ_INTENT_REC_OFF, 1);
538 inode = ll_create_node(dir, (char *)dentry->d_name.name,
539 dentry->d_name.len, NULL, 0, mode, 0, it);
541 RETURN(PTR_ERR(inode));
543 d_instantiate(dentry, inode);
547 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
548 static int ll_create_nd(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd)
550 return ll_create_it(dir, dentry, mode, &nd->intent.open);
554 static void ll_update_times(struct ptlrpc_request *request, int offset,
557 struct mds_body *body = lustre_msg_buf(request->rq_repmsg, offset,
561 if (body->valid & OBD_MD_FLMTIME &&
562 body->mtime > LTIME_S(inode->i_mtime)) {
563 CDEBUG(D_INODE, "setting ino %lu mtime from %lu to %u\n",
564 inode->i_ino, LTIME_S(inode->i_mtime), body->mtime);
565 LTIME_S(inode->i_mtime) = body->mtime;
567 if (body->valid & OBD_MD_FLCTIME &&
568 body->ctime > LTIME_S(inode->i_ctime))
569 LTIME_S(inode->i_ctime) = body->ctime;
572 static int ll_mknod_raw(struct nameidata *nd, int mode, dev_t rdev)
574 struct ptlrpc_request *request = NULL;
575 struct inode *dir = nd->dentry->d_inode;
576 struct ll_sb_info *sbi = ll_i2sbi(dir);
577 struct mdc_op_data *op_data;
578 int err = -EMLINK, key_size = 0;
582 CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
583 nd->last.len, nd->last.name, dir->i_ino,
584 dir->i_generation, dir);
586 mode &= ~current->fs->umask;
588 switch (mode & S_IFMT) {
591 mode |= S_IFREG; /* for mode = 0 case, fallthrough */
592 ll_crypto_create_key(dir, mode, &key, &key_size);
597 OBD_ALLOC(op_data, sizeof(*op_data));
600 ll_prepare_mdc_data(op_data, dir, NULL,
601 (char *)nd->last.name,
603 err = md_create(sbi->ll_md_exp, op_data, key, key_size, mode,
604 current->fsuid, current->fsgid, rdev,
606 OBD_FREE(op_data, sizeof(*op_data));
608 ll_update_times(request, 0, dir);
609 ptlrpc_req_finished(request);
618 OBD_FREE(key, key_size);
622 static int ll_mknod(struct inode *dir, struct dentry *dchild,
623 int mode, ll_dev_t rdev)
625 struct ptlrpc_request *request = NULL;
626 struct inode *inode = NULL;
627 struct ll_sb_info *sbi = ll_i2sbi(dir);
628 struct mdc_op_data *op_data;
632 CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
633 dchild->d_name.len, dchild->d_name.name,
634 dir->i_ino, dir->i_generation, dir);
636 mode &= ~current->fs->umask;
638 switch (mode & S_IFMT) {
641 mode |= S_IFREG; /* for mode = 0 case, fallthrough */
647 OBD_ALLOC(op_data, sizeof(*op_data));
651 ll_prepare_mdc_data(op_data, dir, NULL,
652 (char *)dchild->d_name.name,
653 dchild->d_name.len, 0);
655 err = md_create(sbi->ll_md_exp, op_data, NULL, 0, mode,
656 current->fsuid, current->fsgid, rdev,
658 OBD_FREE(op_data, sizeof(*op_data));
662 ll_update_times(request, 0, dir);
663 err = ll_prep_inode(sbi->ll_dt_exp, sbi->ll_md_exp,
664 &inode, request, 0, dchild->d_sb);
675 d_instantiate(dchild, inode);
678 ptlrpc_req_finished(request);
682 static int ll_symlink_raw(struct nameidata *nd, const char *tgt)
684 const char *name = (char *)nd->last.name;
685 struct inode *dir = nd->dentry->d_inode;
686 struct ptlrpc_request *request = NULL;
687 struct ll_sb_info *sbi = ll_i2sbi(dir);
688 struct mdc_op_data *op_data;
689 int len = nd->last.len;
693 CDEBUG(D_VFSTRACE, "VFS Op:name=%*s,dir=%lu/%u(%p),target=%s\n",
694 nd->last.len, nd->last.name, dir->i_ino, dir->i_generation,
697 if (dir->i_nlink >= EXT3_LINK_MAX)
700 OBD_ALLOC(op_data, sizeof(*op_data));
703 ll_prepare_mdc_data(op_data, dir, NULL, name, len, 0);
705 err = md_create(sbi->ll_md_exp, op_data,
706 tgt, strlen(tgt) + 1, S_IFLNK | S_IRWXUGO,
707 current->fsuid, current->fsgid, 0, &request);
708 OBD_FREE(op_data, sizeof(*op_data));
710 ll_update_times(request, 0, dir);
712 ptlrpc_req_finished(request);
716 static int ll_link_raw(struct nameidata *srcnd, struct nameidata *tgtnd)
718 struct inode *src = srcnd->dentry->d_inode;
719 struct inode *dir = tgtnd->dentry->d_inode;
720 struct ptlrpc_request *request = NULL;
721 struct ll_sb_info *sbi = ll_i2sbi(dir);
722 struct mdc_op_data *op_data;
727 "VFS Op: inode=%lu/%u(%p), dir=%lu/%u(%p), target=%.*s\n",
728 src->i_ino, src->i_generation, src, dir->i_ino,
729 dir->i_generation, dir, tgtnd->last.len, tgtnd->last.name);
731 OBD_ALLOC(op_data, sizeof(*op_data));
735 ll_prepare_mdc_data(op_data, src, dir,
736 (char *)tgtnd->last.name,
739 err = md_link(sbi->ll_md_exp, op_data, &request);
740 OBD_FREE(op_data, sizeof(*op_data));
742 ll_update_times(request, 0, dir);
743 ptlrpc_req_finished(request);
748 static int ll_mkdir_raw(struct nameidata *nd, int mode)
750 struct inode *dir = nd->dentry->d_inode;
751 struct ptlrpc_request *request = NULL;
752 struct ll_sb_info *sbi = ll_i2sbi(dir);
753 struct mdc_op_data *op_data;
756 CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
757 nd->last.len, nd->last.name, dir->i_ino, dir->i_generation, dir);
759 mode = (mode & (S_IRWXUGO|S_ISVTX) & ~current->fs->umask) | S_IFDIR;
760 OBD_ALLOC(op_data, sizeof(*op_data));
764 ll_prepare_mdc_data(op_data, dir, NULL,
765 (char *)nd->last.name,
768 err = md_create(sbi->ll_md_exp, op_data, NULL, 0, mode,
769 current->fsuid, current->fsgid, 0, &request);
770 OBD_FREE(op_data, sizeof(*op_data));
772 ll_update_times(request, 0, dir);
773 ptlrpc_req_finished(request);
777 static int ll_rmdir_raw(struct nameidata *nd)
779 struct inode *dir = nd->dentry->d_inode;
780 struct ptlrpc_request *request = NULL;
781 struct mdc_op_data *op_data;
785 CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
786 nd->last.len, nd->last.name, dir->i_ino,
787 dir->i_generation, dir);
789 OBD_ALLOC(op_data, sizeof(*op_data));
793 ll_prepare_mdc_data(op_data, dir, NULL,
794 (char *)nd->last.name,
795 nd->last.len, S_IFDIR);
797 rc = md_unlink(ll_i2sbi(dir)->ll_md_exp, op_data, &request);
798 OBD_FREE(op_data, sizeof(*op_data));
800 ll_update_times(request, 0, dir);
801 ptlrpc_req_finished(request);
805 static int ll_unlink_raw(struct nameidata *nd)
807 struct inode *dir = nd->dentry->d_inode;
808 struct ptlrpc_request *request = NULL;
809 struct mdc_op_data *op_data;
812 CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
813 nd->last.len, nd->last.name, dir->i_ino,
814 dir->i_generation, dir);
816 OBD_ALLOC(op_data, sizeof(*op_data));
819 ll_prepare_mdc_data(op_data, dir, NULL,
820 (char *)nd->last.name, nd->last.len, 0);
821 rc = md_unlink(ll_i2sbi(dir)->ll_md_exp, op_data, &request);
822 OBD_FREE(op_data, sizeof(*op_data));
825 ll_update_times(request, 0, dir);
828 ptlrpc_req_finished(request);
832 static int ll_rename_raw(struct nameidata *srcnd, struct nameidata *tgtnd)
834 struct inode *src = srcnd->dentry->d_inode;
835 struct inode *tgt = tgtnd->dentry->d_inode;
836 struct ptlrpc_request *request = NULL;
837 struct ll_sb_info *sbi = ll_i2sbi(src);
838 struct mdc_op_data *op_data;
842 if (srcnd->mnt != tgtnd->mnt)
845 CDEBUG(D_VFSTRACE,"VFS Op:oldname=%.*s,src_dir=%lu/%u(%p),newname=%.*s,"
846 "tgt_dir=%lu/%u(%p)\n", srcnd->last.len, srcnd->last.name,
847 src->i_ino, src->i_generation, src, tgtnd->last.len,
848 tgtnd->last.name, tgt->i_ino, tgt->i_generation, tgt);
850 OBD_ALLOC(op_data, sizeof(*op_data));
853 ll_prepare_mdc_data(op_data, src, tgt, NULL, 0, 0);
854 err = md_rename(sbi->ll_md_exp, op_data, (char *)srcnd->last.name,
855 srcnd->last.len, (char *)tgtnd->last.name,
856 tgtnd->last.len, &request);
857 OBD_FREE(op_data, sizeof(*op_data));
859 ll_update_times(request, 0, src);
860 ll_update_times(request, 0, tgt);
863 ptlrpc_req_finished(request);
867 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
868 #define LLITE_IT_RAWOPS (IT_MKNOD|IT_MKDIR|IT_SYMLINK|IT_LINK|IT_UNLINK|IT_RMDIR|IT_RENAME)
869 static int ll_rawop_from_intent(struct nameidata *nd)
873 if (!nd || !(nd->intent.open.op & LLITE_IT_RAWOPS))
876 switch (nd->intent.open.op) {
878 error = ll_mknod_raw(nd, nd->intent.open.create_mode,
879 nd->intent.open.create.dev);
882 error = ll_mkdir_raw(nd, nd->intent.open.create_mode);
885 error = ll_rmdir_raw(nd);
888 error = ll_unlink_raw(nd);
891 LASSERT(nd->intent.open.create.link);
892 error = ll_symlink_raw(nd, nd->intent.open.create.link);
895 error = ll_link_raw(nd->intent.open.create.source_nd, nd);
898 LASSERT(nd->intent.open.create.source_nd);
899 error = ll_rename_raw(nd->intent.open.create.source_nd, nd);
904 if (error != -EOPNOTSUPP)
905 nd->intent.open.flags |= IT_STATUS_RAW;
911 struct inode_operations ll_dir_inode_operations = {
913 .setattr = ll_setattr,
914 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
915 .create_it = ll_create_it,
916 .lookup_it = ll_lookup_it,
917 .revalidate_it = ll_inode_revalidate_it,
919 .lookup = ll_lookup_nd,
920 .create = ll_create_nd,
921 .getattr = ll_getattr,
922 .endparentlookup = ll_rawop_from_intent,
924 .setxattr = ll_setxattr,
925 .getxattr = ll_getxattr,
926 .listxattr = ll_listxattr,
927 .removexattr = ll_removexattr,
928 .permission = ll_inode_permission,