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 "llite_internal.h"
48 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
49 static int ll_test_inode(struct inode *inode, unsigned long ino, void *opaque)
51 static int ll_test_inode(struct inode *inode, void *opaque)
54 struct lustre_md *md = opaque;
56 if (!(md->body->valid & (OBD_MD_FLGENER | OBD_MD_FLID)))
57 CERROR("invalid generation\n");
58 CDEBUG(D_VFSTRACE, "comparing inode %p ino %lu/%u to body %u/%u\n",
59 inode, inode->i_ino, inode->i_generation,
60 md->body->ino, md->body->generation);
62 if (inode->i_generation != md->body->generation)
65 /* Apply the attributes in 'opaque' to this inode */
66 ll_update_inode(inode, md->body, md->lsm);
70 extern struct dentry_operations ll_d_ops;
72 int ll_unlock(__u32 mode, struct lustre_handle *lockh)
76 ldlm_lock_decref(lockh, mode);
81 /* Get an inode by inode number (already instantiated by the intent lookup).
82 * Returns inode or NULL
84 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
85 int ll_set_inode(struct inode *inode, void *opaque)
87 ll_read_inode2(inode, opaque);
90 struct inode *ll_iget(struct super_block *sb, ino_t hash,
96 inode = iget5_locked(sb, hash, ll_test_inode, ll_set_inode, md);
99 return (NULL); /* removed ERR_PTR(-ENOMEM) -eeb */
101 if (inode->i_state & I_NEW)
102 unlock_new_inode(inode);
104 // XXX Coda always fills inodes, should Lustre?
108 struct inode *ll_iget(struct super_block *sb, ino_t hash,
109 struct lustre_md *md)
113 inode = iget4(sb, hash, ll_test_inode, md);
114 CDEBUG(D_VFSTRACE, "inode: %lu/%u(%p)\n", inode->i_ino,
115 inode->i_generation, inode);
120 static int ll_intent_to_lock_mode(struct lookup_intent *it)
122 /* CREAT needs to be tested before open (both could be set) */
123 if (it->it_op & IT_CREAT)
125 else if (it->it_op & (IT_READDIR | IT_GETATTR | IT_OPEN | IT_LOOKUP))
132 int ll_it_open_error(int phase, struct lookup_intent *it)
134 if (it_disposition(it, DISP_OPEN_OPEN)) {
135 if (phase == DISP_OPEN_OPEN)
136 return it->it_status;
141 if (it_disposition(it, DISP_OPEN_CREATE)) {
142 if (phase == DISP_OPEN_CREATE)
143 return it->it_status;
148 if (it_disposition(it, DISP_LOOKUP_EXECD)) {
149 if (phase == DISP_LOOKUP_EXECD)
150 return it->it_status;
155 if (it_disposition(it, DISP_IT_EXECD)) {
156 if (phase == DISP_IT_EXECD)
157 return it->it_status;
161 CERROR("it disp: %X, status: %d\n", it->it_disposition, it->it_status);
166 int ll_mdc_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc,
167 void *data, int flag)
170 struct lustre_handle lockh;
171 struct inode *inode = lock->l_data;
175 case LDLM_CB_BLOCKING:
176 ldlm_lock2handle(lock, &lockh);
177 rc = ldlm_cli_cancel(&lockh);
179 CDEBUG(D_INODE, "ldlm_cli_cancel: %d\n", rc);
183 case LDLM_CB_CANCELING: {
184 /* Invalidate all dentries associated with this inode */
187 if (lock->l_resource->lr_name.name[0] != inode->i_ino ||
188 lock->l_resource->lr_name.name[1] != inode->i_generation) {
189 LDLM_ERROR(lock, "data mismatch with ino %lu/%u",
190 inode->i_ino, inode->i_generation);
192 if (S_ISDIR(inode->i_mode)) {
193 CDEBUG(D_INODE, "invalidating inode %lu\n",
196 ll_invalidate_inode_pages(inode);
199 #warning FIXME: we should probably free this inode if there are no aliases
200 if (inode->i_sb->s_root &&
201 inode != inode->i_sb->s_root->d_inode)
202 ll_unhash_aliases(inode);
212 int ll_mdc_cancel_unused(struct lustre_handle *conn, struct inode *inode,
213 int flags, void *opaque)
215 struct ldlm_res_id res_id =
216 { .name = {inode->i_ino, inode->i_generation} };
217 struct obd_device *obddev = class_conn2obd(conn);
219 RETURN(ldlm_cli_cancel_unused(obddev->obd_namespace, &res_id, flags,
223 void ll_prepare_mdc_op_data(struct mdc_op_data *data,
232 data->ino1 = i1->i_ino;
233 data->gen1 = i1->i_generation;
234 data->typ1 = i1->i_mode & S_IFMT;
235 data->gid1 = i1->i_gid;
238 data->ino2 = i2->i_ino;
239 data->gen2 = i2->i_generation;
240 data->typ2 = i2->i_mode & S_IFMT;
241 data->gid2 = i2->i_gid;
247 data->namelen = namelen;
252 *This long block is all about fixing up the local state so that it is
253 *correct as of the moment _before_ the operation was applied; that
254 *way, the VFS will think that everything is normal and call Lustre's
255 *regular VFS methods.
257 * If we're performing a creation, that means that unless the creation
258 * failed with EEXIST, we should fake up a negative dentry.
260 * For everything else, we want to lookup to succeed.
262 * One additional note: if CREATE or OPEN succeeded, we add an extra
263 * reference to the request because we need to keep it around until
264 * ll_create/ll_open gets called.
266 * The server will return to us, in it_disposition, an indication of
267 * exactly what it_status refers to.
269 * If DISP_OPEN_OPEN is set, then it_status refers to the open() call,
270 * otherwise if DISP_OPEN_CREATE is set, then it status is the
271 * creation failure mode. In either case, one of DISP_LOOKUP_NEG or
272 * DISP_LOOKUP_POS will be set, indicating whether the child lookup
275 * Else, if DISP_LOOKUP_EXECD then it_status is the rc of the child
278 int ll_intent_lock(struct inode *parent, struct dentry **de,
279 struct lookup_intent *it, int flags, intent_finish_cb intent_finish)
281 struct dentry *dentry = *de;
282 struct inode *inode = dentry->d_inode;
283 struct ll_sb_info *sbi = ll_i2sbi(parent);
284 struct lustre_handle lockh;
285 struct lookup_intent lookup_it = { .it_op = IT_LOOKUP };
286 struct ptlrpc_request *request;
288 struct mds_body *mds_body;
293 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
294 if (it && it->it_magic != INTENT_MAGIC) {
295 CERROR("WARNING: uninitialized intent\n");
297 intent_init(it, IT_LOOKUP, 0);
299 if (it->it_op == IT_GETATTR ||
301 it->it_op = IT_LOOKUP;
304 if (!it ||it->it_op == IT_GETXATTR)
307 it->it_op_release = ll_intent_release;
309 CDEBUG(D_DLMTRACE, "name: %*s, intent: %s\n", dentry->d_name.len,
310 dentry->d_name.name, ldlm_it2str(it->it_op));
312 if (dentry->d_name.len > EXT2_NAME_LEN)
313 RETURN(-ENAMETOOLONG);
315 /* This function may be called twice, we only once want to
316 execute the request associated with the intent. If it was
317 done already, we skip past this and use the results. */
318 if (!it_disposition(it, DISP_ENQ_COMPLETE)) {
319 struct mdc_op_data op_data;
321 ll_prepare_mdc_op_data(&op_data, parent, dentry->d_inode,
322 dentry->d_name.name, dentry->d_name.len,
325 rc = mdc_enqueue(&sbi->ll_mdc_conn, LDLM_PLAIN, it,
326 ll_intent_to_lock_mode(it), &op_data,
327 &lockh, NULL, 0, ldlm_completion_ast,
328 ll_mdc_blocking_ast, NULL);
331 memcpy(it->it_lock_handle, &lockh, sizeof(lockh));
333 request = it->it_data;
334 LASSERT(request != NULL);
336 if (!it_disposition(it, DISP_IT_EXECD)) {
337 /* The server failed before it even started executing the
338 * intent, i.e. because it couldn't unpack the request. */
339 LASSERT(it->it_status != 0);
340 GOTO(drop_req, rc = it->it_status);
342 rc = ll_it_open_error(DISP_IT_EXECD, it);
346 mds_body = lustre_msg_buf(request->rq_repmsg, 1, sizeof(*mds_body));
347 LASSERT(mds_body != NULL); /* mdc_enqueue checked */
348 LASSERT_REPSWABBED(request, 1); /* mdc_enqueue swabbed */
350 /* XXX everything with fids please, no ino's inode's etc */
351 ino = mds_body->fid1.id;
352 mode = mds_body->mode;
354 /*We were called from revalidate2: did we find the same inode?*/
356 (ino != inode->i_ino ||
357 mds_body->fid1.generation != inode->i_generation)) {
358 it_set_disposition(it, DISP_ENQ_COMPLETE);
362 /* If we're doing an IT_OPEN which did not result in an actual
363 * successful open, then we need to remove the bit which saves
364 * this request for unconditional replay. */
365 if (it->it_op & IT_OPEN) {
366 if (!it_disposition(it, DISP_OPEN_OPEN) ||
367 it->it_status != 0) {
370 spin_lock_irqsave (&request->rq_lock, flags);
371 request->rq_replay = 0;
372 spin_unlock_irqrestore (&request->rq_lock, flags);
376 rc = ll_it_open_error(DISP_LOOKUP_EXECD, it);
380 /* keep requests around for the multiple phases of the call
381 * this shows the DISP_XX must guarantee we make it into the call
383 if (it_disposition(it, DISP_OPEN_CREATE))
384 ptlrpc_request_addref(request);
385 if (it_disposition(it, DISP_OPEN_OPEN))
386 ptlrpc_request_addref(request);
388 if (it->it_op & IT_CREAT) {
389 /* XXX this belongs in ll_create_iit */
390 } else if (it->it_op == IT_OPEN) {
391 LASSERT(!it_disposition(it, DISP_OPEN_CREATE));
393 LASSERT(it->it_op & (IT_GETATTR | IT_LOOKUP));
395 if (intent_finish != NULL) {
396 struct lustre_handle old_lock;
397 struct ldlm_lock *lock;
399 rc = intent_finish(request, parent, de, it, 1, ino);
400 dentry = *de; /* intent_finish may change *de */
401 inode = dentry->d_inode;
405 /* The intent processing may well have given us a lock different
406 * from the one we requested. If we already have a matching
407 * lock, then cancel the new one. (We have to do this here,
408 * instead of in mdc_enqueue, because we need to use the child's
409 * inode as the l_data to match, and that's not available until
410 * intent_finish has performed the iget().) */
411 lock = ldlm_handle2lock(&lockh);
413 LDLM_DEBUG(lock, "matching against this");
415 memcpy(&old_lock, &lockh, sizeof(lockh));
416 if (ldlm_lock_match(NULL,
417 LDLM_FL_BLOCK_GRANTED |
419 NULL, LDLM_PLAIN, NULL, 0, LCK_NL,
421 ldlm_lock_decref_and_cancel(&lockh,
423 memcpy(&lockh, &old_lock, sizeof(old_lock));
424 memcpy(it->it_lock_handle, &lockh,
430 ptlrpc_req_finished(request);
432 CDEBUG(D_DENTRY, "D_IT dentry %p intent: %s status %d disp %x\n",
433 dentry, ldlm_it2str(it->it_op), it->it_status, it->it_disposition);
435 /* drop IT_LOOKUP locks */
436 if (it->it_op == IT_LOOKUP)
437 ll_intent_release(it);
441 ll_intent_release(it);
443 ptlrpc_req_finished(request);
447 /* Search "inode"'s alias list for a dentry that has the same name and parent as
448 * de. If found, return it. If not found, return de. */
449 struct dentry *ll_find_alias(struct inode *inode, struct dentry *de)
451 struct list_head *tmp;
453 spin_lock(&dcache_lock);
454 list_for_each(tmp, &inode->i_dentry) {
455 struct dentry *dentry = list_entry(tmp, struct dentry, d_alias);
457 /* We are called here with 'de' already on the aliases list. */
463 if (dentry->d_parent != de->d_parent)
466 if (dentry->d_name.len != de->d_name.len)
469 if (memcmp(dentry->d_name.name, de->d_name.name,
470 de->d_name.len) != 0)
473 if (!list_empty(&dentry->d_lru))
474 list_del_init(&dentry->d_lru);
476 hlist_del_init(&dentry->d_hash);
477 __d_rehash(dentry, 0); /* avoid taking dcache_lock inside */
478 spin_unlock(&dcache_lock);
479 atomic_inc(&dentry->d_count);
481 dentry->d_flags &= ~DCACHE_LUSTRE_INVALID;
485 spin_unlock(&dcache_lock);
491 lookup2_finish(struct ptlrpc_request *request,
492 struct inode *parent, struct dentry **de,
493 struct lookup_intent *it, int offset, obd_id ino)
495 struct ll_sb_info *sbi = ll_i2sbi(parent);
496 struct dentry *dentry = *de, *saved = *de;
497 struct inode *inode = NULL;
500 /* NB 1 request reference will be taken away by ll_intent_lock()
502 if (!it_disposition(it, DISP_LOOKUP_NEG)) {
506 rc =mdc_req2lustre_md(request, offset, &sbi->ll_osc_conn, &md);
510 inode = ll_iget(dentry->d_sb, ino, &md);
512 /* free the lsm if we allocated one above */
514 obd_free_memmd(&sbi->ll_osc_conn, &md.lsm);
516 } else if (md.lsm != NULL &&
517 ll_i2info(inode)->lli_smd != md.lsm) {
518 obd_free_memmd(&sbi->ll_osc_conn, &md.lsm);
521 /* If this is a stat, get the authoritative file size */
522 if (it->it_op == IT_GETATTR && S_ISREG(inode->i_mode) &&
523 ll_i2info(inode)->lli_smd != NULL) {
524 struct ldlm_extent extent = {0, OBD_OBJECT_EOF};
525 struct lustre_handle lockh = {0};
526 struct lov_stripe_md *lsm = ll_i2info(inode)->lli_smd;
529 LASSERT(lsm->lsm_object_id != 0);
531 rc = ll_extent_lock(NULL, inode, lsm, LCK_PR, &extent,
533 if (rc != ELDLM_OK) {
537 ll_extent_unlock(NULL, inode, lsm, LCK_PR, &lockh);
540 dentry = *de = ll_find_alias(inode, dentry);
542 /* We asked for a lock on the directory, and may have been
543 * granted a lock on the inode. Just in case, fixup the data
545 CDEBUG(D_DLMTRACE, "setting l_data to inode %p (%lu/%u)\n",
546 inode, inode->i_ino, inode->i_generation);
547 ldlm_lock_set_data((struct lustre_handle*)it->it_lock_handle,
553 dentry->d_op = &ll_d_ops;
557 d_add(dentry, inode);
562 static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry,
563 struct lookup_intent *it, int flags)
565 struct dentry *save = dentry, *retval;
569 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p),intent=%s\n",
570 dentry->d_name.name, parent->i_ino, parent->i_generation,
571 parent, LL_IT2STR(it));
573 if (d_mountpoint(dentry)) {
574 CERROR("Tell Peter, lookup on mtpt, it %s\n", LL_IT2STR(it));
577 rc = ll_intent_lock(parent, &dentry, it, flags, lookup2_finish);
579 CDEBUG(D_INFO, "ll_intent_lock: %d\n", rc);
580 GOTO(out, retval = ERR_PTR(rc));
584 GOTO(out, retval = NULL);
586 GOTO(out, retval = dentry);
591 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
592 static struct dentry *ll_lookup_nd(struct inode *parent, struct dentry *dentry,
593 struct nameidata *nd)
598 if (nd->flags & LOOKUP_LAST && !(nd->flags & LOOKUP_LINK_NOTLAST))
599 de = ll_lookup_it(parent, dentry, &nd->it, nd->flags);
601 de = ll_lookup_it(parent, dentry, NULL, 0);
607 static int ll_mdc_unlink(struct inode *dir, struct inode *child, __u32 mode,
608 const char *name, int len)
610 struct ptlrpc_request *request = NULL;
611 struct mds_body *body;
612 struct lov_mds_md *eadata;
613 struct lov_stripe_md *lsm = NULL;
614 struct obd_trans_info oti = { 0 };
615 struct mdc_op_data op_data;
620 ll_prepare_mdc_op_data(&op_data, dir, child, name, len, mode);
621 rc = mdc_unlink(&ll_i2sbi(dir)->ll_mdc_conn, &op_data, &request);
624 /* req is swabbed so this is safe */
625 body = lustre_msg_buf(request->rq_repmsg, 0, sizeof(*body));
627 if (!(body->valid & OBD_MD_FLEASIZE))
630 if (body->eadatasize == 0) {
631 CERROR("OBD_MD_FLEASIZE set but eadatasize zero\n");
632 GOTO(out, rc = -EPROTO);
635 /* The MDS sent back the EA because we unlinked the last reference
636 * to this file. Use this EA to unlink the objects on the OST.
637 * It's opaque so we don't swab here; we leave it to obd_unpackmd() to
638 * check it is complete and sensible. */
639 eadata = lustre_swab_repbuf(request, 1, body->eadatasize, NULL);
640 LASSERT(eadata != NULL);
641 if (eadata == NULL) {
642 CERROR("Can't unpack MDS EA data\n");
643 GOTO(out, rc = -EPROTO);
646 rc = obd_unpackmd(ll_i2obdconn(dir), &lsm, eadata, body->eadatasize);
648 CERROR("obd_unpackmd: %d\n", rc);
651 LASSERT(rc >= sizeof(*lsm));
655 GOTO(out_free_memmd, rc = -ENOMEM);
657 oa->o_id = lsm->lsm_object_id;
658 oa->o_mode = body->mode & S_IFMT;
659 oa->o_valid = OBD_MD_FLID | OBD_MD_FLTYPE;
661 if (body->valid & OBD_MD_FLCOOKIE) {
662 oa->o_valid |= OBD_MD_FLCOOKIE;
663 oti.oti_logcookies = lustre_msg_buf(request->rq_repmsg, 3,
667 rc = obd_destroy(ll_i2obdconn(dir), oa, lsm, &oti);
670 CERROR("obd destroy objid 0x"LPX64" error %d\n",
671 lsm->lsm_object_id, rc);
673 obd_free_memmd(ll_i2obdconn(dir), &lsm);
675 ptlrpc_req_finished(request);
679 /* We depend on "mode" being set with the proper file type/umask by now */
680 static struct inode *ll_create_node(struct inode *dir, const char *name,
681 int namelen, const void *data, int datalen,
682 int mode, __u64 extra,
683 struct lookup_intent *it)
686 struct ptlrpc_request *request = NULL;
687 struct ll_sb_info *sbi = ll_i2sbi(dir);
692 LASSERT(it && it->it_disposition);
694 ll_invalidate_inode_pages(dir);
696 request = it->it_data;
697 rc = mdc_req2lustre_md(request, 1, &sbi->ll_osc_conn, &md);
699 GOTO(out, inode = ERR_PTR(rc));
702 inode = ll_iget(dir->i_sb, md.body->ino, &md);
703 if (!inode || is_bad_inode(inode)) {
704 /* XXX might need iput() for bad inode */
706 CERROR("new_inode -fatal: rc %d\n", rc);
710 LASSERT(list_empty(&inode->i_dentry));
712 CDEBUG(D_DLMTRACE, "setting l_data to inode %p (%lu/%u)\n",
713 inode, inode->i_ino, inode->i_generation);
714 ldlm_lock_set_data((struct lustre_handle*)it->it_lock_handle,
719 ptlrpc_req_finished(request);
724 * By the time this is called, we already have created the directory cache
725 * entry for the new file, but it is so far negative - it has no inode.
727 * We defer creating the OBD object(s) until open, to keep the intent and
728 * non-intent code paths similar, and also because we do not have the MDS
729 * inode number before calling ll_create_node() (which is needed for LOV),
730 * so we would need to do yet another RPC to the MDS to store the LOV EA
731 * data on the MDS. If needed, we would pass the PACKED lmm as data and
732 * lmm_size in datalen (the MDS still has code which will handle that).
734 * If the create succeeds, we fill in the inode information
735 * with d_instantiate().
737 static int ll_create_it(struct inode *dir, struct dentry *dentry, int mode, struct lookup_intent *it)
740 struct ptlrpc_request *request = it->it_data;
744 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p),intent=%s\n",
745 dentry->d_name.name, dir->i_ino, dir->i_generation, dir,
748 rc = ll_it_open_error(DISP_OPEN_CREATE, it);
750 ptlrpc_req_finished(request);
754 mdc_store_inode_generation(request, 2, 1);
755 inode = ll_create_node(dir, dentry->d_name.name, dentry->d_name.len,
756 NULL, 0, mode, 0, it);
758 RETURN(PTR_ERR(inode));
761 d_instantiate(dentry, inode);
765 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
766 static int ll_create_nd(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd)
768 return ll_create_it(dir, dentry, mode, &nd->it);
772 static int ll_mknod_raw(struct nameidata *nd, int mode, dev_t rdev)
774 struct inode *dir = nd->dentry->d_inode;
775 const char *name = nd->last.name;
776 int len = nd->last.len;
777 struct ptlrpc_request *request = NULL;
778 time_t time = LTIME_S(CURRENT_TIME);
779 struct ll_sb_info *sbi = ll_i2sbi(dir);
780 struct mdc_op_data op_data;
784 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
785 name, dir->i_ino, dir->i_generation, dir);
787 if (dir->i_nlink >= EXT2_LINK_MAX)
790 mode &= ~current->fs->umask;
792 switch (mode & S_IFMT) {
795 mode |= S_IFREG; /* for mode = 0 case, fallthrough */
800 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
801 err = mdc_create(&sbi->ll_mdc_conn, &op_data, NULL, 0, mode,
802 current->fsuid, current->fsgid, time,
804 ptlrpc_req_finished(request);
815 static int ll_symlink_raw(struct nameidata *nd, const char *tgt)
817 struct inode *dir = nd->dentry->d_inode;
818 const char *name = nd->last.name;
819 int len = nd->last.len;
820 struct ptlrpc_request *request = NULL;
821 time_t time = LTIME_S(CURRENT_TIME);
822 struct ll_sb_info *sbi = ll_i2sbi(dir);
823 struct mdc_op_data op_data;
827 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p),target=%s\n",
828 name, dir->i_ino, dir->i_generation, dir, tgt);
830 if (dir->i_nlink >= EXT2_LINK_MAX)
833 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
834 err = mdc_create(&sbi->ll_mdc_conn, &op_data,
835 tgt, strlen(tgt) + 1, S_IFLNK | S_IRWXUGO,
836 current->fsuid, current->fsgid, time, 0, &request);
837 ptlrpc_req_finished(request);
841 static int ll_link_raw(struct nameidata *srcnd, struct nameidata *tgtnd)
843 struct inode *src = srcnd->dentry->d_inode;
844 struct inode *dir = tgtnd->dentry->d_inode;
845 const char *name = tgtnd->last.name;
846 int len = tgtnd->last.len;
847 struct ptlrpc_request *request = NULL;
848 struct mdc_op_data op_data;
850 struct ll_sb_info *sbi = ll_i2sbi(dir);
853 CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),dir=%lu/%u(%p),target=%s\n",
854 src->i_ino, src->i_generation, src,
855 dir->i_ino, dir->i_generation, dir, name);
857 ll_prepare_mdc_op_data(&op_data, src, dir, name, len, 0);
858 err = mdc_link(&sbi->ll_mdc_conn, &op_data, &request);
859 ptlrpc_req_finished(request);
865 static int ll_mkdir_raw(struct nameidata *nd, int mode)
867 struct inode *dir = nd->dentry->d_inode;
868 const char *name = nd->last.name;
869 int len = nd->last.len;
870 struct ptlrpc_request *request = NULL;
871 time_t time = LTIME_S(CURRENT_TIME);
872 struct ll_sb_info *sbi = ll_i2sbi(dir);
873 struct mdc_op_data op_data;
876 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
877 name, dir->i_ino, dir->i_generation, dir);
879 if (dir->i_nlink >= EXT2_LINK_MAX)
882 mode = (mode & (S_IRWXUGO|S_ISVTX) & ~current->fs->umask) | S_IFDIR;
883 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
884 err = mdc_create(&sbi->ll_mdc_conn, &op_data, NULL, 0, mode,
885 current->fsuid, current->fsgid, time, 0, &request);
886 ptlrpc_req_finished(request);
890 static int ll_rmdir_raw(struct nameidata *nd)
892 struct inode *dir = nd->dentry->d_inode;
893 const char *name = nd->last.name;
894 int len = nd->last.len;
897 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
898 name, dir->i_ino, dir->i_generation, dir);
900 rc = ll_mdc_unlink(dir, NULL, S_IFDIR, name, len);
904 static int ll_unlink_raw(struct nameidata *nd)
906 struct inode *dir = nd->dentry->d_inode;
907 const char *name = nd->last.name;
908 int len = nd->last.len;
911 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
912 name, dir->i_ino, dir->i_generation, dir);
914 rc = ll_mdc_unlink(dir, NULL, S_IFREG, name, len);
918 static int ll_rename_raw(struct nameidata *oldnd, struct nameidata *newnd)
920 struct inode *src = oldnd->dentry->d_inode;
921 struct inode *tgt = newnd->dentry->d_inode;
922 const char *oldname = oldnd->last.name;
923 int oldlen = oldnd->last.len;
924 const char *newname = newnd->last.name;
925 int newlen = newnd->last.len;
926 struct ptlrpc_request *request = NULL;
927 struct ll_sb_info *sbi = ll_i2sbi(src);
928 struct mdc_op_data op_data;
931 CDEBUG(D_VFSTRACE, "VFS Op:oldname=%s,src_dir=%lu/%u(%p),newname=%s,"
932 "tgt_dir=%lu/%u(%p)\n", oldname, src->i_ino, src->i_generation,
933 src, newname, tgt->i_ino, tgt->i_generation, tgt);
935 ll_prepare_mdc_op_data(&op_data, src, tgt, NULL, 0, 0);
936 err = mdc_rename(&sbi->ll_mdc_conn, &op_data,
937 oldname, oldlen, newname, newlen, &request);
938 ptlrpc_req_finished(request);
943 struct inode_operations ll_dir_inode_operations = {
944 link_raw: ll_link_raw,
945 unlink_raw: ll_unlink_raw,
946 symlink_raw: ll_symlink_raw,
947 mkdir_raw: ll_mkdir_raw,
948 rmdir_raw: ll_rmdir_raw,
949 mknod_raw: ll_mknod_raw,
950 rename_raw: ll_rename_raw,
952 setattr_raw: ll_setattr_raw,
953 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
954 create_it: ll_create_it,
955 lookup_it: ll_lookup_it,
956 revalidate_it: ll_inode_revalidate_it,
958 lookup_it: ll_lookup_nd,
959 create_nd: ll_create_nd,
960 getattr_it: ll_getattr,