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 == md->body->ino && last_gen == md->body->generation &&
68 CDEBUG(D_VFSTRACE, "compared %u/%u %u times\n",
69 last_ino, last_gen, last_count);
71 last_ino = md->body->ino;
72 last_gen = md->body->generation;
74 "comparing inode %p ino %lu/%u to body %u/%u\n",
75 inode, inode->i_ino, inode->i_generation,
76 md->body->ino, md->body->generation);
79 if (inode->i_generation != md->body->generation)
82 /* Apply the attributes in 'opaque' to this inode */
83 ll_update_inode(inode, md->body, md->lsm);
87 extern struct dentry_operations ll_d_ops;
89 int ll_unlock(__u32 mode, struct lustre_handle *lockh)
93 ldlm_lock_decref(lockh, mode);
98 /* Get an inode by inode number (already instantiated by the intent lookup).
99 * Returns inode or NULL
101 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
102 int ll_set_inode(struct inode *inode, void *opaque)
104 ll_read_inode2(inode, opaque);
108 struct inode *ll_iget(struct super_block *sb, ino_t hash,
109 struct lustre_md *md)
114 inode = iget5_locked(sb, hash, ll_test_inode, ll_set_inode, md);
117 if (inode->i_state & I_NEW)
118 unlock_new_inode(inode);
119 CDEBUG(D_VFSTRACE, "inode: %lu/%u(%p)\n", inode->i_ino,
120 inode->i_generation, inode);
126 struct inode *ll_iget(struct super_block *sb, ino_t hash,
127 struct lustre_md *md)
131 inode = iget4(sb, hash, ll_test_inode, md);
133 CDEBUG(D_VFSTRACE, "inode: %lu/%u(%p)\n", inode->i_ino,
134 inode->i_generation, inode);
139 int ll_mdc_blocking_ast(struct ldlm_lock *lock, struct ldlm_lock_desc *desc,
140 void *data, int flag)
143 struct lustre_handle lockh;
147 case LDLM_CB_BLOCKING:
148 ldlm_lock2handle(lock, &lockh);
149 rc = ldlm_cli_cancel(&lockh);
151 CDEBUG(D_INODE, "ldlm_cli_cancel: %d\n", rc);
155 case LDLM_CB_CANCELING: {
156 struct inode *inode = ll_inode_from_lock(lock);
157 __u64 bits = lock->l_policy_data.l_inodebits.bits;
159 /* For lookup locks: Invalidate all dentries associated with
160 this inode, for UPDATE locks - invalidate directory pages */
164 if (bits & MDS_INODELOCK_UPDATE)
165 clear_bit(LLI_F_HAVE_MDS_SIZE_LOCK,
166 &(ll_i2info(inode)->lli_flags));
169 if (lock->l_resource->lr_name.name[0] != inode->i_ino ||
170 lock->l_resource->lr_name.name[1] != inode->i_generation) {
171 LDLM_ERROR(lock, "data mismatch with ino %lu/%u",
172 inode->i_ino, inode->i_generation);
175 /* If lookup lock is cancelled, we just drop the dentry and
176 this will cause us to reget data from MDS when we'd want to
177 access this dentry/inode again. If this is lock on
178 other parts of inode that is cancelled, we do not need to do
179 much (but need to discard data from readdir, if any), since
180 abscence of lock will cause ll_revalidate_it (called from
181 stat() and similar functions) to renew the data anyway */
182 if (S_ISDIR(inode->i_mode) &&
183 (bits & MDS_INODELOCK_UPDATE)) {
184 CDEBUG(D_INODE, "invalidating inode %lu\n",
187 truncate_inode_pages(inode->i_mapping, 0);
190 if (inode->i_sb->s_root &&
191 inode != inode->i_sb->s_root->d_inode &&
192 (bits & MDS_INODELOCK_LOOKUP))
193 ll_unhash_aliases(inode);
204 int ll_mdc_cancel_unused(struct lustre_handle *conn, struct inode *inode,
205 int flags, void *opaque)
207 struct ldlm_res_id res_id =
208 { .name = {inode->i_ino, inode->i_generation} };
209 struct obd_device *obddev = class_conn2obd(conn);
212 RETURN(ldlm_cli_cancel_unused(obddev->obd_namespace, &res_id, flags,
217 void ll_prepare_mdc_op_data(struct mdc_op_data *data, struct inode *i1,
218 struct inode *i2, const char *name, int namelen,
223 ll_i2uctxt(&data->ctxt, i1, i2);
224 ll_inode2fid(&data->fid1, i1);
227 ll_inode2fid(&data->fid2, i2);
230 data->namelen = namelen;
231 data->create_mode = mode;
232 data->mod_time = LTIME_S(CURRENT_TIME);
235 /* Search "inode"'s alias list for a dentry that has the same name and parent as
236 * de. If found, return it. If not found, return de. */
237 struct dentry *ll_find_alias(struct inode *inode, struct dentry *de)
239 struct list_head *tmp;
241 spin_lock(&dcache_lock);
242 list_for_each(tmp, &inode->i_dentry) {
243 struct dentry *dentry = list_entry(tmp, struct dentry, d_alias);
245 /* We are called here with 'de' already on the aliases list. */
251 if (dentry->d_parent != de->d_parent)
254 if (dentry->d_name.len != de->d_name.len)
257 if (memcmp(dentry->d_name.name, de->d_name.name,
258 de->d_name.len) != 0)
261 if (!list_empty(&dentry->d_lru))
262 list_del_init(&dentry->d_lru);
264 hlist_del_init(&dentry->d_hash);
265 __d_rehash(dentry, 0); /* avoid taking dcache_lock inside */
266 spin_unlock(&dcache_lock);
267 atomic_inc(&dentry->d_count);
269 dentry->d_flags &= ~DCACHE_LUSTRE_INVALID;
273 spin_unlock(&dcache_lock);
278 static int lookup_it_finish(struct ptlrpc_request *request, int offset,
279 struct lookup_intent *it, void *data)
281 struct it_cb_data *icbd = data;
282 struct dentry **de = icbd->icbd_childp;
283 struct inode *parent = icbd->icbd_parent;
284 struct ll_sb_info *sbi = ll_i2sbi(parent);
285 struct dentry *dentry = *de, *saved = *de;
286 struct inode *inode = NULL;
289 /* NB 1 request reference will be taken away by ll_intent_lock()
291 if (!it_disposition(it, DISP_LOOKUP_NEG)) {
294 rc = ll_prep_inode(sbi->ll_osc_exp, &inode, request, offset,
299 CDEBUG(D_DLMTRACE, "setting l_data to inode %p (%lu/%u)\n",
300 inode, inode->i_ino, inode->i_generation);
301 mdc_set_lock_data(&it->d.lustre.it_lock_handle, inode);
303 /* If this is a stat, get the authoritative file size */
304 if (it->it_op == IT_GETATTR && S_ISREG(inode->i_mode) &&
305 ll_i2info(inode)->lli_smd != NULL) {
306 struct lov_stripe_md *lsm = ll_i2info(inode)->lli_smd;
310 LASSERT(lsm->lsm_object_id != 0);
312 /* bug 2334: drop MDS lock before acquiring OST lock */
313 ll_intent_drop_lock(it);
315 rc = ll_glimpse_size(inode, &lvb);
320 inode->i_size = lvb.lvb_size;
323 dentry = *de = ll_find_alias(inode, dentry);
328 dentry->d_op = &ll_d_ops;
331 if (dentry == saved) {
332 d_add(dentry, inode);
339 static struct dentry *ll_lookup_it(struct inode *parent, struct dentry *dentry,
340 struct lookup_intent *it, int flags)
342 struct dentry *save = dentry, *retval;
344 struct ll_uctxt ctxt;
345 struct it_cb_data icbd;
346 struct ptlrpc_request *req = NULL;
347 struct lookup_intent lookup_it = { .it_op = IT_LOOKUP };
351 if (dentry->d_name.len > EXT3_NAME_LEN)
352 RETURN(ERR_PTR(-ENAMETOOLONG));
354 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p),intent=%s\n",
355 dentry->d_name.name, parent->i_ino, parent->i_generation,
356 parent, LL_IT2STR(it));
358 if (d_mountpoint(dentry))
359 CERROR("Tell Peter, lookup on mtpt, it %s\n", LL_IT2STR(it));
361 ll_frob_intent(&it, &lookup_it);
363 icbd.icbd_childp = &dentry;
364 icbd.icbd_parent = parent;
365 ll_inode2fid(&pfid, parent);
366 ll_i2uctxt(&ctxt, parent, NULL);
368 rc = mdc_intent_lock(ll_i2mdcexp(parent), &ctxt, &pfid,
369 dentry->d_name.name, dentry->d_name.len, NULL, 0,
370 NULL, it, flags, &req, ll_mdc_blocking_ast);
372 GOTO(out, retval = ERR_PTR(rc));
374 rc = lookup_it_finish(req, 1, it, &icbd);
376 ll_intent_release(it);
377 GOTO(out, retval = ERR_PTR(rc));
380 ll_lookup_finish_locks(it, dentry);
383 GOTO(out, retval = NULL);
385 GOTO(out, retval = dentry);
388 ptlrpc_req_finished(req);
392 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
393 static struct dentry *ll_lookup_nd(struct inode *parent, struct dentry *dentry,
394 struct nameidata *nd)
399 if (nd && nd->flags & LOOKUP_LAST && !(nd->flags & LOOKUP_LINK_NOTLAST))
400 de = ll_lookup_it(parent, dentry, &nd->intent, nd->flags);
402 de = ll_lookup_it(parent, dentry, NULL, 0);
408 /* We depend on "mode" being set with the proper file type/umask by now */
409 static struct inode *ll_create_node(struct inode *dir, const char *name,
410 int namelen, const void *data, int datalen,
411 int mode, __u64 extra,
412 struct lookup_intent *it)
414 struct inode *inode = NULL;
415 struct ptlrpc_request *request = NULL;
416 struct ll_sb_info *sbi = ll_i2sbi(dir);
420 LASSERT(it && it->d.lustre.it_disposition);
422 request = it->d.lustre.it_data;
423 rc = ll_prep_inode(sbi->ll_osc_exp, &inode, request, 1, dir->i_sb);
425 GOTO(out, inode = ERR_PTR(rc));
427 LASSERT(list_empty(&inode->i_dentry));
429 /* We asked for a lock on the directory, but were granted a
430 * lock on the inode. Since we finally have an inode pointer,
431 * stuff it in the lock. */
432 CDEBUG(D_DLMTRACE, "setting l_ast_data to inode %p (%lu/%u)\n",
433 inode, inode->i_ino, inode->i_generation);
434 mdc_set_lock_data(&it->d.lustre.it_lock_handle, inode);
437 ptlrpc_req_finished(request);
442 * By the time this is called, we already have created the directory cache
443 * entry for the new file, but it is so far negative - it has no inode.
445 * We defer creating the OBD object(s) until open, to keep the intent and
446 * non-intent code paths similar, and also because we do not have the MDS
447 * inode number before calling ll_create_node() (which is needed for LOV),
448 * so we would need to do yet another RPC to the MDS to store the LOV EA
449 * data on the MDS. If needed, we would pass the PACKED lmm as data and
450 * lmm_size in datalen (the MDS still has code which will handle that).
452 * If the create succeeds, we fill in the inode information
453 * with d_instantiate().
455 static int ll_create_it(struct inode *dir, struct dentry *dentry, int mode,
456 struct lookup_intent *it)
459 struct ptlrpc_request *request = it->d.lustre.it_data;
463 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p),intent=%s\n",
464 dentry->d_name.name, dir->i_ino, dir->i_generation, dir,
467 rc = it_open_error(DISP_OPEN_CREATE, it);
471 mdc_store_inode_generation(request, 2, 1);
472 inode = ll_create_node(dir, dentry->d_name.name, dentry->d_name.len,
473 NULL, 0, mode, 0, it);
475 RETURN(PTR_ERR(inode));
478 d_instantiate(dentry, inode);
482 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0))
483 static int ll_create_nd(struct inode *dir, struct dentry *dentry, int mode, struct nameidata *nd)
485 return ll_create_it(dir, dentry, mode, &nd->intent);
489 static int ll_mknod_raw(struct nameidata *nd, int mode, dev_t rdev)
491 struct ptlrpc_request *request = NULL;
492 struct inode *dir = nd->dentry->d_inode;
493 const char *name = nd->last.name;
494 int len = nd->last.len;
495 struct ll_sb_info *sbi = ll_i2sbi(dir);
496 struct mdc_op_data op_data;
500 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
501 name, dir->i_ino, dir->i_generation, dir);
503 if (dir->i_nlink >= EXT3_LINK_MAX)
506 mode &= ~current->fs->umask;
508 switch (mode & S_IFMT) {
511 mode |= S_IFREG; /* for mode = 0 case, fallthrough */
516 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
517 err = mdc_create(sbi->ll_mdc_exp, &op_data, NULL, 0, mode,
518 current->fsuid, current->fsgid,
520 ptlrpc_req_finished(request);
531 static int ll_mknod(struct inode *dir, struct dentry *child, int mode,
534 struct ptlrpc_request *request = NULL;
535 struct inode *inode = NULL;
536 const char *name = child->d_name.name;
537 int len = child->d_name.len;
538 struct ll_sb_info *sbi = ll_i2sbi(dir);
539 struct mdc_op_data op_data;
543 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
544 name, dir->i_ino, dir->i_generation, dir);
546 if (dir->i_nlink >= EXT3_LINK_MAX)
549 mode &= ~current->fs->umask;
551 switch (mode & S_IFMT) {
554 mode |= S_IFREG; /* for mode = 0 case, fallthrough */
559 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
560 err = mdc_create(sbi->ll_mdc_exp, &op_data, NULL, 0, mode,
561 current->fsuid, current->fsgid,
563 err = ll_prep_inode(sbi->ll_osc_exp, &inode, request, 0,
575 d_instantiate(child, inode);
577 ptlrpc_req_finished(request);
581 static int ll_symlink_raw(struct nameidata *nd, const char *tgt)
583 struct inode *dir = nd->dentry->d_inode;
584 const char *name = nd->last.name;
585 int len = nd->last.len;
586 struct ptlrpc_request *request = NULL;
587 struct ll_sb_info *sbi = ll_i2sbi(dir);
588 struct mdc_op_data op_data;
592 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p),target=%s\n",
593 name, dir->i_ino, dir->i_generation, dir, tgt);
595 if (dir->i_nlink >= EXT3_LINK_MAX)
598 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
599 err = mdc_create(sbi->ll_mdc_exp, &op_data,
600 tgt, strlen(tgt) + 1, S_IFLNK | S_IRWXUGO,
601 current->fsuid, current->fsgid, 0, &request);
602 ptlrpc_req_finished(request);
606 static int ll_link_raw(struct nameidata *srcnd, struct nameidata *tgtnd)
608 struct inode *src = srcnd->dentry->d_inode;
609 struct inode *dir = tgtnd->dentry->d_inode;
610 const char *name = tgtnd->last.name;
611 int len = tgtnd->last.len;
612 struct ptlrpc_request *request = NULL;
613 struct mdc_op_data op_data;
615 struct ll_sb_info *sbi = ll_i2sbi(dir);
618 CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu/%u(%p),dir=%lu/%u(%p),target=%s\n",
619 src->i_ino, src->i_generation, src,
620 dir->i_ino, dir->i_generation, dir, name);
622 ll_prepare_mdc_op_data(&op_data, src, dir, name, len, 0);
623 err = mdc_link(sbi->ll_mdc_exp, &op_data, &request);
624 ptlrpc_req_finished(request);
630 static int ll_mkdir_raw(struct nameidata *nd, int mode)
632 struct inode *dir = nd->dentry->d_inode;
633 const char *name = nd->last.name;
634 int len = nd->last.len;
635 struct ptlrpc_request *request = NULL;
636 struct ll_sb_info *sbi = ll_i2sbi(dir);
637 struct mdc_op_data op_data;
640 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
641 name, dir->i_ino, dir->i_generation, dir);
643 if (dir->i_nlink >= EXT3_LINK_MAX)
646 mode = (mode & (S_IRWXUGO|S_ISVTX) & ~current->fs->umask) | S_IFDIR;
647 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
648 err = mdc_create(sbi->ll_mdc_exp, &op_data, NULL, 0, mode,
649 current->fsuid, current->fsgid, 0, &request);
650 ptlrpc_req_finished(request);
654 static int ll_rmdir_raw(struct nameidata *nd)
656 struct inode *dir = nd->dentry->d_inode;
657 const char *name = nd->last.name;
658 int len = nd->last.len;
659 struct ptlrpc_request *request = NULL;
660 struct mdc_op_data op_data;
663 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
664 name, dir->i_ino, dir->i_generation, dir);
666 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, S_IFDIR);
667 rc = mdc_unlink(ll_i2sbi(dir)->ll_mdc_exp, &op_data, &request);
668 ptlrpc_req_finished(request);
672 int ll_objects_destroy(struct ptlrpc_request *request, struct inode *dir)
674 struct mds_body *body;
675 struct lov_mds_md *eadata;
676 struct lov_stripe_md *lsm = NULL;
677 struct obd_trans_info oti = { 0 };
682 /* req is swabbed so this is safe */
683 body = lustre_msg_buf(request->rq_repmsg, 0, sizeof(*body));
685 if (!(body->valid & OBD_MD_FLEASIZE))
688 if (body->eadatasize == 0) {
689 CERROR("OBD_MD_FLEASIZE set but eadatasize zero\n");
690 GOTO(out, rc = -EPROTO);
693 /* The MDS sent back the EA because we unlinked the last reference
694 * to this file. Use this EA to unlink the objects on the OST.
695 * It's opaque so we don't swab here; we leave it to obd_unpackmd() to
696 * check it is complete and sensible. */
697 eadata = lustre_swab_repbuf(request, 1, body->eadatasize, NULL);
698 LASSERT(eadata != NULL);
699 if (eadata == NULL) {
700 CERROR("Can't unpack MDS EA data\n");
701 GOTO(out, rc = -EPROTO);
704 rc = obd_unpackmd(ll_i2obdexp(dir), &lsm, eadata, body->eadatasize);
706 CERROR("obd_unpackmd: %d\n", rc);
709 LASSERT(rc >= sizeof(*lsm));
713 GOTO(out_free_memmd, rc = -ENOMEM);
715 oa->o_id = lsm->lsm_object_id;
716 oa->o_mode = body->mode & S_IFMT;
717 oa->o_valid = OBD_MD_FLID | OBD_MD_FLTYPE;
719 if (body->valid & OBD_MD_FLCOOKIE) {
720 oa->o_valid |= OBD_MD_FLCOOKIE;
722 lustre_msg_buf(request->rq_repmsg, 2,
723 sizeof(struct llog_cookie) *
724 lsm->lsm_stripe_count);
725 if (oti.oti_logcookies == NULL) {
726 oa->o_valid &= ~OBD_MD_FLCOOKIE;
727 body->valid &= ~OBD_MD_FLCOOKIE;
731 rc = obd_destroy(ll_i2obdexp(dir), oa, lsm, &oti);
734 CERROR("obd destroy objid "LPX64" error %d\n",
735 lsm->lsm_object_id, rc);
737 obd_free_memmd(ll_i2obdexp(dir), &lsm);
742 static int ll_unlink_raw(struct nameidata *nd)
744 struct inode *dir = nd->dentry->d_inode;
745 const char *name = nd->last.name;
746 int len = nd->last.len;
747 struct ptlrpc_request *request = NULL;
748 struct mdc_op_data op_data;
751 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu/%u(%p)\n",
752 name, dir->i_ino, dir->i_generation, dir);
754 ll_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
755 rc = mdc_unlink(ll_i2sbi(dir)->ll_mdc_exp, &op_data, &request);
759 rc = ll_objects_destroy(request, dir);
761 ptlrpc_req_finished(request);
765 static int ll_rename_raw(struct nameidata *oldnd, struct nameidata *newnd)
767 struct inode *src = oldnd->dentry->d_inode;
768 struct inode *tgt = newnd->dentry->d_inode;
769 const char *oldname = oldnd->last.name;
770 int oldlen = oldnd->last.len;
771 const char *newname = newnd->last.name;
772 int newlen = newnd->last.len;
773 struct ptlrpc_request *request = NULL;
774 struct ll_sb_info *sbi = ll_i2sbi(src);
775 struct mdc_op_data op_data;
778 CDEBUG(D_VFSTRACE, "VFS Op:oldname=%s,src_dir=%lu/%u(%p),newname=%s,"
779 "tgt_dir=%lu/%u(%p)\n", oldname, src->i_ino, src->i_generation,
780 src, newname, tgt->i_ino, tgt->i_generation, tgt);
782 ll_prepare_mdc_op_data(&op_data, src, tgt, NULL, 0, 0);
783 err = mdc_rename(sbi->ll_mdc_exp, &op_data,
784 oldname, oldlen, newname, newlen, &request);
786 err = ll_objects_destroy(request, src);
789 ptlrpc_req_finished(request);
794 struct inode_operations ll_dir_inode_operations = {
795 link_raw: ll_link_raw,
796 unlink_raw: ll_unlink_raw,
797 symlink_raw: ll_symlink_raw,
798 mkdir_raw: ll_mkdir_raw,
799 rmdir_raw: ll_rmdir_raw,
800 mknod_raw: ll_mknod_raw,
802 rename_raw: ll_rename_raw,
804 setattr_raw: ll_setattr_raw,
805 #if (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0))
806 create_it: ll_create_it,
807 lookup_it: ll_lookup_it,
808 revalidate_it: ll_inode_revalidate_it,
810 lookup: ll_lookup_nd,
811 create: ll_create_nd,
812 getattr_it: ll_getattr,