mds_lib.c

lustre 1.6.5 source code

        r->ur_uc.luc_suppgid2 = rec->lk_suppgid2;
        r->ur_fid1 = &rec->lk_fid1;
        r->ur_fid2 = &rec->lk_fid2;
        r->ur_time = rec->lk_time;

        lustre_set_req_swabbed(req, offset + 1);
        r->ur_name = lustre_msg_string(req->rq_reqmsg, offset + 1, 0);
        if (r->ur_name == NULL)
                RETURN (-EFAULT);
        r->ur_namelen = lustre_msg_buflen(req->rq_reqmsg, offset + 1);
        if (lustre_msg_buflen(req->rq_reqmsg, offset + 2)) {
                r->ur_dlm = lustre_swab_reqbuf(req, offset + 2,
                                               sizeof(*r->ur_dlm),
                                               lustre_swab_ldlm_request); 
                if (r->ur_dlm == NULL)
                        RETURN (-EFAULT);
        }
        RETURN(0);
}

static int mds_unlink_unpack(struct ptlrpc_request *req, int offset,
                             struct mds_update_record *r)
{
        struct mds_rec_unlink *rec;
        ENTRY;

        rec = lustre_swab_reqbuf(req, offset, sizeof (*rec),
                                 lustre_swab_mds_rec_unlink);
        if (rec == NULL)
                RETURN(-EFAULT);

        r->ur_uc.luc_fsuid = rec->ul_fsuid;
        r->ur_uc.luc_fsgid = rec->ul_fsgid;
        r->ur_uc.luc_cap = rec->ul_cap;
        r->ur_uc.luc_suppgid1 = rec->ul_suppgid;
        r->ur_uc.luc_suppgid2 = -1;
        r->ur_mode = rec->ul_mode;
        r->ur_fid1 = &rec->ul_fid1;
        r->ur_fid2 = &rec->ul_fid2;
        r->ur_time = rec->ul_time;

        lustre_set_req_swabbed(req, offset + 1);
        r->ur_name = lustre_msg_string(req->rq_reqmsg, offset + 1, 0);
        if (r->ur_name == NULL)
                RETURN(-EFAULT);
        r->ur_namelen = lustre_msg_buflen(req->rq_reqmsg, offset + 1);
        
        if (lustre_msg_buflen(req->rq_reqmsg, offset + 2)) {
                r->ur_dlm = lustre_swab_reqbuf(req, offset + 2,
                                               sizeof(*r->ur_dlm),
                                               lustre_swab_ldlm_request); 
                if (r->ur_dlm == NULL)
                        RETURN (-EFAULT);
        }
        RETURN(0);
}

static int mds_rename_unpack(struct ptlrpc_request *req, int offset,
                             struct mds_update_record *r)
{
        struct mds_rec_rename *rec;
        ENTRY;

        rec = lustre_swab_reqbuf(req, offset, sizeof (*rec),
                                 lustre_swab_mds_rec_rename);
        if (rec == NULL)
                RETURN(-EFAULT);

        r->ur_uc.luc_fsuid = rec->rn_fsuid;
        r->ur_uc.luc_fsgid = rec->rn_fsgid;
        r->ur_uc.luc_cap = rec->rn_cap;
        r->ur_uc.luc_suppgid1 = rec->rn_suppgid1;
        r->ur_uc.luc_suppgid2 = rec->rn_suppgid2;
        r->ur_fid1 = &rec->rn_fid1;
        r->ur_fid2 = &rec->rn_fid2;
        r->ur_time = rec->rn_time;

        lustre_set_req_swabbed(req, offset + 1);
        r->ur_name = lustre_msg_string(req->rq_reqmsg, offset + 1, 0);
        if (r->ur_name == NULL)
                RETURN(-EFAULT);
        r->ur_namelen = lustre_msg_buflen(req->rq_reqmsg, offset + 1);

        lustre_set_req_swabbed(req, offset + 2);
        r->ur_tgt = lustre_msg_string(req->rq_reqmsg, offset + 2, 0);
        if (r->ur_tgt == NULL)
                RETURN(-EFAULT);
        r->ur_tgtlen = lustre_msg_buflen(req->rq_reqmsg, offset + 2);
        if (lustre_msg_buflen(req->rq_reqmsg, offset + 3)) {
                r->ur_dlm = lustre_swab_reqbuf(req, offset + 3,
                                               sizeof(*r->ur_dlm),
                                               lustre_swab_ldlm_request); 
                if (r->ur_dlm == NULL)
                        RETURN (-EFAULT);
        }
        RETURN(0);
}

static int mds_open_unpack(struct ptlrpc_request *req, int offset,
                           struct mds_update_record *r)
{
        struct mds_rec_create *rec;
        ENTRY;

        rec = lustre_swab_reqbuf(req, offset, sizeof(*rec),
                                 lustre_swab_mds_rec_create);
        if (rec == NULL)
                RETURN(-EFAULT);

        r->ur_uc.luc_fsuid = rec->cr_fsuid;
        r->ur_uc.luc_fsgid = rec->cr_fsgid;
        r->ur_uc.luc_cap = rec->cr_cap;
        r->ur_uc.luc_suppgid1 = rec->cr_suppgid;
        r->ur_uc.luc_suppgid2 = -1;
        r->ur_fid1 = &rec->cr_fid;
        r->ur_fid2 = &rec->cr_replayfid;
        r->ur_mode = rec->cr_mode;
        r->ur_rdev = rec->cr_rdev;
        r->ur_time = rec->cr_time;
        r->ur_flags = rec->cr_flags;

        lustre_set_req_swabbed(req, offset + 1);
        r->ur_name = lustre_msg_string(req->rq_reqmsg, offset + 1, 0);
        if (r->ur_name == NULL)
                RETURN(-EFAULT);
        r->ur_namelen = lustre_msg_buflen(req->rq_reqmsg, offset + 1);

        lustre_set_req_swabbed(req, offset + 2);
        r->ur_eadatalen = lustre_msg_buflen(req->rq_reqmsg, offset + 2);
        if (r->ur_eadatalen) {
                r->ur_eadata = lustre_msg_buf(req->rq_reqmsg, offset + 2, 0);
                if (r->ur_eadata == NULL)
                        RETURN (-EFAULT);
        }
        RETURN(0);
}

typedef int (*update_unpacker)(struct ptlrpc_request *req, int offset,
                               struct mds_update_record *r);

static update_unpacker mds_unpackers[REINT_MAX] = {
        [REINT_SETATTR] mds_setattr_unpack,
        [REINT_CREATE] mds_create_unpack,
        [REINT_LINK] mds_link_unpack,
        [REINT_UNLINK] mds_unlink_unpack,
        [REINT_RENAME] mds_rename_unpack,
        [REINT_OPEN] mds_open_unpack,
};

int mds_update_unpack(struct ptlrpc_request *req, int offset,
                      struct mds_update_record *rec)
{
        mds_reint_t opcode, *opcodep;
        int rc;
        ENTRY;

        /* NB don't lustre_swab_reqbuf() here.  We're just taking a peek
         * and we want to leave it to the specific unpacker once we've
         * identified the message type */
        opcodep = lustre_msg_buf(req->rq_reqmsg, offset, sizeof (*opcodep));
        if (opcodep == NULL)
                RETURN(-EFAULT);

        opcode = *opcodep;
        if (lustre_msg_swabbed(req->rq_reqmsg))
                __swab32s(&opcode);

        if (opcode >= REINT_MAX || mds_unpackers[opcode] == NULL) {
                CERROR("Unexpected opcode %d\n", opcode);
                RETURN(-EFAULT);
        }

        rec->ur_opcode = opcode;
        rc = mds_unpackers[opcode](req, offset, rec);

        RETURN(rc);
}

void mds_root_squash(struct mds_obd *mds, lnet_nid_t *peernid,
                     __u32 *fsuid, __u32 *fsgid, __u32 *cap,
                     __u32 *suppgid, __u32 *suppgid2)
{
        if (!mds->mds_squash_uid || *fsuid)
               return;

        if (*peernid == mds->mds_nosquash_nid)
                return;

        CDEBUG(D_OTHER, "squash req from %s, (%d:%d/%x)=>(%d:%d/%x)\n",
               libcfs_nid2str(*peernid), *fsuid, *fsgid, *cap,
               mds->mds_squash_uid, mds->mds_squash_gid, 0);

        *fsuid = mds->mds_squash_uid;
        *fsgid = mds->mds_squash_gid;
        *cap = 0;
        *suppgid = -1;
        if (suppgid2)
                *suppgid2 = -1;
}

int mds_init_ucred(struct lvfs_ucred *ucred, struct ptlrpc_request *req,
                   int offset)
{
        struct mds_body *body = lustre_msg_buf(req->rq_reqmsg, offset,
                                               sizeof(*body));
        struct mds_obd *mds = mds_req2mds(req);
        int rc;

        LASSERT(body != NULL); /* previously verified & swabbed by caller */

#ifdef CRAY_XT3
        if (req->rq_uid != LNET_UID_ANY) {
                /* Non-root local cluster client */
                LASSERT (req->rq_uid != 0);
                ucred->luc_fsuid = req->rq_uid;
        } else
#endif
        {
                mds_root_squash(mds, &req->rq_peer.nid, &body->fsuid,
                                &body->fsgid, &body->capability,
                                &body->suppgid, NULL);

                ucred->luc_fsuid = body->fsuid;
                ucred->luc_fsgid = body->fsgid;
                ucred->luc_cap = body->capability;
        }

        ucred->luc_uce = upcall_cache_get_entry(mds->mds_group_hash,
                                                ucred->luc_fsuid,
                                                ucred->luc_fsgid, 1,
                                                &body->suppgid);
        if (IS_ERR(ucred->luc_uce)) {
                rc = PTR_ERR(ucred->luc_uce);
                ucred->luc_uce = NULL;
                return rc;
        }

#ifdef CRAY_XT3
        if (ucred->luc_uce)
                ucred->luc_fsgid = ucred->luc_uce->ue_primary;
#endif

        return 0;
}

void mds_exit_ucred(struct lvfs_ucred *ucred, struct mds_obd *mds)
{
        upcall_cache_put_entry(mds->mds_group_hash, ucred->luc_uce);
}