1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2 * vim:expandtab:shiftwidth=8:tabstop=8:
4 * Lustre Light Super operations
6 * Copyright (c) 2002, 2003 Cluster File Systems, Inc.
8 * This file is part of Lustre, http://www.lustre.org.
10 * Lustre is free software; you can redistribute it and/or
11 * modify it under the terms of version 2 of the GNU General Public
12 * License as published by the Free Software Foundation.
14 * Lustre is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with Lustre; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 #define DEBUG_SUBSYSTEM S_LLITE
31 #include <sys/types.h>
32 #include <sys/queue.h>
40 #include "llite_lib.h"
42 static void llu_fsop_gone(struct filesys *fs)
47 static struct inode_ops llu_inode_ops;
49 void llu_update_inode(struct inode *inode, struct mds_body *body,
50 struct lov_stripe_md *lsm)
52 struct llu_inode_info *lli = llu_i2info(inode);
54 LASSERT ((lsm != NULL) == ((body->valid & OBD_MD_FLEASIZE) != 0));
56 if (lli->lli_smd == NULL)
59 LASSERT (!memcmp (lli->lli_smd, lsm,
63 if (body->valid & OBD_MD_FLID)
64 lli->lli_st_ino = body->ino;
65 if (body->valid & OBD_MD_FLATIME)
66 LTIME_S(lli->lli_st_atime) = body->atime;
67 if (body->valid & OBD_MD_FLMTIME)
68 LTIME_S(lli->lli_st_mtime) = body->mtime;
69 if (body->valid & OBD_MD_FLCTIME)
70 LTIME_S(lli->lli_st_ctime) = body->ctime;
71 if (body->valid & OBD_MD_FLMODE)
72 lli->lli_st_mode = (lli->lli_st_mode & S_IFMT)|(body->mode & ~S_IFMT);
73 if (body->valid & OBD_MD_FLTYPE)
74 lli->lli_st_mode = (lli->lli_st_mode & ~S_IFMT)|(body->mode & S_IFMT);
75 if (body->valid & OBD_MD_FLUID)
76 lli->lli_st_uid = body->uid;
77 if (body->valid & OBD_MD_FLGID)
78 lli->lli_st_gid = body->gid;
79 if (body->valid & OBD_MD_FLFLAGS)
80 lli->lli_st_flags = body->flags;
81 if (body->valid & OBD_MD_FLNLINK)
82 lli->lli_st_nlink = body->nlink;
83 if (body->valid & OBD_MD_FLGENER)
84 lli->lli_st_generation = body->generation;
85 if (body->valid & OBD_MD_FLRDEV)
86 lli->lli_st_rdev = body->rdev;
87 if (body->valid & OBD_MD_FLSIZE)
88 lli->lli_st_size = body->size;
89 if (body->valid & OBD_MD_FLBLOCKS)
90 lli->lli_st_blocks = body->blocks;
93 if (body->valid & OBD_MD_FLID)
94 lli->lli_fid.id = body->ino;
95 if (body->valid & OBD_MD_FLGENER)
96 lli->lli_fid.generation = body->generation;
97 if (body->valid & OBD_MD_FLTYPE)
98 lli->lli_fid.f_type = body->mode & S_IFMT;
101 void obdo_to_inode(struct inode *dst, struct obdo *src, obd_flag valid)
103 struct llu_inode_info *lli = llu_i2info(dst);
105 valid &= src->o_valid;
107 if (valid & OBD_MD_FLATIME)
108 LTIME_S(lli->lli_st_atime) = src->o_atime;
109 if (valid & OBD_MD_FLMTIME)
110 LTIME_S(lli->lli_st_mtime) = src->o_mtime;
111 if (valid & OBD_MD_FLCTIME && src->o_ctime > LTIME_S(lli->lli_st_ctime))
112 LTIME_S(lli->lli_st_ctime) = src->o_ctime;
113 if (valid & OBD_MD_FLSIZE)
114 lli->lli_st_size = src->o_size;
115 if (valid & OBD_MD_FLBLOCKS) /* allocation of space */
116 lli->lli_st_blocks = src->o_blocks;
117 if (valid & OBD_MD_FLBLKSZ)
118 lli->lli_st_blksize = src->o_blksize;
119 if (valid & OBD_MD_FLTYPE)
120 lli->lli_st_mode = (lli->lli_st_mode & ~S_IFMT) | (src->o_mode & S_IFMT);
121 if (valid & OBD_MD_FLMODE)
122 lli->lli_st_mode = (lli->lli_st_mode & S_IFMT) | (src->o_mode & ~S_IFMT);
123 if (valid & OBD_MD_FLUID)
124 lli->lli_st_uid = src->o_uid;
125 if (valid & OBD_MD_FLGID)
126 lli->lli_st_gid = src->o_gid;
127 if (valid & OBD_MD_FLFLAGS)
128 lli->lli_st_flags = src->o_flags;
129 if (valid & OBD_MD_FLNLINK)
130 lli->lli_st_nlink = src->o_nlink;
131 if (valid & OBD_MD_FLGENER)
132 lli->lli_st_generation = src->o_generation;
133 if (valid & OBD_MD_FLRDEV)
134 lli->lli_st_rdev = src->o_rdev;
137 void obdo_from_inode(struct obdo *dst, struct inode *src, obd_flag valid)
139 struct llu_inode_info *lli = llu_i2info(src);
141 if (valid & OBD_MD_FLATIME)
142 dst->o_atime = LTIME_S(lli->lli_st_atime);
143 if (valid & OBD_MD_FLMTIME)
144 dst->o_mtime = LTIME_S(lli->lli_st_mtime);
145 if (valid & OBD_MD_FLCTIME)
146 dst->o_ctime = LTIME_S(lli->lli_st_ctime);
147 if (valid & OBD_MD_FLSIZE)
148 dst->o_size = lli->lli_st_size;
149 if (valid & OBD_MD_FLBLOCKS) /* allocation of space */
150 dst->o_blocks = lli->lli_st_blocks;
151 if (valid & OBD_MD_FLBLKSZ)
152 dst->o_blksize = lli->lli_st_blksize;
153 if (valid & OBD_MD_FLTYPE)
154 dst->o_mode = (dst->o_mode & ~S_IFMT) | (lli->lli_st_mode & S_IFMT);
155 if (valid & OBD_MD_FLMODE)
156 dst->o_mode = (dst->o_mode & S_IFMT) | (lli->lli_st_mode & ~S_IFMT);
157 if (valid & OBD_MD_FLUID)
158 dst->o_uid = lli->lli_st_uid;
159 if (valid & OBD_MD_FLGID)
160 dst->o_gid = lli->lli_st_gid;
161 if (valid & OBD_MD_FLFLAGS)
162 dst->o_flags = lli->lli_st_flags;
163 if (valid & OBD_MD_FLNLINK)
164 dst->o_nlink = lli->lli_st_nlink;
165 if (valid & OBD_MD_FLGENER)
166 dst->o_generation = lli->lli_st_generation;
167 if (valid & OBD_MD_FLRDEV)
168 dst->o_rdev = (__u32)(lli->lli_st_rdev);
170 dst->o_valid |= (valid & ~OBD_MD_FLID);
173 int llu_inode_getattr(struct inode *inode, struct lov_stripe_md *lsm,
176 struct llu_sb_info *sbi = llu_i2sbi(inode);
184 memset(&oa, 0, sizeof oa);
185 oa.o_id = lsm->lsm_object_id;
187 oa.o_valid = OBD_MD_FLID | OBD_MD_FLTYPE | OBD_MD_FLSIZE |
188 OBD_MD_FLBLOCKS | OBD_MD_FLMTIME | OBD_MD_FLCTIME;
190 if (ostdata != NULL) {
191 memcpy(&oa.o_inline, ostdata, FD_OSTDATA_SIZE);
192 oa.o_valid |= OBD_MD_FLHANDLE;
195 rc = obd_getattr(&sbi->ll_osc_conn, &oa, lsm);
199 obdo_to_inode(inode, &oa, OBD_MD_FLSIZE | OBD_MD_FLBLOCKS |
200 OBD_MD_FLMTIME | OBD_MD_FLCTIME);
205 struct inode* llu_new_inode(struct filesys *fs, ino_t ino, mode_t mode)
208 struct llu_inode_info *lli;
210 OBD_ALLOC(lli, sizeof(*lli));
214 /* initialize lli here */
215 lli->lli_sbi = llu_fs2sbi(fs);
217 lli->lli_symlink_name = NULL;
219 INIT_LIST_HEAD(&lli->lli_read_extents);
220 lli->lli_file_data = NULL;
222 /* could file_identifier be 0 ? FIXME */
223 inode = _sysio_i_new(fs, ino, NULL,
224 #ifndef AUTOMOUNT_FILE_NAME
227 mode, /* all of the bits! */
230 &llu_inode_ops, lli);
233 OBD_FREE(lli, sizeof(*lli));
238 static int llu_iop_lookup(struct pnode *pnode,
240 struct intent *intnt __IS_UNUSED,
241 const char *path __IS_UNUSED)
243 struct pnode_base *pb_dir = pnode->p_parent->p_base;
244 struct ptlrpc_request *request = NULL;
245 struct llu_sb_info *sbi = llu_i2sbi(pb_dir->pb_ino);
246 struct ll_fid *fid = &llu_i2info(pb_dir->pb_ino)->lli_fid;
247 struct qstr *name = &pnode->p_base->pb_name;
248 struct mds_body *body;
252 struct ll_read_inode2_cookie lic = {.lic_body = NULL, .lic_lsm = NULL};
254 /* the mount root inode have no name, so don't call
255 * remote in this case. but probably we need revalidate
257 if (pnode->p_mount->mnt_root == pnode) {
258 struct inode *i = pnode->p_base->pb_ino;
267 /* mdc_getattr_name require NULL-terminated name */
268 OBD_ALLOC(pname, name->len + 1);
271 memcpy(pname, name->name, name->len);
272 pname[name->len] = 0;
274 valid = OBD_MD_FLID | OBD_MD_FLTYPE | OBD_MD_FLSIZE;
276 /* FIXME before getattr_name, we don't know whether
277 * the inode we are finding is regular or not, so here
278 * we blindly require server feed in EA data */
279 easize = obd_size_diskmd(&sbi->ll_osc_conn, NULL);
280 valid |= OBD_MD_FLEASIZE;
282 rc = mdc_getattr_name(&sbi->ll_mdc_conn, fid,
283 pname, name->len + 1,
284 valid, easize, &request);
286 CERROR("mdc_getattr_name: %d\n", rc);
290 body = lustre_msg_buf(request->rq_repmsg, 0, sizeof(*body));
292 *inop = llu_new_inode(pnode->p_mount->mnt_fs, body->ino, body->mode);
296 lic.lic_body = lustre_msg_buf(request->rq_repmsg, 0, sizeof(*lic.lic_body));
297 LASSERT (lic.lic_body != NULL);
298 LASSERT_REPSWABBED (request, 0);
300 if (S_ISREG(lic.lic_body->mode) &&
301 lic.lic_body->valid & OBD_MD_FLEASIZE) {
302 struct lov_mds_md *lmm;
306 lmm_size = lic.lic_body->eadatasize;
308 CERROR ("OBD_MD_FLEASIZE set but eadatasize 0\n");
311 lmm = lustre_msg_buf(request->rq_repmsg, 0 + 1, lmm_size);
312 LASSERT(lmm != NULL);
313 LASSERT_REPSWABBED (request, 0 + 1);
315 rc = obd_unpackmd (&sbi->ll_osc_conn,
316 &lic.lic_lsm, lmm, lmm_size);
318 CERROR ("Error %d unpacking eadata\n", rc);
321 LASSERT (rc >= sizeof (*lic.lic_lsm));
327 llu_update_inode(*inop, body, lic.lic_lsm);
329 if (llu_i2info(*inop)->lli_smd) {
330 rc = llu_inode_getattr(*inop, llu_i2info(*inop)->lli_smd, NULL);
332 _sysio_i_gone(*inop);
336 ptlrpc_req_finished(request);
337 OBD_FREE(pname, name->len + 1);
342 static int llu_iop_getattr(struct pnode *pno,
344 struct intnl_stat *b)
346 struct llu_inode_info *lli = llu_i2info(ino);
348 b->st_dev = lli->lli_st_dev;
349 b->st_ino = lli->lli_st_ino;
350 b->st_mode = lli->lli_st_mode;
351 b->st_nlink = lli->lli_st_nlink;
352 b->st_uid = lli->lli_st_uid;
353 b->st_gid = lli->lli_st_gid;
354 b->st_rdev = lli->lli_st_rdev;
355 b->st_size = lli->lli_st_size;
356 b->st_blksize = lli->lli_st_blksize;
357 b->st_blocks = lli->lli_st_blocks;
358 b->st_atime = lli->lli_st_atime;
359 b->st_mtime = lli->lli_st_mtime;
360 b->st_ctime = lli->lli_st_ctime;
365 int llu_mdc_cancel_unused(struct lustre_handle *conn,
366 struct llu_inode_info *lli,
369 struct ldlm_res_id res_id =
370 { .name = {lli->lli_st_ino, lli->lli_st_generation} };
371 struct obd_device *obddev = class_conn2obd(conn);
373 RETURN(ldlm_cli_cancel_unused(obddev->obd_namespace, &res_id, flags));
376 static void llu_clear_inode(struct inode *inode)
378 struct llu_sb_info *sbi = llu_i2sbi(inode);
379 struct llu_inode_info *lli = llu_i2info(inode);
383 CDEBUG(D_INODE, "clear inode: %lu\n", lli->lli_st_ino);
384 rc = llu_mdc_cancel_unused(&sbi->ll_mdc_conn, lli,
385 LDLM_FL_NO_CALLBACK);
387 CERROR("ll_mdc_cancel_unused: %d\n", rc);
388 /* XXX FIXME do something dramatic */
392 rc = obd_cancel_unused(&sbi->ll_osc_conn, lli->lli_smd, 0);
394 CERROR("obd_cancel_unused: %d\n", rc);
395 /* XXX FIXME do something dramatic */
400 obd_free_memmd(&sbi->ll_osc_conn, &lli->lli_smd);
402 if (lli->lli_symlink_name) {
403 OBD_FREE(lli->lli_symlink_name,
404 strlen(lli->lli_symlink_name) + 1);
405 lli->lli_symlink_name = NULL;
411 void llu_iop_gone(struct inode *inode)
413 struct llu_inode_info *lli = llu_i2info(inode);
415 llu_clear_inode(inode);
417 OBD_FREE(lli, sizeof(*lli));
420 static int llu_setattr_raw(struct inode *inode, struct iattr *attr)
422 struct ptlrpc_request *request = NULL;
423 struct llu_sb_info *sbi = llu_i2sbi(inode);
424 struct llu_inode_info *lli = llu_i2info(inode);
425 struct mdc_op_data op_data;
428 CDEBUG(D_VFSTRACE, "VFS Op:inode=%lu\n", lli->lli_st_ino);
430 /* if need truncate, do it at first */
431 if (attr->ia_valid & ATTR_SIZE) {
432 printf("************* don't support truncate now !!!!!!!!\n");
436 /* Don't send size changes to MDS to avoid "fast EA" problems, and
437 * also avoid a pointless RPC (we get file size from OST anyways).
439 attr->ia_valid &= ~ATTR_SIZE;
443 llu_prepare_mdc_op_data(&op_data, inode, NULL, NULL, 0, 0);
445 err = mdc_setattr(&sbi->ll_mdc_conn, &op_data,
446 attr, NULL, 0, &request);
448 CERROR("mdc_setattr fails: err = %d\n", err);
450 ptlrpc_req_finished(request);
452 if (S_ISREG(inode->i_mode) && attr->ia_valid & ATTR_MTIME_SET) {
453 struct lov_stripe_md *lsm = lli->lli_smd;
457 CDEBUG(D_INODE, "set mtime on OST inode %lu to %lu\n",
458 lli->lli_st_ino, attr->ia_mtime);
459 oa.o_id = lsm->lsm_object_id;
461 oa.o_valid = OBD_MD_FLID | OBD_MD_FLTYPE | OBD_MD_FLMTIME;
462 oa.o_mtime = attr->ia_mtime;
463 err2 = obd_setattr(&sbi->ll_osc_conn, &oa, lsm, NULL);
465 CERROR("obd_setattr fails: rc=%d\n", err);
473 /* FIXME here we simply act as a thin layer to glue it with
474 * llu_setattr_raw(), which is copy from kernel
476 static int llu_iop_setattr(struct pnode *pno,
479 struct intnl_stat *stbuf)
483 memset(&iattr, 0, sizeof(iattr));
485 if (mask & SETATTR_MODE) {
486 iattr.ia_mode = stbuf->st_mode;
487 iattr.ia_valid |= ATTR_MODE;
489 if (mask & SETATTR_MTIME) {
490 iattr.ia_mtime = stbuf->st_mtime;
491 iattr.ia_valid |= ATTR_MTIME;
493 if (mask & SETATTR_ATIME) {
494 iattr.ia_atime = stbuf->st_atime;
495 iattr.ia_valid |= ATTR_ATIME;
497 if (mask & SETATTR_UID) {
498 iattr.ia_uid = stbuf->st_uid;
499 iattr.ia_valid |= ATTR_UID;
501 if (mask & SETATTR_GID) {
502 iattr.ia_gid = stbuf->st_gid;
503 iattr.ia_valid |= ATTR_GID;
505 if (mask & SETATTR_LEN) {
506 iattr.ia_size = stbuf->st_size; /* FIXME signed expansion problem */
507 iattr.ia_valid |= ATTR_SIZE;
510 iattr.ia_valid |= ATTR_RAW;
511 /* FIXME FIXME FIXME FIXME FIXME FIXME FIXME
512 * without ATTR_FROM_OPEN, mds_reint_setattr will call
513 * mds_fid2locked_dentry() and deadlocked at completion_ast call.
514 * Here we workaround it and avoid any locking.
515 * FIXME FIXME FIXME FIXME FIXME FIXME FIXME
517 iattr.ia_valid |= ATTR_FROM_OPEN;
519 return llu_setattr_raw(ino, &iattr);
523 static int llu_mkdir2(struct inode *dir, const char *name, int len, int mode)
525 struct ptlrpc_request *request = NULL;
526 time_t curtime = CURRENT_TIME;
527 struct llu_sb_info *sbi = llu_i2sbi(dir);
528 struct llu_inode_info *lli = llu_i2info(dir);
529 struct mdc_op_data op_data;
532 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu\n",
533 name, lli->lli_st_ino);
535 /* FIXME check this later */
537 if (dir->i_nlink >= EXT2_LINK_MAX)
539 mode = (mode & (S_IRWXUGO|S_ISVTX) & ~current->fs->umask) | S_IFDIR;
542 llu_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
543 err = mdc_create(&sbi->ll_mdc_conn, &op_data, NULL, 0, mode,
544 current->fsuid, current->fsgid,
545 curtime, 0, &request);
546 ptlrpc_req_finished(request);
550 static int llu_iop_mkdir(struct pnode *pno, mode_t mode)
552 struct inode *dir = pno->p_base->pb_parent->pb_ino;
553 struct qstr *qstr = &pno->p_base->pb_name;
558 rc = llu_mkdir2(dir, qstr->name, qstr->len, mode);
564 #define S_IRWXUGO (S_IRWXU|S_IRWXG|S_IRWXO)
567 static int llu_symlink2(struct inode *dir, const char *name, int len,
570 struct ptlrpc_request *request = NULL;
571 time_t curtime = CURRENT_TIME;
572 struct llu_sb_info *sbi = llu_i2sbi(dir);
573 struct llu_inode_info *lli = llu_i2info(dir);
574 struct mdc_op_data op_data;
578 CDEBUG(D_VFSTRACE, "VFS Op:name=%s,dir=%lu,target=%s\n",
579 name, lli->lli_st_ino, tgt);
582 if (dir->i_nlink >= EXT2_LINK_MAX)
585 llu_prepare_mdc_op_data(&op_data, dir, NULL, name, len, 0);
586 err = mdc_create(&sbi->ll_mdc_conn, &op_data,
587 tgt, strlen(tgt) + 1, S_IFLNK | S_IRWXUGO,
588 current->fsuid, current->fsgid, curtime, 0, &request);
589 ptlrpc_req_finished(request);
593 static int llu_iop_symlink(struct pnode *pno, const char *data)
595 struct inode *dir = pno->p_base->pb_parent->pb_ino;
596 struct qstr *qstr = &pno->p_base->pb_name;
601 rc = llu_symlink2(dir, qstr->name, qstr->len, data);
606 struct filesys_ops llu_filesys_ops =
608 fsop_gone: llu_fsop_gone,
612 static struct inode_ops llu_inode_ops = {
613 inop_lookup: llu_iop_lookup,
614 inop_getattr: llu_iop_getattr,
615 inop_setattr: llu_iop_setattr,
616 inop_getdirentries: NULL,
617 inop_mkdir: llu_iop_mkdir,
619 inop_symlink: llu_iop_symlink,
621 inop_open: llu_iop_open,
622 inop_close: llu_iop_close,
624 inop_ipreadv: llu_iop_ipreadv,
625 inop_ipwritev: llu_iop_ipwritev,
626 inop_iodone: llu_iop_iodone,
633 inop_gone: llu_iop_gone,
638 llu_fsswop_mount(const char *source,
640 const void *data __IS_UNUSED,
641 struct pnode *tocover,
646 struct pnode_base *rootpb;
647 static struct qstr noname = { NULL, 0, 0 };
648 struct ll_fid rootfid;
650 struct llu_sb_info *sbi;
651 struct ptlrpc_connection *mdc_conn;
652 struct ptlrpc_request *request = NULL;
653 struct mds_body *root_body;
654 struct obd_uuid param_uuid;
656 struct obd_device *obd;
657 char *osc=mount_option.osc_uuid;
658 char *mdc=mount_option.mdc_uuid;
663 OBD_ALLOC(sbi, sizeof(*sbi));
667 INIT_LIST_HEAD(&sbi->ll_conn_chain);
668 generate_random_uuid(uuid);
669 class_uuid_unparse(uuid, &sbi->ll_sb_uuid);
671 fs = _sysio_fs_new(&llu_filesys_ops, flags, sbi);
677 strncpy(param_uuid.uuid, mdc, sizeof(param_uuid.uuid));
678 obd = class_uuid2obd(¶m_uuid);
680 CERROR("MDC %s: not setup or attached\n", mdc);
686 /* FIXME need recover stuff */
687 err = obd_connect(&sbi->ll_mdc_conn, obd, &sbi->ll_sb_uuid);
689 CERROR("cannot connect to %s: rc = %d\n", mdc, err);
693 mdc_conn = sbi2mdc(sbi)->cl_import->imp_connection;
696 strncpy(param_uuid.uuid, osc, sizeof(param_uuid.uuid));
697 obd = class_uuid2obd(¶m_uuid);
699 CERROR("OSC %s: not setup or attached\n", osc);
704 err = obd_connect(&sbi->ll_osc_conn, obd, &sbi->ll_sb_uuid);
706 CERROR("cannot connect to %s: rc = %d\n", osc, err);
710 err = mdc_getstatus(&sbi->ll_mdc_conn, &rootfid);
712 CERROR("cannot mds_connect: rc = %d\n", err);
715 CDEBUG(D_SUPER, "rootfid "LPU64"\n", rootfid.id);
716 sbi->ll_rootino = rootfid.id;
718 /* XXX do we need this??
719 memset(&osfs, 0, sizeof(osfs));
720 rc = obd_statfs(&sbi->ll_mdc_conn, &osfs);
722 /* fetch attr of root inode */
723 err = mdc_getattr(&sbi->ll_mdc_conn, &rootfid,
724 OBD_MD_FLNOTOBD|OBD_MD_FLBLOCKS, 0, &request);
726 CERROR("mdc_getattr failed for root: rc = %d\n", err);
730 root_body = lustre_msg_buf(request->rq_repmsg, 0, sizeof(*root_body));
731 LASSERT(sbi->ll_rootino != 0);
733 root = llu_new_inode(fs, root_body->ino, root_body->mode);
739 llu_update_inode(root, root_body, NULL);
742 * Generate base path-node for root.
744 rootpb = _sysio_pb_new(&noname, NULL, root);
750 err = _sysio_do_mount(fs, rootpb, flags, NULL, mntp);
752 _sysio_pb_gone(rootpb);
756 ptlrpc_req_finished(request);
759 printf("************************************************\n");
760 printf("* Mount successfully!!!!!!! *\n");
761 printf("************************************************\n");
768 ptlrpc_req_finished(request);
770 obd_disconnect(&sbi->ll_osc_conn);
772 obd_disconnect(&sbi->ll_mdc_conn);
774 OBD_FREE(sbi, sizeof(*sbi));
778 struct fssw_ops llu_fssw_ops = {