super.c

lustre 1.6.5 source code

                RETURN(err);

        fd->fd_gid = 0;
        memset(&fd->fd_cwlockh, 0, sizeof(fd->fd_cwlockh));

        RETURN(0);
}

static int llu_lov_dir_setstripe(struct inode *ino, unsigned long arg)
{
        struct llu_sb_info *sbi = llu_i2sbi(ino); 
        struct ptlrpc_request *request = NULL;
        struct mdc_op_data op_data;
        struct iattr attr = { 0 };
        struct lov_user_md lum, *lump = (struct lov_user_md *)arg;
        int rc = 0;

        llu_prepare_mdc_op_data(&op_data, ino, NULL, NULL, 0, 0);

        LASSERT(sizeof(lum) == sizeof(*lump));
        LASSERT(sizeof(lum.lmm_objects[0]) ==
                sizeof(lump->lmm_objects[0]));
        rc = copy_from_user(&lum, lump, sizeof(lum));
        if (rc)
                return(-EFAULT);

        if (lum.lmm_magic != LOV_USER_MAGIC)
                RETURN(-EINVAL);

        if (lum.lmm_magic != cpu_to_le32(LOV_USER_MAGIC))
                lustre_swab_lov_user_md(&lum);

        /* swabbing is done in lov_setstripe() on server side */
        rc = mdc_setattr(sbi->ll_mdc_exp, &op_data,
                         &attr, &lum, sizeof(lum), NULL, 0, &request);
        if (rc) {
                ptlrpc_req_finished(request);
                if (rc != -EPERM && rc != -EACCES)
                        CERROR("mdc_setattr fails: rc = %d\n", rc);
                return rc;
        }
        ptlrpc_req_finished(request);

        return rc;
}

static int llu_lov_setstripe_ea_info(struct inode *ino, int flags,
                                     struct lov_user_md *lum, int lum_size)
{
        struct llu_sb_info *sbi = llu_i2sbi(ino); 
        struct obd_export *exp = llu_i2obdexp(ino);
        struct llu_inode_info *lli = llu_i2info(ino);
        struct llu_inode_info *lli2 = NULL;
        struct lov_stripe_md *lsm;
        struct lookup_intent oit = {.it_op = IT_OPEN, .it_flags = flags};
        struct ldlm_enqueue_info einfo = { LDLM_IBITS, LCK_CR,
                llu_mdc_blocking_ast, ldlm_completion_ast, NULL, NULL };

        struct ptlrpc_request *req = NULL;
        struct lustre_md md;
        struct mdc_op_data data;
        struct lustre_handle lockh;
        int rc = 0;
        ENTRY;

        lsm = lli->lli_smd;
        if (lsm) {
                CDEBUG(D_IOCTL, "stripe already exists for ino "LPU64"\n",
                       lli->lli_fid.id);
                return -EEXIST;
        }

        OBD_ALLOC(lli2, sizeof(struct llu_inode_info));
        if (!lli2)
                return -ENOMEM;
        
        memcpy(lli2, lli, sizeof(struct llu_inode_info));
        lli2->lli_open_count = 0;
        lli2->lli_it = NULL;
        lli2->lli_file_data = NULL;
        lli2->lli_smd = NULL;
        lli2->lli_symlink_name = NULL;
        ino->i_private = lli2;

        llu_prepare_mdc_op_data(&data, NULL, ino, NULL, 0, O_RDWR);

        rc = mdc_enqueue(sbi->ll_mdc_exp, &einfo, &oit, &data,
                         &lockh, lum, lum_size, LDLM_FL_INTENT_ONLY);
        if (rc)
                GOTO(out, rc);
        
        req = oit.d.lustre.it_data;
        rc = it_open_error(DISP_IT_EXECD, &oit);
        if (rc) {
                req->rq_replay = 0;
                GOTO(out, rc);
        }
        
        rc = it_open_error(DISP_OPEN_OPEN, &oit);
        if (rc) {
                req->rq_replay = 0;
                GOTO(out, rc);
        }
        
        rc = mdc_req2lustre_md(req, DLM_REPLY_REC_OFF, exp, &md);
        if (rc)
                GOTO(out, rc);
        
        llu_update_inode(ino, md.body, md.lsm);
        lli->lli_smd = lli2->lli_smd;
        lli2->lli_smd = NULL;

        llu_local_open(lli2, &oit);
       
        /* release intent */
        if (lustre_handle_is_used(&lockh))
                ldlm_lock_decref(&lockh, LCK_CR);

        ptlrpc_req_finished(req);
        req = NULL;
        
        rc = llu_file_release(ino);
 out:
        ino->i_private = lli;
        if (lli2)
                OBD_FREE(lli2, sizeof(struct llu_inode_info));
        if (req != NULL)
                ptlrpc_req_finished(req);
        RETURN(rc);
}

static int llu_lov_file_setstripe(struct inode *ino, unsigned long arg)
{
        struct lov_user_md lum, *lump = (struct lov_user_md *)arg;
        int rc;
        int flags = FMODE_WRITE;
        ENTRY;

        LASSERT(sizeof(lum) == sizeof(*lump));
        LASSERT(sizeof(lum.lmm_objects[0]) == sizeof(lump->lmm_objects[0]));
        rc = copy_from_user(&lum, lump, sizeof(lum));
        if (rc)
                RETURN(-EFAULT);

        rc = llu_lov_setstripe_ea_info(ino, flags, &lum, sizeof(lum));
        RETURN(rc);
}

static int llu_lov_setstripe(struct inode *ino, unsigned long arg)
{
        struct intnl_stat *st = llu_i2stat(ino);
        if (S_ISREG(st->st_mode))
                return llu_lov_file_setstripe(ino, arg);
        if (S_ISDIR(st->st_mode))
                return llu_lov_dir_setstripe(ino, arg);
        
        return -EINVAL; 
}

static int llu_lov_getstripe(struct inode *ino, unsigned long arg)
{
        struct lov_stripe_md *lsm = llu_i2info(ino)->lli_smd;

        if (!lsm)
                RETURN(-ENODATA);

        return obd_iocontrol(LL_IOC_LOV_GETSTRIPE, llu_i2obdexp(ino), 0, lsm,
                            (void *)arg);
}

static int llu_iop_ioctl(struct inode *ino, unsigned long int request,
                         va_list ap)
{
        unsigned long arg;
        int rc;

        liblustre_wait_event(0);

        switch (request) {
        case LL_IOC_GROUP_LOCK:
                arg = va_arg(ap, unsigned long);
                rc = llu_get_grouplock(ino, arg);
                break;
        case LL_IOC_GROUP_UNLOCK:
                arg = va_arg(ap, unsigned long);
                rc = llu_put_grouplock(ino, arg);
                break;
        case LL_IOC_LOV_SETSTRIPE:
                arg = va_arg(ap, unsigned long);
                rc = llu_lov_setstripe(ino, arg);
                break;
        case LL_IOC_LOV_GETSTRIPE:
                arg = va_arg(ap, unsigned long);
                rc = llu_lov_getstripe(ino, arg);
                break;
        default:
                CERROR("did not support ioctl cmd %lx\n", request);
                rc = -ENOSYS;
                break;
        }

        liblustre_wait_event(0);
        return rc;
}

/*
 * we already do syncronous read/write
 */
static int llu_iop_sync(struct inode *inode)
{
        liblustre_wait_event(0);
        return 0;
}

static int llu_iop_datasync(struct inode *inode)
{
        liblustre_wait_event(0);
        return 0;
}

struct filesys_ops llu_filesys_ops =
{
        fsop_gone: llu_fsop_gone,
};

struct inode *llu_iget(struct filesys *fs, struct lustre_md *md)
{
        struct inode *inode;
        struct ll_fid fid;
        struct file_identifier fileid = {&fid, sizeof(fid)};

        if ((md->body->valid &
             (OBD_MD_FLGENER | OBD_MD_FLID | OBD_MD_FLTYPE)) !=
            (OBD_MD_FLGENER | OBD_MD_FLID | OBD_MD_FLTYPE)) {
                CERROR("bad md body valid mask "LPX64"\n", md->body->valid);
                LBUG();
                return ERR_PTR(-EPERM);
        }

        /* try to find existing inode */
        fid.id = md->body->ino;
        fid.generation = md->body->generation;
        fid.f_type = md->body->mode & S_IFMT;

        inode = _sysio_i_find(fs, &fileid);
        if (inode) {
                struct llu_inode_info *lli = llu_i2info(inode);

                if (inode->i_zombie ||
                    lli->lli_st_generation != md->body->generation) {
                        I_RELE(inode);
                }
                else {
                        llu_update_inode(inode, md->body, md->lsm);
                        return inode;
                }
        }

        inode = llu_new_inode(fs, &fid);
        if (inode)
                llu_update_inode(inode, md->body, md->lsm);

        return inode;
}

extern struct list_head lustre_profile_list;

static int
llu_fsswop_mount(const char *source,
                 unsigned flags,
                 const void *data __IS_UNUSED,
                 struct pnode *tocover,
                 struct mount **mntp)
{
        struct filesys *fs;
        struct inode *root;
        struct pnode_base *rootpb;
        struct obd_device *obd;
        struct ll_fid rootfid;
        struct llu_sb_info *sbi;
        struct obd_statfs osfs;
        static struct qstr noname = { NULL, 0, 0 };
        struct ptlrpc_request *request = NULL;
        struct lustre_handle mdc_conn = {0, };
        struct lustre_handle osc_conn = {0, };
        struct lustre_md md;
        class_uuid_t uuid;
        struct config_llog_instance cfg = {0, };
        char ll_instance[sizeof(sbi) * 2 + 1];
        struct lustre_profile *lprof;
        char *zconf_mgsnid, *zconf_profile;
        char *osc = NULL, *mdc = NULL;
        int async = 1, err = -EINVAL;
        struct obd_connect_data ocd = {0,};

        ENTRY;

        if (ll_parse_mount_target(source,
                                  &zconf_mgsnid,
                                  &zconf_profile)) {
                CERROR("mal-formed target %s\n", source);
                RETURN(err);
        }
        if (!zconf_mgsnid || !zconf_profile) {
                printf("Liblustre: invalid target %s\n", source);
                RETURN(err);
        }
        /* allocate & initialize sbi */
        OBD_ALLOC(sbi, sizeof(*sbi));
        if (!sbi)
                RETURN(-ENOMEM);

        CFS_INIT_LIST_HEAD(&sbi->ll_conn_chain);
        ll_generate_random_uuid(uuid);
        class_uuid_unparse(uuid, &sbi->ll_sb_uuid);

        /* generate a string unique to this super, let's try
         the address of the super itself.*/
        sprintf(ll_instance, "%p", sbi);

        /* retrive & parse config log */
        cfg.cfg_instance = ll_instance;
        cfg.cfg_uuid = sbi->ll_sb_uuid;
        err = liblustre_process_log(&cfg, zconf_mgsnid, zconf_profile, 1);
        if (err < 0) {
                CERROR("Unable to process log: %s\n", zconf_profile);
                GOTO(out_free, err);
        }

        lprof = class_get_profile(zconf_profile);
        if (lprof == NULL) {
                CERROR("No profile found: %s\n", zconf_profile);
                GOTO(out_free, err = -EINVAL);
        }
        OBD_ALLOC(osc, strlen(lprof->lp_osc) + strlen(ll_instance) + 2);
        sprintf(osc, "%s-%s", lprof->lp_osc, ll_instance);

        OBD_ALLOC(mdc, strlen(lprof->lp_mdc) + strlen(ll_instance) + 2);
        sprintf(mdc, "%s-%s", lprof->lp_mdc, ll_instance);

        if (!osc) {
                CERROR("no osc\n");
                GOTO(out_free, err = -EINVAL);
        }
        if (!mdc) {
                CERROR("no mdc\n");
                GOTO(out_free, err = -EINVAL);
        }

        fs = _sysio_fs_new(&llu_filesys_ops, flags, sbi);
        if (!fs) {
                err = -ENOMEM;
                goto out_free;
        }

        obd = class_name2obd(mdc);
        if (!obd) {
                CERROR("MDC %s: not setup or attached\n", mdc);
                GOTO(out_free, err = -EINVAL);
        }
        obd_set_info_async(obd->obd_self_export, strlen("async"), "async",
                           sizeof(async), &async, NULL);

        ocd.ocd_connect_flags = OBD_CONNECT_IBITS | OBD_CONNECT_VERSION |
                OBD_CONNECT_AT;
#ifdef LIBLUSTRE_POSIX_ACL
        ocd.ocd_connect_flags |= OBD_CONNECT_ACL;
#endif
        ocd.ocd_ibits_known = MDS_INODELOCK_FULL;
        ocd.ocd_version = LUSTRE_VERSION_CODE;

        /* setup mdc */
        err = obd_connect(&mdc_conn, obd, &sbi->ll_sb_uuid, &ocd, NULL);
        if (err) {
                CERROR("cannot connect to %s: rc = %d\n", mdc, err);
                GOTO(out_free, err);
        }
        sbi->ll_mdc_exp = class_conn2export(&mdc_conn);

        err = obd_statfs(obd, &osfs, 100000000, 0);
        if (err)
                GOTO(out_mdc, err);

        /*
         * FIXME fill fs stat data into sbi here!!! FIXME
         */

        /* setup osc */
        obd = class_name2obd(osc);
        if (!obd) {
                CERROR("OSC %s: not setup or attached